From d5f79a91dc2d8475aeb848901132433855617530 Mon Sep 17 00:00:00 2001 From: Lixfel Date: Sun, 10 Nov 2019 17:31:30 +0100 Subject: [PATCH] Refitting vor new Core + 1.14 support --- SchematicSystem_12/pom.xml | 55 +++++++ .../schematicsystem/CheckSchemType_v12.java | 105 +++---------- .../schematicsystem/WorldEdit_v12.java | 64 ++++++++ SchematicSystem_14/pom.xml | 48 ++++++ .../schematicsystem/CheckSchemType_v14.java | 145 ++++++++++++++++++ .../schematicsystem/WorldEdit_v14.java | 66 ++++++++ SchematicSystem_API/pom.xml | 28 ++++ .../steamwar/schematicsystem/Constants.java | 29 ++++ .../schematicsystem/ICheckSchemType.java | 16 ++ SchematicSystem_Main/pom.xml | 86 +++++++++++ .../schematicsystem/CheckSchemType.java | 113 ++++++++++++++ .../schematicsystem/SchematicSystem.java | 8 +- .../steamwar/schematicsystem/WorldEdit.java | 43 ++++++ .../schematicsystem/check/CheckSession.java | 14 +- .../schematicsystem/check/CheckUtils.java | 14 +- .../commands/CheckCommand.java | 33 ++-- .../schematicsystem/commands/GUI.java | 61 ++++---- .../commands/SchematicCommand.java | 116 +++++--------- .../PlayerCommandPreProcessListener.java | 0 .../listener/PlayerJoinListener.java | 16 +- .../listener/PlayerQuitListener.java | 0 {src => SchematicSystem_Main/src}/plugin.yml | 2 +- pom.xml | 43 ++---- src/config.yml | 41 ----- .../utils/CheckedSchematic.java | 102 ------------ .../schematicsystem/utils/CommandRemover.java | 43 ------ 26 files changed, 828 insertions(+), 463 deletions(-) create mode 100644 SchematicSystem_12/pom.xml rename src/de/steamwar/schematicsystem/CheckSchemType.java => SchematicSystem_12/src/de/steamwar/schematicsystem/CheckSchemType_v12.java (57%) create mode 100644 SchematicSystem_12/src/de/steamwar/schematicsystem/WorldEdit_v12.java create mode 100644 SchematicSystem_14/pom.xml create mode 100644 SchematicSystem_14/src/de/steamwar/schematicsystem/CheckSchemType_v14.java create mode 100644 SchematicSystem_14/src/de/steamwar/schematicsystem/WorldEdit_v14.java create mode 100644 SchematicSystem_API/pom.xml create mode 100644 SchematicSystem_API/src/de/steamwar/schematicsystem/Constants.java create mode 100644 SchematicSystem_API/src/de/steamwar/schematicsystem/ICheckSchemType.java create mode 100644 SchematicSystem_Main/pom.xml create mode 100644 SchematicSystem_Main/src/de/steamwar/schematicsystem/CheckSchemType.java rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/SchematicSystem.java (86%) create mode 100644 SchematicSystem_Main/src/de/steamwar/schematicsystem/WorldEdit.java rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/check/CheckSession.java (88%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/check/CheckUtils.java (87%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/commands/CheckCommand.java (79%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/commands/GUI.java (74%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/commands/SchematicCommand.java (77%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/listener/PlayerCommandPreProcessListener.java (100%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/listener/PlayerJoinListener.java (80%) rename {src => SchematicSystem_Main/src}/de/steamwar/schematicsystem/listener/PlayerQuitListener.java (100%) rename {src => SchematicSystem_Main/src}/plugin.yml (76%) delete mode 100644 src/config.yml delete mode 100644 src/de/steamwar/schematicsystem/utils/CheckedSchematic.java delete mode 100644 src/de/steamwar/schematicsystem/utils/CommandRemover.java diff --git a/SchematicSystem_12/pom.xml b/SchematicSystem_12/pom.xml new file mode 100644 index 0000000..db8635d --- /dev/null +++ b/SchematicSystem_12/pom.xml @@ -0,0 +1,55 @@ + + + 4.0.0 + + SchematicSystem_12 + 1.0 + + + steamwar + SchematicSystem + 1.0 + + + + src + + + src + + **/*.java + **/*.kt + + + + + + + + steamwar + Spigot-1.12 + 1.0 + provided + + + steamwar + WorldEdit + 1.0 + provided + + + steamwar + FAWE + 1.0 + provided + + + steamwar + SchematicSystem_API + 1.0 + compile + + + \ No newline at end of file diff --git a/src/de/steamwar/schematicsystem/CheckSchemType.java b/SchematicSystem_12/src/de/steamwar/schematicsystem/CheckSchemType_v12.java similarity index 57% rename from src/de/steamwar/schematicsystem/CheckSchemType.java rename to SchematicSystem_12/src/de/steamwar/schematicsystem/CheckSchemType_v12.java index de98b5a..dd32e41 100644 --- a/src/de/steamwar/schematicsystem/CheckSchemType.java +++ b/SchematicSystem_12/src/de/steamwar/schematicsystem/CheckSchemType_v12.java @@ -6,20 +6,19 @@ import com.sk89q.worldedit.Vector; import com.sk89q.worldedit.blocks.BaseBlock; import com.sk89q.worldedit.extent.clipboard.Clipboard; import com.sk89q.worldedit.regions.Region; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SteamwarUser; import org.bukkit.Bukkit; import org.bukkit.Material; -import org.bukkit.configuration.ConfigurationSection; import java.io.File; import java.io.IOException; -import java.util.*; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import java.util.logging.Level; -public class CheckSchemType { - +class CheckSchemType_v12 { private static final int TNT = Material.TNT.getId(); private static final int SLIME = Material.SLIME_BLOCK.getId(); private static final int DISPENSER = Material.DISPENSER.getId(); @@ -65,57 +64,13 @@ public class CheckSchemType { FLOWERS = flowers; } - private static final Map types = new EnumMap<>(SchematicType.class); + private CheckSchemType_v12(){} - private final String name; - - private final int width; - private final int height; - private final int depth; - - private final int maxTNT; - private final int maxSlime; - private final int maxTNTSlime; - private final int maxDispenser; - private final int maxDispenserItems; - private final List forbiddenIds; - private final LinkedList checkList; - - CheckSchemType(ConfigurationSection section) { - name = section.getName(); - width = section.getInt("width"); - height = section.getInt("height"); - depth = section.getInt("depth"); - - maxTNT = section.getInt("maxTNT"); - maxSlime = section.getInt("maxSlime"); - maxTNTSlime = section.getInt("maxTNTSlime"); - maxDispenser = section.getInt("maxDispenser"); - maxDispenserItems = section.getInt("maxDispenserItems"); - - forbiddenIds = section.getIntegerList("forbiddenIds"); - checkList = new LinkedList<>(section.getStringList("checkList")); - types.put(SchematicType.fromDB(name), this); - types.put(SchematicType.fromDB("c" + name), this); - } - - public static CheckSchemType get(SchematicType type){ - return types.get(type); - } - - public LinkedList getCheckList() { - return checkList; - } - - public SchematicType getAcceptedType(){ - return SchematicType.fromDB(name); - } - - public void autoCheck(Schematic schematic, List errors, List warnings) { + static void autoCheck(Schematic schematic, List errors, List warnings, ICheckSchemType type) { Clipboard clipboard; try { - clipboard = FaweAPI.load(new File(SchematicSystem.SCHEM_DIR + WarkingUser.get(schematic.getSchemOwner()).getUUID(), schematic.getSchemName() + ".schematic")).getClipboard(); + clipboard = FaweAPI.load(new File(Constants.SCHEM_DIR + SteamwarUser.get(schematic.getSchemOwner()).getUUID(), schematic.getSchemName() + ".schematic")).getClipboard(); if(clipboard == null) throw new IOException(); } catch (IOException e) { @@ -126,8 +81,8 @@ public class CheckSchemType { Vector dimensions = clipboard.getDimensions(); - if(dimensions.getBlockX() > width || dimensions.getBlockY() > height || dimensions.getBlockZ() > depth) - errors.add("Das " + name + " überschreitet die Maximalmaße"); + if(dimensions.getBlockX() > type.getWidth() || dimensions.getBlockY() > type.getHeight() || dimensions.getBlockZ() > type.getDepth()) + errors.add("Das " + type.getName() + " überschreitet die Maximalmaße"); Region region = clipboard.getRegion(); Vector min = region.getMinimumPoint(); @@ -153,19 +108,19 @@ public class CheckSchemType { dispenser++; if(INVENTORY.contains(blockId)){ - checkInventory(errors, warnings, block, blockId); + checkInventory(errors, warnings, block, blockId, type); } - if(forbiddenIds.contains(blockId)) + if(type.getForbidden().contains(Material.getMaterial(blockId).name())) errors.add("Der Block " + Material.getMaterial(blockId).name() + " ist verboten"); } } } - finalChecks(errors, tnt, slime, dispenser); + type.finalChecks(errors, tnt, slime, dispenser); } - private void checkInventory(List errors, List warnings, BaseBlock block, int blockId){ + private static void checkInventory(List errors, List warnings, BaseBlock block, int blockId, ICheckSchemType type){ CompoundTag nbt = block.getNbtData(); if(nbt == null){ warnings.add("Ein(e) " + Material.getMaterial(blockId).name() + " ist defekt"); @@ -188,31 +143,19 @@ public class CheckSchemType { continue; } - Material type = Material.getMaterial(item.getString("id").split(":")[1].toUpperCase().replace("SHOVEL", "SPADE")); - if(type == null && item.getString("id").equals("minecraft:fire_charge")) - type = Material.FIREBALL; - if(type == null) //Leere Slots + Material t = Material.getMaterial(item.getString("id").split(":")[1].toUpperCase().replace("SHOVEL", "SPADE")); + if(t == null && item.getString("id").equals("minecraft:fire_charge")) + t = Material.FIREBALL; + if(t == null) //Leere Slots continue; - if(blockId == DISPENSER && (type.equals(Material.FIREBALL) || type.equals(Material.ARROW))) + if(blockId == DISPENSER && (t.equals(Material.FIREBALL) || t.equals(Material.ARROW))) counter += item.getByte("Count"); - else if(!FLOWERS.contains(type) && !(blockId == CHEST && type.equals(Material.TNT))) - errors.add("In einem/r " + Material.getMaterial(blockId).name() + " ist das verbotene Item " + type); + else if(!FLOWERS.contains(t) && !(blockId == CHEST && t.equals(Material.TNT))) + errors.add("In einem/r " + Material.getMaterial(blockId).name() + " ist das verbotene Item " + t); } - if(counter > maxDispenserItems) - errors.add("Ein Werfer enthält mehr als " + maxDispenserItems + " Pfeile und Feuerbälle"); - } - - private void finalChecks(List errors, int tnt, int slime, int dispenser){ - int tntSlime = tnt + slime; - if(maxTNT != 0 && tnt > maxTNT) - errors.add("Zu viele TNT-Blöcke"); - if(maxSlime != 0 && slime > maxSlime) - errors.add("Zu viele Schleim-Blöcke"); - if(maxDispenser != 0 && dispenser > maxDispenser) - errors.add("Zu viele Werfer"); - if(maxTNTSlime != 0 && tntSlime > maxTNTSlime) - errors.add("Zu viel Schleim+TNT"); + if(counter > type.getMaxDispenserItems()) + errors.add("Ein Werfer enthält mehr als " + type.getMaxDispenserItems() + " Pfeile und Feuerbälle"); } } diff --git a/SchematicSystem_12/src/de/steamwar/schematicsystem/WorldEdit_v12.java b/SchematicSystem_12/src/de/steamwar/schematicsystem/WorldEdit_v12.java new file mode 100644 index 0000000..9031000 --- /dev/null +++ b/SchematicSystem_12/src/de/steamwar/schematicsystem/WorldEdit_v12.java @@ -0,0 +1,64 @@ +package de.steamwar.schematicsystem; + +import com.boydti.fawe.FaweAPI; +import com.boydti.fawe.object.schematic.Schematic; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.EmptyClipboardException; +import com.sk89q.worldedit.Vector; +import com.sk89q.worldedit.bukkit.BukkitWorld; +import com.sk89q.worldedit.bukkit.WorldEditPlugin; +import com.sk89q.worldedit.extension.platform.Actor; +import com.sk89q.worldedit.extent.clipboard.Clipboard; +import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat; +import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.session.ClipboardHolder; +import com.sk89q.worldedit.world.World; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; + +class WorldEdit_v12 { + + static void saveSchematic(Player player, String name) throws IOException, EmptyClipboardException { + ClipboardHolder clipboardHolder = FaweAPI.wrapPlayer(player).getSession().getClipboard(); + Clipboard clipboard = clipboardHolder.getClipboard(); + if(clipboard == null) + throw new EmptyClipboardException(); + + File folder = new File(Constants.SCHEM_DIR + player.getUniqueId().toString()); + if(!folder.exists()){ + folder.mkdir(); + Files.setPosixFilePermissions(folder.toPath(), Constants.FOLDER_PERMS); + } + + File file = new File(folder, name + ".schematic"); + file.createNewFile(); + Files.setPosixFilePermissions(file.toPath(), Constants.FILE_PERMS); + Region region = clipboard.getRegion(); + Schematic schem = new Schematic(region); + schem.save(file, ClipboardFormat.SCHEMATIC); + } + + static void loadClipboardToPlayer(Player player, Clipboard clipboard){ + Actor actor = getWorldEditPlugin().wrapCommandSender(player); + getWorldEditPlugin().getWorldEdit().getSessionManager().get(actor).setClipboard(new ClipboardHolder(clipboard, FaweAPI.getWorld(player.getWorld().getName()).getWorldData())); + } + + static EditSession pasteSchematic(Player player, Schematic schematic){ + World weWorld = new BukkitWorld(player.getWorld()); + Location playerLocation = player.getLocation(); + Vector vector = new Vector(playerLocation.getBlockX(), playerLocation.getBlockY(), playerLocation.getBlockZ()); + Vector offset = new Vector(schematic.getClipboard().getRegion().getMinimumPoint()).subtract(schematic.getClipboard().getOrigin()); + Vector dimensions = schematic.getClipboard().getDimensions(); + Vector v = vector.subtract(dimensions.getX()/2 - dimensions.getX()%2, 0, dimensions.getZ()).subtract(offset); + return schematic.paste(weWorld, v); + } + + private static WorldEditPlugin getWorldEditPlugin() { + return (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"); + } +} diff --git a/SchematicSystem_14/pom.xml b/SchematicSystem_14/pom.xml new file mode 100644 index 0000000..cb64822 --- /dev/null +++ b/SchematicSystem_14/pom.xml @@ -0,0 +1,48 @@ + + + 4.0.0 + + SchematicSystem_14 + 1.0 + + + steamwar + SchematicSystem + 1.0 + + + + src + + + src + + **/*.java + **/*.kt + + + + + + + + steamwar + SchematicSystem_API + 1.0 + + + steamwar + Spigot-1.14 + 1.0 + provided + + + steamwar + FAWE + 1.14 + provided + + + \ No newline at end of file diff --git a/SchematicSystem_14/src/de/steamwar/schematicsystem/CheckSchemType_v14.java b/SchematicSystem_14/src/de/steamwar/schematicsystem/CheckSchemType_v14.java new file mode 100644 index 0000000..c3ddc15 --- /dev/null +++ b/SchematicSystem_14/src/de/steamwar/schematicsystem/CheckSchemType_v14.java @@ -0,0 +1,145 @@ +package de.steamwar.schematicsystem; + +import com.boydti.fawe.FaweAPI; +import com.sk89q.jnbt.CompoundTag; +import com.sk89q.worldedit.extent.clipboard.Clipboard; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.world.block.BaseBlock; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SteamwarUser; +import org.bukkit.Bukkit; +import org.bukkit.Material; + +import java.io.File; +import java.io.IOException; +import java.util.EnumSet; +import java.util.List; +import java.util.Set; +import java.util.logging.Level; + +class CheckSchemType_v14 { + private static final Set INVENTORY = EnumSet.of( + Material.CHEST, + Material.TRAPPED_CHEST, + Material.HOPPER, + Material.FURNACE, + Material.DROPPER, + Material.JUKEBOX, + Material.DISPENSER, + Material.ANVIL, + Material.BREWING_STAND, + Material.BLACK_SHULKER_BOX, + Material.RED_SHULKER_BOX, + Material.WHITE_SHULKER_BOX, + Material.ORANGE_SHULKER_BOX, + Material.BLUE_SHULKER_BOX, + Material.LIGHT_BLUE_SHULKER_BOX, + Material.YELLOW_SHULKER_BOX, + Material.GREEN_SHULKER_BOX, + Material.BROWN_SHULKER_BOX, + Material.CYAN_SHULKER_BOX, + Material.GRAY_SHULKER_BOX, + Material.LIGHT_GRAY_SHULKER_BOX, + Material.LIME_SHULKER_BOX, + Material.MAGENTA_SHULKER_BOX, + Material.PINK_SHULKER_BOX, + Material.PURPLE_SHULKER_BOX); + //TODO: New Inventory Items + //TODO: Adding flowers + private static final Set FLOWERS = EnumSet.of( + Material.CORNFLOWER); + + private CheckSchemType_v14(){} + + static void autoCheck(Schematic schematic, List errors, List warnings, ICheckSchemType type) { + Clipboard clipboard; + + try { + clipboard = FaweAPI.load(new File(Constants.SCHEM_DIR + SteamwarUser.get(schematic.getSchemOwner()).getUUID(), schematic.getSchemName() + ".schematic")).getClipboard(); + if(clipboard == null) + throw new IOException(); + } catch (IOException e) { + Bukkit.getLogger().log(Level.SEVERE, "Schematic could not be loaded", e); + errors.add("Die Schematic konnte nicht geladen werden"); + return; + } + + BlockVector3 dimensions = clipboard.getDimensions(); + + if(dimensions.getBlockX() > type.getWidth() || dimensions.getBlockY() > type.getHeight() || dimensions.getBlockZ() > type.getDepth()) + errors.add("Das " + type.getName() + " überschreitet die Maximalmaße"); + + Region region = clipboard.getRegion(); + BlockVector3 min = region.getMinimumPoint(); + BlockVector3 max = region.getMaximumPoint(); + + int tnt = 0; + int slime = 0; + int dispenser = 0; + + for(int x = min.getBlockX(); x <= max.getBlockX(); x++){ + for(int y = min.getBlockY(); y <= max.getBlockY(); y++){ + for(int z = min.getBlockZ(); z <= max.getBlockZ(); z++){ + final BaseBlock block = clipboard.getFullBlock(BlockVector3.at(x, y, z)); + final Material blockMaterial = Material.matchMaterial(block.getBlockType().getId()); + + if(blockMaterial == Material.TNT) + tnt++; + + if(blockMaterial == Material.SLIME_BLOCK) + slime++; + + if(blockMaterial == Material.DISPENSER) + dispenser++; + + if(INVENTORY.contains(blockMaterial)){ + checkInventory(errors, warnings, block, blockMaterial, type); + } + + if(type.getForbidden().contains(blockMaterial.name())) + errors.add("Der Block " + blockMaterial.name() + " ist verboten"); + } + } + } + + type.finalChecks(errors, tnt, slime, dispenser); + } + + private static void checkInventory(List errors, List warnings, BaseBlock block, Material blockMaterial, ICheckSchemType type){ + CompoundTag nbt = block.getNbtData(); + if(nbt == null){ + warnings.add("Ein(e) " + blockMaterial.name() + " ist defekt"); + return; + } + + if(blockMaterial == Material.JUKEBOX && nbt.getValue().containsKey("RecordItem")){ + errors.add("Schallplatten sind auch nicht in Schallplattenspielern gestattet"); + return; + } + + List items = nbt.getList("Items", CompoundTag.class); + if(items.isEmpty()) + return; //Leeres Inventar + + int counter = 0; + for(CompoundTag item : items){ + if(!item.containsKey("id")){ + warnings.add("Ein(e) " + blockMaterial.name() + " ist defekt"); + continue; + } + + Material t = Material.matchMaterial(item.getString("id")); + if(t == null) //Leere Slots + continue; + + if(blockMaterial == Material.DISPENSER && (t.equals(Material.FIRE_CHARGE) || t.equals(Material.ARROW))) + counter += item.getByte("Count"); + else if(!FLOWERS.contains(t) && !(blockMaterial == Material.CHEST && t.equals(Material.TNT))) + errors.add("In einem/r " + blockMaterial.name() + " ist das verbotene Item " + t); + } + + if(counter > type.getMaxDispenserItems()) + errors.add("Ein Werfer enthält mehr als " + type.getMaxDispenserItems() + " Pfeile und Feuerbälle"); + } +} diff --git a/SchematicSystem_14/src/de/steamwar/schematicsystem/WorldEdit_v14.java b/SchematicSystem_14/src/de/steamwar/schematicsystem/WorldEdit_v14.java new file mode 100644 index 0000000..dad1da1 --- /dev/null +++ b/SchematicSystem_14/src/de/steamwar/schematicsystem/WorldEdit_v14.java @@ -0,0 +1,66 @@ +package de.steamwar.schematicsystem; + +import com.boydti.fawe.FaweAPI; +import com.boydti.fawe.object.schematic.Schematic; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.EmptyClipboardException; +import com.sk89q.worldedit.bukkit.BukkitWorld; +import com.sk89q.worldedit.bukkit.WorldEditPlugin; +import com.sk89q.worldedit.extension.platform.Actor; +import com.sk89q.worldedit.extent.clipboard.Clipboard; +import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.session.ClipboardHolder; +import com.sk89q.worldedit.world.World; +import org.bukkit.Bukkit; +import org.bukkit.Location; +import org.bukkit.entity.Player; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; + +class WorldEdit_v14 { + private WorldEdit_v14(){} + + static void saveSchematic(Player player, String name) throws IOException, EmptyClipboardException { + ClipboardHolder clipboardHolder = FaweAPI.wrapPlayer(player).getSession().getClipboard(); + Clipboard clipboard = clipboardHolder.getClipboard(); + if(clipboard == null) + throw new EmptyClipboardException(); + + File folder = new File(Constants.SCHEM_DIR + player.getUniqueId().toString()); + if(!folder.exists()){ + folder.mkdir(); + Files.setPosixFilePermissions(folder.toPath(), Constants.FOLDER_PERMS); + } + + File file = new File(folder, name + ".schematic"); + file.createNewFile(); + Files.setPosixFilePermissions(file.toPath(), Constants.FILE_PERMS); + + Region region = clipboard.getRegion(); + Schematic schem = new Schematic(region); + schem.save(file, ClipboardFormats.findByExtension("schem")); + } + + static void loadClipboardToPlayer(Player player, Clipboard clipboard){ + Actor actor = getWorldEditPlugin().wrapCommandSender(player); + getWorldEditPlugin().getWorldEdit().getSessionManager().get(actor).setClipboard(new ClipboardHolder(clipboard)); + } + + static EditSession pasteSchematic(Player player, Schematic schematic){ + World weWorld = new BukkitWorld(player.getWorld()); + Location playerLocation = player.getLocation(); + BlockVector3 vector = BlockVector3.at(playerLocation.getBlockX(), playerLocation.getBlockY(), playerLocation.getBlockZ()); + BlockVector3 offset = schematic.getClipboard().getRegion().getMinimumPoint().subtract(schematic.getClipboard().getOrigin()); + BlockVector3 dimensions = schematic.getClipboard().getDimensions(); + BlockVector3 v = vector.subtract(dimensions.getX()/2 - dimensions.getX()%2, 0, dimensions.getZ()).subtract(offset); + return schematic.paste(weWorld, v); + } + + private static WorldEditPlugin getWorldEditPlugin() { + return (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"); + } +} diff --git a/SchematicSystem_API/pom.xml b/SchematicSystem_API/pom.xml new file mode 100644 index 0000000..9cbe30a --- /dev/null +++ b/SchematicSystem_API/pom.xml @@ -0,0 +1,28 @@ + + + 4.0.0 + + + steamwar + SchematicSystem + 1.0 + + + SchematicSystem_API + 1.0 + + + src + + + src + + **/*.java + **/*.kt + + + + + \ No newline at end of file diff --git a/SchematicSystem_API/src/de/steamwar/schematicsystem/Constants.java b/SchematicSystem_API/src/de/steamwar/schematicsystem/Constants.java new file mode 100644 index 0000000..ea0cec0 --- /dev/null +++ b/SchematicSystem_API/src/de/steamwar/schematicsystem/Constants.java @@ -0,0 +1,29 @@ +package de.steamwar.schematicsystem; + +import java.nio.file.attribute.PosixFilePermission; +import java.util.EnumSet; +import java.util.Set; + +public class Constants { + private Constants(){} + + public static final Set FILE_PERMS = EnumSet.of( + PosixFilePermission.OWNER_READ, + PosixFilePermission.OWNER_WRITE, + PosixFilePermission.GROUP_READ, + PosixFilePermission.GROUP_WRITE, + PosixFilePermission.OTHERS_READ, + PosixFilePermission.OTHERS_WRITE); + public static final Set FOLDER_PERMS = EnumSet.of( + PosixFilePermission.OWNER_READ, + PosixFilePermission.OWNER_WRITE, + PosixFilePermission.GROUP_READ, + PosixFilePermission.GROUP_WRITE, + PosixFilePermission.OTHERS_READ, + PosixFilePermission.OTHERS_WRITE, + PosixFilePermission.OWNER_EXECUTE, + PosixFilePermission.GROUP_EXECUTE, + PosixFilePermission.OTHERS_EXECUTE); + + public static final String SCHEM_DIR = "/home/minecraft/schematics/"; +} diff --git a/SchematicSystem_API/src/de/steamwar/schematicsystem/ICheckSchemType.java b/SchematicSystem_API/src/de/steamwar/schematicsystem/ICheckSchemType.java new file mode 100644 index 0000000..8ec60dc --- /dev/null +++ b/SchematicSystem_API/src/de/steamwar/schematicsystem/ICheckSchemType.java @@ -0,0 +1,16 @@ +package de.steamwar.schematicsystem; + +import java.util.List; + +interface ICheckSchemType { + String getName(); + + int getWidth(); + int getHeight(); + int getDepth(); + int getMaxDispenserItems(); + + List getForbidden(); + + void finalChecks(List errors, int tnt, int slime, int dispenser); +} diff --git a/SchematicSystem_Main/pom.xml b/SchematicSystem_Main/pom.xml new file mode 100644 index 0000000..24d475f --- /dev/null +++ b/SchematicSystem_Main/pom.xml @@ -0,0 +1,86 @@ + + + 4.0.0 + + + steamwar + SchematicSystem + 1.0 + + + SchematicSystem_Main + 1.0 + jar + + + src + + + src + + **/*.java + **/*.kt + + + + + + maven-assembly-plugin + + + package + + single + + + + + + jar-with-dependencies + + + + + + + + + steamwar + Spigot-1.12 + 1.0 + provided + + + steamwar + FAWE + 1.0 + provided + + + steamwar + WorldEdit + 1.0 + provided + + + steamwar + SchematicSystem_14 + 1.0 + compile + + + steamwar + SchematicSystem_12 + 1.0 + compile + + + steamwar + SchematicSystem_API + 1.0 + compile + + + \ No newline at end of file diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/CheckSchemType.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/CheckSchemType.java new file mode 100644 index 0000000..6b05ad4 --- /dev/null +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/CheckSchemType.java @@ -0,0 +1,113 @@ +package de.steamwar.schematicsystem; + +import de.steamwar.core.Core; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SchematicType; +import org.bukkit.configuration.ConfigurationSection; + +import java.util.EnumMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +public class CheckSchemType implements ICheckSchemType { + + private static final Map types = new EnumMap<>(SchematicType.class); + + private final String name; + + private final int width; + private final int height; + private final int depth; + private final int maxDispenserItems; + private final List forbiddenMaterials; + + private final int maxTNT; + private final int maxSlime; + private final int maxTNTSlime; + private final int maxDispenser; + private final LinkedList checkList; + + CheckSchemType(ConfigurationSection section) { + name = section.getName(); + width = section.getInt("width"); + height = section.getInt("height"); + depth = section.getInt("depth"); + + maxTNT = section.getInt("maxTNT"); + maxSlime = section.getInt("maxSlime"); + maxTNTSlime = section.getInt("maxTNTSlime"); + maxDispenser = section.getInt("maxDispenser"); + maxDispenserItems = section.getInt("maxDispenserItems"); + + forbiddenMaterials = section.getStringList("forbiddenMaterials"); + checkList = new LinkedList<>(section.getStringList("checkList")); + types.put(SchematicType.fromDB(name), this); + types.put(SchematicType.fromDB("c" + name), this); + } + + public static CheckSchemType get(SchematicType type){ + return types.get(type); + } + + public List getCheckList() { + return checkList; + } + + public SchematicType getAcceptedType(){ + return SchematicType.fromDB(name); + } + + public void autoCheck(Schematic schematic, List errors, List warnings) { + switch(Core.getVersion()){ + case 14: + CheckSchemType_v14.autoCheck(schematic, errors, warnings, this); + break; + default: + CheckSchemType_v12.autoCheck(schematic, errors, warnings, this); + } + } + + @Override + public void finalChecks(List errors, int tnt, int slime, int dispenser){ + int tntSlime = tnt + slime; + if(maxTNT != 0 && tnt > maxTNT) + errors.add("Zu viele TNT-Blöcke"); + if(maxSlime != 0 && slime > maxSlime) + errors.add("Zu viele Schleim-Blöcke"); + if(maxDispenser != 0 && dispenser > maxDispenser) + errors.add("Zu viele Werfer"); + if(maxTNTSlime != 0 && tntSlime > maxTNTSlime) + errors.add("Zu viel Schleim+TNT"); + } + + @Override + public String getName() { + return name; + } + + @Override + public int getWidth() { + return width; + } + + @Override + public int getHeight() { + return height; + } + + @Override + public int getDepth() { + return depth; + } + + @Override + public int getMaxDispenserItems() { + return maxDispenserItems; + } + + @Override + public List getForbidden() { + return forbiddenMaterials; + } +} diff --git a/src/de/steamwar/schematicsystem/SchematicSystem.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java similarity index 86% rename from src/de/steamwar/schematicsystem/SchematicSystem.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java index b13ec5b..f1a0dd0 100644 --- a/src/de/steamwar/schematicsystem/SchematicSystem.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java @@ -1,13 +1,12 @@ package de.steamwar.schematicsystem; -import com.sk89q.worldedit.bukkit.WorldEditPlugin; +import de.steamwar.core.CommandRemover; import de.steamwar.schematicsystem.check.CheckUtils; import de.steamwar.schematicsystem.commands.CheckCommand; import de.steamwar.schematicsystem.commands.SchematicCommand; import de.steamwar.schematicsystem.listener.PlayerCommandPreProcessListener; import de.steamwar.schematicsystem.listener.PlayerJoinListener; import de.steamwar.schematicsystem.listener.PlayerQuitListener; -import de.steamwar.schematicsystem.utils.CommandRemover; import org.bukkit.Bukkit; import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.file.FileConfiguration; @@ -18,7 +17,6 @@ import java.io.File; public class SchematicSystem extends JavaPlugin { - public static final String SCHEM_DIR = "/home/minecraft/schematics/"; public static final String PREFIX = "§eSchematic§8» §7"; @Override @@ -50,8 +48,4 @@ public class SchematicSystem extends JavaPlugin { CheckUtils.sendTeamMembersCSchematics(CheckUtils.sendTeamMembersCSchematicsInfo()); }, 0, 6000); } - - public static WorldEditPlugin getWorldEditPlugin() { - return (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"); - } } diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/WorldEdit.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/WorldEdit.java new file mode 100644 index 0000000..22825db --- /dev/null +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/WorldEdit.java @@ -0,0 +1,43 @@ +package de.steamwar.schematicsystem; + +import com.boydti.fawe.object.schematic.Schematic; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.EmptyClipboardException; +import com.sk89q.worldedit.extent.clipboard.Clipboard; +import de.steamwar.core.Core; +import org.bukkit.entity.Player; + +import java.io.IOException; + +public class WorldEdit { + private WorldEdit(){} + + public static void saveSchematic(Player player, String name) throws IOException, EmptyClipboardException { + switch(Core.getVersion()){ + case 14: + WorldEdit_v14.saveSchematic(player, name); + break; + default: + WorldEdit_v12.saveSchematic(player, name); + } + } + + public static void loadClipboardToPlayer(Player player, Clipboard clipboard){ + switch(Core.getVersion()){ + case 14: + WorldEdit_v14.loadClipboardToPlayer(player, clipboard); + break; + default: + WorldEdit_v12.loadClipboardToPlayer(player, clipboard); + } + } + + public static EditSession pasteSchematic(Player player, Schematic schematic){ + switch(Core.getVersion()){ + case 14: + return WorldEdit_v14.pasteSchematic(player, schematic); + default: + return WorldEdit_v12.pasteSchematic(player, schematic); + } + } +} diff --git a/src/de/steamwar/schematicsystem/check/CheckSession.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckSession.java similarity index 88% rename from src/de/steamwar/schematicsystem/check/CheckSession.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckSession.java index 8c7f8e6..69bfbd4 100644 --- a/src/de/steamwar/schematicsystem/check/CheckSession.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckSession.java @@ -3,10 +3,10 @@ package de.steamwar.schematicsystem.check; import com.sk89q.worldedit.EditSession; import de.steamwar.schematicsystem.CheckSchemType; import de.steamwar.schematicsystem.SchematicSystem; -import de.steamwar.schematicsystem.utils.CheckedSchematic; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.CheckedSchematic; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SchematicType; +import de.steamwar.sql.SteamwarUser; import net.md_5.bungee.api.ChatColor; import net.md_5.bungee.api.chat.ClickEvent; import net.md_5.bungee.api.chat.TextComponent; @@ -58,9 +58,9 @@ public class CheckSession { public void sendNextCheck() { if(!checkList.hasNext()){ - Bukkit.getPlayer(uuid).sendMessage(SchematicSystem.PREFIX + "§aDie Schematic §e" + schematic.getSchemName() + " §avon §e" + WarkingUser.get(schematic.getSchemOwner()).getUserName() + " §aist nun freigegeben!"); + Bukkit.getPlayer(uuid).sendMessage(SchematicSystem.PREFIX + "§aDie Schematic §e" + schematic.getSchemName() + " §avon §e" + SteamwarUser.get(schematic.getSchemOwner()).getUserName() + " §aist nun freigegeben!"); schematic.setSchemType(CheckSchemType.get(schematic.getSchemType()).getAcceptedType()); - new CheckedSchematic(this.schematic.getSchemName(), this.schematic.getSchemOwner(), WarkingUser.get(this.uuid).getId(), this.startTime, this.stopTime, "freigegeben"); + new CheckedSchematic(this.schematic.getSchemName(), this.schematic.getSchemOwner(), SteamwarUser.get(this.uuid).getId(), this.startTime, this.stopTime, "freigegeben"); removeSchematic(); return; @@ -98,7 +98,7 @@ public class CheckSession { public void declineSchematic(String declineReason) { schematic.setSchemType(SchematicType.Normal); - new CheckedSchematic(this.schematic.getSchemName(), this.schematic.getSchemOwner(), WarkingUser.get(this.uuid).getId(), this.startTime, this.stopTime, declineReason); + new CheckedSchematic(this.schematic.getSchemName(), this.schematic.getSchemOwner(), SteamwarUser.get(this.uuid).getId(), this.startTime, this.stopTime, declineReason); removeSchematic(); } diff --git a/src/de/steamwar/schematicsystem/check/CheckUtils.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckUtils.java similarity index 87% rename from src/de/steamwar/schematicsystem/check/CheckUtils.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckUtils.java index 8807c43..90893a9 100644 --- a/src/de/steamwar/schematicsystem/check/CheckUtils.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/check/CheckUtils.java @@ -1,10 +1,10 @@ package de.steamwar.schematicsystem.check; import de.steamwar.schematicsystem.SchematicSystem; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.UserGroup; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SchematicType; +import de.steamwar.sql.SteamwarUser; +import de.steamwar.sql.UserGroup; import net.md_5.bungee.api.chat.ClickEvent; import net.md_5.bungee.api.chat.ComponentBuilder; import net.md_5.bungee.api.chat.HoverEvent; @@ -30,7 +30,7 @@ public class CheckUtils { } public static boolean allowedToCheck(Player player) { - WarkingUser warkingUser = WarkingUser.get(player.getUniqueId()); + SteamwarUser warkingUser = SteamwarUser.get(player.getUniqueId()); return warkingUser.getUserGroup() == UserGroup.Supporter || warkingUser.getUserGroup() == UserGroup.Developer || warkingUser.getUserGroup() == UserGroup.Moderator || @@ -83,10 +83,10 @@ public class CheckUtils { player.sendMessage("§e" + schematicList.size() + " ungeprüfte Schematics"); for(Schematic schematic : schematicList) { - TextComponent schematics = new TextComponent("§8" + schematic.getSchemType().getKuerzel() + " §7" + WarkingUser.get(schematic.getSchemOwner()).getUserName() + " §e" + schematic.getSchemName()); + TextComponent schematics = new TextComponent("§8" + schematic.getSchemType().getKuerzel() + " §7" + SteamwarUser.get(schematic.getSchemOwner()).getUserName() + " §e" + schematic.getSchemName()); schematics.setBold(true); schematics.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder("Schematic prüfen").create())); - schematics.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check schematic " + schematic.getSchemName() + " " + WarkingUser.get(schematic.getSchemOwner()).getUserName())); + schematics.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check schematic " + schematic.getSchemName() + " " + SteamwarUser.get(schematic.getSchemOwner()).getUserName())); player.spigot().sendMessage(schematics); } } diff --git a/src/de/steamwar/schematicsystem/commands/CheckCommand.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/CheckCommand.java similarity index 79% rename from src/de/steamwar/schematicsystem/commands/CheckCommand.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/CheckCommand.java index 666a600..5b63aa5 100644 --- a/src/de/steamwar/schematicsystem/commands/CheckCommand.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/CheckCommand.java @@ -1,16 +1,14 @@ package de.steamwar.schematicsystem.commands; import com.boydti.fawe.FaweAPI; -import com.sk89q.worldedit.Vector; -import com.sk89q.worldedit.bukkit.BukkitWorld; -import com.sk89q.worldedit.world.World; +import de.steamwar.schematicsystem.Constants; import de.steamwar.schematicsystem.SchematicSystem; +import de.steamwar.schematicsystem.WorldEdit; import de.steamwar.schematicsystem.check.CheckSession; import de.steamwar.schematicsystem.check.CheckUtils; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SteamwarUser; import org.bukkit.Bukkit; -import org.bukkit.Location; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; @@ -66,7 +64,7 @@ public class CheckCommand implements CommandExecutor { return false; } - WarkingUser user = WarkingUser.get(args[2]); + SteamwarUser user = SteamwarUser.get(args[2]); if(user.getUUID() == null){ player.sendMessage(SchematicSystem.PREFIX + "§cUnbekannter Benutzer"); return false; @@ -79,7 +77,7 @@ public class CheckCommand implements CommandExecutor { }else if(!schematic.getSchemType().check()){ player.sendMessage(SchematicSystem.PREFIX + "§cSchematic ist nicht zu prüfen"); return false; - }else if(schematic.getSchemOwner() == WarkingUser.get(player.getUniqueId()).getId()) { + }else if(schematic.getSchemOwner() == SteamwarUser.get(player.getUniqueId()).getId()) { player.sendMessage(SchematicSystem.PREFIX + "§cDu kannst nicht deine eigenen Schematics prüfen"); return false; } @@ -87,16 +85,16 @@ public class CheckCommand implements CommandExecutor { List worldPlayers = player.getWorld().getPlayers(); for(Player players : worldPlayers) { if(!players.getUniqueId().toString().equals(player.getWorld().getName())) { - WarkingUser warkingUsers = WarkingUser.get(players.getUniqueId()); + SteamwarUser warkingUsers = SteamwarUser.get(players.getUniqueId()); if(!CheckUtils.allowedToCheck(players) && - !warkingUsers.getUUID().toString().equals(WarkingUser.get(schematic.getSchemOwner()).getUUID().toString())) { + !warkingUsers.getUUID().toString().equals(SteamwarUser.get(schematic.getSchemOwner()).getUUID().toString())) { player.sendMessage(SchematicSystem.PREFIX + "§cZum Prüfen darf sich kein Unbeteiligter auf deinem Bauserver befinden!"); return false; } } } - File file = new File(SchematicSystem.SCHEM_DIR + user.getUUID().toString(),schematic.getSchemName() + ".schematic"); + File file = new File(Constants.SCHEM_DIR + user.getUUID().toString(),schematic.getSchemName() + ".schematic"); if(!file.exists()) { player.sendMessage(SchematicSystem.PREFIX + "§cDie Schematic gibts nicht?!?!"); return false; @@ -104,19 +102,10 @@ public class CheckCommand implements CommandExecutor { try { com.boydti.fawe.object.schematic.Schematic schematicFAWE = FaweAPI.load(file); - Location playerLocation = player.getLocation(); - - World weWorld = new BukkitWorld(player.getWorld()); - Vector vector = new Vector(playerLocation.getBlockX(), playerLocation.getBlockY(), playerLocation.getBlockZ()); - Vector offset = new Vector(schematicFAWE.getClipboard().getRegion().getMinimumPoint()).subtract(schematicFAWE.getClipboard().getOrigin()); - Vector v; - Vector dimensions = schematicFAWE.getClipboard().getDimensions(); - v = vector.subtract(dimensions.getX()/2 - dimensions.getX()%2, 0, dimensions.getZ()).subtract(offset); - checkSession = new CheckSession(player.getUniqueId(), schematic); checkSession.sendNextCheck(); - checkSession.setEditSession(schematicFAWE.paste(weWorld, v)); + checkSession.setEditSession(WorldEdit.pasteSchematic(player, schematicFAWE)); } catch (IOException ex) { player.sendMessage(SchematicSystem.PREFIX + "§cSchematic konnte nicht geladen/gepastet werden"); Bukkit.getLogger().log(Level.SEVERE, "Failed to load schematic", ex); @@ -135,7 +124,7 @@ public class CheckCommand implements CommandExecutor { StringBuilder message = new StringBuilder(); for (int i = 1; i < args.length; i++) message.append(args[i]).append(" "); - player.sendMessage(SchematicSystem.PREFIX + "§aDie Schematic §6" + checkSession.getSchematic().getSchemName() + " §avon §6" + WarkingUser.get(checkSession.getSchematic().getSchemOwner()).getUserName() + " §awurde aufgrund von §6" + message + " §anicht freigegeben!"); + player.sendMessage(SchematicSystem.PREFIX + "§aDie Schematic §6" + checkSession.getSchematic().getSchemName() + " §avon §6" + SteamwarUser.get(checkSession.getSchematic().getSchemOwner()).getUserName() + " §awurde aufgrund von §6" + message + " §anicht freigegeben!"); checkSession.declineSchematic(message.toString()); break; default: diff --git a/src/de/steamwar/schematicsystem/commands/GUI.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java similarity index 74% rename from src/de/steamwar/schematicsystem/commands/GUI.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java index b6db76b..5c7b52e 100644 --- a/src/de/steamwar/schematicsystem/commands/GUI.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java @@ -3,12 +3,9 @@ package de.steamwar.schematicsystem.commands; import de.steamwar.inventory.SWInventory; import de.steamwar.inventory.SWItem; import de.steamwar.inventory.SWListInv; +import de.steamwar.schematicsystem.Constants; import de.steamwar.schematicsystem.SchematicSystem; -import de.steamwar.schematicsystem.utils.CheckedSchematic; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicMember; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.*; import javafx.util.Pair; import org.bukkit.Bukkit; import org.bukkit.Material; @@ -18,7 +15,10 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.SkullMeta; import java.io.File; -import java.util.*; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; class GUI { private GUI(){} @@ -29,7 +29,7 @@ class GUI { if(!type.isAssignable()) continue; - SWItem item = new SWItem(Material.STONE_BUTTON, type.name()); + SWItem item = new SWItem(SWItem.getMaterial("STONE_BUTTON"), type.name()); if(type.fightType()) item.setEnchanted(true); @@ -46,8 +46,8 @@ class GUI { static void delete(Player p, Schematic schem){ SWInventory inv = new SWInventory(p, 9, schem.getSchemName() + " löschen"); - inv.setItem(0, Material.INK_SACK, (byte) 1, "§eLöschen", click -> { - File file = new File(SchematicSystem.SCHEM_DIR + p.getUniqueId(), schem.getSchemName() + ".schematic"); + inv.setItem(0, SWItem.getDye(1), (byte) 1, "§eLöschen", click -> { + File file = new File(Constants.SCHEM_DIR + p.getUniqueId(), schem.getSchemName() + ".schematic"); file.delete(); schem.remove(); @@ -60,7 +60,7 @@ class GUI { p.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + schem.getSchemName() + " §7gelöscht"); p.closeInventory(); }); - inv.setItem(8, Material.INK_SACK, (byte) 14, "§cAbbruch", click -> p.closeInventory()); + inv.setItem(8, SWItem.getDye(14), (byte) 14, "§cAbbruch", click -> p.closeInventory()); inv.setCallback(-999, click -> p.closeInventory()); inv.open(); } @@ -68,17 +68,8 @@ class GUI { static void delmembers(Player p, Schematic schem){ List> members = new LinkedList<>(); for(SchematicMember member : SchematicMember.getSchemMembers(schem.getSchemName(), schem.getSchemOwner())){ - WarkingUser user = WarkingUser.get(member.getMember()); - - SWItem item = new SWItem(); - ItemStack head = new ItemStack(Material.SKULL_ITEM, 1, (short)3); - SkullMeta headmeta = (SkullMeta)head.getItemMeta(); - headmeta.setOwningPlayer(Bukkit.getOfflinePlayer(user.getUUID())); - headmeta.setDisplayName(user.getUserName()); - head.setItemMeta(headmeta); - item.setItemStack(head); - - members.add(new Pair<>(item, member)); + SteamwarUser user = SteamwarUser.get(member.getMember()); + members.add(new Pair<>(SWItem.getPlayerSkull(Bukkit.getOfflinePlayer(user.getUUID())), member)); } SWListInv inv = new SWListInv<>(p, "Mitglieder entfernen", (clickType, member) -> { @@ -109,48 +100,48 @@ class GUI { private static void info(Player p, Schematic schem){ SWInventory inv = new SWInventory(p, 9, schem.getSchemName()); - inv.setItem(0, Material.WOOD_AXE, "§eLaden", click -> { + inv.setItem(0, SWItem.getMaterial("WOOD_AXE"), "§eLaden", click -> { SchematicCommand.load(p, schem); p.closeInventory(); }); - if(schem.getSchemOwner() == WarkingUser.get(p.getUniqueId()).getId()){ + if(schem.getSchemOwner() == SteamwarUser.get(p.getUniqueId()).getId()){ if(schem.getSchemType().writeable()){ List checkedSchematics = CheckedSchematic.getLastDeclined(p.getUniqueId()); for(CheckedSchematic checkedSchematic : checkedSchematics) { if(checkedSchematic.getSchemName().equals(schem.getSchemName()) && checkedSchematic.getSchemOwner() == schem.getSchemOwner()) { - inv.setItem(1, Material.INK_SACK, (byte) 10, "§eStatus " + schem.getSchemType().name(), Collections.singletonList("§7" + checkedSchematic.getDeclineReason()), false, click -> {}); + inv.setItem(1, SWItem.getDye(10), (byte) 10, "§eStatus " + schem.getSchemType().name(), Collections.singletonList("§7" + checkedSchematic.getDeclineReason()), false, click -> {}); break; } } } - Material mat = Material.CAULDRON_ITEM; + Material mat = SWItem.getMaterial("CAULDRON_ITEM"); if(schem.getItem() != null && !schem.getItem().equals("")) - mat = Material.valueOf(schem.getItem()); + mat = SWItem.getMaterial(schem.getItem()); inv.setItem(2, mat, "§e" + mat.name(), Arrays.asList("§7Zum Ändern", "§7anklicken"), false, click -> { p.closeInventory(); changeItem(p, schem); }); - inv.setItem(4, Material.CAULDRON_ITEM, "§e" + schem.getSchemType().name(), Arrays.asList("§7Zum Ändern", "§7anklicken"), false, click -> { + inv.setItem(4, SWItem.getMaterial("CAULDRON_ITEM"), "§e" + schem.getSchemType().name(), Arrays.asList("§7Zum Ändern", "§7anklicken"), false, click -> { p.closeInventory(); changeType(p, schem); }); - inv.setItem(6, Material.SKULL_ITEM, "§eMitglieder", click -> { + inv.setItem(6, SWItem.getMaterial("SKULL_ITEM"), "§eMitglieder", click -> { p.closeInventory(); delmembers(p, schem); }); - inv.setItem(8, Material.INK_SACK, (byte) 1, "§cLöschen", click -> { + inv.setItem(8, SWItem.getDye(1), (byte) 1, "§cLöschen", click -> { p.closeInventory(); delete(p, schem); }); }else{ - inv.setItem(4, Material.CAULDRON_ITEM, "§e" + schem.getSchemType().name(), click -> {}); + inv.setItem(4, SWItem.getMaterial("CAULDRON_ITEM"), "§e" + schem.getSchemType().name(), click -> {}); - WarkingUser owneruser = WarkingUser.get(schem.getSchemOwner()); + SteamwarUser owneruser = SteamwarUser.get(schem.getSchemOwner()); SWItem owner = new SWItem(); - ItemStack head = new ItemStack(Material.SKULL_ITEM, 1, (short)3); + ItemStack head = new ItemStack(SWItem.getMaterial("SKULL_ITEM"), 1, (short)3); SkullMeta headmeta = (SkullMeta)head.getItemMeta(); headmeta.setOwningPlayer(Bukkit.getOfflinePlayer(owneruser.getUUID())); headmeta.setDisplayName("§7von §e" + owneruser.getUserName()); @@ -164,7 +155,7 @@ class GUI { } static void list(Player p){ - list(p, WarkingUser.get(p.getUniqueId()).getId()); + list(p, SteamwarUser.get(p.getUniqueId()).getId()); } static void list(Player p, int pid){ @@ -174,9 +165,9 @@ class GUI { for(Schematic schem : schems) { Material m; if (schem.getItem().isEmpty()) - m = Material.CAULDRON_ITEM; + m = SWItem.getMaterial("CAULDRON_ITEM"); else - m = Material.valueOf(schem.getItem()); + m = SWItem.getMaterial(schem.getItem()); SWItem item = new SWItem(m, "§e" + schem.getSchemName(), Collections.singletonList("§7" + schem.getSchemType().name()), !schem.getSchemType().writeable(), click -> {}); schemList.add(new Pair<>(item, schem)); diff --git a/src/de/steamwar/schematicsystem/commands/SchematicCommand.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java similarity index 77% rename from src/de/steamwar/schematicsystem/commands/SchematicCommand.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java index cf55a6b..5a5ab31 100644 --- a/src/de/steamwar/schematicsystem/commands/SchematicCommand.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java @@ -2,18 +2,13 @@ package de.steamwar.schematicsystem.commands; import com.boydti.fawe.FaweAPI; import com.sk89q.worldedit.EmptyClipboardException; -import com.sk89q.worldedit.extension.platform.Actor; import com.sk89q.worldedit.extent.clipboard.Clipboard; -import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat; -import com.sk89q.worldedit.session.ClipboardHolder; import de.steamwar.schematicsystem.CheckSchemType; +import de.steamwar.schematicsystem.Constants; import de.steamwar.schematicsystem.SchematicSystem; +import de.steamwar.schematicsystem.WorldEdit; import de.steamwar.schematicsystem.check.CheckUtils; -import de.steamwar.schematicsystem.utils.CheckedSchematic; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicMember; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.*; import net.md_5.bungee.api.ChatColor; import net.md_5.bungee.api.chat.ClickEvent; import net.md_5.bungee.api.chat.ComponentBuilder; @@ -26,12 +21,8 @@ import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.io.File; -import java.io.FileOutputStream; import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.attribute.PosixFilePermission; import java.util.ArrayList; -import java.util.EnumSet; import java.util.LinkedList; import java.util.List; import java.util.logging.Level; @@ -39,23 +30,6 @@ import java.util.logging.Level; public class SchematicCommand implements CommandExecutor { private static final int FILES_PER_PAGE = 15; - private static final EnumSet FILE_PERMS = EnumSet.of( - PosixFilePermission.OWNER_READ, - PosixFilePermission.OWNER_WRITE, - PosixFilePermission.GROUP_READ, - PosixFilePermission.GROUP_WRITE, - PosixFilePermission.OTHERS_READ, - PosixFilePermission.OTHERS_WRITE); - private static final EnumSet FOLDER_PERMS = EnumSet.of( - PosixFilePermission.OWNER_READ, - PosixFilePermission.OWNER_WRITE, - PosixFilePermission.GROUP_READ, - PosixFilePermission.GROUP_WRITE, - PosixFilePermission.OTHERS_READ, - PosixFilePermission.OTHERS_WRITE, - PosixFilePermission.OWNER_EXECUTE, - PosixFilePermission.GROUP_EXECUTE, - PosixFilePermission.OTHERS_EXECUTE); @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { @@ -104,7 +78,7 @@ public class SchematicCommand implements CommandExecutor { private void list(Player player, String[] args){ if(args.length <= 1){ - sendPlayerSchematicList(0, WarkingUser.get(player.getUniqueId()).getId(), player); + sendPlayerSchematicList(0, SteamwarUser.get(player.getUniqueId()).getId(), player); return; } @@ -114,7 +88,7 @@ public class SchematicCommand implements CommandExecutor { } try { - sendPlayerSchematicList(Integer.parseInt(args[1]), WarkingUser.get(player.getUniqueId()).getId(), player); + sendPlayerSchematicList(Integer.parseInt(args[1]), SteamwarUser.get(player.getUniqueId()).getId(), player); } catch (NumberFormatException ex) { player.sendMessage(SchematicSystem.PREFIX + "§cUngültige Seitenzahl"); } @@ -158,20 +132,18 @@ public class SchematicCommand implements CommandExecutor { } static void load(Player player, Schematic schematic){ - try{ - Actor actor = SchematicSystem.getWorldEditPlugin().wrapCommandSender(player); + try { + File file = new File(Constants.SCHEM_DIR + SteamwarUser.get(schematic.getSchemOwner()).getUUID(), schematic.getSchemName() + ".schematic"); - File file = new File(SchematicSystem.SCHEM_DIR + WarkingUser.get(schematic.getSchemOwner()).getUUID(), schematic.getSchemName() + ".schematic"); - - if(!file.exists()) { + if (!file.exists()) { player.sendMessage(SchematicSystem.PREFIX + "§cDie angegebene Schematic existiert nicht"); return; } Clipboard clipboard = FaweAPI.load(file).getClipboard(); - if(clipboard == null) + if (clipboard == null) throw new IOException("File not a schematic"); - SchematicSystem.getWorldEditPlugin().getWorldEdit().getSessionManager().get(actor).setClipboard(new ClipboardHolder(clipboard, FaweAPI.getWorld(player.getWorld().getName()).getWorldData())); + WorldEdit.loadClipboardToPlayer(player, clipboard); player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + schematic.getSchemName() + " §7geladen"); }catch (IOException ex){ Bukkit.getLogger().log(Level.SEVERE, "Schematic konnte nicht geladen werden", ex); @@ -189,7 +161,7 @@ public class SchematicCommand implements CommandExecutor { if(schematic == null) return; - if(WarkingUser.get(player.getUniqueId()).getId() != schematic.getSchemOwner()){ + if(SteamwarUser.get(player.getUniqueId()).getId() != schematic.getSchemOwner()){ player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst nur deine eigenen Schematics löschen"); return; } @@ -213,33 +185,21 @@ public class SchematicCommand implements CommandExecutor { } try { - ClipboardHolder clipboardHolder = FaweAPI.wrapPlayer(player).getSession().getClipboard(); - Clipboard clipboard = clipboardHolder.getClipboard(); - if(clipboard == null) { - player.sendMessage(SchematicSystem.PREFIX + "§cDein Clipboard ist leer"); - return; - } - - File folder = new File(SchematicSystem.SCHEM_DIR + player.getUniqueId().toString()); - if(!folder.exists()){ - folder.mkdir(); - Files.setPosixFilePermissions(folder.toPath(), FOLDER_PERMS); - } - - File file = new File(folder, args[1] + ".schematic"); - file.createNewFile(); - Files.setPosixFilePermissions(file.toPath(), FILE_PERMS); - ClipboardFormat.SCHEMATIC.getWriter(new FileOutputStream(file)).write(clipboard, clipboardHolder.getWorldData()); - - if(schematic != null && schematic.getSchemOwner() == WarkingUser.get(player.getUniqueId()).getId()){ - player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7überschrieben"); - }else{ - new Schematic(args[1], player.getUniqueId(), "", SchematicType.Normal); - player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7gespeichert"); - } - }catch(IOException | EmptyClipboardException ex){ + WorldEdit.saveSchematic(player, args[1]); + }catch(EmptyClipboardException e){ + player.sendMessage(SchematicSystem.PREFIX + "§cDein Clipboard ist leer"); + return; + }catch(IOException ex){ Bukkit.getLogger().log(Level.SEVERE, "Could not save schematic", ex); player.sendMessage(SchematicSystem.PREFIX + "§cFehler beim Speichern der Schematic. Bitte wende dich an einen Developer"); + return; + } + + if (schematic != null && schematic.getSchemOwner() == SteamwarUser.get(player.getUniqueId()).getId()) { + player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7überschrieben"); + } else { + new Schematic(args[1], player.getUniqueId(), "", SchematicType.Normal); + player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7gespeichert"); } } @@ -315,7 +275,7 @@ public class SchematicCommand implements CommandExecutor { player.sendMessage("§eName: §7" + schematic.getSchemName()); TextComponent type = new TextComponent("§eTyp: §7" + schematic.getSchemType().name()); - if(WarkingUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())){ + if(SteamwarUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())){ type.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText("§eTyp ändern"))); type.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem changetype " + schematic.getSchemName())); } @@ -330,12 +290,12 @@ public class SchematicCommand implements CommandExecutor { } } - if(!WarkingUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())) { - player.sendMessage("§eBesitzer: §7" + WarkingUser.get(schematic.getSchemOwner()).getUserName()); + if(!SteamwarUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())) { + player.sendMessage("§eBesitzer: §7" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); } else { List schematicMembers = new ArrayList<>(); for(SchematicMember schematicMember : SchematicMember.getSchemMembers(schematic.getSchemName(), schematic.getSchemOwner())) { - schematicMembers.add(WarkingUser.get(schematicMember.getMember()).getUserName()); + schematicMembers.add(SteamwarUser.get(schematicMember.getMember()).getUserName()); } player.sendMessage("§eMitglieder: §7" + schematicMembers.toString()); } @@ -356,12 +316,12 @@ public class SchematicCommand implements CommandExecutor { if(schematic == null) return; - if(schematic.getSchemOwner() != WarkingUser.get(player.getUniqueId()).getId()) { + if(schematic.getSchemOwner() != SteamwarUser.get(player.getUniqueId()).getId()) { player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst nur auf deine eigene Schematic Mitglieder hinzufügen"); return; } - WarkingUser warkingUser = WarkingUser.get(args[2]); + SteamwarUser warkingUser = SteamwarUser.get(args[2]); if(warkingUser.getUUID() == null){ player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler existiert nicht"); return; @@ -371,17 +331,17 @@ public class SchematicCommand implements CommandExecutor { return; } - if(SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), WarkingUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()) != null){ + if(SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()) != null){ player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler ist bereits auf diese Schematic geaddet"); return; } - new SchematicMember(schematic.getSchemName(), WarkingUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()); + new SchematicMember(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()); player.sendMessage(SchematicSystem.PREFIX + "Der Spieler §e" + warkingUser.getUserName() + " §7hat nun Zugriff auf die Schematic §e" + schematic.getSchemName()); Player target = Bukkit.getPlayer(warkingUser.getUUID()); if(target != null) - target.sendMessage(SchematicSystem.PREFIX + "Du hast nun Zugriff auf die Schematic §e" + schematic.getSchemName() + " §7von §e" + WarkingUser.get(schematic.getSchemOwner()).getUserName()); + target.sendMessage(SchematicSystem.PREFIX + "Du hast nun Zugriff auf die Schematic §e" + schematic.getSchemName() + " §7von §e" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); } private void delmember(Player player, String[] args){ @@ -394,7 +354,7 @@ public class SchematicCommand implements CommandExecutor { if(schematic == null) return; - if(schematic.getSchemOwner() != WarkingUser.get(player.getUniqueId()).getId()) { + if(schematic.getSchemOwner() != SteamwarUser.get(player.getUniqueId()).getId()) { player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst nur von deinen eigenen Schematics Mitglieder entfernen"); return; } @@ -404,7 +364,7 @@ public class SchematicCommand implements CommandExecutor { return; } - WarkingUser warkingUser = WarkingUser.get(args[2]); + SteamwarUser warkingUser = SteamwarUser.get(args[2]); if(warkingUser.getUUID() == null){ player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler existiert nicht"); return; @@ -414,7 +374,7 @@ public class SchematicCommand implements CommandExecutor { return; } - SchematicMember schematicMember = SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), WarkingUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()); + SchematicMember schematicMember = SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), warkingUser.getUUID()); if(schematicMember == null) { player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler ist nicht auf die Schematic hinzugefügt"); return; @@ -425,7 +385,7 @@ public class SchematicCommand implements CommandExecutor { Player target = Bukkit.getPlayer(warkingUser.getUUID()); if(target != null) - target.sendMessage(SchematicSystem.PREFIX + "Du hast keinen Zugriff mehr auf die Schematic §e" + schematic.getSchemName() + "§7von §e" + WarkingUser.get(schematic.getSchemOwner()).getUserName()); + target.sendMessage(SchematicSystem.PREFIX + "Du hast keinen Zugriff mehr auf die Schematic §e" + schematic.getSchemName() + "§7von §e" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); } private void help(Player player) { @@ -473,7 +433,7 @@ public class SchematicCommand implements CommandExecutor { String schematicPlayer = ""; if(schematic.getSchemOwner() != schemOwner) - schematicPlayer = " §8von §7" + WarkingUser.get(schematic.getSchemOwner()).getUserName(); + schematicPlayer = " §8von §7" + SteamwarUser.get(schematic.getSchemOwner()).getUserName(); TextComponent schematics = new TextComponent("§e" + schematic.getSchemType().getKuerzel() + " §7" + schematic.getSchemName() + schematicPlayer); schematics.setBold(true); diff --git a/src/de/steamwar/schematicsystem/listener/PlayerCommandPreProcessListener.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerCommandPreProcessListener.java similarity index 100% rename from src/de/steamwar/schematicsystem/listener/PlayerCommandPreProcessListener.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerCommandPreProcessListener.java diff --git a/src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java similarity index 80% rename from src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java index c43718f..ea7c898 100644 --- a/src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerJoinListener.java @@ -1,11 +1,12 @@ package de.steamwar.schematicsystem.listener; +import de.steamwar.schematicsystem.Constants; import de.steamwar.schematicsystem.SchematicSystem; import de.steamwar.schematicsystem.check.CheckSession; import de.steamwar.schematicsystem.check.CheckUtils; -import de.warking.hunjy.MySQL.Schematic; -import de.warking.hunjy.MySQL.SchematicType; -import de.warking.hunjy.MySQL.WarkingUser; +import de.steamwar.sql.Schematic; +import de.steamwar.sql.SchematicType; +import de.steamwar.sql.SteamwarUser; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; @@ -13,6 +14,7 @@ import org.bukkit.event.player.PlayerJoinEvent; import java.io.File; import java.util.ArrayList; +import java.util.LinkedList; import java.util.List; public class PlayerJoinListener implements Listener { @@ -23,7 +25,7 @@ public class PlayerJoinListener implements Listener { if(CheckSession.currentChecking()){ CheckSession current = CheckSession.getCheckSession(); - if(!CheckUtils.allowedToCheck(player) && !WarkingUser.get(current.getSchematic().getSchemOwner()).getUUID().equals(player.getUniqueId())){ + if(!CheckUtils.allowedToCheck(player) && !SteamwarUser.get(current.getSchematic().getSchemOwner()).getUUID().equals(player.getUniqueId())){ player.sendMessage(SchematicSystem.PREFIX + "§cAuf diesem Server wird momentan eine Schematic geprüft!"); player.kickPlayer(""); return; @@ -35,7 +37,7 @@ public class PlayerJoinListener implements Listener { if(CheckUtils.allowedToCheck(player)) player.sendMessage(CheckUtils.sendTeamMembersCSchematicsInfo()); - List uncheckedSchematics = new ArrayList<>(); + List uncheckedSchematics = new LinkedList<>(); for(SchematicType type : SchematicType.values()){ if(type.check()) @@ -47,7 +49,7 @@ public class PlayerJoinListener implements Listener { } private void addNewSchems(Player player){ - File file = new File(SchematicSystem.SCHEM_DIR + player.getUniqueId()); + File file = new File(Constants.SCHEM_DIR + player.getUniqueId()); File[] files = file.listFiles(); if(files != null && files.length > 0) { @@ -55,7 +57,7 @@ public class PlayerJoinListener implements Listener { List schematicNames = new ArrayList<>(); for(Schematic schematic : schematics) { - if(schematic.getSchemOwner() == WarkingUser.get(player.getUniqueId()).getId()) { + if(schematic.getSchemOwner() == SteamwarUser.get(player.getUniqueId()).getId()) { schematicNames.add(schematic.getSchemName()); } } diff --git a/src/de/steamwar/schematicsystem/listener/PlayerQuitListener.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerQuitListener.java similarity index 100% rename from src/de/steamwar/schematicsystem/listener/PlayerQuitListener.java rename to SchematicSystem_Main/src/de/steamwar/schematicsystem/listener/PlayerQuitListener.java diff --git a/src/plugin.yml b/SchematicSystem_Main/src/plugin.yml similarity index 76% rename from src/plugin.yml rename to SchematicSystem_Main/src/plugin.yml index 442c679..ce8624a 100644 --- a/src/plugin.yml +++ b/SchematicSystem_Main/src/plugin.yml @@ -1,7 +1,7 @@ name: SchematicSystem version: "1.0" authors: [Yaruma3341, Lixfel] -depend: [CoreSystem, WorldEdit, FastAsyncWorldEdit] +depend: [SpigotCore, WorldEdit] main: de.steamwar.schematicsystem.SchematicSystem commands: diff --git a/pom.xml b/pom.xml index 1e73429..7f048a3 100644 --- a/pom.xml +++ b/pom.xml @@ -4,11 +4,11 @@ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 4.0.0 - de.warking + steamwar SchematicSystem 1.0 - jar https://maven.apache.org + pom UTF-8 @@ -17,21 +17,11 @@ maven - https://steamwar.de:81/maven/ + https://steamwar.de/maven/ - src - - - src - - **/*.java - **/*.kt - - - org.apache.maven.plugins @@ -45,29 +35,18 @@ + + SchematicSystem_12 + SchematicSystem_14 + SchematicSystem_API + SchematicSystem_Main + + - - steamwar - Spigot - 1.0 - provided - steamwar SpigotCore - 1.0 - provided - - - steamwar - WorldEdit - 1.0 - provided - - - steamwar - FAWE - 1.0 + 2.0 provided diff --git a/src/config.yml b/src/config.yml deleted file mode 100644 index 3f24ed8..0000000 --- a/src/config.yml +++ /dev/null @@ -1,41 +0,0 @@ -Schematics: - WarGear: - Breite: - Höhe: - Tiefe: - TNT: - Schleim: - TNTSchleim: - Dispenser: - ForbiddenIds: - CheckList: - MiniWarGear: - Breite: - Höhe: - Tiefe: - TNT: - Schleim: - TNTSchleim: - Dispenser: - ForbiddenIds: - CheckList: - WarShip: - Breite: - Höhe: - Tiefe: - TNT: - Schleim: - TNTSchleim: - Dispenser: - ForbiddenIds: - CheckList: - AirShip: - Breite: - Höhe: - Tiefe: - TNT: - Schleim: - TNTSchleim: - Dispenser: - ForbiddenIds: - CheckList: \ No newline at end of file diff --git a/src/de/steamwar/schematicsystem/utils/CheckedSchematic.java b/src/de/steamwar/schematicsystem/utils/CheckedSchematic.java deleted file mode 100644 index 0b5bfdf..0000000 --- a/src/de/steamwar/schematicsystem/utils/CheckedSchematic.java +++ /dev/null @@ -1,102 +0,0 @@ -package de.steamwar.schematicsystem.utils; - -import de.warking.hunjy.Core; -import de.warking.hunjy.MySQL.MySQL; -import de.warking.hunjy.MySQL.WarkingUser; -import org.bukkit.Bukkit; - -import java.sql.ResultSet; -import java.sql.SQLException; -import java.sql.Timestamp; -import java.util.LinkedList; -import java.util.List; -import java.util.UUID; -import java.util.logging.Level; - -import static de.warking.hunjy.Core.sql; - -public class CheckedSchematic { - - private final String schemName; - private final int schemOwner; - private final int validator; - private final Timestamp startTime; - private final Timestamp endTime; - private final String declineReason; - - private CheckedSchematic(String schemName, int schemOwner, int validator, Timestamp startTime, Timestamp endTime, String declineReason, boolean insertDB){ - this.schemName = MySQL.disarmString(schemName); - this.schemOwner = schemOwner; - this.validator = validator; - this.startTime = startTime; - this.endTime = endTime; - this.declineReason = MySQL.disarmString(declineReason); - if(insertDB) - insertDB(); - } - - public CheckedSchematic(String schemName, int schemOwner, int validator, Timestamp startTime, Timestamp endTime, String declineReason){ - this(schemName, schemOwner, validator, startTime, endTime, declineReason, true); - } - - public CheckedSchematic(String schemName, UUID schemOwner, UUID validator, Timestamp startTime, Timestamp endTime, String declineReason){ - this(schemName, WarkingUser.get(schemOwner).getId(), WarkingUser.get(validator).getId(), startTime, endTime, declineReason, true); - } - - private void insertDB(){ - sql.update("INSERT INTO CheckedSchematic" + - " (SchemName, SchemOwner, Validator, StartTime, EndTime, DeclineReason)" + - " VALUES" + - " ('"+ schemName + "', '" + schemOwner + "', '" + validator + "', '" + startTime.toString() + "', '" + endTime.toString() + "', '" + declineReason + "')"); - } - - public static List getLastDeclined(UUID schemOwner){ - return getLastDelined(WarkingUser.get(schemOwner).getId()); - } - - public static List getLastDelined(int schemOwner){ - List lastDeclined = new LinkedList<>(); - try{ - ResultSet lastRS = sql.select("SELECT * FROM CheckedSchematic WHERE SchemOwner = '" + schemOwner + "' AND DeclineReason != '' ORDER BY EndTime DESC"); - while(lastRS.next()){ - String schemName = lastRS.getString("SchemName"); - int validator = lastRS.getInt("Validator"); - Timestamp startTime = lastRS.getTimestamp("StartTime"); - Timestamp endTime = lastRS.getTimestamp("EndTime"); - String declineReason = lastRS.getString("DeclineReason"); - lastDeclined.add(new CheckedSchematic(schemName, schemOwner, validator, startTime, endTime, declineReason, false)); - } - }catch(SQLException e){ - Bukkit.getLogger().log(Level.SEVERE, "getLastDeclined failed", e); - } - return lastDeclined; - } - - public void remove() { - Core.sql.update("DELETE FROM CheckedSchematic WHERE SchemOwner = " + this.schemOwner + " AND SchemName = '" + this.schemName + "'"); - } - - public String getSchemName() { - return schemName; - } - - public int getSchemOwner() { - return schemOwner; - } - - public int getValidator() { - return validator; - } - - public Timestamp getStartTime() { - return startTime; - } - - public Timestamp getEndTime() { - return endTime; - } - - public String getDeclineReason() { - return declineReason; - } -} diff --git a/src/de/steamwar/schematicsystem/utils/CommandRemover.java b/src/de/steamwar/schematicsystem/utils/CommandRemover.java deleted file mode 100644 index d5fbf5c..0000000 --- a/src/de/steamwar/schematicsystem/utils/CommandRemover.java +++ /dev/null @@ -1,43 +0,0 @@ -package de.steamwar.schematicsystem.utils; - -import org.bukkit.Bukkit; -import org.bukkit.command.Command; -import org.bukkit.command.SimpleCommandMap; - -import java.lang.reflect.Field; -import java.util.Map; -import java.util.logging.Level; - -public class CommandRemover { - private CommandRemover(){} - - private static String packageName = Bukkit.getServer().getClass().getPackage().getName(); - private static String version = packageName.substring(packageName.lastIndexOf('.') + 1); - - public static void removeAll(String... cmds){ - for (String cmd : cmds) removeCommand(cmd); - } - - - private static void removeCommand(String command) { - try { - Class serverClass = Class.forName("org.bukkit.craftbukkit." + version + ".CraftServer"); - - - Field f1 = serverClass.getDeclaredField("commandMap"); - f1.setAccessible(true); - SimpleCommandMap commandMap = (SimpleCommandMap) f1.get(Bukkit.getServer()); - - Field f2 = SimpleCommandMap.class.getDeclaredField("knownCommands"); - f2.setAccessible(true); - Map knownCommands = (Map) f2.get(commandMap); - - knownCommands.remove(command.toLowerCase()); - } catch (Exception e) { - Bukkit.getLogger().log(Level.SEVERE, "Could not remove command", e); - } - } - - - -}