2020-08-23 08:52:36 -04:00
|
|
|
package com.flemmli97.flan.claim;
|
|
|
|
|
|
|
|
import com.flemmli97.flan.IClaimData;
|
2020-08-23 17:18:18 -04:00
|
|
|
import com.flemmli97.flan.config.ConfigHandler;
|
|
|
|
import com.flemmli97.flan.player.EnumDisplayType;
|
2020-08-24 15:03:06 -04:00
|
|
|
import com.flemmli97.flan.player.EnumEditMode;
|
2020-08-23 08:52:36 -04:00
|
|
|
import com.flemmli97.flan.player.PlayerClaimData;
|
|
|
|
import com.google.common.collect.ImmutableSet;
|
|
|
|
import com.google.common.collect.Lists;
|
|
|
|
import com.google.common.collect.Maps;
|
|
|
|
import com.google.common.collect.Sets;
|
|
|
|
import com.google.gson.JsonArray;
|
|
|
|
import com.google.gson.JsonObject;
|
|
|
|
import com.ibm.icu.impl.Pair;
|
|
|
|
import it.unimi.dsi.fastutil.longs.Long2ObjectArrayMap;
|
|
|
|
import net.minecraft.server.MinecraftServer;
|
2020-09-02 09:19:31 -04:00
|
|
|
import net.minecraft.server.command.ServerCommandSource;
|
2020-08-23 17:18:18 -04:00
|
|
|
import net.minecraft.server.network.ServerPlayerEntity;
|
2020-08-23 08:52:36 -04:00
|
|
|
import net.minecraft.server.world.ServerWorld;
|
2020-09-02 09:19:31 -04:00
|
|
|
import net.minecraft.text.ClickEvent;
|
|
|
|
import net.minecraft.text.HoverEvent;
|
|
|
|
import net.minecraft.text.MutableText;
|
|
|
|
import net.minecraft.text.TranslatableText;
|
2020-08-24 15:03:06 -04:00
|
|
|
import net.minecraft.util.Formatting;
|
2020-08-23 08:52:36 -04:00
|
|
|
import net.minecraft.util.WorldSavePath;
|
|
|
|
import net.minecraft.util.math.BlockPos;
|
|
|
|
import net.minecraft.util.math.ChunkPos;
|
|
|
|
import net.minecraft.util.registry.RegistryKey;
|
|
|
|
import net.minecraft.world.World;
|
|
|
|
import net.minecraft.world.dimension.DimensionType;
|
|
|
|
import org.yaml.snakeyaml.Yaml;
|
|
|
|
|
|
|
|
import java.io.File;
|
|
|
|
import java.io.FileReader;
|
|
|
|
import java.io.FileWriter;
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.util.Collection;
|
2020-09-01 16:59:12 -04:00
|
|
|
import java.util.EnumSet;
|
2020-08-23 08:52:36 -04:00
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.Set;
|
|
|
|
import java.util.UUID;
|
|
|
|
|
|
|
|
public class ClaimStorage {
|
|
|
|
|
2020-09-02 09:19:31 -04:00
|
|
|
public static final String adminClaimString = "!AdminClaims";
|
2020-08-25 15:06:36 -04:00
|
|
|
private final Long2ObjectArrayMap<List<Claim>> claims = new Long2ObjectArrayMap<>();
|
|
|
|
private final Map<UUID, Claim> claimUUIDMap = Maps.newHashMap();
|
|
|
|
private final Map<UUID, Set<Claim>> playerClaimMap = Maps.newHashMap();
|
2020-09-02 09:19:31 -04:00
|
|
|
private final Set<UUID> dirty = Sets.newHashSet();
|
2020-09-02 09:36:58 -04:00
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
public static ClaimStorage get(ServerWorld world) {
|
|
|
|
return (ClaimStorage) ((IClaimData) world).getClaimData();
|
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
public ClaimStorage(MinecraftServer server, ServerWorld world) {
|
|
|
|
this.read(server, world);
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public UUID generateUUID() {
|
|
|
|
UUID uuid = UUID.randomUUID();
|
|
|
|
if (this.claimUUIDMap.containsKey(uuid))
|
|
|
|
return generateUUID();
|
|
|
|
return uuid;
|
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
public boolean createClaim(BlockPos pos1, BlockPos pos2, ServerPlayerEntity player) {
|
|
|
|
Claim claim = new Claim(pos1.down(ConfigHandler.config.defaultClaimDepth), pos2.down(ConfigHandler.config.defaultClaimDepth), player.getUuid(), player.getServerWorld());
|
|
|
|
Set<Claim> conflicts = conflicts(claim, null);
|
|
|
|
if (conflicts.isEmpty()) {
|
2020-08-23 08:52:36 -04:00
|
|
|
PlayerClaimData data = PlayerClaimData.get(player);
|
2020-08-25 13:43:52 -04:00
|
|
|
if (claim.getPlane() < ConfigHandler.config.minClaimsize) {
|
2020-08-24 15:03:06 -04:00
|
|
|
player.sendMessage(PermHelper.simpleColoredText(String.format(ConfigHandler.lang.minClaimSize, ConfigHandler.config.minClaimsize), Formatting.RED), false);
|
2020-08-23 08:52:36 -04:00
|
|
|
return false;
|
2020-08-24 15:03:06 -04:00
|
|
|
}
|
|
|
|
if (!data.canUseClaimBlocks(claim.getPlane())) {
|
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.notEnoughBlocks, Formatting.RED), false);
|
|
|
|
return false;
|
|
|
|
}
|
2020-08-23 08:52:36 -04:00
|
|
|
claim.setClaimID(this.generateUUID());
|
|
|
|
this.addClaim(claim);
|
2020-08-24 16:19:09 -04:00
|
|
|
data.addDisplayClaim(claim, EnumDisplayType.MAIN, player.getBlockPos().getY());
|
2020-08-24 15:03:06 -04:00
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.claimCreateSuccess, Formatting.GOLD), false);
|
2020-08-23 08:52:36 -04:00
|
|
|
return true;
|
|
|
|
}
|
2020-08-24 16:32:29 -04:00
|
|
|
PlayerClaimData data = PlayerClaimData.get(player);
|
2020-08-25 13:43:52 -04:00
|
|
|
conflicts.forEach(conf -> data.addDisplayClaim(conf, EnumDisplayType.CONFLICT, player.getBlockPos().getY()));
|
2020-08-24 15:03:06 -04:00
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.conflictOther, Formatting.RED), false);
|
2020-08-23 08:52:36 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
private Set<Claim> conflicts(Claim claim, Claim except) {
|
|
|
|
Set<Claim> conflicted = Sets.newHashSet();
|
2020-08-23 08:52:36 -04:00
|
|
|
int[] chunks = getChunkPos(claim);
|
|
|
|
for (int x = chunks[0]; x <= chunks[1]; x++)
|
|
|
|
for (int z = chunks[2]; z <= chunks[3]; z++) {
|
2020-09-15 07:54:24 -04:00
|
|
|
List<Claim> claims = this.claims.get(ChunkPos.toLong(x, z));
|
2020-08-23 08:52:36 -04:00
|
|
|
if (claims != null)
|
|
|
|
for (Claim other : claims) {
|
2020-08-24 15:03:06 -04:00
|
|
|
if (claim.intersects(other) && !other.equals(except)) {
|
2020-08-24 16:32:29 -04:00
|
|
|
conflicted.add(other);
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-08-24 15:03:06 -04:00
|
|
|
return conflicted;
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
public boolean deleteClaim(Claim claim, boolean updateClaim, EnumEditMode mode, ServerWorld world) {
|
2020-08-25 13:43:52 -04:00
|
|
|
if (mode == EnumEditMode.SUBCLAIM) {
|
|
|
|
if (claim.parentClaim() != null)
|
2020-08-24 15:03:06 -04:00
|
|
|
return claim.parentClaim().deleteSubClaim(claim);
|
|
|
|
return false;
|
|
|
|
}
|
2020-08-25 13:43:52 -04:00
|
|
|
if (updateClaim)
|
2020-08-24 15:03:06 -04:00
|
|
|
claim.remove();
|
2020-08-23 08:52:36 -04:00
|
|
|
int[] pos = getChunkPos(claim);
|
|
|
|
for (int x = pos[0]; x <= pos[1]; x++)
|
|
|
|
for (int z = pos[2]; z <= pos[3]; z++) {
|
2020-09-15 07:54:24 -04:00
|
|
|
this.claims.compute(ChunkPos.toLong(x, z), (key, val) -> {
|
2020-08-23 08:52:36 -04:00
|
|
|
if (val == null)
|
|
|
|
return null;
|
|
|
|
val.remove(claim);
|
|
|
|
return val.isEmpty() ? null : val;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
this.playerClaimMap.getOrDefault(claim.getOwner(), Sets.newHashSet()).remove(claim);
|
2020-09-02 09:19:31 -04:00
|
|
|
this.dirty.add(claim.getOwner());
|
2020-08-23 08:52:36 -04:00
|
|
|
return this.claimUUIDMap.remove(claim.getClaimID()) != null;
|
|
|
|
}
|
|
|
|
|
2020-09-02 09:36:58 -04:00
|
|
|
public void toggleAdminClaim(ServerPlayerEntity player, Claim claim, boolean toggle) {
|
2020-09-02 09:19:31 -04:00
|
|
|
this.deleteClaim(claim, false, EnumEditMode.DEFAULT, player.getServerWorld());
|
|
|
|
claim.toggleAdminClaim(player, toggle);
|
|
|
|
this.addClaim(claim);
|
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
public boolean resizeClaim(Claim claim, BlockPos from, BlockPos to, ServerPlayerEntity player) {
|
2020-08-25 13:43:52 -04:00
|
|
|
int[] dims = claim.getDimensions();
|
|
|
|
BlockPos opposite = new BlockPos(dims[0] == from.getX() ? dims[1] : dims[0], dims[4], dims[2] == from.getZ() ? dims[3] : dims[2]);
|
2020-08-24 15:03:06 -04:00
|
|
|
Claim newClaim = new Claim(opposite, to, player.getUuid(), player.getServerWorld());
|
|
|
|
Set<Claim> conflicts = conflicts(newClaim, claim);
|
2020-08-25 13:43:52 -04:00
|
|
|
if (!conflicts.isEmpty()) {
|
|
|
|
conflicts.forEach(conf -> PlayerClaimData.get(player).addDisplayClaim(conf, EnumDisplayType.CONFLICT, player.getBlockPos().getY()));
|
2020-08-24 15:03:06 -04:00
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.conflictOther, Formatting.RED), false);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
PlayerClaimData data = PlayerClaimData.get(player);
|
2020-08-25 13:43:52 -04:00
|
|
|
int diff = newClaim.getPlane() - claim.getPlane();
|
|
|
|
if (data.canUseClaimBlocks(diff)) {
|
2020-08-24 15:03:06 -04:00
|
|
|
this.deleteClaim(claim, false, EnumEditMode.DEFAULT, player.getServerWorld());
|
|
|
|
claim.copySizes(newClaim);
|
|
|
|
this.addClaim(claim);
|
2020-08-24 16:19:09 -04:00
|
|
|
data.addDisplayClaim(claim, EnumDisplayType.MAIN, player.getBlockPos().getY());
|
2020-08-24 15:03:06 -04:00
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.resizeSuccess, Formatting.GOLD), false);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
player.sendMessage(PermHelper.simpleColoredText(ConfigHandler.lang.notEnoughBlocks, Formatting.RED), false);
|
2020-08-23 08:52:36 -04:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
public Claim getClaimAt(BlockPos pos) {
|
2020-09-15 07:54:24 -04:00
|
|
|
long chunk = ChunkPos.toLong(pos.getX()>>4, pos.getZ()>>4);
|
2020-08-23 08:52:36 -04:00
|
|
|
if (this.claims.containsKey(chunk))
|
|
|
|
for (Claim claim : this.claims.get(chunk)) {
|
|
|
|
if (claim.insideClaim(pos))
|
|
|
|
return claim;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2020-08-25 15:06:36 -04:00
|
|
|
public Claim getFromUUID(UUID uuid) {
|
|
|
|
return this.claimUUIDMap.get(uuid);
|
|
|
|
}
|
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
private void addClaim(Claim claim) {
|
|
|
|
int[] pos = getChunkPos(claim);
|
|
|
|
for (int x = pos[0]; x <= pos[1]; x++)
|
|
|
|
for (int z = pos[2]; z <= pos[3]; z++) {
|
2020-09-15 07:54:24 -04:00
|
|
|
this.claims.merge(ChunkPos.toLong(x, z), Lists.newArrayList(claim), (old, val) -> {
|
2020-08-23 17:18:18 -04:00
|
|
|
old.add(claim);
|
|
|
|
return old;
|
2020-08-23 08:52:36 -04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
this.claimUUIDMap.put(claim.getClaimID(), claim);
|
2020-08-23 17:18:18 -04:00
|
|
|
this.playerClaimMap.merge(claim.getOwner(), Sets.newHashSet(claim), (old, val) -> {
|
|
|
|
old.add(claim);
|
|
|
|
return old;
|
2020-08-23 08:52:36 -04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-09-03 12:00:37 -04:00
|
|
|
public boolean transferOwner(Claim claim, ServerPlayerEntity player, UUID newOwner) {
|
|
|
|
if (!player.getUuid().equals(claim.getOwner()))
|
|
|
|
return false;
|
|
|
|
this.playerClaimMap.merge(claim.getOwner(), Sets.newHashSet(), (old, val) -> {
|
|
|
|
old.remove(claim);
|
|
|
|
return old;
|
|
|
|
});
|
|
|
|
this.dirty.add(claim.getOwner());
|
|
|
|
claim.transferOwner(newOwner);
|
|
|
|
this.playerClaimMap.merge(claim.getOwner(), Sets.newHashSet(claim), (old, val) -> {
|
|
|
|
old.add(claim);
|
|
|
|
return old;
|
|
|
|
});
|
|
|
|
this.dirty.add(claim.getOwner());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
public Collection<Claim> allClaimsFromPlayer(UUID player) {
|
|
|
|
return this.playerClaimMap.containsKey(player) ? ImmutableSet.copyOf(this.playerClaimMap.get(player)) : ImmutableSet.of();
|
|
|
|
}
|
|
|
|
|
2020-09-02 09:36:58 -04:00
|
|
|
public Collection<Claim> getAdminClaims() {
|
2020-09-02 09:19:31 -04:00
|
|
|
return ImmutableSet.copyOf(this.playerClaimMap.get(null));
|
2020-08-25 15:06:36 -04:00
|
|
|
}
|
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
public static int[] getChunkPos(Claim claim) {
|
|
|
|
int[] dim = claim.getDimensions();
|
|
|
|
int[] pos = new int[4];
|
|
|
|
pos[0] = dim[0] >> 4;
|
|
|
|
pos[1] = dim[1] >> 4;
|
|
|
|
pos[2] = dim[2] >> 4;
|
|
|
|
pos[3] = dim[3] >> 4;
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2020-08-24 15:03:06 -04:00
|
|
|
public void read(MinecraftServer server, ServerWorld world) {
|
|
|
|
File dir = new File(DimensionType.getSaveDirectory(world.getRegistryKey(), server.getSavePath(WorldSavePath.ROOT).toFile()), "/data/claims/");
|
2020-08-23 08:52:36 -04:00
|
|
|
if (dir.exists()) {
|
|
|
|
try {
|
|
|
|
for (File file : dir.listFiles()) {
|
|
|
|
if (!file.getName().endsWith(".json"))
|
|
|
|
continue;
|
2020-09-02 09:19:31 -04:00
|
|
|
String realName = file.getName().replace(".json", "");
|
2020-09-02 09:36:58 -04:00
|
|
|
UUID uuid = realName.equals(adminClaimString) ? null : UUID.fromString(file.getName().replace(".json", ""));
|
2020-08-23 08:52:36 -04:00
|
|
|
FileReader reader = new FileReader(file);
|
2020-08-23 17:18:18 -04:00
|
|
|
JsonArray arr = ConfigHandler.GSON.fromJson(reader, JsonArray.class);
|
2020-08-23 08:52:36 -04:00
|
|
|
if (arr == null)
|
|
|
|
continue;
|
|
|
|
arr.forEach(el -> {
|
|
|
|
if (el.isJsonObject()) {
|
2020-08-24 15:03:06 -04:00
|
|
|
this.addClaim(Claim.fromJson((JsonObject) el, uuid, world));
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
});
|
|
|
|
reader.close();
|
|
|
|
}
|
|
|
|
} catch (IOException e) {
|
2020-08-25 13:43:52 -04:00
|
|
|
e.printStackTrace();
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public void save(MinecraftServer server, RegistryKey<World> reg) {
|
|
|
|
File dir = new File(DimensionType.getSaveDirectory(reg, server.getSavePath(WorldSavePath.ROOT).toFile()), "/data/claims/");
|
|
|
|
if (!dir.exists())
|
|
|
|
dir.mkdir();
|
|
|
|
try {
|
|
|
|
for (Map.Entry<UUID, Set<Claim>> e : this.playerClaimMap.entrySet()) {
|
2020-09-02 09:36:58 -04:00
|
|
|
String owner = e.getKey() == null ? adminClaimString : e.getKey().toString();
|
2020-09-02 09:19:31 -04:00
|
|
|
File file = new File(dir, owner + ".json");
|
2020-08-24 15:03:06 -04:00
|
|
|
boolean dirty = false;
|
2020-08-23 08:52:36 -04:00
|
|
|
if (!file.exists()) {
|
|
|
|
if (e.getValue().isEmpty())
|
|
|
|
continue;
|
|
|
|
file.createNewFile();
|
2020-08-24 15:03:06 -04:00
|
|
|
dirty = true;
|
2020-08-25 13:43:52 -04:00
|
|
|
} else {
|
2020-09-15 07:54:24 -04:00
|
|
|
if (this.dirty.remove(owner.equals(adminClaimString) ? null : e.getKey())) {
|
2020-09-02 09:19:31 -04:00
|
|
|
dirty = true;
|
2020-09-02 09:36:58 -04:00
|
|
|
} else {
|
2020-09-02 09:19:31 -04:00
|
|
|
for (Claim claim : e.getValue())
|
|
|
|
if (claim.isDirty()) {
|
|
|
|
dirty = true;
|
|
|
|
claim.setDirty(false);
|
|
|
|
}
|
|
|
|
}
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
2020-08-25 13:43:52 -04:00
|
|
|
if (dirty) {
|
2020-08-24 16:19:09 -04:00
|
|
|
JsonArray arr = new JsonArray();
|
2020-08-24 15:03:06 -04:00
|
|
|
e.getValue().forEach(claim -> arr.add(claim.toJson(new JsonObject())));
|
2020-08-26 10:39:13 -04:00
|
|
|
FileWriter writer = new FileWriter(file);
|
2020-08-24 16:19:09 -04:00
|
|
|
ConfigHandler.GSON.toJson(arr, writer);
|
|
|
|
writer.close();
|
|
|
|
}
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
} catch (IOException e) {
|
2020-08-25 13:43:52 -04:00
|
|
|
e.printStackTrace();
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-02 09:19:31 -04:00
|
|
|
public static void readGriefPreventionData(MinecraftServer server, ServerCommandSource src) {
|
2020-08-23 08:52:36 -04:00
|
|
|
Yaml yml = new Yaml();
|
2020-08-24 15:03:06 -04:00
|
|
|
File griefPrevention = server.getSavePath(WorldSavePath.ROOT).resolve("plugins/GriefPreventionData/ClaimData").toFile();
|
2020-08-23 08:52:36 -04:00
|
|
|
if (!griefPrevention.exists())
|
2020-09-02 09:19:31 -04:00
|
|
|
return;
|
2020-08-23 08:52:36 -04:00
|
|
|
Map<File, List<File>> subClaimMap = Maps.newHashMap();
|
|
|
|
Map<Integer, File> intFileMap = Maps.newHashMap();
|
|
|
|
|
2020-09-01 16:59:12 -04:00
|
|
|
EnumSet<EnumPermission> managers = EnumSet.complementOf(EnumSet.of(EnumPermission.EDITCLAIM));
|
|
|
|
EnumSet<EnumPermission> builders = EnumSet.complementOf(EnumSet.of(EnumPermission.EDITPERMS, EnumPermission.EDITCLAIM));
|
|
|
|
EnumSet<EnumPermission> containers = EnumSet.complementOf(EnumSet.of(EnumPermission.EDITPERMS, EnumPermission.EDITCLAIM,
|
|
|
|
EnumPermission.BREAK, EnumPermission.PLACE, EnumPermission.NOTEBLOCK, EnumPermission.REDSTONE, EnumPermission.JUKEBOX,
|
|
|
|
EnumPermission.ITEMFRAMEROTATE, EnumPermission.LECTERNTAKE, EnumPermission.ENDCRYSTALPLACE, EnumPermission.PROJECTILES,
|
|
|
|
EnumPermission.TRAMPLE, EnumPermission.RAID, EnumPermission.BUCKET, EnumPermission.ARMORSTAND, EnumPermission.BREAKNONLIVING));
|
|
|
|
EnumSet<EnumPermission> accessors = EnumSet.complementOf(EnumSet.of(EnumPermission.EDITPERMS, EnumPermission.EDITCLAIM,
|
|
|
|
EnumPermission.BREAK, EnumPermission.PLACE, EnumPermission.OPENCONTAINER, EnumPermission.ANVIL, EnumPermission.BEACON,
|
|
|
|
EnumPermission.NOTEBLOCK, EnumPermission.REDSTONE, EnumPermission.JUKEBOX, EnumPermission.ITEMFRAMEROTATE,
|
|
|
|
EnumPermission.LECTERNTAKE, EnumPermission.ENDCRYSTALPLACE, EnumPermission.PROJECTILES, EnumPermission.TRAMPLE, EnumPermission.RAID,
|
|
|
|
EnumPermission.BUCKET, EnumPermission.ANIMALINTERACT, EnumPermission.HURTANIMAL, EnumPermission.TRADING, EnumPermission.ARMORSTAND,
|
|
|
|
EnumPermission.BREAKNONLIVING));
|
2020-09-02 09:19:31 -04:00
|
|
|
Map<String, EnumSet<EnumPermission>> perms = Maps.newHashMap();
|
|
|
|
perms.put("managers", managers);
|
|
|
|
perms.put("builders", builders);
|
|
|
|
perms.put("containers", containers);
|
|
|
|
perms.put("accessors", accessors);
|
2020-09-01 16:59:12 -04:00
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
try {
|
|
|
|
//Get all parent claims
|
|
|
|
for (File f : griefPrevention.listFiles()) {
|
|
|
|
if (f.getName().endsWith(".yml")) {
|
|
|
|
FileReader reader = new FileReader(f);
|
|
|
|
Map<String, Object> values = yml.load(reader);
|
2020-08-23 09:16:26 -04:00
|
|
|
if (values.get("Parent Claim ID").equals(-1)) {
|
2020-08-26 10:39:13 -04:00
|
|
|
try {
|
|
|
|
intFileMap.put(Integer.valueOf(f.getName().replace(".yml", "")), f);
|
2020-09-02 09:36:58 -04:00
|
|
|
} catch (NumberFormatException e) {
|
2020-09-02 09:19:31 -04:00
|
|
|
src.sendFeedback(PermHelper.simpleColoredText(String.format(ConfigHandler.lang.errorFile, f.getName(), Formatting.RED)), false);
|
2020-08-26 10:39:13 -04:00
|
|
|
}
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//Map child to parent claims
|
|
|
|
for (File f : griefPrevention.listFiles()) {
|
|
|
|
if (f.getName().endsWith(".yml")) {
|
|
|
|
FileReader reader = new FileReader(f);
|
|
|
|
Map<String, Object> values = yml.load(reader);
|
2020-08-23 09:16:26 -04:00
|
|
|
if (!values.get("Parent Claim ID").equals(-1)) {
|
2020-08-23 08:52:36 -04:00
|
|
|
subClaimMap.merge(intFileMap.get(Integer.valueOf(values.get("Parent Claim ID").toString()))
|
|
|
|
, Lists.newArrayList(f), (key, val) -> {
|
2020-08-26 10:39:13 -04:00
|
|
|
key.add(f);
|
|
|
|
return key;
|
2020-08-23 08:52:36 -04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (File parent : intFileMap.values()) {
|
2020-09-02 09:19:31 -04:00
|
|
|
try {
|
|
|
|
Pair<ServerWorld, Claim> parentClaim = parseFromYaml(parent, yml, server, perms);
|
|
|
|
List<File> childs = subClaimMap.get(parent);
|
|
|
|
if (childs != null && !childs.isEmpty()) {
|
|
|
|
for (File childF : childs)
|
|
|
|
parentClaim.second.addSubClaimGriefprevention(parseFromYaml(childF, yml, server, perms).second);
|
|
|
|
}
|
|
|
|
ClaimStorage storage = ClaimStorage.get(parentClaim.first);
|
|
|
|
Set<Claim> conflicts = storage.conflicts(parentClaim.second, null);
|
|
|
|
if (conflicts.isEmpty()) {
|
|
|
|
parentClaim.second.setClaimID(storage.generateUUID());
|
|
|
|
storage.addClaim(parentClaim.second);
|
|
|
|
} else {
|
|
|
|
src.sendFeedback(PermHelper.simpleColoredText(String.format(ConfigHandler.lang.readConflict, parent.getName(), conflicts), Formatting.DARK_RED), false);
|
2020-09-02 09:36:58 -04:00
|
|
|
for (Claim claim : conflicts) {
|
2020-09-02 09:19:31 -04:00
|
|
|
int[] dim = claim.getDimensions();
|
|
|
|
MutableText text = PermHelper.simpleColoredText(String.format("@[x=%d;z=%d]", dim[0], dim[2]), Formatting.RED);
|
|
|
|
text.setStyle(text.getStyle().withClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/tp @s " + dim[0] + " ~ " + dim[2])).withHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new TranslatableText("chat.coordinates.tooltip"))));
|
|
|
|
src.sendFeedback(text, false);
|
|
|
|
}
|
|
|
|
}
|
2020-09-02 09:36:58 -04:00
|
|
|
} catch (Exception e) {
|
2020-09-02 09:19:31 -04:00
|
|
|
src.sendFeedback(PermHelper.simpleColoredText(String.format(ConfigHandler.lang.errorFile, parent.getName(), Formatting.RED)), false);
|
|
|
|
e.printStackTrace();
|
2020-08-26 10:39:13 -04:00
|
|
|
}
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
} catch (IOException e) {
|
2020-08-25 13:43:52 -04:00
|
|
|
e.printStackTrace();
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-02 09:19:31 -04:00
|
|
|
private static Pair<ServerWorld, Claim> parseFromYaml(File file, Yaml yml, MinecraftServer server,
|
2020-09-02 09:36:58 -04:00
|
|
|
Map<String, EnumSet<EnumPermission>> perms) throws IOException {
|
2020-08-23 08:52:36 -04:00
|
|
|
FileReader reader = new FileReader(file);
|
|
|
|
Map<String, Object> values = yml.load(reader);
|
|
|
|
reader.close();
|
2020-09-02 09:19:31 -04:00
|
|
|
String ownerString = (String) values.get("Owner");
|
|
|
|
|
2020-09-02 09:36:58 -04:00
|
|
|
UUID owner = ownerString.isEmpty() ? null : UUID.fromString(ownerString);
|
2020-09-02 09:19:31 -04:00
|
|
|
List<String> builders = readList(values, "Builders");
|
|
|
|
List<String> managers = readList(values, "Managers");
|
|
|
|
List<String> containers = readList(values, "Containers");
|
|
|
|
List<String> accessors = readList(values, "Accessors");
|
2020-08-23 08:52:36 -04:00
|
|
|
String[] lesserCorner = values.get("Lesser Boundary Corner").toString().split(";");
|
|
|
|
String[] greaterCorner = values.get("Greater Boundary Corner").toString().split(";");
|
2020-08-24 15:03:06 -04:00
|
|
|
ServerWorld world = server.getWorld(worldRegFromString(lesserCorner[0]));
|
2020-08-23 08:52:36 -04:00
|
|
|
Claim claim = new Claim(Integer.parseInt(lesserCorner[1]), Integer.parseInt(greaterCorner[1]),
|
2020-09-02 09:36:58 -04:00
|
|
|
Integer.parseInt(lesserCorner[3]), Integer.parseInt(greaterCorner[3]), ConfigHandler.config.defaultClaimDepth == 255 ? 0 :
|
2020-08-24 15:03:06 -04:00
|
|
|
Integer.parseInt(lesserCorner[2]), owner, world);
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!builders.isEmpty() && !builders.contains(ownerString)) {
|
|
|
|
if (builders.contains("public")) {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("builders").forEach(perm -> {
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!perm.isAlwaysGlobalPerm())
|
2020-09-02 09:19:31 -04:00
|
|
|
claim.editGlobalPerms(perm, 1);
|
|
|
|
});
|
2020-09-02 09:36:58 -04:00
|
|
|
} else {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("builders").forEach(perm -> claim.editPerms(null, "Builders", perm, 1, true));
|
|
|
|
builders.forEach(s -> claim.setPlayerGroup(UUID.fromString(s), "Builders", true));
|
|
|
|
}
|
|
|
|
}
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!managers.isEmpty() && !managers.contains(ownerString)) {
|
|
|
|
if (managers.contains("public")) {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("managers").forEach(perm -> {
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!perm.isAlwaysGlobalPerm())
|
2020-09-02 09:19:31 -04:00
|
|
|
claim.editGlobalPerms(perm, 1);
|
|
|
|
});
|
2020-09-02 09:36:58 -04:00
|
|
|
} else {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("managers").forEach(perm -> claim.editPerms(null, "Managers", perm, 1, true));
|
|
|
|
managers.forEach(s -> claim.setPlayerGroup(UUID.fromString(s), "Managers", true));
|
|
|
|
}
|
|
|
|
}
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!containers.isEmpty() && !containers.contains(ownerString)) {
|
|
|
|
if (containers.contains("public")) {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("containers").forEach(perm -> {
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!perm.isAlwaysGlobalPerm())
|
2020-09-02 09:19:31 -04:00
|
|
|
claim.editGlobalPerms(perm, 1);
|
|
|
|
});
|
2020-09-02 09:36:58 -04:00
|
|
|
} else {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("containers").forEach(perm -> claim.editPerms(null, "Containers", perm, 1, true));
|
|
|
|
containers.forEach(s -> claim.setPlayerGroup(UUID.fromString(s), "Containers", true));
|
|
|
|
}
|
|
|
|
}
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!accessors.isEmpty() && !accessors.contains(ownerString)) {
|
|
|
|
if (accessors.contains("public")) {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("accessors").forEach(perm -> {
|
2020-09-02 09:36:58 -04:00
|
|
|
if (!perm.isAlwaysGlobalPerm())
|
2020-09-02 09:19:31 -04:00
|
|
|
claim.editGlobalPerms(perm, 1);
|
|
|
|
});
|
2020-09-02 09:36:58 -04:00
|
|
|
} else {
|
2020-09-02 09:19:31 -04:00
|
|
|
perms.get("accessors").forEach(perm -> claim.editPerms(null, "Accessors", perm, 1, true));
|
|
|
|
accessors.forEach(s -> claim.setPlayerGroup(UUID.fromString(s), "Accessors", true));
|
|
|
|
}
|
|
|
|
}
|
2020-08-24 15:03:06 -04:00
|
|
|
return Pair.of(world, claim);
|
2020-08-23 08:52:36 -04:00
|
|
|
}
|
|
|
|
|
2020-09-02 09:36:58 -04:00
|
|
|
private static <T> List<T> readList(Map<String, Object> values, String key) {
|
2020-09-02 09:19:31 -04:00
|
|
|
Object obj = values.get(key);
|
2020-09-02 09:36:58 -04:00
|
|
|
if (obj instanceof List)
|
2020-09-02 09:19:31 -04:00
|
|
|
return (List<T>) obj;
|
|
|
|
return Lists.newArrayList();
|
|
|
|
}
|
|
|
|
|
2020-08-23 08:52:36 -04:00
|
|
|
public static RegistryKey<World> worldRegFromString(String spigot) {
|
|
|
|
if (spigot.equals("world_the_end"))
|
|
|
|
return World.END;
|
|
|
|
if (spigot.equals("world_nether"))
|
|
|
|
return World.NETHER;
|
|
|
|
return World.OVERWORLD;
|
|
|
|
}
|
|
|
|
}
|