Jaki/SteamWar
1
0
Fork 0
forked from SteamWar/SteamWar
Code Pull Requests Activity

Move regionold to RegionFixed module

Browse Source
This commit is contained in:
YoyoNow
2025-07-31 14:14:12 +02:00
parent e6196251a6
commit c49a212c05
5 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/regionold/Prototype.java.txt
+226
View File
@@ -0,0 +1,226 @@
/*
* This file is a part of the SteamWar software.
*
* Copyright (C) 2021 SteamWar.de-Serverteam
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package de.steamwar.bausystem.region;
import lombok.AllArgsConstructor;
import lombok.Getter;
import yapion.hierarchy.types.YAPIONObject;
import yapion.hierarchy.types.YAPIONType;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Getter
public class Prototype {
static final Map<String, Prototype> PROTOTYPE_MAP = new HashMap<>();
public static Prototype getByName(String name) {
return PROTOTYPE_MAP.get(name);
}
public static Prototype getByDisplayName(String name) {
return PROTOTYPE_MAP.values().stream().filter(prototype -> prototype.getDisplayName().equals(name)).findFirst().orElse(null);
}
public static List<Prototype> getPrototypes() {
return new ArrayList<>(PROTOTYPE_MAP.values());
}
@AllArgsConstructor
@Getter
public static class Skin {
private final String name;
private final String creator; // Nullable
private final File schematicFile;
private final File testblockSchematicFile; // Nullable
private final File buildSchematicFile; // Nullable
}
private final String name;
private final String displayName;
private final String defaultSkin;
private final Map<String, Skin> skinMap = new HashMap<>();
private final int sizeX;
private final int sizeY;
private final int sizeZ;
private final int floorOffset;
private final int waterOffset;
private final SubPrototype testblock; // Nullable
private final SubPrototype build; // Nullable
private final int copyPointOffsetX;
private final int copyPointOffsetY;
private final int copyPointOffsetZ;
public Prototype(String name, YAPIONObject yapionObject) {
this.name = name;
displayName = yapionObject.getPlainValueOrDefault("displayName", name);
sizeX = yapionObject.getPlainValue("sizeX");
sizeY = yapionObject.getPlainValue("sizeY");
sizeZ = yapionObject.getPlainValue("sizeZ");
copyPointOffsetX = yapionObject.getPlainValueOrDefault("copyOffsetX", 0);
copyPointOffsetY = yapionObject.getPlainValueOrDefault("copyOffsetY", 0);
copyPointOffsetZ = yapionObject.getPlainValueOrDefault("copyOffsetZ", 0);
floorOffset = yapionObject.getPlainValueOrDefault("floorOffset", 0);
waterOffset = yapionObject.getPlainValueOrDefault("waterOffset", 0);
if (yapionObject.containsKey("testblock", YAPIONType.OBJECT)) {
testblock = new SubPrototype(yapionObject.getObject("testblock"));
} else {
testblock = null;
}
if (yapionObject.containsKey("build", YAPIONType.OBJECT)) {
build = new SubPrototype(yapionObject.getObject("build"));
} else {
build = null;
}
this.defaultSkin = yapionObject.getPlainValueOrDefault("defaultSkin", displayName);
if (yapionObject.containsKey("skins", YAPIONType.ARRAY)) {
yapionObject.getArray("skins").forEach(yapionAnyType -> {
YAPIONObject skinObject = (YAPIONObject) yapionAnyType;
String skinName = skinObject.getPlainValue("name");
String skinCreator = skinObject.getPlainValueOrDefault("creator", null);
String schematicFileName = skinObject.getPlainValue("schematic");
String testblockSchematicFileName = skinObject.getPlainValueOrDefault("testblockSchematic", null);
String buildSchematicFileName = skinObject.getPlainValueOrDefault("buildSchematic", null);
boolean disabled = skinObject.getPlainValueOrDefault("disabled", false);
if (disabled) {
return;
}
skinMap.put(skinName, new Skin(skinName, skinCreator, new File(schematicFileName), testblockSchematicFileName == null ? null : new File(testblockSchematicFileName), buildSchematicFileName == null ? null : new File(buildSchematicFileName)));
});
} else {
String s = yapionObject.getPlainValueOrDefault("schematic", null);
File schematicFile = s == null ? null : new File(s);
File testblockSchematicFile = testblock != null ? testblock.getSchematicFile() : null;
File buildSchematicFile = build != null ? build.getSchematicFile() : null;
skinMap.put(displayName, new Skin(defaultSkin, null, schematicFile, testblockSchematicFile, buildSchematicFile));
}
if (PROTOTYPE_MAP.containsKey(name)) {
Region.getRegion(PROTOTYPE_MAP.remove(name)).forEach(region -> {
region._setPrototype(this);
});
}
PROTOTYPE_MAP.put(name, this);
}
@Getter
public static class SubPrototype {
private final int offsetX;
private final int offsetY;
private final int offsetZ;
private final int sizeX;
private final int sizeY;
private final int sizeZ;
private final File schematicFile; // Nullable
private final int extensionNegativeX;
private final int extensionPositiveX;
private final int extensionNegativeY;
private final int extensionPositiveY;
private final int extensionNegativeZ;
private final int extensionPositiveZ;
private boolean extensionRegistered;
private final boolean hasCopyPoint;
private final int copyOffsetX;
private final int copyOffsetY;
private final int copyOffsetZ;
private SubPrototype(YAPIONObject yapionObject) {
offsetX = yapionObject.getPlainValueOrDefault("offsetX", 0);
offsetY = yapionObject.getPlainValueOrDefault("offsetY", 0);
offsetZ = yapionObject.getPlainValueOrDefault("offsetZ", 0);
sizeX = yapionObject.getPlainValue("sizeX");
sizeY = yapionObject.getPlainValue("sizeY");
sizeZ = yapionObject.getPlainValue("sizeZ");
if (yapionObject.containsKey("schematic", String.class)) {
schematicFile = new File(yapionObject.getValue("schematic", String.class).get());
} else {
schematicFile = null;
}
if (yapionObject.containsKey("extensionX", Integer.class)) {
extensionNegativeX = yapionObject.getPlainValue("extensionX");
extensionPositiveX = yapionObject.getPlainValue("extensionX");
} else {
extensionNegativeX = yapionObject.getPlainValueOrDefault("extensionNegativeX", 0);
extensionPositiveX = yapionObject.getPlainValueOrDefault("extensionPositiveX", 0);
}
if (yapionObject.containsKey("extensionY", Integer.class)) {
extensionNegativeY = yapionObject.getPlainValue("extensionY");
extensionPositiveY = yapionObject.getPlainValue("extensionY");
} else {
extensionNegativeY = yapionObject.getPlainValueOrDefault("extensionNegativeY", 0);
extensionPositiveY = yapionObject.getPlainValueOrDefault("extensionPositiveY", 0);
}
if (yapionObject.containsKey("extensionZ", Integer.class)) {
extensionNegativeZ = yapionObject.getPlainValue("extensionZ");
extensionPositiveZ = yapionObject.getPlainValue("extensionZ");
} else {
extensionNegativeZ = yapionObject.getPlainValueOrDefault("extensionNegativeZ", 0);
extensionPositiveZ = yapionObject.getPlainValueOrDefault("extensionPositiveZ", 0);
}
extensionRegistered = extensionNegativeX != 0 || extensionPositiveX != 0 || extensionNegativeY != 0 || extensionPositiveY != 0 || extensionNegativeZ != 0 || extensionPositiveZ != 0;
copyOffsetX = yapionObject.getPlainValueOrDefault("copyOffsetX", 0);
copyOffsetY = yapionObject.getPlainValueOrDefault("copyOffsetY", 0);
copyOffsetZ = yapionObject.getPlainValueOrDefault("copyOffsetZ", 0);
hasCopyPoint = yapionObject.containsKey("copyOffsetX") || yapionObject.containsKey("copyOffsetY") || yapionObject.containsKey("copyOffsetZ");
}
}
public static Region generateRegion(String name, YAPIONObject regionConfig, YAPIONObject regionData) {
Prototype prototype;
if (regionData.containsKey("prototype", String.class)) {
prototype = PROTOTYPE_MAP.get(regionData.getPlainValue("prototype"));
} else {
prototype = PROTOTYPE_MAP.get(regionConfig.getPlainValue("prototype"));
}
FlagStorage flagStorage;
if (regionData.containsKey("flagStorage", YAPIONType.OBJECT)) {
flagStorage = FlagStorage.createStorage(regionData.getObject("flagStorage"));
} else {
flagStorage = new FlagStorage();
}
return new Region(name, prototype, regionConfig, flagStorage, regionData);
}
}
BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/regionold/Region.java.txt
+584
View File
@@ -0,0 +1,584 @@
/*
* This file is a part of the SteamWar software.
*
* Copyright (C) 2021 SteamWar.de-Serverteam
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package de.steamwar.bausystem.region;
import com.sk89q.worldedit.EditSession;
import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.bukkit.BukkitWorld;
import de.steamwar.bausystem.BauSystem;
import de.steamwar.bausystem.region.flags.Flag;
import de.steamwar.bausystem.region.flags.flagvalues.TNTMode;
import de.steamwar.bausystem.region.tags.Tag;
import de.steamwar.bausystem.region.utils.RegionExtensionType;
import de.steamwar.bausystem.region.utils.RegionType;
import de.steamwar.bausystem.shared.SizedStack;
import de.steamwar.bausystem.utils.FlatteningWrapper;
import de.steamwar.bausystem.utils.PasteBuilder;
import de.steamwar.core.Core;
import de.steamwar.sql.SchematicType;
import lombok.AccessLevel;
import lombok.Getter;
import lombok.NonNull;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import yapion.hierarchy.types.YAPIONObject;
import yapion.hierarchy.types.YAPIONType;
import yapion.hierarchy.types.YAPIONValue;
import java.io.File;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.ObjIntConsumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@Getter
public class Region {
@Getter
private static final Map<String, Region> REGION_MAP = new HashMap<>();
private static final File backupFolder = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "backup");
private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd' 'HH:mm:ss");
public static Region getRegion(Location location) {
return REGION_MAP.values().stream()
.filter(r -> r.inRegion(location, r.minPoint, r.maxPoint))
.findFirst()
.orElse(GlobalRegion.instance);
}
public static Set<Region> getRegion(Prototype prototype) {
return REGION_MAP.values().stream()
.filter(r -> r.getPrototype() == prototype)
.collect(Collectors.toSet());
}
public static void setGlobal(Flag flagType, Flag.Value<?> value) {
REGION_MAP.values().forEach(region -> region.set(flagType, value));
}
YAPIONObject regionData;
private String name;
private Prototype prototype;
private Set<String> prototypes;
private String skin;
private Point minPoint;
private Point maxPoint;
private Point minPointTestblock;
private Point maxPointTestblock;
private Point minPointTestblockExtension;
private Point maxPointTestblockExtension;
private Point minPointBuild;
private Point maxPointBuild;
private Point minPointBuildExtension;
private Point maxPointBuildExtension;
private int floorLevel;
private int waterLevel;
private Point copyPoint; // Nullable
private Point testBlockPoint; // Nullable
private String linkedRegionName = null; // Nullable
private Region linkedRegion = null; // Nullable
private FlagStorage flagStorage;
@Getter(AccessLevel.PRIVATE)
private SizedStack<EditSession> undoSessions;
@Getter(AccessLevel.PRIVATE)
private SizedStack<EditSession> redoSessions;
public Region(String name, Prototype prototype, YAPIONObject regionConfig, FlagStorage flagStorage, YAPIONObject regionData) {
this.name = name;
this.regionData = regionData;
if (prototype != null) {
REGION_MAP.put(name, this);
}
linkedRegionName = regionConfig.getPlainValueOrDefault("optionsLinkedWith", null);
prototypes = new HashSet<>();
if (regionConfig.containsKey("prototypes", YAPIONType.ARRAY)) {
regionConfig.getArray("prototypes").forEach(yapionAnyType -> {
if (yapionAnyType instanceof YAPIONValue) {
prototypes.add(((YAPIONValue<String>) yapionAnyType).get());
}
});
}
if (regionConfig.containsKey("prototype")) {
prototypes.add(regionConfig.getPlainValue("prototype"));
}
this.flagStorage = flagStorage;
Point point = null;
if (regionConfig.containsKey("minX", Integer.class) && regionConfig.containsKey("minY", Integer.class) && regionConfig.containsKey("minZ", Integer.class)) {
point = new Point(regionConfig.getPlainValue("minX"), regionConfig.getPlainValue("minY"), regionConfig.getPlainValue("minZ"));
}
if (prototype != null && prototypes.contains(prototype.getName())) {
generatePrototypeData(prototype, point);
} else if (regionConfig.containsKey("prototype")) {
generatePrototypeData(Prototype.getByName(regionConfig.getPlainValue("prototype")), point);
}
if (prototype != null) {
skin = regionData.getPlainValueOrDefault("skin", prototype.getDefaultSkin());
if (!prototype.getSkinMap().containsKey(skin)) {
skin = prototype.getDefaultSkin();
}
}
regionData.add("skin", skin);
if (!hasType(RegionType.BUILD) || !hasType(RegionType.TESTBLOCK)) {
flagStorage.set(Flag.TNT, TNTMode.DENY);
}
}
private void generatePrototypeData(Prototype prototype, Point point) {
if (prototype == null) {
return;
}
this.prototype = prototype;
this.skin = prototype.getDefaultSkin();
this.minPoint = point;
this.maxPoint = point.add(prototype.getSizeX() - 1, prototype.getSizeY() - 1, prototype.getSizeZ() - 1);
if (prototype.getTestblock() != null) {
this.minPointTestblock = point.add(prototype.getTestblock().getOffsetX(), prototype.getTestblock().getOffsetY(), prototype.getTestblock().getOffsetZ());
this.maxPointTestblock = this.minPointTestblock.add(prototype.getTestblock().getSizeX() - 1, prototype.getTestblock().getSizeY() - 1, prototype.getTestblock().getSizeZ() - 1);
this.minPointTestblockExtension = this.minPointTestblock.subtract(prototype.getTestblock().getExtensionNegativeX(), prototype.getTestblock().getExtensionNegativeY(), prototype.getTestblock().getExtensionNegativeZ());
this.maxPointTestblockExtension = this.maxPointTestblock.add(prototype.getTestblock().getExtensionPositiveX(), prototype.getTestblock().getExtensionPositiveY(), prototype.getTestblock().getExtensionPositiveZ());
if (prototype.getTestblock().getCopyOffsetX() != 0 || prototype.getTestblock().getCopyOffsetY() != 0 || prototype.getTestblock().getCopyOffsetZ() != 0) {
this.testBlockPoint = this.minPointTestblock.add(prototype.getTestblock().getCopyOffsetX(), prototype.getTestblock().getCopyOffsetY(), prototype.getTestblock().getCopyOffsetZ());
} else {
this.testBlockPoint = this.minPointTestblock.add(prototype.getTestblock().getSizeX() / 2, 0, -1);
}
}
if (prototype.getBuild() != null) {
this.minPointBuild = point.add(prototype.getBuild().getOffsetX(), prototype.getBuild().getOffsetY(), prototype.getBuild().getOffsetZ());
this.maxPointBuild = this.minPointBuild.add(prototype.getBuild().getSizeX() - 1, prototype.getBuild().getSizeY() - 1, prototype.getBuild().getSizeZ() - 1);
this.minPointBuildExtension = this.minPointBuild.subtract(prototype.getBuild().getExtensionNegativeX(), prototype.getBuild().getExtensionNegativeY(), prototype.getBuild().getExtensionNegativeZ());
this.maxPointBuildExtension = this.maxPointBuild.add(prototype.getBuild().getExtensionPositiveX(), prototype.getBuild().getExtensionPositiveY(), prototype.getBuild().getExtensionPositiveZ());
if (!prototype.getBuild().isHasCopyPoint() && (prototype.getCopyPointOffsetX() != 0 || prototype.getCopyPointOffsetY() != 0 || prototype.getCopyPointOffsetZ() != 0)) {
this.copyPoint = minPoint.add(prototype.getCopyPointOffsetX(), prototype.getCopyPointOffsetY(), prototype.getCopyPointOffsetZ());
} else if (prototype.getBuild().getCopyOffsetX() != 0 || prototype.getBuild().getCopyOffsetY() != 0 || prototype.getBuild().getCopyOffsetZ() != 0) {
this.copyPoint = this.minPointBuild.add(prototype.getBuild().getCopyOffsetX(), prototype.getBuild().getCopyOffsetY(), prototype.getBuild().getCopyOffsetZ());
} else {
this.copyPoint = this.minPointBuild.add(prototype.getBuild().getSizeX() / 2, 0, prototype.getBuild().getSizeZ());
}
} else if (prototype.getCopyPointOffsetX() != 0 || prototype.getCopyPointOffsetY() != 0 || prototype.getCopyPointOffsetZ() != 0) {
this.copyPoint = minPoint.add(prototype.getCopyPointOffsetX(), prototype.getCopyPointOffsetY(), prototype.getCopyPointOffsetZ());
}
if (prototype.getFloorOffset() != 0) {
floorLevel = minPoint.getY() + prototype.getFloorOffset();
} else {
floorLevel = 0;
}
if (prototype.getWaterOffset() != 0) {
waterLevel = minPoint.getY() + prototype.getWaterOffset();
} else {
waterLevel = 0;
}
}
public boolean inRegion(Location location, RegionType regionType, RegionExtensionType regionExtensionType) {
if (!hasType(regionType)) {
return false;
}
switch (regionType) {
case BUILD:
Point minBPoint = regionExtensionType == RegionExtensionType.EXTENSION ? minPointBuildExtension : minPointBuild;
Point maxBPoint = regionExtensionType == RegionExtensionType.EXTENSION ? maxPointBuildExtension : maxPointBuild;
return inRegion(location, minBPoint, maxBPoint);
case TESTBLOCK:
Point minTBPoint = regionExtensionType == RegionExtensionType.EXTENSION ? minPointTestblockExtension : minPointTestblock;
Point maxTBPoint = regionExtensionType == RegionExtensionType.EXTENSION ? maxPointTestblockExtension : maxPointTestblock;
return inRegion(location, minTBPoint, maxTBPoint);
default:
case NORMAL:
return inRegion(location, minPoint, maxPoint);
}
}
private boolean inRegion(Location location, Point minPoint, Point maxPoint) {
int blockX = location.getBlockX();
int blockY = location.getBlockY();
int blockZ = location.getBlockZ();
return blockX >= minPoint.getX() && blockX <= maxPoint.getX() &&
blockY >= minPoint.getY() && blockY <= maxPoint.getY() &&
blockZ >= minPoint.getZ() && blockZ <= maxPoint.getZ();
}
public boolean hasType(RegionType regionType) {
if (prototype == null) {
return false;
}
if (regionType == null) {
return false;
}
switch (regionType) {
case BUILD:
return prototype.getBuild() != null;
case TESTBLOCK:
return prototype.getTestblock() != null;
default:
case NORMAL:
return true;
}
}
public boolean hasExtensionType(RegionType regionType) {
if (!hasType(regionType)) {
return false;
}
switch (regionType) {
case BUILD:
return prototype.getBuild().isExtensionRegistered();
case TESTBLOCK:
return prototype.getTestblock().isExtensionRegistered();
default:
case NORMAL:
return false;
}
}
public String getDisplayName() {
return prototype != null ? prototype.getSkinMap().get(skin).getName() : "";
}
private void setLinkedRegion(Predicate<Region> regionConsumer) {
if (linkedRegionName == null) {
return;
}
if (linkedRegion != null) {
if (regionConsumer.test(linkedRegion)) {
RegionUtils.save(linkedRegion);
}
return;
}
for (Region region : REGION_MAP.values()) {
if (region.name.equals(linkedRegionName)) {
linkedRegion = region;
if (regionConsumer.test(linkedRegion)) {
RegionUtils.save(linkedRegion);
}
return;
}
}
}
public Region getLinkedRegion() {
if (linkedRegion == null && linkedRegionName != null) {
setLinkedRegion(region -> false);
}
return linkedRegion;
}
public boolean setPrototype(@NonNull Prototype prototype) {
if (!prototypes.contains(prototype.getName())) {
return false;
}
return _setPrototype(prototype);
}
boolean _setPrototype(@NonNull Prototype prototype) {
generatePrototypeData(prototype, minPoint);
RegionUtils.save(this);
return true;
}
public boolean setSkin(@NonNull String skinName) {
if (!prototype.getSkinMap().containsKey(skinName)) {
return false;
}
this.skin = skinName;
setLinkedRegion(region -> {
region.skin = skinName;
return true;
});
regionData.add("skin", skin);
return true;
}
public void set(Flag flagType, Flag.Value<?> value) {
if (flagStorage.set(flagType, value)) {
RegionUtils.save(this);
}
setLinkedRegion(region -> region.flagStorage.set(flagType, value));
}
public void set(Tag tag) {
if (flagStorage.set(tag)) {
RegionUtils.save(this);
}
setLinkedRegion(region -> region.flagStorage.set(tag));
}
public void remove(Tag tag) {
if (flagStorage.remove(tag)) {
RegionUtils.save(this);
}
}
public Flag.Value<?> get(Flag flagType) {
return flagStorage.get(flagType);
}
public boolean get(Tag tagType) {
return flagStorage.is(tagType);
}
public <T extends Enum<T> & Flag.Value<T>> T getPlain(Flag flagType) {
return (T) flagStorage.get(flagType).getValue();
}
public <T extends Enum<T> & Flag.Value<T>> T getPlain(Flag flagType, Class<T> type) {
return (T) flagStorage.get(flagType).getValue();
}
public Point getMinPoint(RegionType regionType, RegionExtensionType regionExtensionType) {
switch (regionType) {
case TESTBLOCK:
return (regionExtensionType == null || regionExtensionType == RegionExtensionType.NORMAL) ? minPointTestblock : minPointTestblockExtension;
case BUILD:
return (regionExtensionType == null || regionExtensionType == RegionExtensionType.NORMAL) ? minPointBuild : minPointBuildExtension;
default:
case NORMAL:
return minPoint;
}
}
public Point getMaxPoint(RegionType regionType, RegionExtensionType regionExtensionType) {
switch (regionType) {
case TESTBLOCK:
return (regionExtensionType == null || regionExtensionType == RegionExtensionType.NORMAL) ? maxPointTestblock : maxPointTestblockExtension;
case BUILD:
return (regionExtensionType == null || regionExtensionType == RegionExtensionType.NORMAL) ? maxPointBuild : maxPointBuildExtension;
default:
case NORMAL:
return maxPoint;
}
}
boolean hasReset(RegionType regionType) {
if (!hasType(regionType)) {
return false;
}
switch (regionType) {
case TESTBLOCK:
return prototype.getSkinMap().get(skin).getTestblockSchematicFile() != null;
case BUILD:
return prototype.getSkinMap().get(skin).getBuildSchematicFile() != null;
default:
case NORMAL:
return prototype.getSkinMap().get(skin).getSchematicFile() != null;
}
}
public File getResetFile(RegionType regionType) {
if (!hasReset(regionType)) {
return null;
}
switch (regionType) {
case TESTBLOCK:
return prototype.getSkinMap().get(skin).getTestblockSchematicFile();
case BUILD:
return prototype.getSkinMap().get(skin).getBuildSchematicFile();
default:
case NORMAL:
return prototype.getSkinMap().get(skin).getSchematicFile();
}
}
public void reset(PasteBuilder pasteBuilder, RegionType regionType, RegionExtensionType regionExtensionType) {
if (!hasReset(regionType)) {
return;
}
if (regionExtensionType == RegionExtensionType.EXTENSION && !hasExtensionType(regionType)) {
regionExtensionType = RegionExtensionType.NORMAL;
}
pasteBuilder.reset(regionExtensionType == RegionExtensionType.EXTENSION)
.minPoint(getMinPoint(regionType, regionExtensionType))
.maxPoint(getMaxPoint(regionType, regionExtensionType))
.waterLevel(waterLevel);
if (pasteBuilder.getClipboardProvider().is(PasteBuilder.SchematicProvider.class)) {
SchematicType schematicType = pasteBuilder.getClipboardProvider().as(PasteBuilder.SchematicProvider.class).getSchematic().getSchemtype();
pasteBuilder.rotate(schematicType.fightType() || schematicType.check());
}
switch (regionType) {
case BUILD:
pasteBuilder.pastePoint(minPointBuild.add(prototype.getBuild().getSizeX() / 2, 0, prototype.getBuild().getSizeZ() / 2));
break;
case TESTBLOCK:
Point pastePoint = minPointTestblock.add(prototype.getTestblock().getSizeX() / 2, 0, prototype.getTestblock().getSizeZ() / 2);
if (pasteBuilder.getClipboardProvider().is(PasteBuilder.SchematicProvider.class)) {
SchematicType schematicType = pasteBuilder.getClipboardProvider().as(PasteBuilder.SchematicProvider.class).getSchematic().getSchemtype();
if (schematicType.getKuerzel().equalsIgnoreCase("wg")) {
pastePoint = pastePoint.add(0, 0, 1);
}
if (schematicType.getKuerzel().equalsIgnoreCase("ws")) {
pastePoint = pastePoint.add(-1, 0, 1);
}
if (schematicType.getKuerzel().equalsIgnoreCase("as")) {
pastePoint = pastePoint.add(-1, 0, 1);
}
}
pasteBuilder.pastePoint(pastePoint);
break;
default:
case NORMAL:
pasteBuilder.pastePoint(minPoint.add(prototype.getSizeX() / 2, 0, prototype.getSizeZ() / 2));
break;
}
initSessions();
undoSessions.push(pasteBuilder.run());
}
public void remember(EditSession editSession) {
initSessions();
undoSessions.push(editSession);
}
public boolean isGlobal() {
return this == GlobalRegion.getInstance();
}
private void initSessions() {
if (undoSessions == null) {
undoSessions = new SizedStack<>(20);
redoSessions = new SizedStack<>(20);
}
}
public boolean undo() {
initSessions();
EditSession session = undoSessions.pop();
if (session == null)
return false;
try (EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(new BukkitWorld(Bukkit.getWorlds().get(0)), -1)) {
session.undo(e);
redoSessions.push(e);
}
return true;
}
public boolean redo() {
initSessions();
EditSession session = redoSessions.pop();
if (session == null)
return false;
try (EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(new BukkitWorld(Bukkit.getWorlds().get(0)), -1)) {
session.redo(e);
undoSessions.push(e);
}
return true;
}
public boolean backup() {
final File definedBackupFolder = new File(new File(backupFolder, prototype.getName()), name);
//noinspection ResultOfMethodCallIgnored
definedBackupFolder.mkdirs();
File[] currentBackups = definedBackupFolder.listFiles();
if (currentBackups != null && currentBackups.length >= 20) {
List<File> files = new ArrayList<>(Arrays.asList(currentBackups));
files.sort(Comparator.comparingLong(File::lastModified));
while (files.size() >= 20) files.remove(0).delete();
}
final File backupFile = new File(definedBackupFolder, LocalDateTime.now().format(formatter) + ".schem");
return FlatteningWrapper.impl.backup(minPoint, maxPoint, backupFile);
}
public static boolean copy(Point minPoint, Point maxPoint, File file) {
return FlatteningWrapper.impl.backup(minPoint, maxPoint, file);
}
public List<String> listBackup() {
final File definedBackupFolder = new File(new File(backupFolder, prototype.getName()), name);
//noinspection ResultOfMethodCallIgnored
definedBackupFolder.mkdirs();
File[] currentBackups = definedBackupFolder.listFiles();
List<File> files = new ArrayList<>(Arrays.asList(currentBackups));
files.sort(Comparator.comparingLong(File::lastModified));
return files.stream().map(File::getName).collect(Collectors.toList());
}
public File getBackupFile(String backupName) {
final File definedBackupFolder = new File(new File(backupFolder, prototype.getName()), name);
//noinspection ResultOfMethodCallIgnored
definedBackupFolder.mkdirs();
File[] files = definedBackupFolder.listFiles((dir, name) -> name.equals(backupName + ".schem"));
if (files == null || files.length == 0) return null;
return files[0];
}
public void forEachChunk(ObjIntConsumer<Integer> executor) {
for (int x = (int) Math.floor(minPoint.getX() / 16.0); x <= (int) Math.ceil(maxPoint.getX() / 16.0); x++) {
for (int z = (int) Math.floor(minPoint.getZ() / 16.0); z <= (int) Math.ceil(maxPoint.getZ() / 16.0); z++) {
executor.accept(x, z);
}
}
}
public boolean buildChunkOutside(int chunkX, int chunkY) {
if (!hasType(RegionType.BUILD)) {
return Math.floor(minPoint.getX() / 16.0) > chunkX || chunkX >= Math.ceil(maxPoint.getX() / 16.0) ||
Math.floor(minPoint.getZ() / 16.0) > chunkY || chunkY >= Math.ceil(maxPoint.getZ() / 16.0);
}
if (!hasExtensionType(RegionType.BUILD)) {
return Math.floor(minPointBuild.getX() / 16.0) > chunkX || chunkX >= Math.ceil(maxPointBuild.getX() / 16.0) ||
Math.floor(minPointBuild.getZ() / 16.0) > chunkY || chunkY >= Math.ceil(maxPointBuild.getZ() / 16.0);
}
return Math.floor(minPointBuildExtension.getX() / 16.0) > chunkX || chunkX >= Math.ceil(maxPointBuildExtension.getX() / 16.0) ||
Math.floor(minPointBuildExtension.getZ() / 16.0) > chunkY || chunkY >= Math.ceil(maxPointBuildExtension.getZ() / 16.0);
}
public File gameModeConfig() {
File baseFile = new File(BauSystem.getInstance().getDataFolder().getParentFile(), "FightSystem");
for (int version = Core.getVersion(); version >= 15; version--) {
File specific = new File(baseFile, prototype.getDisplayName() + version + ".yml");
if (specific.exists()) return specific;
}
return null;
}
}
BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/regionold/loader/PrototypeLoader.java.txt
+60
View File
@@ -0,0 +1,60 @@
/*
* This file is a part of the SteamWar software.
*
* Copyright (C) 2021 SteamWar.de-Serverteam
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package de.steamwar.bausystem.region.loader;
import de.steamwar.bausystem.region.Prototype;
import lombok.experimental.UtilityClass;
import org.bukkit.Bukkit;
import yapion.hierarchy.diff.DiffDelete;
import yapion.hierarchy.diff.YAPIONDiff;
import yapion.hierarchy.types.YAPIONObject;
import yapion.parser.YAPIONParser;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
@UtilityClass
public class PrototypeLoader {
private YAPIONObject loaded = null;
public static final File file = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "prototypes.yapion");
public void load() {
YAPIONObject yapionObject = null;
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file))) {
yapionObject = YAPIONParser.parse(bufferedInputStream);
} catch (IOException e) {
throw new SecurityException(e.getMessage(), e);
}
if (loaded != null && new YAPIONDiff(loaded, yapionObject).getDiffs().stream().anyMatch(DiffDelete.class::isInstance)) {
throw new SecurityException("Version was not the specified version needed.");
}
loaded = yapionObject;
yapionObject.forEach((key, yapionAnyType) -> {
if (yapionAnyType instanceof YAPIONObject) {
new Prototype(key, (YAPIONObject) yapionAnyType);
}
});
}
}
BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/regionold/loader/RegionLoader.java.txt
+91
View File
@@ -0,0 +1,91 @@
/*
* This file is a part of the SteamWar software.
*
* Copyright (C) 2021 SteamWar.de-Serverteam
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package de.steamwar.bausystem.region.loader;
import de.steamwar.bausystem.region.FlagStorage;
import de.steamwar.bausystem.region.GlobalRegion;
import de.steamwar.bausystem.region.Prototype;
import de.steamwar.bausystem.worlddata.WorldData;
import lombok.experimental.UtilityClass;
import org.bukkit.Bukkit;
import yapion.hierarchy.diff.DiffChange;
import yapion.hierarchy.diff.YAPIONDiff;
import yapion.hierarchy.types.YAPIONObject;
import yapion.hierarchy.types.YAPIONType;
import yapion.parser.YAPIONParser;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
@UtilityClass
public class RegionLoader {
private YAPIONObject loaded = null;
public static final File file = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "regions.yapion");
public void load() {
YAPIONObject yapionObject = null;
try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file))) {
yapionObject = YAPIONParser.parse(bufferedInputStream);
} catch (IOException e) {
throw new SecurityException(e.getMessage(), e);
}
if (loaded != null && new YAPIONDiff(loaded, yapionObject).getDiffs().stream().anyMatch(diffBase -> !(diffBase instanceof DiffChange))) {
throw new SecurityException("Version was not the specified version needed.");
}
loaded = yapionObject;
YAPIONObject optionsYapionObject = WorldData.getRegionsData();
yapionObject.forEach((key, yapionAnyType) -> {
if (key.equals("global")) {
return;
}
if (!(yapionAnyType instanceof YAPIONObject)) {
return;
}
YAPIONObject regionConfig = (YAPIONObject) yapionAnyType;
YAPIONObject regionData = new YAPIONObject();
if (optionsYapionObject.containsKey(key, YAPIONType.OBJECT)) {
regionData = optionsYapionObject.getObject(key);
} else {
optionsYapionObject.add(key, regionData);
}
Prototype.generateRegion(key, regionConfig, regionData);
});
YAPIONObject globalOptions = optionsYapionObject.getObject("global");
if (globalOptions == null) {
globalOptions = new YAPIONObject();
optionsYapionObject.add("global", globalOptions);
}
FlagStorage flagStorage;
if (globalOptions.containsKey("flagStorage", YAPIONType.OBJECT)) {
flagStorage = FlagStorage.createStorage(globalOptions.getObject("flagStorage"));
} else {
flagStorage = new FlagStorage();
}
new GlobalRegion(flagStorage, globalOptions);
}
}
BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/regionold/loader/Updater.java.txt
+47
View File
@@ -0,0 +1,47 @@
/*
* This file is a part of the SteamWar software.
*
* Copyright (C) 2021 SteamWar.de-Serverteam
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package de.steamwar.bausystem.region.loader;
import de.steamwar.bausystem.BauSystem;
import org.bukkit.Bukkit;
import java.io.File;
import java.util.logging.Level;
public class Updater {
private long lastUpdate;
public Updater(File file, Runnable updaterCode) {
this.lastUpdate = file.lastModified();
Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
if (file.lastModified() > lastUpdate + 10) {
try {
updaterCode.run();
Bukkit.getLogger().log(Level.INFO, "Update complete of " + file.getAbsolutePath());
} catch (Exception e) {
Bukkit.getLogger().log(Level.INFO, "Error while loading file " + file.getAbsolutePath() + " for config: " + e.getMessage(), e);
}
lastUpdate = file.lastModified();
}
}, 20, 20);
}
}