Angepinnt Unser eigenes Weltensystem - Das Filesystem.

    • Bukkit Spigot

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Unser eigenes Weltensystem - Das Filesystem.

      Herzlich Willkommen zurück meine Lieben,

      Dies ist nun der zweite Teil meiner Forumreihe zum Thema Weltensysteme. Legen wir also direkt los.

      Java-Quellcode

      1. @Override
      2. public void onEnable() {
      3. registerCommands();
      4. registerEvents();
      5. FileManager.createStandardFiles();
      6. Bukkit.getConsoleSender().sendMessage(prefix + "§aDas Plugin wurde aktiviert!");
      7. }
      8. public void registerEvents() {
      9. new PlayerJoin(this);
      10. }
      Alles anzeigen
      In der Main-Klasse wurde nun die Methode createStandardFiles() und die Klasse für das PlayerJoinEvent regisrtiert.

      Java-Quellcode

      1. package Commands;
      2. import java.io.File;
      3. import org.bukkit.Bukkit;
      4. import org.bukkit.World.Environment;
      5. import org.bukkit.WorldCreator;
      6. import org.bukkit.WorldType;
      7. import org.bukkit.command.Command;
      8. import org.bukkit.command.CommandExecutor;
      9. import org.bukkit.command.CommandSender;
      10. import org.bukkit.command.ConsoleCommandSender;
      11. import org.bukkit.entity.Player;
      12. import Main.Worldsystem;
      13. public class CreateCommand implements CommandExecutor {
      14. @SuppressWarnings("unused")
      15. private Worldsystem plugin;
      16. public CreateCommand(Worldsystem plugin) {
      17. this.plugin = plugin;
      18. }
      19. @Override
      20. public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
      21. if(!(sender instanceof ConsoleCommandSender)) {
      22. Player p = (Player) sender;
      23. if(p.hasPermission("Worldsystem.Create")) {
      24. if(args.length == 1) {
      25. String world = args[0];
      26. File worldfile = new File("plugins/Worldsystem/Worlds/" + world + ".yml");
      27. if(!worldfile.exists()) {
      28. p.sendMessage(Worldsystem.prefix + "§aDie Welt wird erstellt...");
      29. WorldCreator wc = (WorldCreator) WorldCreator.name(world).environment(Environment.NORMAL).type(WorldType.NORMAL);
      30. Bukkit.createWorld(wc);
      31. p.sendMessage(Worldsystem.prefix + "§aDie Welt §e" + world + " §awurde erstellt.");
      32. p.teleport(Bukkit.getWorld(world).getSpawnLocation());
      33. p.sendMessage(Worldsystem.prefix + "§cDer Weltenspawn wurde noch nicht gesetzt! Dieser muss mit dem Befehl /setspawn gesetzt werden!");
      34. } else {
      35. p.sendMessage(Worldsystem.prefix + "§cDiese Welt existiert bereits!");
      36. }
      37. } else {
      38. p.sendMessage(Worldsystem.prefix + "§cVerwende: /create <Weltname>");
      39. }
      40. } else {
      41. p.sendMessage(Worldsystem.prefix + Worldsystem.noperms);
      42. }
      43. } else {
      44. if(args.length == 1) {
      45. String world = args[0];
      46. File worldfile = new File("plugins/Worldsystem/Worlds/" + world + ".yml");
      47. if(!worldfile.exists()) {
      48. sender.sendMessage(Worldsystem.prefix + "§aDie Welt wird erstellt...");
      49. WorldCreator wc = (WorldCreator) WorldCreator.name(world).environment(Environment.NORMAL).type(WorldType.NORMAL);
      50. Bukkit.createWorld(wc);
      51. sender.sendMessage(Worldsystem.prefix + "§aDie Welt §e" + world + " §awurde erstellt.");
      52. sender.sendMessage(Worldsystem.prefix + "§cDer Weltenspawn wurde noch nicht gesetzt! Dieser muss von einem Admin gesetzt werden!");
      53. } else {
      54. sender.sendMessage(Worldsystem.prefix + "§cDiese Welt existiert bereits!");
      55. }
      56. } else {
      57. sender.sendMessage(Worldsystem.prefix + "§cVerwende: /create <Weltname>");
      58. }
      59. }
      60. return true;
      61. }
      62. }
      Alles anzeigen
      In der /create Befehls Klasse wurde nun die Abfrage eingebaut, ob die Welt schon existiert, außerdem bekommt der Spieler beim erstellen eine Nachricht, dass der Weltenspawn noch gesetzt werden muss, um die Datei zu der Welt noch zu erstellen.

      Java-Quellcode

      1. package Utils;
      2. import java.io.File;
      3. import java.io.IOException;
      4. import org.bukkit.Location;
      5. import org.bukkit.configuration.file.YamlConfiguration;
      6. import org.bukkit.entity.Player;
      7. public class FileManager {
      8. public static void createStandardFiles() {
      9. File mainfolder = new File("plugins/Worldsystem");
      10. File worldfolder = new File("plugins/Worldsystem/Worlds");
      11. if(!mainfolder.exists()) {
      12. mainfolder.mkdir();
      13. }
      14. if(!worldfolder.exists()) {
      15. worldfolder.mkdir();
      16. }
      17. }
      18. public static void setWorldSpawn(String world, Player p) {
      19. File worldfile = new File("plugins/Worldsystem/Worlds/" + world + ".yml");
      20. if(!worldfile.exists()) {
      21. try {
      22. worldfile.createNewFile();
      23. } catch (IOException ex) {
      24. ex.printStackTrace();
      25. }
      26. }
      27. YamlConfiguration cfg = YamlConfiguration.loadConfiguration(worldfile);
      28. Location loc = p.getLocation();
      29. double x = loc.getX();
      30. double y = loc.getY();
      31. double z = loc.getZ();
      32. float yaw = loc.getYaw();
      33. float pitch = loc.getPitch();
      34. String worldname = loc.getWorld().getName();
      35. cfg.set("X", x);
      36. cfg.set("Y", y);
      37. cfg.set("Z", z);
      38. cfg.set("Yaw", yaw);
      39. cfg.set("Pitch", pitch);
      40. cfg.set("Worldname", worldname);
      41. try {
      42. cfg.save(worldfile);
      43. } catch (IOException ex) {
      44. ex.printStackTrace();
      45. }
      46. }
      47. }
      Alles anzeigen
      In der FileManager-Klasse habe ich nun zum einem die Standard Ordner des Plugins mit der Methode createStandardFiles() erstellt und zum anderen habe ich die Methode setWorldSpawn() zum erstellen der Weltdateien geschrieben

      Java-Quellcode

      1. package Events;
      2. import java.io.File;
      3. import org.bukkit.Bukkit;
      4. import org.bukkit.Location;
      5. import org.bukkit.World;
      6. import org.bukkit.configuration.file.YamlConfiguration;
      7. import org.bukkit.entity.Player;
      8. import org.bukkit.event.EventHandler;
      9. import org.bukkit.event.Listener;
      10. import org.bukkit.event.player.PlayerJoinEvent;
      11. import Main.Worldsystem;
      12. import Utils.FileManager;
      13. public class PlayerJoin implements Listener {
      14. @SuppressWarnings("unused")
      15. private Worldsystem plugin;
      16. public PlayerJoin(Worldsystem plugin) {
      17. this.plugin = plugin;
      18. plugin.getServer().getPluginManager().registerEvents(this, plugin);
      19. }
      20. @EventHandler
      21. public void PlayerJoinEvent(PlayerJoinEvent e) {
      22. Player p = e.getPlayer();
      23. String world = p.getLocation().getWorld().getName();
      24. File worldfile = new File("plugins/Worldsystem/Worlds/" + world + ".yml");
      25. if(!worldfile.exists()) {
      26. FileManager.setWorldSpawn(world, p);
      27. } else {
      28. if(!p.hasPlayedBefore()) {
      29. File file = new File("plugins/Furnilla/Locations/world.yml");
      30. YamlConfiguration cfg = YamlConfiguration.loadConfiguration(file);
      31. Location loc = p.getLocation();
      32. loc.setX(cfg.getDouble("X"));
      33. loc.setY(cfg.getDouble("Y"));
      34. loc.setZ(cfg.getDouble("Z"));
      35. double yaw = cfg.getDouble("Yaw");
      36. double pitch = cfg.getDouble("Pitch");
      37. loc.setYaw((float) yaw);
      38. loc.setPitch((float) pitch);
      39. World w = Bukkit.getWorld(cfg.getString("Worldname"));
      40. loc.setWorld(w);
      41. p.teleport(loc);
      42. }
      43. }
      44. }
      45. }
      Alles anzeigen
      Zu guter Letzt habe ich in der PlayerJoin-Klasse festgelegt, dass die Weltdatei erstellt wird, sollte sie noch nicht existieren und dass man an dem gespeichertem Spawn aus der world-Datei gespawnt wird, sollte man noch nicht auf dem Server gespielt haben.

      Liebe Grüße,

      Mimnu • Martin

      PS: Der /setspawn Befehl kommt in der nächsten Folge des Tutorials.
    • Java-Quellcode

      1. if( !stmt ) {
      2. return;
      3. }
      4. if( !stmt ) {
      5. return;
      6. }
      7. if( !stmt ) {
      8. return;
      9. }
      Alles anzeigen
      Ich gebe dir zumindest Recht das es auch anders ginge:
      Es kann nach diesem Code übersichtlicher werden :)
      Liebe Grüße, Pixel


      -> Ich bin euch immer ein Pixel vorraus!
      -> Ohne mich würdet ihr Minecraft nicht spielen können


      Der Pixelige-YouTube-Kanal: BestPixelHD
      - YouTube
      Der Pixelige-Twitch-Kanal: Twitch
    • Hallo,

      ich habe ein paar störende Dinge welche mir aufgefallen sind:
      1. Die Benennung von Paketen. Definitiv nicht Konventionen-Konform. Pakete werden klein und Klassen groß geschrieben. Dazu sind die so aufgebaut: com.domain.paket.Klasse
      2. Statische Methoden - Darauf sollte man weitestgehend verzichten. Beispielsweise eine Klassen-Instanz in der Main.
      3. Zum ganzen (WorldSystem plugin) im Konstruktor - Schau dir am besten mal das Singleton Pattern an.
      4. Daten cachen. Du liest bei jedem Join-Event die Datei für das holen der Weltdaten aus. Cache diese Daten am besten beim Laden des Plugins und zusätzlich beim erstellen einer Welt.
      5. Kleiner Tipp am Rande, du brauchst nicht X, Y, Z Koordinate und Yaw und Pitch einzeln speichern. Du hast die Möglichkeit Location-Objekte direkt per set zu speichern und mittels get zu laden (natürlich zur Location casten)


      MfG
    • SpigotException schrieb:

      Hallo,

      ich habe ein paar störende Dinge welche mir aufgefallen sind:
      1. Kleiner Tipp am Rande, du brauchst nicht X, Y, Z Koordinate und Yaw und Pitch einzeln speichern. Du hast die Möglichkeit Location-Objekte direkt per set zu speichern und mittels get zu laden (natürlich zur Location casten)


      MfG
      Ich nutze dafür am liebsten meine Methode :) und danke für deine detaillierte Antwort:

      Java-Quellcode

      1. public static String serializeLocation(Location l, boolean exact) {
      2. if (l != null) {
      3. String key = l.getWorld().getName() + ",";
      4. if (exact) {
      5. key += l.getX() + "," + l.getY() + "," + l.getZ() + "," + l.getYaw() + "," + l.getPitch();
      6. } else {
      7. key += l.getBlockX() + "," + l.getBlockY() + "," + l.getBlockZ();
      8. }
      9. return key;
      10. }
      11. return null;
      12. }
      Alles anzeigen

      Wo ich aber so nen bisschen anderer Meinung bin ist hier:

      SpigotException schrieb:

      Hallo,

      ich habe ein paar störende Dinge welche mir aufgefallen sind:
      1. Statische Methoden - Darauf sollte man weitestgehend verzichten. Beispielsweise eine Klassen-Instanz in der Main.


      MfG

      Was natürlich nicht nötig ist, ist das hier:

      Quellcode

      1. public CreateCommand(Worldsystem plugin) {
      2. this.plugin = plugin;
      3. }

      Hier reicht eine Instanz in der Main Klasse selbst(die statisch ist) und z.B. mit einer get-Methode aufgerufen werden kann, z.B. Main.getInstance();
      Dies meintest du aber im Punkt 3.
      Liebe Grüße, Pixel


      -> Ich bin euch immer ein Pixel vorraus!
      -> Ohne mich würdet ihr Minecraft nicht spielen können


      Der Pixelige-YouTube-Kanal: BestPixelHD
      - YouTube
      Der Pixelige-Twitch-Kanal: Twitch

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von BestPixelHD ()