SteamWar/BauSystem2.0
Archiviert
12
0
Dieses Repository wurde am 2024-08-05 archiviert. Du kannst Dateien ansehen und es klonen, aber nicht pushen oder Issues/Pull-Requests öffnen.
BauSystem2.0/BauSystem_Main/src/de/steamwar/bausystem/region/Region.java

405 Zeilen
16 KiB
Java

/*
* 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.extent.clipboard.Clipboard;
2021-04-18 18:37:32 +02:00
import de.steamwar.bausystem.region.flags.Flag;
import de.steamwar.bausystem.region.flags.flagvalues.ColorMode;
import de.steamwar.bausystem.region.flags.flagvalues.TNTMode;
2021-04-19 17:54:30 +02:00
import de.steamwar.bausystem.region.loader.RegionLoader;
import de.steamwar.bausystem.region.utils.RegionExtensionType;
import de.steamwar.bausystem.region.utils.RegionType;
import de.steamwar.bausystem.shared.SizedStack;
import de.steamwar.core.VersionedCallable;
2021-04-20 09:24:15 +02:00
import de.steamwar.sql.Schematic;
2021-04-20 11:03:46 +02:00
import lombok.AccessLevel;
2021-04-18 15:48:15 +02:00
import lombok.Getter;
2021-04-18 18:37:32 +02:00
import lombok.NonNull;
import org.bukkit.Location;
import yapion.hierarchy.types.YAPIONObject;
import yapion.hierarchy.types.YAPIONType;
import yapion.hierarchy.types.YAPIONValue;
2021-04-18 15:48:15 +02:00
import java.io.File;
2021-04-20 09:24:15 +02:00
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
2021-04-18 15:34:31 +02:00
import java.util.Set;
2021-04-19 20:33:15 +02:00
import java.util.function.Predicate;
2021-04-18 15:34:31 +02:00
2021-04-18 15:48:15 +02:00
@Getter
public class Region {
2021-04-18 15:34:31 +02:00
private static final List<Region> REGION_LIST = new ArrayList<>();
public static Region getRegion(Location location) {
for (Region region : REGION_LIST) {
if (region.inRegion(location, RegionType.NORMAL, RegionExtensionType.NORMAL)) {
return region;
}
}
return GlobalRegion.instance;
}
2021-04-20 08:39:35 +02:00
public static void setGlobal(Flag flagType, Flag.Value<?> value) {
for (Region region : REGION_LIST) {
region.set(flagType, value);
}
}
2021-04-18 18:37:32 +02:00
private YAPIONObject regionData;
2021-04-18 19:00:19 +02:00
private String name;
2021-04-18 15:34:31 +02:00
private Prototype prototype;
private Set<Prototype> prototypes;
2021-04-18 15:34:31 +02:00
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;
2021-04-19 17:32:16 +02:00
private int floorLevel;
private int waterLevel;
2021-04-18 19:00:19 +02:00
private String linkedRegionName = null; // Nullable
2021-04-18 15:34:31 +02:00
private Region linkedRegion = null; // Nullable
private FlagStorage flagStorage;
2021-04-20 11:03:46 +02:00
@Getter(AccessLevel.PRIVATE)
private SizedStack<EditSession> undoSessions;
2021-04-20 11:03:46 +02:00
@Getter(AccessLevel.PRIVATE)
private SizedStack<EditSession> redoSessions;
2021-04-18 19:00:19 +02:00
public Region(String name, Prototype prototype, YAPIONObject regionConfig, FlagStorage flagStorage, YAPIONObject regionData) {
this.name = name;
2021-04-18 18:37:32 +02:00
this.regionData = regionData;
if (prototype != null) {
REGION_LIST.add(this);
}
2021-04-19 20:33:15 +02:00
linkedRegionName = regionConfig.getPlainValueOrDefault("optionsLinkedWith", null);
2021-04-18 19:00:19 +02:00
prototypes = new HashSet<>();
if (regionConfig.containsKey("prototypes", YAPIONType.ARRAY)) {
regionConfig.getArray("prototypes").forEach(yapionAnyType -> {
if (yapionAnyType instanceof YAPIONValue) {
prototypes.add(Prototype.PROTOTYPE_MAP.get(((YAPIONValue<String>) yapionAnyType).get()));
}
});
}
this.flagStorage = flagStorage;
2021-04-18 18:27:54 +02:00
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"));
}
generatePrototypeData(prototype, point);
2021-04-19 20:01:38 +02:00
if (!hasType(RegionType.BUILD) || !hasType(RegionType.TESTBLOCK)) {
flagStorage.set(Flag.TNT, TNTMode.DENY);
}
}
2021-04-18 18:20:27 +02:00
private void generatePrototypeData(Prototype prototype, Point point) {
if (prototype == null) {
return;
}
2021-04-18 18:21:34 +02:00
if (this.prototype != null && !prototypes.contains(prototype)) {
return;
}
this.prototype = prototype;
2021-04-18 18:20:27 +02:00
this.minPoint = point;
this.maxPoint = point.add(prototype.getSizeX(), prototype.getSizeY(), prototype.getSizeZ());
2021-04-18 18:27:54 +02:00
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(), prototype.getTestblock().getSizeY(), prototype.getTestblock().getSizeZ());
2021-04-18 18:20:27 +02:00
2021-04-18 18:27:54 +02:00
this.minPointTestblockExtension = this.minPointTestblock.substract(prototype.getTestblock().getExtensionNegativeX(), prototype.getTestblock().getExtensionNegativeY(), prototype.getTestblock().getExtensionNegativeZ());
this.maxPointTestblockExtension = this.maxPointTestblock.add(prototype.getTestblock().getExtensionPositiveX(), prototype.getTestblock().getExtensionPositiveY(), prototype.getTestblock().getExtensionPositiveZ());
}
2021-04-18 18:20:27 +02:00
2021-04-18 18:27:54 +02:00
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(), prototype.getBuild().getSizeY(), prototype.getBuild().getSizeZ());
2021-04-18 18:20:27 +02:00
2021-04-18 18:27:54 +02:00
this.minPointBuildExtension = this.minPointBuild.substract(prototype.getBuild().getExtensionNegativeX(), prototype.getBuild().getExtensionNegativeY(), prototype.getBuild().getExtensionNegativeZ());
this.maxPointBuildExtension = this.maxPointBuild.add(prototype.getBuild().getExtensionPositiveX(), prototype.getBuild().getExtensionPositiveY(), prototype.getBuild().getExtensionPositiveZ());
}
2021-04-19 17:32:16 +02:00
if (prototype.getFloorOffset() != 0) {
floorLevel = minPoint.getY() + prototype.getFloorOffset();
} else {
floorLevel = 0;
}
if (prototype.getWaterOffset() != 0) {
waterLevel = minPoint.getY() + prototype.getWaterOffset();
} else {
waterLevel = 0;
}
}
2021-04-20 11:03:46 +02:00
private void initSessions() {
if (undoSessions == null) {
undoSessions = new SizedStack<>(20);
redoSessions = new SizedStack<>(20);
}
}
public boolean inRegion(Location location, RegionType regionType, RegionExtensionType regionExtensionType) {
if (!hasType(regionType)) {
return false;
}
2021-04-18 17:42:46 +02:00
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) {
return location.getBlockX() >= minPoint.getX() && location.getBlockX() < maxPoint.getX() &&
location.getBlockY() >= minPoint.getY() && location.getBlockY() < maxPoint.getY() &&
location.getBlockZ() >= minPoint.getZ() && location.getBlockZ() < maxPoint.getZ();
}
public boolean hasType(RegionType regionType) {
2021-04-20 11:15:35 +02:00
if (prototype == null) {
return false;
}
2021-04-20 11:36:39 +02:00
if (regionType == null) {
return false;
}
2021-04-18 17:42:46 +02:00
switch (regionType) {
case BUILD:
2021-04-20 11:15:35 +02:00
return prototype.getBuild() != null;
2021-04-18 17:42:46 +02:00
case TESTBLOCK:
2021-04-20 11:15:35 +02:00
return prototype.getTestblock() != null;
2021-04-18 17:42:46 +02:00
default:
case NORMAL:
2021-04-20 11:15:35 +02:00
return true;
2021-04-18 17:42:46 +02:00
}
}
2021-04-20 08:20:53 +02:00
public boolean hasExtensionType(RegionType regionType) {
2021-04-20 11:18:57 +02:00
if (!hasType(regionType)) {
return false;
}
2021-04-20 08:20:53 +02:00
switch (regionType) {
case BUILD:
2021-04-20 11:18:57 +02:00
return prototype.getBuild().isExtensionRegistered();
2021-04-20 08:20:53 +02:00
case TESTBLOCK:
2021-04-20 11:18:57 +02:00
return prototype.getTestblock().isExtensionRegistered();
2021-04-20 08:20:53 +02:00
default:
case NORMAL:
return false;
}
}
public String getDisplayName() {
return prototype != null ? prototype.getDisplayName() : "";
}
2021-04-18 18:37:32 +02:00
2021-04-19 20:33:15 +02:00
private void setLinkedRegion(Predicate<Region> regionConsumer) {
2021-04-18 19:00:19 +02:00
if (linkedRegionName == null) {
return;
}
if (linkedRegion != null) {
2021-04-19 20:33:15 +02:00
if (regionConsumer.test(linkedRegion)) {
linkedRegion.regionData.add("flagStorage", FlagStorage.toYAPION(linkedRegion.flagStorage));
RegionLoader.save();
}
2021-04-18 19:00:19 +02:00
return;
}
for (Region region : REGION_LIST) {
2021-04-19 20:33:15 +02:00
if (region.name.equals(linkedRegionName)) {
2021-04-18 19:00:19 +02:00
linkedRegion = region;
2021-04-19 20:33:15 +02:00
if (regionConsumer.test(linkedRegion)) {
linkedRegion.regionData.add("flagStorage", FlagStorage.toYAPION(linkedRegion.flagStorage));
RegionLoader.save();
}
2021-04-18 19:00:19 +02:00
return;
}
}
}
2021-04-18 18:37:32 +02:00
public void setPrototype(@NonNull Prototype prototype) {
if (this.prototype == null) {
return;
}
2021-04-19 20:33:15 +02:00
if (!prototypes.contains(prototype)) {
return;
}
2021-04-18 18:37:32 +02:00
regionData.add("prototype", prototype.getName());
generatePrototypeData(prototype, minPoint);
2021-04-18 19:00:19 +02:00
setLinkedRegion(region -> {
region.regionData.add("prototype", prototype.getName());
region.generatePrototypeData(prototype, region.minPoint);
2021-04-19 20:33:15 +02:00
return true;
2021-04-18 19:00:19 +02:00
});
2021-04-18 18:37:32 +02:00
}
public void set(Flag flagType, Flag.Value<?> value) {
if (flagStorage.set(flagType, value)) {
regionData.add("flagStorage", FlagStorage.toYAPION(flagStorage));
2021-04-19 17:54:30 +02:00
RegionLoader.save();
2021-04-18 18:37:32 +02:00
}
2021-04-19 20:33:15 +02:00
setLinkedRegion(region -> region.flagStorage.set(flagType, value));
2021-04-18 18:37:32 +02:00
}
public <T extends Enum<T> & Flag.Value<T>> Flag.Value<T> get(Flag flagType) {
return flagStorage.get(flagType);
}
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();
}
2021-04-20 08:20:53 +02:00
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;
}
}
2021-04-20 09:24:15 +02:00
boolean hasReset(RegionType regionType) {
if (!hasType(regionType)) {
2021-04-20 09:24:15 +02:00
return false;
}
switch (regionType) {
case TESTBLOCK:
return prototype.getTestblock().getSchematicFile() != null;
case BUILD:
return prototype.getBuild().getSchematicFile() != null;
default:
case NORMAL:
return prototype.getSchematicFile() != null;
}
}
public void reset(RegionType regionType) throws IOException {
reset(null, regionType);
}
public void reset(Schematic schematic, RegionType regionType) throws IOException {
reset(schematic, regionType, RegionExtensionType.NORMAL, false);
2021-04-20 09:24:15 +02:00
}
public void reset(RegionType regionType, RegionExtensionType regionExtensionType) throws IOException {
reset(null, regionType, regionExtensionType, false);
2021-04-20 09:24:15 +02:00
}
public void reset(Schematic schematic, RegionType regionType, RegionExtensionType regionExtensionType, boolean ignoreAir) throws IOException {
2021-04-20 09:24:15 +02:00
if (!hasReset(regionType)) {
return;
}
2021-04-20 09:24:15 +02:00
if (regionExtensionType == RegionExtensionType.EXTENSION && !hasExtensionType(regionType)) {
regionExtensionType = RegionExtensionType.NORMAL;
}
PasteOptions pasteOptions = new PasteOptions((schematic != null && (schematic.getSchemType().fightType() || schematic.getSchemType().check())), ignoreAir, getPlain(Flag.COLOR, ColorMode.class).getColor(), regionExtensionType == RegionExtensionType.EXTENSION, getMinPoint(regionType, regionExtensionType), getMaxPoint(regionType, regionExtensionType), waterLevel);
switch (regionType) {
case BUILD:
System.out.println(schematic + " " + prototype.getBuild().getSchematicFile() + " " + regionType + " " + regionExtensionType + " " + minPointBuild);
if (schematic != null) {
paste(schematic.load(), minPointBuild, pasteOptions);
} else {
paste(prototype.getBuild().getSchematicFile(), minPointBuild, pasteOptions);
}
2021-04-20 11:01:19 +02:00
break;
case TESTBLOCK:
System.out.println(schematic + " " + prototype.getBuild().getSchematicFile() + " " + regionType + " " + regionExtensionType + " " + minPointTestblock);
if (schematic != null) {
paste(schematic.load(), minPointTestblock, pasteOptions);
} else {
paste(prototype.getTestblock().getSchematicFile(), minPointTestblock, pasteOptions);
}
2021-04-20 11:01:19 +02:00
break;
default:
case NORMAL:
System.out.println(schematic + " " + prototype.getBuild().getSchematicFile() + " " + regionType + " " + regionExtensionType + " " + minPoint);
if (schematic != null) {
paste(schematic.load(), minPoint, pasteOptions);
} else {
paste(prototype.getSchematicFile(), minPoint, pasteOptions);
}
2021-04-20 11:01:19 +02:00
break;
}
}
private static EditSession paste(File file, Point pastePoint, PasteOptions pasteOptions) {
return VersionedCallable.call(new VersionedCallable<>(() -> Region_15.paste(file, pastePoint, pasteOptions), 15));
}
private static EditSession paste(Clipboard clipboard, Point pastePoint, PasteOptions pasteOptions) {
return VersionedCallable.call(new VersionedCallable<>(() -> Region_15.paste(clipboard, pastePoint, pasteOptions), 15));
}
2021-04-20 08:20:53 +02:00
public boolean isGlobal() {
return this == GlobalRegion.getInstance();
}
2021-04-18 18:20:27 +02:00
}