diff --git a/SchematicSystem_API/src/de/steamwar/schematicsystem/AutoCheckResult.java b/SchematicSystem_API/src/de/steamwar/schematicsystem/AutoCheckResult.java index 317df27..ffa40ff 100644 --- a/SchematicSystem_API/src/de/steamwar/schematicsystem/AutoCheckResult.java +++ b/SchematicSystem_API/src/de/steamwar/schematicsystem/AutoCheckResult.java @@ -19,8 +19,6 @@ package de.steamwar.schematicsystem; -import de.steamwar.core.Core; - import java.util.*; public class AutoCheckResult { @@ -28,7 +26,6 @@ public class AutoCheckResult { private final ICheckSchemType type; private final boolean noChecksInThisVersion; - private boolean wrongVersionException = false; // Schematic nicht in der Version ladbar private boolean errorLoadingSchematic = false; // Schematic irgendwie invalide private int width = 0; @@ -40,12 +37,12 @@ public class AutoCheckResult { private int dispenser = 0; private int blocks = 0; - private Map forbiddenMaterials = new HashMap<>(); // Anzahl verbotener Blöcke nach Material + private final Map forbiddenMaterials = new HashMap<>(); // Anzahl verbotener Blöcke nach Material - private Map defunctNbt = new HashMap<>(); // Anzahl an defekten NBT-Blöcken nach Materialname + private final Map defunctNbt = new HashMap<>(); // Anzahl an defekten NBT-Blöcken nach Materialname private int records = 0; // Gefundene Schallplatten - private Map> forbiddenItems = new HashMap<>(); // Anzahl verbotener Items nach Inventartyp - private Map> itemsWithTag = new HashMap<>(); // Anzahl an Items mit Tag nach Inventartyp + private final Map> forbiddenItems = new HashMap<>(); // Anzahl verbotener Items nach Inventartyp + private final Map> itemsWithTag = new HashMap<>(); // Anzahl an Items mit Tag nach Inventartyp private int tooManyDispenserItems = 0; // Gefundene Überschreitungen von DispenserItems AutoCheckResult(ICheckSchemType type){ @@ -58,71 +55,6 @@ public class AutoCheckResult { noChecksInThisVersion = true; } - public Collection errors(){ - List errors = new LinkedList<>(); - - if(noChecksInThisVersion){ - errors.add("In der 1." + Core.getVersion() + " können keine Schematics eingesendet werden"); - return errors; - } - if(wrongVersionException) - errors.add("Diese Schematic kann nicht in dieser Version geändert werden"); - if(errorLoadingSchematic) - errors.add("Die Schematic konnte nicht geladen werden"); - - assert type != null; - if(width > type.getDepth()) - errors.add("Die Schematic ist zu breit (" + width + " > " + type.getDepth() + ")"); - if(length > type.getWidth()) - errors.add("Die Schematic ist zu lang (" + length + " > " + type.getWidth() + ")"); - if(height > type.getHeight()) - errors.add("Die Schematic ist zu hoch (" + height + " > " + type.getHeight() + ")"); - - int errorTNTSlime = slime + tnt; - if(type.getMaxTNT() != 0 && tnt > type.getMaxTNT()) - errors.add("Zu viele TNT-Blöcke (" + tnt + " > " + type.getMaxTNT() + ")"); - if(type.getMaxSlime() != 0 && slime > type.getMaxSlime()) - errors.add("Zu viele Schleim/Honig-Blöcke (" + slime + " > " + type.getMaxSlime() + ")"); - if(type.getMaxDispenser() != 0 && dispenser > type.getMaxDispenser()) - errors.add("Zu viele Werfer (" + dispenser + " > " + type.getMaxDispenser() + ")"); - if(type.getMaxTNTSlime() != 0 && errorTNTSlime > type.getMaxTNTSlime()) - errors.add("Zu viel Schleim+TNT" + errorTNTSlime + " > " + type.getMaxTNTSlime() + ")"); - if(type.getMaxBlocks() != 0 && blocks > type.getMaxBlocks()) { - errors.add("Zu viele Blöcke (" + blocks + " > " + type.getMaxBlocks() + ")"); - } - - for(Map.Entry block : forbiddenMaterials.entrySet()) - errors.add("Der Block " + block.getKey() + " ist verboten (" + block.getValue() + " verbaut)"); - - if(records > 0) - errors.add("Keine Schallplatten erlaubt (" + records + " gefunden)"); - for(Map.Entry> block : forbiddenItems.entrySet()) - for(Map.Entry item : block.getValue().entrySet()) - errors.add("In " + block.getKey() + "s wurde das verbotene Item " + item.getKey() + " " + item.getValue() + " mal gefunden"); - for(Map.Entry> block : itemsWithTag.entrySet()) - for(Map.Entry item : block.getValue().entrySet()) - errors.add("In " + block.getKey() + "s wurde das Item " + item.getKey() + " " + item.getValue() + " mal mit Custom-Tag gefunden"); - if(tooManyDispenserItems == 1) - errors.add("Ein Werfer enthält mehr als " + type.getMaxDispenserItems() + " Pfeile und Feuerbälle"); - else if(tooManyDispenserItems > 1) - errors.add(tooManyDispenserItems + " Werfer enthalten mehr als " + type.getMaxDispenserItems() + " Pfeile und Feuerbälle"); - - return errors; - } - - public Collection warnings(){ - List warnings = new LinkedList<>(); - - for(Map.Entry nbtBlock : defunctNbt.entrySet()){ - if(nbtBlock.getValue() > 1) - warnings.add(nbtBlock.getValue() + " " + nbtBlock.getKey() + "s enthalten keine oder inkorrekte NBT-Daten"); - else - warnings.add("Ein(e) " + nbtBlock.getKey() + " enthält keine oder inkorrekte NBT-Daten"); - } - - return warnings; - } - void setErrorLoadingSchematic(){ errorLoadingSchematic = true; } @@ -183,4 +115,68 @@ public class AutoCheckResult { if(counter > type.getMaxDispenserItems()) tooManyDispenserItems++; } + + public boolean noChecksInThisVersion() { + return noChecksInThisVersion; + } + + public boolean errorLoadingSchematic() { + return errorLoadingSchematic; + } + + public int getWidth() { + return width; + } + + public int getHeight() { + return height; + } + + public int getLength() { + return length; + } + + public int getTnt() { + return tnt; + } + + public int getSlime() { + return slime; + } + + public int getTntSlime() { + return slime + tnt; + } + + public int getDispenser() { + return dispenser; + } + + public int getBlocks() { + return blocks; + } + + public Map getForbiddenMaterials() { + return forbiddenMaterials; + } + + public Map getDefunctNbt() { + return defunctNbt; + } + + public int getRecords() { + return records; + } + + public Map> getForbiddenItems() { + return forbiddenItems; + } + + public Map> getItemsWithTag() { + return itemsWithTag; + } + + public int getTooManyDispenserItems() { + return tooManyDispenserItems; + } } diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java index ddb8d6c..d495700 100644 --- a/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.java @@ -19,6 +19,7 @@ package de.steamwar.schematicsystem; +import de.steamwar.message.Message; import de.steamwar.schematicsystem.commands.SchematicCommand; import org.bukkit.Bukkit; import org.bukkit.plugin.java.JavaPlugin; @@ -27,7 +28,7 @@ import java.io.File; import java.util.logging.Level; public class SchematicSystem extends JavaPlugin { - public static final String PREFIX = "§eSchematic§8» §7"; + public static Message MESSAGE; @Override public void onEnable() { @@ -36,6 +37,7 @@ public class SchematicSystem extends JavaPlugin { Bukkit.getLogger().log(Level.SEVERE, "config.yml erstellt und geladen!"); } + MESSAGE = new Message("de.steamwar.SchematicSystem", getClassLoader()); CheckSchemType.init(getConfig()); getCommand("schem").setExecutor(new SchematicCommand()); } diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.properties b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.properties new file mode 100644 index 0000000..09fa969 --- /dev/null +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/SchematicSystem.properties @@ -0,0 +1,107 @@ +PREFIX=§eSchematic§8» + +HELP=§8/§eschem gui §8- §7Öffnet die Schematic-GUI\ + §8/§eschem list §8- §7Zeigt dir deine Schematics an\ + §8/§eschem list public §8- §7Zeigt alle Public-Schematics\ + §8/§eschem search §8[§7Stichwort§8] - §7Sucht nach passenden Schematics\ + §8/§eschem load §8[§7Schematic§8] - §7Lädt eine Schematic\ + §8/§eschem save §8[§7Schematic§8] - §7Speichert dein Clipboard als Schematic\ + §8/§eschem changetype §8[§7Schematic§8] - §7Ändert die Art deiner Schematic\ + §8/§eschem delete §8[§7Schematic§8] - §7Löscht eine Schematic\ + §8/§eschem info §8[§7Schematic§8] - §7Zeigt dir Informationen zur Schematic\ + §8/§eschem download §8[§7Schematic§8] - §7Gibt dir einen Downloadlink (1 min gültig)\ + §8/§eschem addmember §8[§7Schematic§8] §8[§7Spieler§8] - §7Fügt einen Spieler zu einer Schematic hinzu\ + §8/§eschem delmember §8[§7Schematic§8] §8[§7Spieler§8] - §7Entfernt einen Spieler von einer Schematic + +INVALID_PAGE=§cUngültige Seitenzahl +INVALID_SCHEMNAME=§cDer angegebene Schematicname enthält verbotene Zeichen +UNKNOWN_SCHEM=§cDie angegebene Schematic existiert nicht +UNKNOWN_USER=§cUnbekannter Spieler + +CHANGETYPE_INVALID_TYPE=§cDiesen Schematictypen gibt es nicht +CHANGETYPE_ALREADY=§cDie Schematic hat bereits diesen Typen +CHANGETYPE_CHANGED=§aSchematictyp geändert +CHANGETYPE_PENDING=§cDu hast diese Schematic bereits eingesendet +CHANGETYPE_REJECT=§cDie Schematic ist nicht regelkonform +CHANGETYPE_ACCEPT=§aDie Schematic wird zeitnah überprüft + +LOAD_LOADED=§7Schematic §e{0} §7geladen +LOAD_FAILED=§cFehler beim Laden der Schematic. Dies liegt wahrscheinlich an einer defekten Schematic. + +SAVE_NAME_TOO_LONG=§cDer Name der Schematic ist zu lang +SAVE_NO_OVERRIDE=§cDu darfst diese Schematic nicht überschreiben +SAVE_EMPTY=§cDein Clipboard ist leer +SAVE_FAILED=§cFehler beim Speichern der Schematic +SAVE_SAVED=§7Schematic §e{0} §7gespeichert +SAVE_OVERRIDE=§7Schematic §e{0} §7überschrieben + +INFO_NAME=§7Name§8: §e{0} +INFO_TYPE=§7Typ§8: §e{0} +INFO_TYPE_HOVER=§eTyp ändern +INFO_RANK=§7Rang§8: §7{0} +INFO_DOWNLOAD=§7Download Schematic +INFO_DOWNLOAD_HOVER=§eGeneriere Downloadlink +INFO_STATUS=§7Status§8: §7{0} §e{1} +INFO_OWNER=§7Besitzer§8: §e{0} +INFO_MEMBER=§7Mitglieder§8: §e{0} + +DOWNLOAD_ONLY_OWN=§cDu darfst nur deine eigenen Schematics herunterladen! + +MEMBER_ON_OWN=§cAlso bitte: Das ist deine eigene Schematic! +ADDMEMBER_ONLY_OWN=§cDu darfst nur auf deine eigene Schematic Mitglieder hinzufügen +ADDMEMBER_ALREADY=§cDieser Spieler ist bereits auf diese Schematic geaddet +ADDMEMBER_ADDED=§7Der Spieler §e{0} §7hat nun Zugriff auf die Schematic §e{1} +ADDMEMBER_ACCESS=§7Du hast nun Zugriff auf die Schematic §e{0} §7von §e{1} + +DELMEMBER_ONLY_OWN=§cDu darfst nur von deinen eigenen Schematics Mitglieder entfernen +DELMEMBER_NOT_ADDED=§cDieser Spieler ist nicht auf die Schematic hinzugefügt +DELMEMBER_REMOVED=§7Der Spieler §e{0} §7hat keinen Zugriff mehr auf die Schematic §e{1} +DELMEMBER_REVOKED=§7Du hast keinen Zugriff mehr auf die Schematic §e{0} §7von §e{1} + +LIST_NO_SCHEMS=§cKeine Schematics gefunden +LIST_HEADER=§eSeite {0}§8/{1} §8| §e{2} Schematics +LIST_INFO=§e{0} §7§l{1}{2} +LIST_INFO_BY=§8von §7{0} +LIST_INFO_HOVER=§eSchematic verwalten +LIST_PREVIOUS=«« +LIST_PREVIOUS_HOVER=§eVorherige Seite +LIST_NEXT= Seite »» +LIST_NEXT_HOVER=§eNächste Seite + +GUI_CHANGETYPE=Typ ändern + +GUI_ABORT=§cAbbruch +GUI_DELETEOWN={0} löschen +GUI_DELETEOWN_DELETE=§eLöschen +GUI_DELETEOWN_DELETED=§7Schematic §e{0} §7gelöscht + +GUI_DELETEMEMBER={0} entfernen +GUI_DELETEMEMBER_DELETE=§eZugriff entfernen +GUI_DELETEMEMBER_REMOVED=§7Zugriff zu Schematic §e{0} §7entfernt + +GUI_DELMEMBER=Mitglieder entfernen + +GUI_CHANGEITEM=Item ändern + +GUI_INFO_LOAD=§eLaden + +#Autochecker +AUTO_ERR_VERSION= §cIn der 1.{0} können keine Schematics eingesendet werden +AUTO_ERR_LOADING= §cDie Schematic konnte nicht geladen werden +AUTO_ERR_WIDTH= §cDie Schematic ist zu breit ({0} > {1}) +AUTO_ERR_LENGTH= §cDie Schematic ist zu lang ({0} > {1}) +AUTO_ERR_HEIGHT= §cDie Schematic ist zu hoch ({0} > {1}) +AUTO_ERR_TNT= §cZu viele TNT-Blöcke ({0} > {1}) +AUTO_ERR_SLIME= §cZu viele Schleim+Honig-Blöcke ({0} > {1}) +AUTO_ERR_DISPENSER= §cZu viele Werfer ({0} > {1}) +AUTO_ERR_TNTSLIME= §cZu viel Schleim+Honig+TNT ({0} > {1}) +AUTO_ERR_MAXBLOCKS= §cZu viele Blöcke ({0} > {1}) +AUTO_ERR_BLOCK= §cDer Block {0} ist verboten ({1} verbaut) +AUTO_ERR_RECORDS= §cKeine Schallplatten erlaubt ({0} gefunden) +AUTO_ERR_SING_DISPENSER_ITEMS= §cEin Werfer enthält mehr als {0} Pfeile und Feuerbälle +AUTO_ERR_PLUR_DISPENSER_ITEMS= §c{0} Werfer enthalten mehr als {1} Pfeile und Feuerbälle +AUTO_ERR_ITEMS= §cIn {0}s wurde das verbotene Item {1} {2} mal gefunden +AUTO_ERR_TAG= §cIn {0}s wurde das Item {1} {2} mal mit Custom-Tag gefunden + +AUTO_WARN_SING_NBT= §eEin(e) {0} enthält keine oder möglicherweise inkorrekte NBT-Daten +AUTO_WARN_PLUR_NBT= §e{0} {1}s enthalten keine oder möglicherweise inkorrekte NBT-Daten diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java index d14f7ea..33a22a1 100644 --- a/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/GUI.java @@ -48,7 +48,7 @@ class GUI { types.add(new SWListInv.SWListEntry<>(item, type)); } - SWListInv inv = new SWListInv<>(p, "Typ ändern", types, (clickType, schematicType) -> { + SWListInv inv = new SWListInv<>(p, SchematicSystem.MESSAGE.parse("GUI_CHANGETYPE", p), types, (clickType, schematicType) -> { SchematicCommand.changetype(p, schem, schematicType); p.closeInventory(); }); @@ -57,8 +57,8 @@ class GUI { } private static void deleteOwn(Player p, Schematic schem){ - SWInventory inv = new SWInventory(p, 9, schem.getSchemName() + " löschen"); - inv.setItem(0, SWItem.getDye(1), (byte) 1, "§eLöschen", click -> { + SWInventory inv = new SWInventory(p, 9, SchematicSystem.MESSAGE.parse("GUI_DELETEOWN", p, schem.getSchemName())); + inv.setItem(0, SWItem.getDye(1), (byte) 1, SchematicSystem.MESSAGE.parse("GUI_DELETEOWN_DELETE", p), click -> { schem.remove(); List checkedSchematics = CheckedSchematic.getLastDeclined(p.getUniqueId()); @@ -67,24 +67,24 @@ class GUI { checkedSchematic.getSchemName().equals(schem.getSchemName())) checkedSchematic.remove(); } - p.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + schem.getSchemName() + " §7gelöscht"); + SchematicSystem.MESSAGE.send("GUI_DELETEOWN_DELETED", p, schem.getSchemName()); p.closeInventory(); }); - inv.setItem(8, SWItem.getDye(14), (byte) 14, "§cAbbruch", click -> p.closeInventory()); + inv.setItem(8, SWItem.getDye(14), (byte) 14, SchematicSystem.MESSAGE.parse("GUI_ABORT", p), click -> p.closeInventory()); inv.setCallback(-999, click -> p.closeInventory()); inv.open(); } private static void deleteMembership(Player p, Schematic schem){ - SWInventory inv = new SWInventory(p, 9, schem.getSchemName() + " entfernen"); - inv.setItem(0, SWItem.getDye(1), (byte) 1, "§eZugriff entfernen", click -> { + SWInventory inv = new SWInventory(p, 9, SchematicSystem.MESSAGE.parse("GUI_DELETEMEMBER", p, schem.getSchemName())); + inv.setItem(0, SWItem.getDye(1), (byte) 1, SchematicSystem.MESSAGE.parse("GUI_DELETEMEMBER_DELETE", p), click -> { SchematicMember member = SchematicMember.getSchemMemberFromDB(schem.getSchemName(), schem.getSchemOwner(), SteamwarUser.get(p.getUniqueId()).getId()); if(member != null) member.remove(); - p.sendMessage(SchematicSystem.PREFIX + "Zugriff zu Schematic §e" + schem.getSchemName() + " §7entfernt"); + SchematicSystem.MESSAGE.send("GUI_DELETEMEMBER_REMOVED", p, schem.getSchemName()); p.closeInventory(); }); - inv.setItem(8, SWItem.getDye(14), (byte) 14, "§cAbbruch", click -> p.closeInventory()); + inv.setItem(8, SWItem.getDye(14), (byte) 14, SchematicSystem.MESSAGE.parse("GUI_ABORT", p), click -> p.closeInventory()); inv.setCallback(-999, click -> p.closeInventory()); inv.open(); } @@ -103,7 +103,7 @@ class GUI { members.add(new SWListInv.SWListEntry<>(SWItem.getPlayerSkull(user.getUserName()), member)); } - SWListInv inv = new SWListInv<>(p, "Mitglieder entfernen", members, (clickType, member) -> { + SWListInv inv = new SWListInv<>(p, SchematicSystem.MESSAGE.parse("GUI_DELMEMBER", p), members, (clickType, member) -> { member.remove(); p.closeInventory(); delmembers(p, schem); @@ -120,7 +120,7 @@ class GUI { materials.add(new SWListInv.SWListEntry<>(item, material)); } - SWListInv inv = new SWListInv<>(p, "Item ändern", materials, (clickType, material) -> { + SWListInv inv = new SWListInv<>(p, SchematicSystem.MESSAGE.parse("GUI_CHANGEITEM", p), materials, (clickType, material) -> { schem.setItem(material.name()); p.closeInventory(); info(p, schem); diff --git a/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java index de130c6..f8dfe0d 100644 --- a/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java +++ b/SchematicSystem_Main/src/de/steamwar/schematicsystem/commands/SchematicCommand.java @@ -19,13 +19,13 @@ package de.steamwar.schematicsystem.commands; +import de.steamwar.core.Core; import de.steamwar.schematicsystem.AutoCheckResult; import de.steamwar.schematicsystem.CheckSchemType; import de.steamwar.schematicsystem.SchematicSystem; 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; import net.md_5.bungee.api.chat.HoverEvent; import net.md_5.bungee.api.chat.TextComponent; import org.bukkit.Bukkit; @@ -35,8 +35,8 @@ import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import java.util.ArrayList; -import java.util.Collection; import java.util.List; +import java.util.Map; import java.util.logging.Level; public class SchematicCommand implements CommandExecutor { @@ -109,7 +109,7 @@ public class SchematicCommand implements CommandExecutor { try { sendPlayerSchematicList(Integer.parseInt(args[2]), player, "/schem list public ", Schematic.getSchemsAccessibleByUser(0)); } catch (NumberFormatException ex) { - player.sendMessage(SchematicSystem.PREFIX + "§cUngültige Seitenzahl"); + SchematicSystem.MESSAGE.send("INVALID_PAGE", player); } return; } @@ -117,7 +117,7 @@ public class SchematicCommand implements CommandExecutor { try { sendPlayerSchematicList(Integer.parseInt(args[1]), player, "/schem list ", Schematic.getSchemsAccessibleByUser(SteamwarUser.get(player.getUniqueId()).getId())); } catch (NumberFormatException ex) { - player.sendMessage(SchematicSystem.PREFIX + "§cUngültige Seitenzahl"); + SchematicSystem.MESSAGE.send("INVALID_PAGE", player); } } @@ -130,7 +130,7 @@ public class SchematicCommand implements CommandExecutor { name.contains("°") || name.contains("'") || name.contains("\"")){ - player.sendMessage(SchematicSystem.PREFIX + "§cDer angegebene Schematicname enthält verbotene Zeichen"); + SchematicSystem.MESSAGE.send("INVALID_SCHEMNAME", player); return true; } return false; @@ -145,7 +145,7 @@ public class SchematicCommand implements CommandExecutor { schematic = Schematic.getSchemFromDB(name, 0); //public schematic if (schematic == null) { - player.sendMessage(SchematicSystem.PREFIX + "§cDie angegebene Schematic existiert nicht"); + SchematicSystem.MESSAGE.send("UNKNOWN_SCHEM", player); return null; } @@ -168,10 +168,10 @@ public class SchematicCommand implements CommandExecutor { static void load(Player player, Schematic schematic){ try { schematic.loadToPlayer(player); - player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + schematic.getSchemName() + " §7geladen"); + SchematicSystem.MESSAGE.send("LOAD_LOADED", player, schematic.getSchemName()); }catch (Exception e){ - Bukkit.getLogger().log(Level.SEVERE, "Schematic konnte nicht geladen werden", e); - player.sendMessage(SchematicSystem.PREFIX + "§cFehler beim Laden der Schematic. Dies liegt wahrscheinlich an einer defekten Schematic."); + Bukkit.getLogger().log(Level.SEVERE, "Could not load schematic", e); + SchematicSystem.MESSAGE.send("LOAD_FAILED", player); } } @@ -198,13 +198,13 @@ public class SchematicCommand implements CommandExecutor { return; if(args[1].length() > 64){ - player.sendMessage(SchematicSystem.PREFIX + "§cDer Name der Schematic ist zu lang"); + SchematicSystem.MESSAGE.send("SAVE_NAME_TOO_LONG", player); return; } Schematic schematic = Schematic.getSchemFromDB(args[1], player.getUniqueId()); if(schematic != null && !schematic.getSchemType().writeable()) { - player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst diese Schematic nicht überschreiben"); + SchematicSystem.MESSAGE.send("SAVE_NO_OVERRIDE", player); return; } @@ -218,22 +218,23 @@ public class SchematicCommand implements CommandExecutor { try { schematic.saveFromPlayer(player); }catch (NoClipboardException e) { - player.sendMessage(SchematicSystem.PREFIX + "§cDein Clipboard ist leer"); + SchematicSystem.MESSAGE.send("SAVE_EMPTY", player); if(newSchem) schematic.remove(); return; }catch(Exception ex){ Bukkit.getLogger().log(Level.SEVERE, "Could not save schematic", ex); - player.sendMessage(SchematicSystem.PREFIX + "§cFehler beim Speichern der Schematic."); + SchematicSystem.MESSAGE.send("SAVE_FAILED", player); if(newSchem) schematic.remove(); return; } - if (newSchem) - player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7gespeichert"); - else - player.sendMessage(SchematicSystem.PREFIX + "Schematic §e" + args[1] + " §7überschrieben"); + if(newSchem){ + SchematicSystem.MESSAGE.send("SAVE_SAVED", player, args[1]); + }else{ + SchematicSystem.MESSAGE.send("SAVE_OVERRIDE", player, args[1]); + } } private void changetype(Player player, String[] args){ @@ -253,7 +254,7 @@ public class SchematicCommand implements CommandExecutor { SchematicType type = SchematicType.fromDB(args[2]); if(type == null || !type.isAssignable()){ - player.sendMessage(SchematicSystem.PREFIX + "§cDiesen Schematictypen gibt es nicht"); + SchematicSystem.MESSAGE.send("CHANGETYPE_INVALID_TYPE", player); return; } @@ -262,37 +263,118 @@ public class SchematicCommand implements CommandExecutor { static void changetype(Player player, Schematic schematic, SchematicType type){ if(schematic.getSchemType() == type){ - player.sendMessage(SchematicSystem.PREFIX + "§cDie Schematic hat bereits diesen Typen"); + SchematicSystem.MESSAGE.send("CHANGETYPE_ALREADY", player); return; } if(type.writeable()){ schematic.setSchemType(type); - player.sendMessage(SchematicSystem.PREFIX + "§aSchematictyp geändert"); + SchematicSystem.MESSAGE.send("CHANGETYPE_CHANGED", player); }else if(type.fightType()){ if(schematic.getSchemType().check()){ - player.sendMessage(SchematicSystem.PREFIX + "§cDu hast diese Schematic bereits eingesendet"); + SchematicSystem.MESSAGE.send("CHANGETYPE_PENDING", player); return; } - AutoCheckResult result = CheckSchemType.get(type).autoCheck(schematic); - Collection errors = result.errors(); - for(String warning : result.warnings()){ - player.sendMessage(" §e" + warning); - } - for(String error : errors){ - player.sendMessage(" §c" + error); - } - if(!errors.isEmpty()){ - player.sendMessage(SchematicSystem.PREFIX + "§cDie Schematic ist nicht regelkonform"); + CheckSchemType checkType = CheckSchemType.get(type); + AutoCheckResult result = checkType.autoCheck(schematic); + autoCheckWarnings(player, result); + if(autoCheckErrors(player, checkType, result)){ + SchematicSystem.MESSAGE.send("CHANGETYPE_REJECT", player); return; } schematic.setSchemType(type.checkType()); - player.sendMessage(SchematicSystem.PREFIX + "§aDie Schematic wird zeitnah überprüft"); + SchematicSystem.MESSAGE.send("CHANGETYPE_ACCEPT", player); } } + private static void autoCheckWarnings(Player player, AutoCheckResult result){ + for(Map.Entry nbtBlock : result.getDefunctNbt().entrySet()){ + if(nbtBlock.getValue() > 1){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_WARN_PLUR_NBT", player, nbtBlock.getValue(), nbtBlock.getKey()); + }else{ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_WARN_SING_NBT", player, nbtBlock.getKey()); + } + } + } + + private static boolean autoCheckErrors(Player player, CheckSchemType type, AutoCheckResult result){ + if(result.noChecksInThisVersion()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_VERSION", player, Core.getVersion()); + return true; + } + if(result.errorLoadingSchematic()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_LOADING", player); + return true; + } + + boolean error = false; + if(result.getWidth() > type.getDepth()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_WIDTH", player, result.getWidth(), type.getDepth()); + error = true; + } + if(result.getLength() > type.getWidth()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_LENGTH", player, result.getLength(), type.getWidth()); + error = true; + } + if(result.getHeight() > type.getHeight()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_HEIGHT", player, result.getHeight(), type.getHeight()); + error = true; + } + + if(type.getMaxTNT() != 0 && result.getTnt() > type.getMaxTNT()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_TNT", player, result.getTnt(), type.getMaxTNT()); + error = true; + } + if(type.getMaxSlime() != 0 && result.getSlime() > type.getMaxSlime()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_SLIME", player, result.getSlime(), type.getMaxSlime()); + error = true; + } + if(type.getMaxDispenser() != 0 && result.getDispenser() > type.getMaxDispenser()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_DISPENSER", player, result.getDispenser(), type.getMaxDispenser()); + error = true; + } + if(type.getMaxTNTSlime() != 0 && result.getTntSlime() > type.getMaxTNTSlime()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_TNTSLIME", player, result.getTntSlime(), type.getMaxTNTSlime()); + error = true; + } + if(type.getMaxBlocks() != 0 && result.getBlocks() > type.getMaxBlocks()) { + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_MAXBLOCKS", player, result.getBlocks(), type.getMaxBlocks()); + error = true; + } + + for(Map.Entry block : result.getForbiddenMaterials().entrySet()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_BLOCK", player, block.getKey(), block.getValue()); + error = true; + } + + if(result.getRecords() > 0){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_RECORDS", player, result.getRecords()); + error = true; + } + if(result.getTooManyDispenserItems() == 1) { + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_SING_DISPENSER_ITEMS", player, type.getMaxDispenserItems()); + error = true; + }else if(result.getTooManyDispenserItems() > 1){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_PLUR_DISPENSER_ITEMS", player, result.getTooManyDispenserItems(), type.getMaxDispenserItems()); + error = true; + } + for(Map.Entry> block : result.getForbiddenItems().entrySet()){ + for(Map.Entry item : block.getValue().entrySet()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_ITEMS", player, block.getKey(), item.getKey(), item.getValue()); + error = true; + } + } + for(Map.Entry> block : result.getItemsWithTag().entrySet()){ + for(Map.Entry item : block.getValue().entrySet()){ + SchematicSystem.MESSAGE.sendPrefixless("AUTO_ERR_TAG", player, block.getKey(), item.getKey(), item.getValue()); + error = true; + } + } + return error; + } + private void info(Player player, String[] args){ if(args.length < 2){ help(player); @@ -303,42 +385,39 @@ public class SchematicCommand implements CommandExecutor { if(schematic == null) return; - player.sendMessage("§eName: §7" + schematic.getSchemName()); + SchematicSystem.MESSAGE.sendPrefixless("INFO_NAME", player, schematic.getSchemName()); - TextComponent type = new TextComponent("§eTyp: §7" + schematic.getSchemType().name()); if(SteamwarUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId()) && schematic.availible()){ - type.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText("§eTyp ändern"))); - type.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem changetype " + schematic.getSchemName())); + SchematicSystem.MESSAGE.sendPrefixless("INFO_TYPE", player, "INFO_TYPE_HOVER", new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem changetype " + schematic.getSchemName())); + }else{ + SchematicSystem.MESSAGE.sendPrefixless("INFO_TYPE", player); } if(schematic.getRank() > 0){ - type.addExtra("§8Rang " + schematic.getRank()); + SchematicSystem.MESSAGE.sendPrefixless("INFO_RANK", player); } - player.spigot().sendMessage(type); if(SteamwarUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())){ - TextComponent download = new TextComponent("§eDownload Schematic"); - download.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText("§eGeneriere Downloadlink"))); - download.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem download " + schematic.getSchemName())); - player.spigot().sendMessage(download); - } + SchematicSystem.MESSAGE.sendPrefixless("INFO_DOWNLOAD", player, "INFO_DOWNLOAD_HOVER", new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem download " + schematic.getSchemName())); - List checkedSchematics = CheckedSchematic.getLastDeclined(player.getUniqueId()); - for(int i = checkedSchematics.size() -1; i >= 0; i--) { - if(checkedSchematics.get(i).getSchemName().equals(schematic.getSchemName()) && - checkedSchematics.get(i).getSchemOwner() == schematic.getSchemOwner()) { - player.sendMessage("§cStatus: §c" + checkedSchematics.get(i).getStartTime() + " : " + checkedSchematics.get(i).getDeclineReason()); - break; + List checkedSchematics = CheckedSchematic.getLastDeclined(player.getUniqueId()); + for(int i = checkedSchematics.size() -1; i >= 0; i--) { + CheckedSchematic check = checkedSchematics.get(i); + if(check.getSchemName().equals(schematic.getSchemName()) && + check.getSchemOwner() == schematic.getSchemOwner()) { + SchematicSystem.MESSAGE.sendPrefixless("INFO_STATUS", player, check.getStartTime(), check.getDeclineReason()); + break; + } } } if(!SteamwarUser.get(schematic.getSchemOwner()).getUUID().equals(player.getUniqueId())) { - player.sendMessage("§eBesitzer: §7" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); + SchematicSystem.MESSAGE.sendPrefixless("INFO_OWNER", player, SteamwarUser.get(schematic.getSchemOwner()).getUserName()); } else { List schematicMembers = new ArrayList<>(); for(SchematicMember schematicMember : SchematicMember.getSchemMembers(schematic.getSchemName(), schematic.getSchemOwner())) { schematicMembers.add(SteamwarUser.get(schematicMember.getMember()).getUserName()); } - player.sendMessage("§eMitglieder: §7" + schematicMembers.toString()); + SchematicSystem.MESSAGE.sendPrefixless("INFO_MEMBER", player, schematicMembers.toString()); } if(schematic.availible()){ @@ -379,13 +458,13 @@ public class SchematicCommand implements CommandExecutor { try { sendPlayerSchematicList(Integer.parseInt(args[2]), player, "/schem search " + args[1] + " ", schems); } catch (NumberFormatException ex) { - player.sendMessage(SchematicSystem.PREFIX + "§cUngültige Seitenzahl"); + SchematicSystem.MESSAGE.send("INVALID_PAGE", player); } } static void download(Player player, Schematic schematic){ if(schematic.getSchemOwner() != SteamwarUser.get(player.getUniqueId()).getId()){ - player.sendMessage("§cDu darfst nur deine eigenen Schematics herunterladen!"); + SchematicSystem.MESSAGE.send("DOWNLOAD_ONLY_OWN", player); return; } @@ -403,31 +482,32 @@ public class SchematicCommand implements CommandExecutor { return; if(schematic.getSchemOwner() != SteamwarUser.get(player.getUniqueId()).getId()) { - player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst nur auf deine eigene Schematic Mitglieder hinzufügen"); + SchematicSystem.MESSAGE.send("ADDMEMBER_ONLY_OWN", player); return; } - SteamwarUser warkingUser = SteamwarUser.get(args[2]); - if(warkingUser == null){ - player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler existiert nicht"); + SteamwarUser user = SteamwarUser.get(args[2]); + if(user == null){ + SchematicSystem.MESSAGE.send("UNKNOWN_USER", player); return; } - if(schematic.getSchemOwner() == warkingUser.getId()){ - player.sendMessage(SchematicSystem.PREFIX + "§cAlso bitte: Das ist deine eigene Schematic!"); + if(schematic.getSchemOwner() == user.getId()){ + SchematicSystem.MESSAGE.send("MEMBER_ON_OWN", player); return; } - 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"); + if(SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), user.getUUID()) != null){ + SchematicSystem.MESSAGE.send("ADDMEMBER_ALREADY", player); return; } - 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()); + new SchematicMember(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), user.getUUID()); + SchematicSystem.MESSAGE.send("ADDMEMBER_ADDED", player, user.getUserName(), 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" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); + Player target = Bukkit.getPlayer(user.getUUID()); + if(target != null){ + SchematicSystem.MESSAGE.send("ADDMEMBER_ACCESS", target, schematic.getSchemName(), player.getName()); + } } private void delmember(Player player, String[] args){ @@ -441,7 +521,7 @@ public class SchematicCommand implements CommandExecutor { return; if(schematic.getSchemOwner() != SteamwarUser.get(player.getUniqueId()).getId()) { - player.sendMessage(SchematicSystem.PREFIX + "§cDu darfst nur von deinen eigenen Schematics Mitglieder entfernen"); + SchematicSystem.MESSAGE.send("DELMEMBER_ONLY_OWN", player); return; } @@ -452,49 +532,38 @@ public class SchematicCommand implements CommandExecutor { SteamwarUser user = SteamwarUser.get(args[2]); if(user == null){ - player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler existiert nicht"); + SchematicSystem.MESSAGE.send("UNKNOWN_USER", player); return; } if(schematic.getSchemOwner() == user.getId()){ - player.sendMessage(SchematicSystem.PREFIX + "§cAlso bitte: Das ist deine eigene Schematic!"); + SchematicSystem.MESSAGE.send("MEMBER_ON_OWN", player); return; } SchematicMember schematicMember = SchematicMember.getSchemMemberFromDB(schematic.getSchemName(), SteamwarUser.get(schematic.getSchemOwner()).getUUID(), user.getUUID()); if(schematicMember == null) { - player.sendMessage(SchematicSystem.PREFIX + "§cDieser Spieler ist nicht auf die Schematic hinzugefügt"); + SchematicSystem.MESSAGE.send("DELMEMBER_NOT_ADDED", player); return; } schematicMember.remove(); - player.sendMessage(SchematicSystem.PREFIX + "Der Spieler §e" + user.getUserName() + " §7hat keinen Zugriff mehr auf die Schematic §e" + schematic.getSchemName()); + SchematicSystem.MESSAGE.send("DELMEMBER_REMOVED", player, user.getUserName(), schematic.getSchemName()); Player target = Bukkit.getPlayer(user.getUUID()); - if(target != null) - target.sendMessage(SchematicSystem.PREFIX + "Du hast keinen Zugriff mehr auf die Schematic §e" + schematic.getSchemName() + "§7von §e" + SteamwarUser.get(schematic.getSchemOwner()).getUserName()); + if(target != null){ + SchematicSystem.MESSAGE.send("DELMEMBER_REVOKED", player, schematic.getSchemName(), player.getName()); + } } private void help(Player player) { - player.sendMessage(SchematicSystem.PREFIX + "Befehle§8:"); - player.sendMessage("§8/§eschem gui §8- §7Öffnet die Schematic-GUI"); - player.sendMessage("§8/§eschem list §8- §7Zeigt dir deine Schematics an"); - player.sendMessage("§8/§eschem list public §8- §7Zeigt alle Public-Schematics"); - player.sendMessage("§8/§eschem search §8[§7Stichwort§8] - §7Sucht nach passenden Schematics"); - player.sendMessage("§8/§eschem load §8[§7Schematic§8] - §7Lädt eine Schematic"); - player.sendMessage("§8/§eschem save §8[§7Schematic§8] - §7Speichert dein Clipboard als Schematic"); - player.sendMessage("§8/§eschem changetype §8[§7Schematic§8] - §7Ändert die Art deiner Schematic"); - player.sendMessage("§8/§eschem delete §8[§7Schematic§8] - §7Löscht eine Schematic"); - player.sendMessage("§8/§eschem info §8[§7Schematic§8] - §7Zeigt dir Informationen zur Schematic"); - player.sendMessage("§8/§eschem download §8[§7Schematic§8] - §7Gibt dir einen Downloadlink (1 min gültig)"); - player.sendMessage("§8/§eschem addmember §8[§7Schematic§8] §8[§7Spieler§8] - §7Fügt einen Spieler zu einer Schematic hinzu"); - player.sendMessage("§8/§eschem delmember §8[§7Schematic§8] §8[§7Spieler§8] - §7Entfernt einen Spieler von einer Schematic"); + SchematicSystem.MESSAGE.sendPrefixless("HELP", player); } private void sendPlayerSchematicList(int currentPage, Player player, String precommand, List schematicList) { SteamwarUser user = SteamwarUser.get(player.getUniqueId()); if(schematicList.isEmpty()) { - player.sendMessage(SchematicSystem.PREFIX + "§cKeine Schematics gefunden"); + SchematicSystem.MESSAGE.send("LIST_NO_SCHEMS", player); return; } @@ -512,40 +581,31 @@ public class SchematicCommand implements CommandExecutor { if(currentPage >= pages || currentPage < 0) return; - player.sendMessage("§eSeite " + (currentPage + 1) + " §8/ " + pages + " §8| §e" + schematicList.size() + " Schematics"); + SchematicSystem.MESSAGE.send("LIST_HEADER", player, currentPage + 1, pages, schematicList.size()); for(int i = currentPage * FILES_PER_PAGE; i < (currentPage * FILES_PER_PAGE) + FILES_PER_PAGE; i++) { if(schematicList.size() <= i) break; Schematic schematic = schematicList.get(i); - - String schematicPlayer = ""; - if(schematic.getSchemOwner() != user.getId()) - schematicPlayer = " §8von §7" + SteamwarUser.get(schematic.getSchemOwner()).getUserName(); - - TextComponent schematics = new TextComponent("§e" + schematic.getSchemType().getKuerzel() + " §7" + schematic.getSchemName() + schematicPlayer); - schematics.setBold(true); - - schematics.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder("§eSchematic verwalten").create())); - schematics.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem info " + schematic.getSchemName())); - - player.spigot().sendMessage(schematics); + SchematicSystem.MESSAGE.send("LIST_INFO", player, "LIST_INFO_HOVER", new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/schem info " + schematic.getSchemName()), + schematic.getSchemType().getKuerzel(), schematic.getSchemName(), + schematic.getSchemOwner() != user.getId() ? SchematicSystem.MESSAGE.parse("LIST_INFO_BY", player, SteamwarUser.get(schematic.getSchemOwner()).getUserName()) : ""); } if(pages <= 1) return; - TextComponent beforePage = new TextComponent("««"); + TextComponent beforePage = SchematicSystem.MESSAGE.parseToComponent("LIST_PREVIOUS", false, player); if(currentPage > 0){ beforePage.setColor(ChatColor.YELLOW); - beforePage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder("§eVorherige Seite").create())); + beforePage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText(SchematicSystem.MESSAGE.parse("LIST_PREVIOUS_HOVER", player)))); beforePage.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, precommand + (currentPage - 1))); }else beforePage.setColor(ChatColor.RED); - TextComponent nextPage = new TextComponent(" Seite »»"); + TextComponent nextPage = SchematicSystem.MESSAGE.parseToComponent("LIST_NEXT", false, player); if(currentPage < pages-1){ nextPage.setColor(ChatColor.YELLOW); - nextPage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder("§eNächste Seite").create())); + nextPage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText(SchematicSystem.MESSAGE.parse("LIST_NEXT_HOVER", player)))); nextPage.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, precommand + (currentPage + 1))); }else nextPage.setColor(ChatColor.RED);