world / plot / protection functions moved to snuvi script

src/main/java/me/km/KajetansMod.java

@@ -14,6 +14,7 @@ import me.km.playerbank.PlayerManager;
 import me.km.plots.ProtectionBank;
 import me.km.scheduler.SnuviScheduler;
 import me.km.snuviscript.ScriptModule;
+import me.km.world.ChangeWorldEvent;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.text.TextComponentString;
@@ -158,9 +159,8 @@ public class KajetansMod
         datatools.registerEvent(new DataToolsEvents(datatools));
 
         // Worldmanager
-        world = new Module("Worlds", TextFormatting.RED);
-        world.registerCommands(e, "me.km.dimensions");          
-        world.registerEvents("me.km.dimensions");
+        world = new Module("Worlds", TextFormatting.RED);      
+        world.registerEvent(new ChangeWorldEvent());
 
         // Scriptsystem
         scripts = new ScriptModule("Scripts", TextFormatting.LIGHT_PURPLE);

src/main/java/me/km/blockprotections/BlockProtection.java

@@ -30,6 +30,11 @@ public class BlockProtection extends Module
         registerEvent(this);
     }
     
+    public BlockProtectionBank getDatabank()
+    {
+        return bank;
+    }
+    
     @SubscribeEvent(priority = EventPriority.HIGHEST)
     public void onBlockPlace(BlockEvent.PlaceEvent e)
     {

src/main/java/me/km/blockprotections/BlockProtectionBank.java

@@ -171,7 +171,7 @@ public class BlockProtectionBank
     
     public boolean hasAccess(BlockPos pos, World w, EntityPlayer p)
     {
-        return hasAccess(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(w), KajetansMod.playerbank.getPlayerId(p));
+        return hasAccess(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(w), KajetansMod.playerbank.getPlayerId(p.getUniqueID()));
     }
     
     private final IStatement getId = KajetansMod.databank.createStatement(

src/main/java/me/km/playerbank/PlayerBank.java

@@ -95,8 +95,10 @@ public class PlayerBank
             getUUID.setString(1, name);
             try(ResultSet rs = getUUID.executeQuery())
             {
-                rs.next();
-                return new UUID(rs.getLong(2), rs.getLong(1));
+                if(rs.next())
+                {
+                    return new UUID(rs.getLong(2), rs.getLong(1));
+                }
             }
             catch(Exception ex)
             {

src/main/java/me/km/playerbank/PlayerManager.java

@@ -30,9 +30,14 @@ public class PlayerManager extends Module
         return bank;
     }
     
-    public int getPlayerId(EntityPlayer p)
+    public int getPlayerId(UUID uuid)
     {
-        return playerIds.getOrDefault(p, -1);
+        Integer i = playerIds.get(uuid);
+        if(i != null)
+        {
+            return i;
+        }
+        return bank.getId(uuid);
     }
     
     @SubscribeEvent(priority = EventPriority.HIGH)

src/main/java/me/km/plots/ProtectionBank.java

@@ -50,10 +50,7 @@ public class ProtectionBank extends Module
     
     private final IStatement add = KajetansMod.databank.createStatement(
             "INSERT INTO plots (x1,y1,z1,x2,y2,z2,world_name,name) VALUES (?,?,?,?,?,?,?,?);");
-    private final IStatement addPlotGrant = KajetansMod.databank.createStatement(
-            "INSERT INTO plot_grant (plot_id,player_id) VALUES (LAST_INSERT_ID(), ?);");
-    
-    public void add(int x1, int y1, int z1, int x2, int y2, int z2, String worldName, String plotName, int playerId)
+    public void add(int x1, int y1, int z1, int x2, int y2, int z2, String worldName, String plotName)
     {
         int minX = Math.min(x1, x2);
         int minY = Math.min(y1, y2);
@@ -74,10 +71,6 @@ public class ProtectionBank extends Module
             add.setString(7, worldName);
             add.setString(8, plotName);
             add.executeUpdate();
-            
-            addPlotGrant.validate();
-            addPlotGrant.setInt(1, playerId);
-            addPlotGrant.executeUpdate();
         }
         catch(SQLException ex)
         {
@@ -161,9 +154,9 @@ public class ProtectionBank extends Module
     private final IStatement getIds = KajetansMod.databank.createStatement(
             "SELECT id FROM plots WHERE x1<=? AND x2>=? AND y1<=? AND y2>=? AND z1<=? AND z2>=? AND world_name=?;");
     
-    public ArrayList<Integer> getIds(int x, int y, int z, String worldName)
+    public ArrayList<Double> getIds(int x, int y, int z, String worldName)
     {
-        ArrayList<Integer> list = new ArrayList<>();
+        ArrayList<Double> list = new ArrayList<>();
         try
         {
             getIds.validate();
@@ -178,7 +171,7 @@ public class ProtectionBank extends Module
             {
                 while(rs.next())
                 {
-                    list.add(rs.getInt(1));
+                    list.add((double) rs.getInt(1));
                 }
             }
             catch(SQLException ex)
@@ -198,17 +191,17 @@ public class ProtectionBank extends Module
     
     public boolean canBuild(int x, int y, int z, String worldName, int playerId)
     {
-        ArrayList<Integer> ids = getIds(x, y, z, worldName);
+        ArrayList<Double> ids = getIds(x, y, z, worldName);
         if(ids.isEmpty())
         {
             return true;
         }
-        for(int plotId : ids)
+        for(double plotId : ids)
         {
             try
             {
                 canBuild.validate();
-                canBuild.setInt(1, plotId);
+                canBuild.setInt(1, (int) plotId);
                 canBuild.setInt(2, playerId);
                 try(ResultSet rs = canBuild.executeQuery())
                 {
@@ -232,7 +225,7 @@ public class ProtectionBank extends Module
     
     public boolean canBuild(World w, BlockPos pos, EntityPlayer p)
     {
-        return canBuild(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(w), KajetansMod.playerbank.getPlayerId(p));
+        return canBuild(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(w), KajetansMod.playerbank.getPlayerId(p.getUniqueID()));
     }
     
     private final IStatement remove = KajetansMod.databank.createStatement(

src/main/java/me/km/snuviscript/MinecraftFunctions.java

@@ -1,9 +1,11 @@
 package me.km.snuviscript;
 
 import com.mojang.authlib.GameProfile;
+import java.io.File;
 import me.km.KajetansMod;
 import me.km.utils.NBTUtils;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.List;
@@ -91,6 +93,7 @@ import net.minecraft.util.NonNullList;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.TextComponentString;
+import net.minecraft.world.EnumDifficulty;
 import net.minecraft.world.GameType;
 import net.minecraft.world.chunk.storage.AnvilChunkLoader;
 import net.minecraft.world.storage.WorldInfo;
@@ -281,6 +284,7 @@ public class MinecraftFunctions
             }
             return KajetansMod.playerbank.getDataBank().getUUID(o.toString());
         });
+        parser.registerFunction("player.getid", (sc, in) -> KajetansMod.playerbank.getPlayerId(getUUID(in[0].get(sc))));
         parser.registerFunction("player.get", (sc, in) -> 
         { 
             return KajetansMod.server.getPlayerList().getPlayerByUUID(getUUID(in[0].get(sc)));
@@ -467,6 +471,24 @@ public class MinecraftFunctions
             in[0].set(sc, Utils.getPlayers(p, in[2].getDouble(sc))); 
             return Void.TYPE;
         });
+        parser.registerFunction("player.getinvslot", (sc, in) -> 
+        {     
+            return ((EntityPlayer) in[0].get(sc)).inventory.mainInventory.get(in[1].getInt(sc));
+        });
+        parser.registerFunction("player.setinvslot", (sc, in) -> 
+        {     
+            ((EntityPlayer) in[0].get(sc)).inventory.mainInventory.set(in[1].getInt(sc), ((ItemStack) in[2].get(sc)).copy()); 
+            return Void.TYPE;
+        });
+        parser.registerFunction("player.getenderslot", (sc, in) -> 
+        {     
+            return ((EntityPlayer) in[0].get(sc)).getInventoryEnderChest().getStackInSlot(in[1].getInt(sc));
+        });
+        parser.registerFunction("player.setenderslot", (sc, in) -> 
+        {     
+            ((EntityPlayer) in[0].get(sc)).getInventoryEnderChest().setInventorySlotContents(in[1].getInt(sc), ((ItemStack) in[2].get(sc)).copy()); 
+            return Void.TYPE;
+        });
 
         // ---------------------------------------------------------------------    
         // Players-library
@@ -544,12 +566,58 @@ public class MinecraftFunctions
         {     
             return ModDimensions.getWorldFromName(in[0].getString(sc));
         });
+        parser.registerFunction("world.load", (sc, in) -> 
+        {                    
+            String name = in[0].getString(sc);
+            if(!new File("./" + name).isDirectory())
+            {
+                return false;
+            }
+            return ModDimensions.loadWorld(name, ModDimensions.CUSTOM_WORLD);
+        });    
+        parser.registerFunction("world.unload", (sc, in) -> 
+        {                    
+            return ModDimensions.unloadWorld(in[0].getString(sc));
+        });  
+        parser.registerFunction("world.getname", (sc, in) -> 
+        {     
+            return ModDimensions.getWorldName((World) in[0].get(sc));
+        });
+        parser.registerFunction("world.setdiffi", (sc, in) -> 
+        {                    
+            EnumDifficulty diffi = EnumDifficulty.valueOf(in[1].getString(sc).toUpperCase());
+            ((World) in[0].get(sc)).getWorldInfo().setDifficulty(diffi);                                     
+            return Void.TYPE;
+        });  
+        parser.registerFunction("world.setgamerule", (sc, in) -> 
+        {                    
+            ((World) in[0].get(sc)).getGameRules().setOrCreateGameRule(in[1].getString(sc), in[2].getString(sc));
+            return Void.TYPE;
+        });  
+        parser.registerFunction("world.getgamerule", (sc, in) -> 
+        {                    
+            return ((World) in[0].get(sc)).getGameRules().getString(in[1].getString(sc));
+        });  
         parser.registerFunction("world.setspawn", (sc, in) -> 
         {    
             Location l = ((Location) in[0].get(sc));
             l.getWorld().setSpawnPoint(l.getBlockPos());
             return Void.TYPE;
         });
+        parser.registerFunction("world.getspawn", (sc, in) -> 
+        {    
+            World w = (World) in[0].get(sc);
+            return new Location(w, w.getSpawnPoint());
+        });
+        parser.registerFunction("world.getall", (sc, in) -> 
+        {    
+            ArrayList<World> worlds = new ArrayList<>();
+            for(World w : KajetansMod.server.worlds)
+            {
+                worlds.add(w);
+            }
+            return worlds;
+        });
         parser.registerFunction("world.settime", (sc, in) -> 
         {    
             ((World) in[0].get(sc)).setWorldTime(in[0].getLong(sc));
@@ -1218,6 +1286,11 @@ public class MinecraftFunctions
             EffectUtils.addPotionTo(base, potion, in[2].getInt(sc), in[3].getInt(sc));
             return Void.TYPE; 
         });
+        parser.registerFunction("entity.cleareffects", (sc, in) -> 
+        { 
+            ((EntityLivingBase) in[0].get(sc)).clearActivePotions();
+            return Void.TYPE; 
+        });
         parser.registerFunction("entity.haseffect", (sc, in) -> ((EntityLivingBase) in[0].get(sc)).isPotionActive(Potion.getPotionFromResourceLocation(in[1].getString(sc))));
         parser.registerFunction("entity.explode", (sc, in) -> 
         { 
@@ -1423,56 +1496,148 @@ public class MinecraftFunctions
         // ---------------------------------------------------------------------  
         // Plot-library   
         // ---------------------------------------------------------------------  
-        parser.registerFunction("plot.hastag", (sc, in) -> true);//KajetansMod.plots.getDataBank(ProtectionBank.class).hasTag(((Location) in[0].get(sc)).getWorld(), ((Location) in[0].get(sc)).getBlockPos(), in[1].getString(sc))); 
         parser.registerFunction("plot.add", (sc, in) -> 
         {    
-            /*final Location l1 = (Location) in[0].get(sc);
+            final Location l1 = (Location) in[0].get(sc);
             final Location l2 = (Location) in[1].get(sc);
             final BlockPos pos1 = l1.getBlockPos();
             final BlockPos pos2 = l2.getBlockPos();
+            final int x1 = pos1.getX();
+            final int y1 = pos1.getY();
+            final int z1 = pos1.getZ();
+            final int x2 = pos2.getX();
+            final int y2 = pos2.getY();
+            final int z2 = pos2.getZ();
+            final String world = ModDimensions.getWorldName(l1.getWorld());
+            final String name = in[2].getString(sc);
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.plots.add(x1, y1, z1, x2, y2, z2, world, name);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("plot.remove", (sc, in) -> 
+        {    
+            final int plotId = in[0].getInt(sc);
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.plots.remove(plotId);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("plot.addplayer", (sc, in) -> 
+        {    
+            final int plotId = in[0].getInt(sc);
+            final int playerId = in[1].getInt(sc);
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.plots.addPlayer(plotId, playerId);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("plot.removeplayer", (sc, in) -> 
+        {    
+            final int plotId = in[0].getInt(sc);
+            final int playerId = in[1].getInt(sc);
             KajetansMod.scheduler.getWorker().add(() -> 
             {
-                KajetansMod.plots.getDataBank(ProtectionBank.class).addPlot(Math.min(pos1.getX(), pos2.getX()),
-                            Math.min(pos1.getY(), pos2.getY()),
-                            Math.min(pos1.getZ(), pos2.getZ()),
-                            Math.max(pos1.getX(), pos2.getX()),
-                            Math.max(pos1.getY(), pos2.getY()),
-                            Math.max(pos1.getZ(), pos2.getZ()),
-                            ModDimensions.getWorldName(l1.getWorld()), null, in[2].getString(sc));
-            });*/
+                KajetansMod.plots.removePlayer(plotId, playerId);
+            });
             return Void.TYPE;
         });
         parser.registerFunction("plot.getids", (sc, in) -> 
         {  
-            /*Location l = (Location) in[1].get(sc);
-            in[0].set(sc, KajetansMod.plots.getDataBank(ProtectionBank.class).getRegionIds(l.getWorld(), 
-                l.getBlockPos()).stream().map(o -> ((Number) o).doubleValue()).collect(Collectors.toSet())); */
-            return Void.TYPE; 
+            Location l = (Location) in[0].get(sc);
+            BlockPos pos = l.getBlockPos();
+            return KajetansMod.plots.getIds(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(l.getWorld())); 
         });
         parser.registerFunction("plot.canbuild", (sc, in) -> 
         {    
-            return false;
-            /*Location l = (Location) in[0].get(sc);
-            return KajetansMod.plots.getDataBank(ProtectionBank.class).canBuild(l.getWorld(), l.getBlockPos(), (EntityPlayer) in[1].get(sc));*/
+            Location l = (Location) in[0].get(sc);
+            return KajetansMod.plots.canBuild(l.getWorld(), l.getBlockPos(), (EntityPlayer) in[1].get(sc));
         });
-        parser.registerFunction("plot.getname", (sc, in) -> 
+        parser.registerFunction("plot.getname", (sc, in) -> KajetansMod.plots.getName(in[0].getInt(sc)));
+        parser.registerFunction("plot.doesintersect", (sc, in) -> 
         {    
-            /*Location l = (Location) in[0].get(sc);
-            KajetansMod.plots.getDataBank(ProtectionBank.class).getFirstRegionName(l.getWorld(), l.getBlockPos()); */
-            return Void.TYPE; 
+            Location l = (Location) in[0].get(sc);
+            BlockPos l1 = l.getBlockPos();
+            BlockPos l2 = ((Location) in[1].get(sc)).getBlockPos();
+            return KajetansMod.plots.isOverlapping(l1.getX(), l1.getY(), l1.getZ(), l2.getX(), l2.getY(), l2.getZ(), l.getWorld());
         });
-        parser.registerFunction("plot.doesintersect", (sc, in) -> 
+        
+        // ---------------------------------------------------------------------  
+        // block protection library   
+        // ---------------------------------------------------------------------  
+        parser.registerFunction("protect.add", (sc, in) -> 
         {    
-            return false;
-            /*Location l1 = (Location) in[0].get(sc);
-            Location l2 = (Location) in[1].get(sc);
-            int x1 = (int) Math.min(l1.getX(), l2.getX());
-            int x2 = (int) Math.max(l1.getX(), l2.getX());
-            int y1 = (int) Math.min(l1.getY(), l2.getY());
-            int y2 = (int) Math.max(l1.getY(), l2.getY());
-            int z1 = (int) Math.min(l1.getZ(), l2.getZ());
-            int z2 = (int) Math.max(l1.getZ(), l2.getZ());
-            return KajetansMod.plots.getDataBank(ProtectionBank.class).isPlotOverlapping(x1, y1, z1, x2, y2, z2, l1.getWorld());*/
+            final Location l1 = (Location) in[0].get(sc);
+            final BlockPos pos1 = l1.getBlockPos();
+            final int x1 = pos1.getX();
+            final int y1 = pos1.getY();
+            final int z1 = pos1.getZ();
+            final int playerId = in[1].getInt(sc);
+            final String world = ModDimensions.getWorldName(l1.getWorld());
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.blocks.getDatabank().add(x1, y1, z1, world, playerId);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("protect.remove", (sc, in) -> 
+        {    
+            final Location l1 = (Location) in[0].get(sc);
+            final BlockPos pos1 = l1.getBlockPos();
+            final int x1 = pos1.getX();
+            final int y1 = pos1.getY();
+            final int z1 = pos1.getZ();
+            final String world = ModDimensions.getWorldName(l1.getWorld());
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.blocks.getDatabank().remove(x1, y1, z1, world);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("protect.addplayer", (sc, in) -> 
+        {    
+            final Location l1 = (Location) in[0].get(sc);
+            final BlockPos pos1 = l1.getBlockPos();
+            final int x1 = pos1.getX();
+            final int y1 = pos1.getY();
+            final int z1 = pos1.getZ();
+            final String world = ModDimensions.getWorldName(l1.getWorld());
+            final int playerId = in[1].getInt(sc);
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.blocks.getDatabank().addPlayer(x1, y1, z1, world, playerId);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("protect.removeplayer", (sc, in) -> 
+        {    
+            final Location l1 = (Location) in[0].get(sc);
+            final BlockPos pos1 = l1.getBlockPos();
+            final int x1 = pos1.getX();
+            final int y1 = pos1.getY();
+            final int z1 = pos1.getZ();
+            final String world = ModDimensions.getWorldName(l1.getWorld());
+            final int playerId = in[1].getInt(sc);
+            KajetansMod.scheduler.getWorker().add(() -> 
+            {
+                KajetansMod.blocks.getDatabank().removePlayer(x1, y1, z1, world, playerId);
+            });
+            return Void.TYPE;
+        });
+        parser.registerFunction("protect.hasaccess", (sc, in) -> 
+        {  
+            Location l = (Location) in[0].get(sc);
+            BlockPos pos = l.getBlockPos();
+            return KajetansMod.blocks.getDatabank().hasAccess(pos, l.getWorld(), (EntityPlayer) in[1].get(sc));
+        });
+        parser.registerFunction("protect.getids", (sc, in) -> 
+        {    
+            Location l = (Location) in[0].get(sc);
+            BlockPos pos = l.getBlockPos();
+            return KajetansMod.blocks.getDatabank().getAllIds(pos.getX(), pos.getY(), pos.getZ(), ModDimensions.getWorldName(l.getWorld()));
         });
         
         // ---------------------------------------------------------------------  

src/main/java/me/km/world/ChangeWorldEvent.java

@@ -1,27 +1,11 @@
 package me.km.world;
 
-import me.km.KajetansMod;
-import me.km.utils.Location;
-import me.km.module.Module;
-import me.km.module.ModuleListener;
-import me.km.module.SimpleConfig;
-import me.km.utils.ReflectionUtils;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.InventoryEnderChest;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.FoodStats;
-import net.minecraft.util.NonNullList;
 import net.minecraftforge.common.DimensionManager;
 import net.minecraftforge.event.world.WorldEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.PlayerEvent;
 
-public class ChangeWorldEvent implements ModuleListener 
+public class ChangeWorldEvent
 {
-    public ChangeWorldEvent(Module m)
-    {
-    }
-
     @SubscribeEvent
     public void onWorldUnload(WorldEvent.Unload e)
     {
@@ -37,152 +21,4 @@ public class ChangeWorldEvent implements ModuleListener
             ModDimensions.LOADED_DIMS.remove(i);
         }
     }
-
-    @SubscribeEvent
-    public void changeWorldEvent(PlayerEvent.PlayerChangedDimensionEvent e)
-    { 
-        if(e.fromDim >= 2 || e.toDim >= 2)
-        {
-            savePlayerInventory(e.player, e.fromDim);
-            loadPlayerInventory(e.player, e.toDim);
-        }
-    }   
-    
-    public void savePlayerInventory(EntityPlayer p, int dimension)
-    {
-        /*String s;
-        if(dimension <= 1)
-        {
-            s = DimensionManager.getWorld(0).getWorldInfo().getWorldName();
-        }
-        else
-        {
-            s = ModDimensions.getWorldName(DimensionManager.getWorld(dimension));
-        }
-        SimpleConfig sp = new SimpleConfig(KajetansMod.worldManager, "worldinfo/" + p.getUniqueID(), s, false);  
-        
-        // general data
-        sp.set("exp", p.experienceTotal);     
-        FoodStats stats = p.getFoodStats();
-        sp.set("exhaustion", ReflectionUtils.getExhaustion(stats));
-        sp.set("saturation", ReflectionUtils.getSaturation(stats));
-        sp.set("foodlevel", stats.getFoodLevel());
-        sp.set("currenthealth", p.getHealth());
-        sp.set("maxhealth", 20);
-        sp.set("maxair", p.getAir());
-        
-        
-        // position in world
-        sp.setLocation("location", new Location(p.world, p.getPositionVector()));
-        
-        // main inventory
-        int counter = 0;
-        for(ItemStack stack : p.inventory.mainInventory)
-        {
-            sp.setItemStack("inv." + counter, stack);      
-            counter++;
-        }
-        
-        // armor inventory
-        counter = 0;
-        for(ItemStack stack : p.inventory.armorInventory)
-        {
-            sp.setItemStack("armor." + counter, stack);      
-            counter++;
-        }
-        
-        // offhand inventory
-        counter = 0;
-        for(ItemStack stack : p.inventory.offHandInventory)
-        {
-            sp.setItemStack("offhand." + counter, stack);      
-            counter++;
-        }
-        
-        // enderchest
-        InventoryEnderChest chest = p.getInventoryEnderChest();
-        for(counter = 0; counter <  chest.getSizeInventory(); counter++)
-        {
-            sp.setItemStack("enderchest." + counter, chest.getStackInSlot(counter));   
-        }
-        
-        if(sp.save())
-        {
-            this.getModule().sendToConsole("Der Spieler '" + p.getName() + "' wurde gespeichert.");
-            return;
-        }
-        this.getModule().sendWarningToConsole("Der Spieler '" + p.getName() + "' konnte nicht gespeichert werden.");*/
-    }
-    
-    public void loadPlayerInventory(EntityPlayer p, int dimension)
-    {
-        /*String s;
-        if(dimension <= 1)
-        {
-            s = DimensionManager.getWorld(0).getWorldInfo().getWorldName();
-        }
-        else
-        {
-            s = ModDimensions.getWorldName(DimensionManager.getWorld(dimension));
-        }
-        SimpleConfig sp = new SimpleConfig(KajetansMod.worldManager, "worldinfo/" + p.getUniqueID(), s, true); 
-        if(!sp.exists())
-        {
-            this.getModule().sendToConsole("Der Spieler '" + p.getName() + "' hat keine Daten in der Welt '" + s + "'.");
-            p.inventory.clear();
-            p.experienceTotal = 0;   
-            FoodStats stats = p.getFoodStats();
-            stats.setFoodLevel(20);
-            ReflectionUtils.setExhaustion(stats, 1);
-            ReflectionUtils.setSaturation(stats, 5);
-            p.setHealth(20);
-            p.getInventoryEnderChest().clear();
-            return;
-        }
-
-        // general data  
-        p.experience = 0;
-        p.experienceTotal = 0;
-        p.experienceLevel = 0;
-        p.addExperience(sp.getInt("exp", 0));  
-        FoodStats stats = p.getFoodStats();
-        ReflectionUtils.setExhaustion(stats, sp.getFloat("exhaustion", 1));
-        ReflectionUtils.setSaturation(stats, sp.getFloat("saturation", 5));   
-        stats.setFoodLevel(sp.getInt("foodlevel", 20));    
-        p.setHealth(sp.getFloat("currenthealth", 20));    
-
-        // position in world
-        //Utils.teleportEntity(p, sp.getLocation("location"));      
-        
-        // main inventory
-        int counter;
-        NonNullList<ItemStack> inv = p.inventory.mainInventory;
-        for(counter = 0; counter < inv.size(); counter++)
-        {
-            inv.set(counter, sp.getItemStack("inv." + counter)); 
-        }
-        
-        // armor inventory
-        inv = p.inventory.armorInventory;
-        for(counter = 0; counter < inv.size(); counter++)
-        {
-            inv.set(counter, sp.getItemStack("armor." + counter)); 
-        }
-        
-        // offhand inventory
-        inv = p.inventory.offHandInventory;
-        for(counter = 0; counter < inv.size(); counter++)
-        {
-            inv.set(counter, sp.getItemStack("offhand." + counter)); 
-        }
-        
-        // enderchest
-        InventoryEnderChest chest = p.getInventoryEnderChest();
-        for(counter = 0; counter <  chest.getSizeInventory(); counter++)
-        {
-            chest.setInventorySlotContents(counter, sp.getItemStack("enderchest." + counter));  
-        }
-
-        this.getModule().sendToConsole("Der Spieler '" + p.getName() + "' wurde geladen.");*/
-    }
 }

src/main/java/me/km/world/CommandGameRule.java

@@ -1,97 +0,0 @@
-package me.km.world;
-
-import java.util.Collections;
-import java.util.List;
-import javax.annotation.Nullable;
-import me.km.module.Module;
-import me.km.module.ModuleCommand;
-import me.km.permissions.Permissions;
-import net.minecraft.command.ICommandSender;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.GameRules;
-import net.minecraftforge.common.DimensionManager;
-
-public class CommandGameRule extends ModuleCommand
-{
-    public CommandGameRule(Module m) 
-    {
-        super("gamerule", m);
-        super.setDescription("Setzt GameRules einer Welt");
-        super.setUsage("/gamerule <name> [value]");
-        super.setPermission(Permissions.WORLD);            
-    }
-    
-    private GameRules getOverWorldGameRules()
-    {
-        return DimensionManager.getWorld(0).getGameRules();
-    }
-    
-    @Override
-    public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, @Nullable BlockPos targetPos)
-    {
-        if(args.length == 1)
-        {
-            return getListOfStringsMatchingLastWord(args, getOverWorldGameRules().getRules());
-        }
-        else
-        {
-            if(args.length == 2)
-            {
-                GameRules gamerules = getOverWorldGameRules();
-                if(gamerules.areSameType(args[0], GameRules.ValueType.BOOLEAN_VALUE))
-                {
-                    return getListOfStringsMatchingLastWord(args, new String[] {"true", "false"});
-                }
-                else if(gamerules.areSameType(args[0], GameRules.ValueType.FUNCTION))
-                {
-                    return getListOfStringsMatchingLastWord(args, server.getFunctionManager().getFunctions().keySet());
-                }
-            }
-            return Collections.<String>emptyList();
-        }
-    }
-
-    @Override
-    public boolean execute(ICommandSender cs, String[] arg) 
-    {
-        GameRules rules;
-        if(cs instanceof EntityPlayer)
-        {
-            rules = ((EntityPlayer) cs).world.getGameRules();
-        }
-        else
-        {
-            rules = getOverWorldGameRules();
-        }
-        
-        String rule = arg.length > 0 ? arg[0] : "";
-        String value = arg.length > 1 ? buildString(arg, 1) : "";
-
-        switch(arg.length)
-        {
-            case 0:
-                this.getModule().send(cs, joinNiceString(rules.getRules()));
-                return true;
-            case 1:
-                if(!rules.hasRule(rule))
-                {
-                    this.getModule().send(cs, "'" + rule + "' ist keine gültige GameRule.");
-                    return true;
-                }
-                this.getModule().send(cs, rule + " = " + rules.getString(rule));
-                return true;
-            default:
-                if(rules.areSameType(rule, GameRules.ValueType.BOOLEAN_VALUE) && 
-                        !"true".equals(value) && !"false".equals(value))
-                {
-                    this.getModule().send(cs, "Es wird 'true' oder 'false' erwartet.");
-                    return true;
-                }
-                rules.setOrCreateGameRule(rule, value);
-                this.getModule().send(cs, "'" + rule + "' wurde auf '" + value + "' gesetzt.");
-        }
-        return true;
-    }
-}

src/main/java/me/km/world/CommandWorld.java

@@ -1,225 +0,0 @@
-package me.km.world;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import me.km.KajetansMod;
-import me.km.utils.Location;
-import me.km.module.Module;
-import me.km.module.ModuleCommand;
-import me.km.utils.Utils;
-import me.km.exception.PlayerNotFoundException;
-import me.km.permissions.Permissions;
-import net.minecraft.command.ICommandSender;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.EnumDifficulty;
-import net.minecraft.world.WorldServer;
-
-public class CommandWorld extends ModuleCommand
-{
-    public CommandWorld(Module m) 
-    {
-        super("world", m);
-        super.setDescription("Befehle für die Verwaltung der Welten");
-        super.setUsage("/world für die Hilfe");
-        super.setPermission(Permissions.WORLD);
-    }
-
-    private boolean doesWorldExist(String name)
-    {
-        return new File("./" + name).isDirectory();       
-    }  
-    
-    private ArrayList<String> getAllWorlds()
-    {
-        File worlds = new File("./"); 
-        ArrayList<String> list = new ArrayList<>();
-        for(File f : worlds.listFiles())
-        {
-            if(!f.isDirectory())
-            {
-                continue;
-            }
-            if(new File(f, "level.dat").exists())
-            {
-                list.add(f.getName());
-            }
-        }
-        return list;       
-    }
-    
-    @Override
-    public boolean execute(ICommandSender cs, String[] arg) 
-    {
-        Module m = this.getModule();
-        if(arg.length >= 1)
-        {
-            switch(arg[0].toLowerCase())
-            {
-                case "tp":
-                {
-                    if(arg.length >= 2)
-                    {
-                        WorldServer w = ModDimensions.getWorldFromName(arg[1]);
-                        if(w == null)
-                        {
-                            m.send(cs, "Die Welt '" + arg[1] + "' wurde nicht gefunden.");
-                            return true;
-                        }
-                        EntityPlayerMP affectedEntityPlayerMP;
-                        try
-                        {
-                            affectedEntityPlayerMP = Utils.getPlayerByName(arg[2]);
-                        }
-                        catch(PlayerNotFoundException ex)
-                        {
-                            //m.send(cs, GlobalText.cantFindPlayer(arg[2]));
-                            return true;
-                        }
-                        catch(IndexOutOfBoundsException ex)
-                        {
-                            if(!(cs instanceof EntityPlayerMP))
-                            {
-                                //m.send(cs, GlobalText.missingParameter());
-                                return true;
-                            }
-                            affectedEntityPlayerMP = (EntityPlayerMP) cs;
-                        }
-                        BlockPos pos = w.getSpawnPoint();
-                        while(pos.getY() <= 255 && !w.isAirBlock(pos))
-                        {
-                            pos = pos.add(0, 1, 0);
-                        }
-                        Utils.teleportEntity(affectedEntityPlayerMP, new Location(w, pos));
-                        return true;
-                    }
-                    break;
-                }
-                case "setspawn":
-                {
-                    if(!(cs instanceof EntityPlayerMP))
-                    {
-                        //m.send(cs, GlobalText.onlyPlayer());
-                        return true;
-                    }
-                    EntityPlayerMP p = (EntityPlayerMP) cs;
-                    p.getEntityWorld().setSpawnPoint(p.getPosition());
-                    m.send(cs, "Der Spawn der Welt '" + p.getEntityWorld().getWorldInfo().getWorldName() + "' wurde gesetzt.");
-                    return true;
-                }
-                case "list":
-                {
-                    m.send(cs, "Folgende Welten sind geladen:");
-                    Arrays.stream(KajetansMod.server.worlds).forEach((w) -> 
-                    {
-                        m.sendListElement(cs, ModDimensions.getWorldName(w));
-                    });
-                    return true;
-                }
-                case "listall":
-                {
-                    m.send(cs, "Folgende Welten sind verfügbar:");
-                    getAllWorlds().stream().forEach((s) -> 
-                    {
-                        m.sendListElement(cs, s);
-                    });
-                    return true;
-                }
-                case "load":
-                {
-                    if(arg.length >= 2)
-                    {                       
-                        if(!doesWorldExist(arg[1]))
-                        {
-                            m.send(cs, "Die Welt '" + arg[1] + "' wurde nicht gefunden.");
-                            return true;
-                        }
-                        if(ModDimensions.loadWorld(arg[1], ModDimensions.CUSTOM_WORLD))
-                        {
-                            m.send(cs, "'" + arg[1] + "' wurde geladen.");
-                        }
-                        else
-                        {
-                            m.send(cs, "'" + arg[1] + "' ist bereits geladen.");
-                        }
-                        return true;
-                    }
-                    break;
-                }
-                case "unload":
-                {
-                    if(arg.length >= 2)
-                    {                       
-                        if(ModDimensions.unloadWorld(arg[1]))
-                        {
-                            m.send(cs, "'" + arg[1] + "' wurde aus dem Speicher entfernt.");
-                            return true;
-                        }
-                        m.send(cs, "'" + arg[1] + "' kann nicht entfernt werden.");
-                        return true;
-                    }
-                    break;
-                }
-                case "diffi":
-                {
-                    if(arg[0].equals("diffi") && arg.length >= 3)
-                    {
-                        WorldServer w = ModDimensions.getWorldFromName(arg[1]);
-                        if(w == null)
-                        {
-                            m.send(cs, "Die Welt '" + arg[1] + "' wurde nicht gefunden.");
-                            return true;
-                        }
-                        try
-                        {
-                            EnumDifficulty diffi = EnumDifficulty.valueOf(arg[2].toUpperCase());
-                            w.getWorldInfo().setDifficulty(diffi);
-                            m.send(cs, "Schwierigkeit in der Welt '" + arg[1] + "' ist nun '" + Utils.formatString(diffi.name()) + "'.");
-                            return true;
-                        }
-                        catch(IllegalArgumentException ex)
-                        {
-                            m.send(cs, "Diese Schwierigkeitsstufe gibt es nicht.");
-                            return true;
-                        }                                         
-                    }
-                    break;
-                }
-                case "info":
-                {
-                    if(arg.length >= 2)
-                    {
-                        WorldServer w = ModDimensions.getWorldFromName(arg[1]);
-                        if(w == null)
-                        {
-                            m.send(cs, "Die Welt '" + arg[1] + "' wurde nicht gefunden.");
-                            return true;
-                        }                          
-                        m.send(cs, "Infos zur Welt '" + arg[1] + "'");
-                        for(String rule : w.getGameRules().getRules())
-                        {
-                            m.sendListElement(cs, rule + " = " + w.getGameRules().getString(rule));
-                        }                     
-                        m.sendListElement(cs, "Zeit = " + w.getWorldInfo().getWorldTime());
-                        m.sendListElement(cs, "Schwierigkeit = " + Utils.formatString(w.getDifficulty().name()));  
-                        return true;
-                    }
-                    break;
-                }
-            }
-        }            
-        
-        // Help Menu
-        m.send(cs, "/world ...");
-        m.sendHelpListElement(cs, "info <world>", "Gibt Infos über die Welt");
-        m.sendHelpListElement(cs, "tp <id> [player]", "Bringt den Spieler in eine andere Welt");
-        m.sendHelpListElement(cs, "list", "Zeigt alle geladenen Welten");
-        m.sendHelpListElement(cs, "listall", "Zeigt alle Welten");
-        m.sendHelpListElement(cs, "load <world>", "Lädt eine Welt");
-        m.sendHelpListElement(cs, "unload <world>", "Entfernt die Welt aus dem Speicher");
-        m.sendHelpListElement(cs, "setspawn", "Setzt den Welten-Spawn");
-        m.sendHelpListElement(cs, "diffi <world> <diffi>", "Setzt die Schwierigkeit");
-        return true;
-    }
-}

src/main/java/me/km/world/ModWorldGeneration.java

@@ -41,7 +41,7 @@ public class ModWorldGeneration implements IWorldGenerator
         int deltaY = maxY - minY;
         BlockPos pos;
         WorldGenMinable generator;
-        for (int i = 0; i < chances; i++) 
+        for(int i = 0; i < chances; i++) 
         {
             // generates position in chunk
             pos = new BlockPos(x + random.nextInt(16), minY + random.nextInt(deltaY), z + random.nextInt(16));