Portierung fast alles allgemeinen Commands, PlayerBank, Scoreboard, Module-, Command-, Event-Handler

build.gradle

@@ -54,7 +54,8 @@ dependencies {
     // for more info...
     // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
     // http://www.gradle.org/docs/current/userguide/dependency_management.html
-
+    
+    compile group: 'mysql', name: 'mysql-connector-java', version: '5.1.42'
 }
 
 processResources {

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

@@ -1,46 +0,0 @@
-package me.hammerle.km;
-
-import me.hammerle.km.blocks.ModBlocks;
-import me.hammerle.km.entities.ModEntities;
-import me.hammerle.km.fluids.ModFluids;
-import me.hammerle.km.items.ModItems;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-
-@Mod(modid = KajetansMod.MODID, version = KajetansMod.VERSION, name = KajetansMod.NAME)
-public class KajetansMod
-{
-    @SidedProxy(serverSide = "me.hammerle.km.CommonProxy", clientSide = "me.hammerle.km.ClientProxy")
-    public static CommonProxy proxy;
-
-    public static final String MODID = "km";
-    public static final String NAME = "Kajetans Mod";
-    public static final String VERSION = "1.0.0";
-
-    @Mod.Instance(MODID)
-    public static KajetansMod instance;
-
-    @Mod.EventHandler
-    public void preInit(FMLPreInitializationEvent event) 
-    {
-        System.out.println(NAME + " is loading!");
-        ModFluids.init();
-        ModItems.init();
-        ModBlocks.init();
-    }
-
-    @Mod.EventHandler
-    public void init(FMLInitializationEvent event) 
-    {
-        ModEntities.init();
-    }
-
-    @Mod.EventHandler
-    public void postInit(FMLPostInitializationEvent event) 
-    {
-
-    }
-}

src/main/java/me/hammerle/km/ClientProxy.java → src/main/java/me/km/ClientProxy.java

@@ -1,4 +1,4 @@
-package me.hammerle.km;
+package me.km;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;

src/main/java/me/hammerle/km/CommonProxy.java → src/main/java/me/km/CommonProxy.java

@@ -1,4 +1,4 @@
-package me.hammerle.km;
+package me.km;
 
 import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.entity.Entity;

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

@@ -0,0 +1,224 @@
+package me.km;
+
+import me.km.api.Module;
+import me.km.api.SimpleConfig;
+import me.km.blocks.ModBlocks;
+import me.km.databank.DataBank;
+import me.km.entities.ModEntities;
+import me.km.fluids.ModFluids;
+import me.km.items.ModItems;
+import me.km.playerbank.PlayerBank;
+import me.km.playerbank.PlayerManager;
+import me.km.scheduler.SnuviScheduler;
+import me.km.scoreboard.ScoreboardAPI;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.SidedProxy;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.event.FMLServerStoppingEvent;
+
+@Mod(modid = KajetansMod.MODID, version = KajetansMod.VERSION, name = KajetansMod.NAME)
+public class KajetansMod
+{    
+    public static SimpleConfig conf;
+    
+    public static DataBank databank;
+    public static SnuviScheduler scheduler;
+    public static PlayerManager playerbank;
+    public static Module generalCommands;
+    //public static ChatManager chatManager;
+    //public static Module afkManager;
+    //public static Module plots;
+    //public static Module blocks;
+    //public static Module datatools;
+    //public static WorldData worldManager;
+    //public static Module environment;
+    //public static QuestAPI quest;
+    //public static JobAPI jobs;
+    //public static EffectUtils effects;
+    //public static SkillManager skills;
+    //public static Module scrolls;
+    //public static Customs customs;
+    //public static PiercingAPI piercing;
+    public static ScoreboardAPI scoreboard;
+    
+    @SidedProxy(serverSide = "me.km.CommonProxy", clientSide = "me.km.ClientProxy")
+    public static CommonProxy proxy;
+
+    public static final String MODID = "km";
+    public static final String NAME = "Kajetans Mod";
+    public static final String VERSION = "0.0.1";
+
+    @Mod.Instance(MODID)
+    public static KajetansMod instance;
+    
+    public static MinecraftServer server;
+
+    @Mod.EventHandler
+    public void preInit(FMLPreInitializationEvent event) 
+    {
+        System.out.println(NAME + " is loading!");
+        ModFluids.init();
+        ModItems.init();
+        ModBlocks.init();
+    }
+    
+    @Mod.EventHandler
+    public void serverStarting(FMLServerStartingEvent e) 
+    {
+        server = FMLCommonHandler.instance().getMinecraftServerInstance();
+        
+        // Konfiguration und Error-Dummy
+        Module error = new Module("ERROR", "ERROR", TextFormatting.RED);
+        conf = new SimpleConfig(error, "config", true);
+        
+        // Datenbankverbindung
+        databank = new DataBank("DataBank", "DataBank", TextFormatting.RED);
+        if(!databank.openDataBankConnection(conf.getString("user", "root"), conf.getString("password", "")))
+        {
+            return;
+        }
+        
+        // Scheduler
+        scheduler = new SnuviScheduler("Scheduler", "Scheduler", TextFormatting.GREEN);
+        scheduler.registerEvents("me.km.scheduler");
+                
+        // Spielerdatenbank
+        playerbank = new PlayerManager("PlayerBank", "PlayerBank", TextFormatting.RED);
+        playerbank.setDataBank(new PlayerBank(playerbank, databank.getConnection()));
+        playerbank.registerEvents("me.kt.playerbank");
+        
+        // Grundlegende Commands
+        generalCommands = new Module("GeneralCommands", "Commands", TextFormatting.GOLD);
+        generalCommands.registerCommands(e, "me.km.commands");
+        
+        // Chatmanager
+        /*chatManager = new ChatManager("ChatManager", "Chat", TextFormatting.BLUE);
+        chatManager.registerCommands(e, "me.kt.chatmanager");
+        chatManager.registerEvents("me.kt.chatmanager");*/
+        
+        // AFK-Manager
+        /*afkManager = new Module("AfkManager", "AFK", TextFormatting.GRAY);
+        afkManager.registerCommands(e, "me.kt.afk");
+        afkManager.registerEvents("me.kt.afk");*/
+        
+        // Plot-System
+        /*plots = new Module("Plots", "Plots", TextFormatting.GOLD);
+        plots.setDataBank(new ProtectionBank(plots, databank.getConnection()));
+        plots.registerCommands(e, "me.kt.plots");          
+        plots.registerEvents("me.kt.plots");*/
+        
+        // Chests- und Co-Protections
+        /*blocks = new Module("BlockProtections", "Blocks", TextFormatting.BLUE);
+        blocks.setDataBank(new BlockProtectionBank(blocks, databank.getConnection()));
+        blocks.registerCommands(e, "me.kt.blockprotections");          
+        blocks.registerEvents("me.kt.blockprotections");*/
+        
+        // DataTools
+        /*datatools = new Module("DataTools", "DataTools", TextFormatting.GRAY);
+        datatools.registerCommands(e, "me.kt.datatools");          
+        datatools.registerEvents("me.kt.datatools");*/
+
+        // Worldmanager
+        /*worldManager = new WorldData("WorldManager", "Worlds", TextFormatting.RED);
+        worldManager.registerCommands(e, "me.kt.worlds");          
+        worldManager.registerEvents("me.kt.worlds");*/
+        
+        // Questsystem
+        /*quest = new QuestAPI("Quests", "Quests", TextFormatting.LIGHT_PURPLE);
+        quest.registerPrefix("Scripts", TextFormatting.LIGHT_PURPLE);
+        quest.setDataBank(new QuestBank(quest, databank.getConnection()));
+        quest.registerCommands(e, "me.kt.quests");          
+        quest.registerEvents("me.kt.quests");*/
+        
+        // Jobsystem
+        /*jobs = new JobAPI("JobSystem", "Jobs", TextFormatting.GREEN);
+        jobs.setDataBank(new JobBank(jobs, databank.getConnection()));
+        jobs.registerCommands(e, "me.kt.jobsystem");      
+        jobs.registerEvents("me.kt.jobsystem"); */
+        
+        // Effectsystem
+        /*effects = new EffectUtils("Effects", "Effects", TextFormatting.BLUE);
+        effects.registerCommands(e, "me.kt.effects"); 
+        effects.registerEvents("me.kt.effects.passive"); */
+        
+        // Skillshopsystem
+        /*skills = new SkillManager("SkillSystem", "Skills", TextFormatting.BLUE);
+        skills.registerCommands(e, "me.kt.skills"); 
+        skills.registerEvents("me.kt.skills"); */
+        
+        // Scrollsystem
+        /*scrolls = new Module("Scrolls", "Scrolls", TextFormatting.BLUE);
+        scrolls.registerCommands(e, "me.kt.scrolls"); 
+        scrolls.registerEvents("me.kt.scrolls");    */ 
+        
+        // Environment
+        /*environment = new Module("Environment", "Environment", TextFormatting.GREEN);
+        environment.registerCommands(e, "me.kt.environment");      
+        environment.registerEvents("me.kt.environment");  */
+        
+        // Scoreboard
+        scoreboard = new ScoreboardAPI("Scoreboard", "Scoreboard", TextFormatting.GOLD);
+        scoreboard.registerEvents("me.km.scoreboard");
+        
+        // Customs
+        /*customs = new Customs("Customs", "Customs", TextFormatting.GRAY);
+        customs.registerCommands(e, "me.kt.custom");
+        customs.registerEvents("me.kt.custom");*/
+        
+        // Piercing
+        /*piercing = new PiercingAPI("Piercing", "Piercing", TextFormatting.DARK_PURPLE);
+        piercing.registerEvents("me.kt.piercing.events");*/
+          
+        //quest.startScript(this.getServer().getConsoleSender(), "startscript");
+    }
+    
+    @Mod.EventHandler
+    public void serverStarting(FMLServerStoppingEvent e) 
+    {
+        databank.closeDataBankConnection();
+    }
+
+    @Mod.EventHandler
+    public void init(FMLInitializationEvent event) 
+    {
+        ModEntities.init();
+    }
+
+    @Mod.EventHandler
+    public void postInit(FMLPostInitializationEvent event) 
+    {
+
+    }
+    
+    /*public static void main(String[] args)
+    {
+        // Erstellt alle Enums für die aktiven Effekte
+        PackageHelper.getClassesInIde("me.kt.effects.active").stream()
+            .forEach(s -> 
+            {
+                StringBuilder en = new StringBuilder(s.substring(0, s.length() - 6));
+                int i = 1;
+                while(i < en.length())
+                {
+                    if(Character.isUpperCase(en.charAt(i)))
+                    {
+                        en.insert(i, "_");
+                        i++;
+                    } 
+                    i++;
+                }
+                String wusi = "                        (true, " + s + "),";
+                wusi = en.toString().toUpperCase() + wusi.substring(en.length());
+                System.out.println(wusi);
+            });
+    }*/ 
+}
+
+
+ 

src/main/java/me/hammerle/km/MeshDefinitionFix.java → src/main/java/me/km/MeshDefinitionFix.java

@@ -1,4 +1,4 @@
-package me.hammerle.km;
+package me.km;
 
 import net.minecraft.client.renderer.ItemMeshDefinition;
 import net.minecraft.client.renderer.block.model.ModelResourceLocation;

src/main/java/me/km/PackageHelper.java

@@ -0,0 +1,75 @@
+package me.km;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class PackageHelper 
+{
+    public static ArrayList<Class> getClasses(String packageName)
+    {
+        URL jar = getPath();
+        if (jar != null)
+        {
+            try
+            {
+                ZipInputStream zip = new ZipInputStream(jar.openStream());
+                ArrayList<Class> classes = new ArrayList<>();
+                String path = packageName.replace(".", "/");
+                while(true) 
+                {
+                    ZipEntry e = zip.getNextEntry();
+                    if (e == null)
+                    {
+                        break;
+                    }
+                    String name = e.getName();
+                    if(name.startsWith(path))
+                    {
+                        name = name.replace("/", ".").substring(0, e.getName().length() - 6);
+                        try 
+                        {
+                            classes.add(Class.forName(name));
+                        } 
+                        catch (ClassNotFoundException ex) 
+                        {
+                        } 
+                    }
+                }
+                return classes;
+            }
+            catch(IOException ex)
+            {
+            }
+        } 
+        return new ArrayList<>();
+    }
+    
+    public static URL getPath()
+    {
+        try
+        {
+            String s = KajetansMod.class.getProtectionDomain().getCodeSource().getLocation().getPath();
+            s = s.substring(5, s.length() - 25);
+            
+            File f = new File(s);
+            if(!f.exists())
+            {
+                for(int i = 0; i < 20; i++)
+                {
+                    System.out.println(f + " does not exist");
+                }
+            }
+            
+            return new URL("file:" + s);
+        }
+        catch(Exception ex)
+        {
+            System.out.println(ex);
+        }
+        return null;
+    }
+}

src/main/java/me/hammerle/km/TestEvents.java → src/main/java/me/km/TestEvents.java

@@ -1,4 +1,4 @@
-package me.hammerle.km;
+package me.km;
 
 import net.minecraftforge.event.entity.player.EntityItemPickupEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;

src/main/java/me/km/api/GlobalText.java

@@ -0,0 +1,54 @@
+package me.km.api;
+
+public class GlobalText 
+{
+    public static String cantFindPlayer(String name)
+    {
+        return "Der Spieler '" + name + "' wurde nicht gefunden.";
+    }
+    
+    public static String missingParameter()
+    {
+        return "Dem Command fehlt mindestens ein Parameter.";
+    }
+    
+    public static String onlyPlayer()
+    {
+        return "Dieser Command kann nur von einem Spieler ausgeführt werden.";
+    }
+    
+    public static String noNaturalNumber()
+    {
+        return "Die gegebene Zahl muss eine natürliche Zahl sein.";
+    }
+    
+    public static String noPositiveNaturalNumber()
+    {
+        return "Die gegebene Zahl muss eine positive, natürliche Zahl sein.";
+    }
+    
+    public static String noIntegerNumber()
+    {
+        return "Die gegebene Zahl muss eine ganze Zahl sein.";
+    }
+    
+    public static String noSkills()
+    {
+        return "Skills sind in dieser Welt deaktiviert.";
+    }
+    
+    public static String noScrolls()
+    {
+        return "Zauberschriftrollen sind in dieser Welt deaktiviert.";
+    }
+    
+    public static String shouldNotHappen()
+    {
+        return "Dieser Fehler sollte nie passieren.";
+    }
+    
+    public static String Spacer()
+    {
+        return "§0-----------------------------------------------------";
+    }
+}

src/main/java/me/km/api/ItemStackBuilder.java

@@ -0,0 +1,99 @@
+package me.km.api;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ItemStackBuilder 
+{
+    private final ItemStack stack;
+    
+    public ItemStackBuilder(Block b, int amount)
+    {
+        stack = new ItemStack(b, amount);
+    }
+    
+    public ItemStackBuilder(Block b, int amount, int meta)
+    {
+        stack = new ItemStack(b, amount, meta);
+    }
+    
+    public ItemStackBuilder(Item i, int amount)
+    {
+        stack = new ItemStack(i, amount);
+    }
+    
+    public ItemStackBuilder(Item i, int amount, int meta)
+    {
+        stack = new ItemStack(i, amount, meta);
+    }
+    
+    public ItemStackBuilder(ItemStack stack, int amount)
+    {
+        this.stack = stack.copy();
+        this.stack.setCount(amount);
+    }
+
+    public ItemStack build()
+    {
+        return stack;
+    }
+    
+    public void drop(World w, BlockPos l)
+    {
+        Block.spawnAsEntity(w, l, stack);
+    }
+ 
+    public ItemStackBuilder setName(String name)
+    {
+        stack.setStackDisplayName(name);
+        return this;
+    }
+    
+    public ItemStackBuilder addToName(String name)
+    {
+        stack.setStackDisplayName(stack.getDisplayName() + name);
+        return this;
+    }
+    
+    public ItemStackBuilder addLore(String line)
+    {
+        //TODO
+        return this;
+    }
+    
+    public ItemStackBuilder addLimitedLore(String whole, int limit, String addition)
+    {
+        //TODO
+        /*ItemMeta meta = stack.getItemMeta();
+        meta.setLore(Utils.buildLimitedLore(whole, limit, addition));
+        stack.setItemMeta(meta);*/
+        return this;
+    }
+    
+    public ItemStackBuilder addLimitedLore(String whole, String addition)
+    {
+        return addLimitedLore(whole, 25, addition);
+    }
+    
+    public ItemStackBuilder hideTags()
+    {
+        //TODO
+        /*stack.setTagCompound(nbt);
+        ItemMeta meta = stack.getItemMeta();
+        meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES);
+        meta.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS);
+        meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+        stack.setItemMeta(meta);*/
+        return this;
+    }
+    
+    public ItemStackBuilder addGlow()
+    {
+        //TODO
+        //stack.addUnsafeEnchantment(Enchantment.LUCK, 1);
+        return this;
+    }
+}

src/main/java/me/km/api/Location.java

@@ -0,0 +1,79 @@
+package me.km.api;
+
+import me.km.KajetansMod;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+
+public class Location 
+{
+    private final World w;
+    private final Vec3d pos;
+    private float yaw;
+    private float pitch;
+    
+    public Location(World w, Vec3d pos, float yaw, float pitch)
+    {
+        this.w = w;
+        this.pos = pos;
+        this.yaw = yaw;
+        this.pitch = pitch;
+    }
+    
+    public Location(World w, Vec3d pos)
+    {
+        this(w, pos, 0, 0);
+    }
+
+    public World getWorld() 
+    {
+        return w;
+    }
+
+    public Vec3d getPos() 
+    {
+        return pos;
+    }
+
+    public float getYaw() 
+    {
+        return yaw;
+    }
+
+    public float getPitch() 
+    {
+        return pitch;
+    }
+
+    public void setPitch(float pitch) 
+    {
+        this.pitch = pitch;
+    }
+
+    public void setYaw(float yaw) 
+    {
+        this.yaw = yaw;
+    }
+    
+    public static World getWorld(String s)
+    {
+        if(s == null)
+        {
+            return null;
+        }
+        for(World w : KajetansMod.server.worlds)
+        {
+            if(w.getWorldInfo().getWorldName().equals(s))
+            {
+                return w;
+            }
+        }
+        return null;
+    }
+    
+    public static IBlockState getRelativeBlock(World w, BlockPos pos, int x, int y, int z)
+    {
+        return w.getBlockState(new BlockPos(pos.getX() + x, pos.getY() + y, pos.getZ() + z));
+    }
+}

src/main/java/me/km/api/MessageSender.java

@@ -0,0 +1,125 @@
+package me.km.api;
+
+import java.util.ArrayList;
+import me.km.KajetansMod;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.world.World;
+
+public class MessageSender 
+{
+    private final ArrayList<ITextComponent> prefixes;
+    
+    public MessageSender()
+    {
+        prefixes = new ArrayList<>();
+    }
+    
+    public void registerPrefix(String name, TextFormatting color)
+    {
+        TextComponentString text = new TextComponentString(name);
+        text.getStyle().setColor(color);
+        prefixes.add(new TextComponentString("[").appendSibling(text).appendText("] "));
+    }
+
+    public void send(ICommandSender cs, String msg, int id)
+    {
+        if(cs == null)
+        {
+            return;
+        }
+        cs.sendMessage(prefixes.get(id).createCopy().appendText(msg));
+    }
+    
+    public void send(ICommandSender cs, String msg)
+    {
+        send(cs, msg, 0);
+    }
+    
+    public void sendToPlayers(World w, BlockPos l, double radius, String msg)
+    {
+        ITextComponent s = prefixes.get(0).createCopy().appendText(msg);
+        Utils.getNearbyEntities(w, l, radius, EntityPlayer.class).forEach(p -> ((EntityPlayer) p).sendMessage(s));
+    }
+    
+    public void sendBroadcast(String msg)
+    {
+        KajetansMod.server.getPlayerList().sendMessage(prefixes.get(0).createCopy().appendText(msg));
+    }
+    
+    public void sendListElement(ICommandSender cs, String msg, int id)
+    {
+        if(cs == null)
+        {
+            return;
+        }
+        TextComponentString text = new TextComponentString(" - ");
+        text.getStyle().setColor(prefixes.get(id).getStyle().getColor());
+        cs.sendMessage(text.appendText(msg));
+    }
+    
+    public void sendListElement(ICommandSender cs, String msg)
+    {
+        sendListElement(cs, msg, 0);
+    }
+    
+    public void sendHelpListElement(ICommandSender cs, String msg, String msg2, int id)
+    {
+        if(cs == null)
+        {
+            return;
+        }
+        TextComponentString text = new TextComponentString(" - ");
+        text.getStyle().setColor(prefixes.get(id).getStyle().getColor());
+        cs.sendMessage(text.appendText(msg + " " + msg2));
+    }
+    
+    public void sendHelpListElement(ICommandSender cs, String msg, String msg2)
+    {
+        sendHelpListElement(cs, msg, msg2, 0);
+    }
+    
+    public void sendWarning(ICommandSender cs, String msg, int id)
+    {
+        if(cs == null)
+        {
+            return;
+        }
+        TextComponentString text = new TextComponentString(msg);
+        text.getStyle().setColor(TextFormatting.RED);
+        cs.sendMessage(prefixes.get(id).createCopy().appendSibling(text));
+    }
+    
+    public void sendWarning(ICommandSender cs, String msg)
+    {
+        if(cs == null)
+        {
+            return;
+        }
+        sendWarning(cs, msg, 0);
+    }
+   
+    public void sendToConsole(String msg, int id)
+    {
+        send(KajetansMod.server, msg, id);
+    }
+    
+    public void sendToConsole(String msg)
+    {
+        sendToConsole(msg, 0);
+    }
+    
+    public void sendWarningToConsole(String msg, int id)
+    {
+        sendWarning(KajetansMod.server, msg, id);
+    }
+    
+    public void sendWarningToConsole(String msg)
+    {
+        sendWarningToConsole(msg, 0);
+    }
+}

src/main/java/me/km/api/Module.java

@@ -0,0 +1,124 @@
+package me.km.api;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashMap;
+import me.km.PackageHelper;
+import me.km.databank.SimpleDataBank;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.eventhandler.EventBus;
+
+public class Module extends MessageSender
+{
+    private final HashMap<String, ModuleCommand> commands;
+    private final String mname;
+    private final HashMap<Class, ModuleListener> events;
+    private SimpleDataBank bank;
+    
+    public Module(String mname, String prefix, TextFormatting color)
+    {
+        commands = new HashMap<>();
+        this.mname = mname;
+        super.registerPrefix(prefix, color);
+        events = new HashMap<>();
+        bank = null;
+        
+        super.sendToConsole("Das Modul " + color + mname + TextFormatting.RESET + " wurde geladen.");
+    }
+    
+    //--------------------------------------------------------------------------
+    // Allgemeine Rückgaben
+    //--------------------------------------------------------------------------
+    
+    public String getName()
+    {
+        return mname;
+    }
+    
+    //--------------------------------------------------------------------------
+    // DataBank
+    //--------------------------------------------------------------------------
+    
+    public void setDataBank(SimpleDataBank bank)
+    {
+        this.bank = bank;
+        this.sendToConsole("Die Datenbank wurde geladen.");
+    }
+    
+    @SuppressWarnings("unchecked")
+    public <T extends SimpleDataBank> T getDataBank(Class<T> c)
+    {
+        return (T) bank;
+    }  
+    
+    //--------------------------------------------------------------------------
+    // Command-Methoden
+    //--------------------------------------------------------------------------
+    
+    @SuppressWarnings("unchecked")
+    public void registerCommands(FMLServerStartingEvent e, String packageName)
+    {
+        PackageHelper.getClasses(packageName).stream().filter(c -> ModuleCommand.class.isAssignableFrom(c)).forEach((Class c) -> 
+        {
+            try 
+            {
+                ModuleCommand command = (ModuleCommand) c.getDeclaredConstructor(Module.class).newInstance(this);
+                e.registerServerCommand(command);
+                if (commands.put(command.getName(), command) != null) 
+                {
+                    this.sendWarningToConsole("Der Command '" + command.getName() + "' wurde ein weiteres Mal geladen.");
+                }
+                else
+                {
+                   this.sendWarningToConsole("Der Command '" + command.getName() + "' wurde geladen.");
+                }
+            }
+            catch(ClassCastException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
+            { 
+                this.sendWarningToConsole("Die Klasse '" + c + "' wurde nicht geladen.");
+            }
+        });
+        this.sendToConsole("Alle Commands wurden geladen.");
+    }
+    
+    public ModuleCommand getCommand(String name)
+    {
+        return commands.get(name);
+    }
+    
+    @SuppressWarnings("unchecked")
+    public <T extends ModuleCommand> T getCommand(Class<T> c)
+    {   
+        return (T) commands.get(c.getSimpleName().substring(7).toLowerCase());
+    }
+    
+    //--------------------------------------------------------------------------
+    // Event-Methoden
+    //--------------------------------------------------------------------------
+    
+    @SuppressWarnings("unchecked")
+    public void registerEvents(String packageName)
+    {
+        EventBus bus = MinecraftForge.EVENT_BUS;
+        PackageHelper.getClasses(packageName).stream().filter(c -> ModuleListener.class.isAssignableFrom(c)).forEach((Class c) -> 
+        {
+            try 
+            {   
+                ModuleListener l = (ModuleListener) c.getDeclaredConstructor(Module.class).newInstance(this);
+                events.put(c, l);
+                bus.register(l);
+            }
+            catch(NoSuchMethodException | ClassCastException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex)
+            {
+            }
+        });
+        this.sendToConsole("Alle Events wurden geladen.");
+    }
+    
+    @SuppressWarnings("unchecked")
+    public <T extends ModuleListener> T getEvent(Class<T> c)
+    {
+        return (T) events.get(c);
+    }
+}

src/main/java/me/km/api/ModuleCommand.java

@@ -0,0 +1,94 @@
+package me.km.api;
+
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.server.MinecraftServer;
+
+public abstract class ModuleCommand extends CommandBase
+{   
+    private final Module m;
+    private final String name;
+    private String usage;
+    private String description;
+    private Permissions perm;
+    
+    public ModuleCommand(String name, Module m) 
+    {
+        this.name = name;
+        this.m = m;
+        this.usage = "";
+        this.perm = null;
+    }
+    
+    public Module getModule()
+    {
+        return m;
+    }
+    
+    @Override
+    public String getName()
+    {
+        return name;
+    }
+    
+    public void setUsage(String s)
+    {
+        usage = s;
+    }
+    
+    @Override
+    public String getUsage(ICommandSender sender)
+    {
+        return usage;
+    }
+    
+    public void setDescription(String s)
+    {
+        description = s;
+    }
+    
+    public String getDescription()
+    {
+        return description;
+    }
+    
+    public void setPermission(Permissions perm)
+    {
+        this.perm = perm;
+    }
+    
+    public Permissions getPermission()
+    {
+        return perm;
+    }
+    
+    public abstract boolean execute(ICommandSender cs, String[] arg);
+    
+    @Override
+    public void execute(MinecraftServer server, ICommandSender cs, String[] args) throws CommandException
+    {
+        if(!Permission.hasPermission(cs, this))
+        {
+            m.sendWarning(cs, "Du hast keine Rechte für diesen Command.");
+            return;
+        }       
+        if(!execute(cs, args))
+        {
+            m.send(cs, this.getUsage(cs));
+        }
+    }
+
+    @Override
+    public boolean checkPermission(MinecraftServer server, ICommandSender cs) 
+    {
+        if(Permission.hasPermission(cs, this))
+        {
+            return true;
+        }  
+        m.sendWarning(cs, "Du hast keine Rechte für diesen Command. 2");
+        return false;
+    }
+}

src/main/java/me/km/api/ModuleListener.java

@@ -0,0 +1,16 @@
+package me.km.api;
+
+public abstract class ModuleListener
+{
+    private final Module m;
+    
+    public ModuleListener(Module m) 
+    {
+        this.m = m;
+    }
+    
+    public Module getModule()
+    {
+        return m;
+    }
+}

src/main/java/me/km/api/ModuleTabCommand.java

@@ -0,0 +1,27 @@
+package me.km.api;
+
+import java.util.Collections;
+import java.util.List;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.math.BlockPos;
+
+public abstract class ModuleTabCommand extends ModuleCommand
+{
+    private final List<String> list;
+    private final int argument;
+    
+    public ModuleTabCommand(String name, Module m, List<String> list, int argument) 
+    {
+        super(name, m);
+        this.list = list;
+        this.argument = argument;
+    }
+
+    @Override
+    public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos targetPos) 
+    {
+        return args.length == argument - 1 ? CommandBase.getListOfStringsMatchingLastWord(args, list) : Collections.<String>emptyList();
+    }
+}

src/main/java/me/km/api/SimpleConfig.java

@@ -0,0 +1,170 @@
+package me.km.api;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.MalformedInputException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import net.minecraft.util.math.Vec3d;
+
+public class SimpleConfig
+{            
+    private Module m;
+    
+    private final TreeMap<String, String> conf;
+    private File file;
+    
+    public SimpleConfig(Module m, String path, boolean load)
+    {    
+        this.m = m;
+        file = new File("./" + path + ".snuvi");
+        conf = new TreeMap<>();
+        if(load && file.exists())
+        {
+            try
+            {
+                Files.readAllLines(file.toPath()).stream().forEach(s -> 
+                {
+                    int b = s.indexOf("=");
+                    if(b == -1)
+                    {
+                        m.sendWarningToConsole("Wrong syntax in '" + file.getPath() + "' - " + s);
+                        return;
+                    }
+                    conf.put(s.substring(0, b).trim(), s.substring(b + 1).trim());
+                });
+            } 
+            catch (MalformedInputException ex) 
+            {
+                m.sendWarningToConsole("'" + file.getPath() + "' contains an illegal character, change file encoding");
+            }
+            catch (IOException ex) 
+            {
+                m.sendWarningToConsole("File '" + file.getPath() + "' cannot be read");
+            }
+        }
+    }
+    
+    public static List<File> getFiles(String path)
+    {
+        return Arrays.asList(new File("./" + path).listFiles());
+    }
+    
+    public boolean exists()
+    {
+        return file.exists();
+    }
+    
+    public boolean delete()
+    {
+        return file.delete();
+    }
+    
+    public void save()
+    {
+        try
+        {
+            Files.write(Paths.get(file.toURI()), conf.entrySet().stream()
+                            .map(e -> e.getKey() + "=" + e.getValue())
+                            .collect(Collectors.toList()), Charset.forName("UTF-8"));
+        }
+        catch(IOException ex)
+        {
+            m.sendWarningToConsole("Can't write to '" + file.getPath() + "'");
+        }
+    }
+    
+    // -----------------------------------------------------------------------------------
+    // Get Data
+    // -----------------------------------------------------------------------------------
+    
+    public String getString(String key)
+    {
+        return conf.get(key);
+    }
+    
+    public String getString(String key, String error)
+    {
+        String s =  conf.get(key);
+        if(s == null)
+        {
+            return error;
+        }
+        return s;
+    }
+    
+    public float getFloat(String key, float error)
+    {
+        String s = conf.get(key);
+        if(s == null)
+        {
+            return error;
+        }
+        try
+        {
+            return Float.parseFloat(s);
+        }
+        catch(NumberFormatException ex)
+        {
+            return error;
+        }
+    }
+    
+    public double getDouble(String key, double error)
+    {
+        String s = conf.get(key);
+        if(s == null)
+        {
+            return error;
+        }
+        try
+        {
+            return Double.parseDouble(s);
+        }
+        catch(NumberFormatException ex)
+        {
+            return error;
+        }
+    }
+    
+    public Location getLocation(String key)
+    {
+        return new Location(Location.getWorld(getString(key + ".world")), 
+                new Vec3d(getDouble(key + ".x", 0), getDouble(key + ".y", 0), getDouble(key + ".z", 0)),
+                getFloat(key + ".yaw", 0), getFloat(key + ".pitch", 0));
+    }
+    
+    // -----------------------------------------------------------------------------------
+    // Add Data
+    // -----------------------------------------------------------------------------------
+    
+    public void setString(String key, String value)
+    {
+        conf.put(key, value);
+    }
+    
+    public void setDouble(String key, double d)
+    {
+        setString(key, String.valueOf(d));
+    }
+    
+    public void setDouble(String key, float d)
+    {
+        setString(key, String.valueOf(d));
+    }
+    
+    public void setLocation(String key, Location l)
+    {
+        setString(key + ".world", l.getWorld().getWorldInfo().getWorldName());
+        setDouble(key + ".x", l.getPos().xCoord);
+        setDouble(key + ".y", l.getPos().yCoord);
+        setDouble(key + ".z", l.getPos().zCoord);
+        setDouble(key + ".yaw", l.getYaw());
+        setDouble(key + ".pitch", l.getPitch());
+    }
+}

src/main/java/me/km/api/Utils.java

@@ -0,0 +1,558 @@
+package me.km.api;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+import me.km.KajetansMod;
+import me.km.exception.PlayerNotFoundException;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockButton;
+import net.minecraft.block.BlockContainer;
+import net.minecraft.block.BlockDoor;
+import net.minecraft.block.BlockPistonMoving;
+import net.minecraft.block.BlockTrapDoor;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemAxe;
+import net.minecraft.item.ItemHoe;
+import net.minecraft.item.ItemPickaxe;
+import net.minecraft.item.ItemSpade;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
+import net.minecraft.world.World;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemSword;
+
+public class Utils 
+{    
+    // -------------------------------------------------------------------------
+    // Befehle für Werkzeuge
+    // -------------------------------------------------------------------------
+    
+    public enum ToolTypes
+    {
+        PICKAXE, AXE, HOE, SHOVEL, SWORD, MUSKET, DAGGER, HAMMER, STICK, WAND, SPEAR
+    }
+    
+    public static ToolTypes getToolType(ItemStack stack)
+    {
+        if(stack == null)
+        {
+            return null;
+        }
+        Item item = stack.getItem();
+        if(item instanceof ItemHoe)
+        {
+            return ToolTypes.HOE;
+        }
+        else if(item instanceof ItemPickaxe)
+        {
+            return ToolTypes.PICKAXE;
+        }
+        else if(item instanceof ItemAxe)
+        {
+            return ToolTypes.AXE;
+        }
+        else if(item instanceof ItemSpade)
+        {
+            return ToolTypes.SHOVEL;
+        }
+        else if(item instanceof ItemSword)
+        {
+            return ToolTypes.SWORD;
+        }
+        return null;
+    }
+       
+    // -------------------------------------------------------------------------
+    // Zufallszahlen
+    // -------------------------------------------------------------------------
+    
+    public static int randomInt(int min, int max)
+    {
+        return new Random().nextInt((max - min) + 1) + min;
+    }
+    
+    public static boolean randomBoolean()
+    {
+        return new Random().nextBoolean();
+    }
+             
+    // -------------------------------------------------------------------------
+    // String-Tools
+    // -------------------------------------------------------------------------
+    
+    public static String formatString(String original)
+    {
+        if(original.length() == 0)
+        {
+            return original;
+        }
+        else if(original.length() == 1)
+        {
+            return original.toUpperCase();
+        }
+        String[] parts = original.split("_");
+        for(int i = 0; i < parts.length; i++)
+        {
+            parts[i] = parts[i].substring(0, 1).toUpperCase() + parts[i].substring(1).toLowerCase();
+        }
+        return connectSpaces(parts, 0);
+    }
+    
+    public static String connect(String[] array, int start, String c)
+    {
+        if(start >= array.length)
+        {
+            return "";
+        }
+        return Arrays.stream(array, start, array.length).collect(Collectors.joining(c));
+    }
+    
+    public static String connectSpaces(String[] array, int start)
+    {
+        return connect(array, start, " ");
+    }
+    
+    public static String connect(String[] array, int start)
+    {
+        if(start >= array.length)
+        {
+            return "";
+        }
+        return Arrays.stream(array, start, array.length).collect(Collectors.joining());
+    }
+    
+    // -------------------------------------------------------------------------
+    // ItemStack-Tools
+    // -------------------------------------------------------------------------
+    
+    public static List<String> getLore(ItemStack stack)
+    {
+        //TODO
+        /*if(!stack.hasItemMeta() || !stack.getItemMeta().hasLore())
+        {*/
+            return new ArrayList<>();
+        /*}
+        return new ArrayList<>(stack.getItemMeta().getLore());*/
+    }    
+    
+    public static void setLore(ItemStack stack, String s, int i)
+    {     
+        //TODO
+        /*ItemMeta meta = stack.getItemMeta();
+        List<String> list;
+        if(meta.hasLore())
+        {
+            list = meta.getLore();
+        }
+        else
+        {
+            list = new ArrayList<>();
+        }                           
+        if(i >= list.size())
+        {
+            list.add(s);
+        }
+        else
+        {
+            list.set(i, s);
+        }           
+        meta.setLore(list);
+        stack.setItemMeta(meta);*/
+    }
+    
+    public static ArrayList<String> buildLimitedLore(String whole, int limit, String addition)
+    {
+        ArrayList<String> list = new ArrayList<>();
+        int pos = 0;
+        int space;
+        while(pos + limit < whole.length())
+        {
+            space = whole.lastIndexOf(" ", pos + limit);
+            if(space == -1 || pos > space)
+            {
+                space = whole.indexOf(" ", pos + limit);
+            }          
+            list.add(addition + whole.substring(pos, space));  
+            pos = space + 1;
+        }
+        list.add(addition + whole.substring(pos));
+        return list;
+    }
+    
+    public static ArrayList<String> buildLimitedLore(String whole, String addition)
+    { 
+        return buildLimitedLore(whole, 25, addition);
+    }
+    
+    public static void dropRandomTreeItem(World w, BlockPos l, IBlockState b)
+    {
+        Block block = b.getBlock();
+        int identifier = block.getMetaFromState(b) % 4;
+        if(b == Blocks.LEAVES2)
+        {
+            identifier += 4;
+        }
+        ArrayList<Object> list = new ArrayList<>();
+        list.add(Items.NAME_TAG);
+        list.add(Items.LEAD);
+        list.add(Blocks.WEB);
+        if(identifier == 3)
+        {
+            list.add(Blocks.VINE);
+            list.add(Items.DYE);
+            list.add(Blocks.VINE);
+            list.add(Items.DYE);
+            list.add(Blocks.VINE);
+            list.add(Items.DYE);
+        }       
+        if(identifier == 0 || identifier == 5)
+        {
+            list.add(Items.APPLE);
+            list.add(Items.APPLE);
+            list.add(Items.APPLE);
+            list.add(Items.APPLE);
+            list.add(Items.GOLDEN_APPLE);
+        }
+        list.add(Items.STICK);
+        list.add(Items.STICK);
+        list.add(Items.STICK);
+        list.add(Items.STICK);
+        list.add(Items.STRING);       
+        list.add(Items.STRING);
+        list.add(Items.FEATHER); 
+        list.add(Items.FEATHER); 
+        if(identifier == 4)
+        {
+            list.add(Items.BONE);
+            list.add(Items.BONE);
+            list.add(Items.BONE);
+        }       
+        int rand = Utils.randomInt(0, 19);
+        if(rand >= list.size())
+        {
+            return;
+        }
+        if(list.get(rand) == Items.DYE)
+        {
+            new ItemStackBuilder(Items.DYE, 1, (short) 3).drop(w, l);
+            return;
+        }
+        if(list.get(rand) instanceof Item)
+        {
+            new ItemStackBuilder((Item) list.get(rand), 1).drop(w, l);
+            return;
+        }
+        new ItemStackBuilder((Block) list.get(rand), 1).drop(w, l);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Inventory-Tools
+    // -------------------------------------------------------------------------
+
+    /*public static int getLowestStackAmount(CraftingInventory inv)
+    {
+        return Arrays.stream(inv.getMatrix()).filter(s -> s != null && s.getType() != Material.AIR).mapToInt(s -> s.getAmount()).min().orElse(0);
+    }
+
+    public static Integer searchInventoryFor(Inventory inv, ItemStack searchfor, boolean ignoreDv)
+    {
+        if(!ignoreDv)
+        {
+            return Arrays.stream(inv.getContents()).filter(s -> s != null && s.isSimilar(searchfor)).mapToInt(s -> s.getAmount()).sum();
+        }
+        Material m = searchfor.getType();
+        return Arrays.stream(inv.getContents()).filter(s -> s != null && s.getType() == m).mapToInt(s -> s.getAmount()).sum();
+    }*/
+        
+    // -------------------------------------------------------------------------
+    // Entities
+    // -------------------------------------------------------------------------
+    
+    public static Location getEntityLocation(Entity ent)
+    {
+        return new Location(ent.getEntityWorld(), ent.getPositionVector(), ent.rotationYaw, ent.rotationPitch);
+    }
+    
+    public static BlockPos getEyeLocation(Entity ent) 
+    {
+        return ent.getPosition().add(0, ent.getEyeHeight(), 0);
+    }
+    
+    public static void teleportEntity(Entity ent, Location l)
+    {
+        Vec3d pos = l.getPos();
+        
+        if(ent instanceof EntityPlayerMP)
+        {
+            if(l.getYaw() != 0 && l.getPitch() != 0)
+            {
+                ((EntityPlayerMP) ent).connection.setPlayerLocation(pos.xCoord, pos.yCoord, pos.zCoord, l.getYaw(), l.getPitch());
+            }
+            else
+            {
+                ((EntityPlayerMP) ent).connection.setPlayerLocation(pos.xCoord, pos.yCoord, pos.zCoord, ent.rotationYaw, ent.rotationPitch);
+            }
+        }
+        else
+        {
+            if(l.getYaw() != 0 && l.getPitch() != 0)
+            {
+                ent.setLocationAndAngles(pos.xCoord, pos.yCoord, pos.zCoord, l.getYaw(), l.getPitch());
+            }
+            else
+            {
+                ent.setLocationAndAngles(pos.xCoord, pos.yCoord, pos.zCoord, ent.rotationYaw, ent.rotationPitch);
+            }
+        }
+    }
+    
+    public static void teleportEntity(Entity ent, Entity ent2)
+    {
+        teleportEntity(ent, new Location(ent2.world, ent.getPositionVector(), ent2.rotationYaw, ent2.rotationPitch));
+    }
+    
+    // -------------------------------------------------------------------------
+    // Entities aus Umgebung
+    // -------------------------------------------------------------------------
+
+    @SuppressWarnings("unchecked")
+    public static List<Entity> getEntitiesExcluding(Entity ent, World w, BlockPos pos, BlockPos pos2)
+    {       
+        return w.getEntitiesWithinAABBExcludingEntity(ent, new AxisAlignedBB(pos, pos2));
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static <T extends Entity> Collection<T> getNearbyEntities(World w, BlockPos l, double radius, Class<T> type)
+    {       
+        double sqareRadius = radius * radius;
+        return w.getEntitiesWithinAABB(type, new AxisAlignedBB(
+                l.getX() - radius, l.getY() - radius, l.getZ() - radius, 
+                l.getX() + radius, l.getY() + radius, l.getZ() + radius), ent -> ent.getDistanceSq(l) <= sqareRadius);
+    }
+
+    public static <T extends Entity> T getNearestEntity(World w, BlockPos l, double radius, Class<T> type)
+    {
+        return getNearbyEntities(w, l, radius, type).stream().min((e1, e2) -> Double.compare(
+                        e1.getDistanceSq(l), 
+                        e2.getDistanceSq(l)))
+                .orElse(null);
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static <T extends Entity> T getTargetedEntity(EntityPlayer p, int radius, Class<T> type)
+    {
+        World w = p.getEntityWorld();
+        BlockPos l = getPlayerTarget(p, radius);
+        BlockPos eye = getEyeLocation(p);
+        List<Entity> col = getEntitiesExcluding(p, w, eye, l);
+        col.removeIf(ent -> !type.isAssignableFrom(ent.getClass()));
+        
+        // Entfernt Entities, die sich nicht mit dem Blick-Vektor schneiden
+        Vec3d first = new Vec3d(eye.getX(), eye.getY(), eye.getZ());
+        Vec3d second = new Vec3d(l.getX(), l.getY(), l.getZ());
+        col.removeIf(ent -> 
+        {
+            AxisAlignedBB bound = ent.getCollisionBoundingBox();
+            if(bound == null)
+            {
+                return true;
+            }
+            return bound.calculateIntercept(first, second) == null;
+        });
+
+        return (T) col.stream().sorted((Entity e1, Entity e2) -> 
+        {
+            return Double.compare(e1.getDistanceSq(eye), e2.getDistanceSq(eye));
+        }).findFirst().orElse(null);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Player-Tools
+    // -------------------------------------------------------------------------
+    
+    public static EntityPlayer getNearestPlayer(World w, BlockPos l)
+    {
+        return w.getPlayers(EntityPlayer.class, p -> true).stream().min((p1, p2) -> Double.compare(p1.getDistanceSq(l), p2.getDistanceSq(l))).orElse(null);
+    }
+    
+    public static BlockPos getPlayerTarget(EntityPlayer p, int range)
+    {
+        if(range > 64)
+        {
+            range = 64;
+        }
+        World w = p.getEntityWorld();
+        BlockPos l = getEyeLocation(p);
+        Vec3d unit2 = p.getLookVec();
+        Vec3i unit = new Vec3i(unit2.xCoord, unit2.yCoord, unit2.zCoord);
+        for(int i = 0; i < range; i++)
+        {
+            l = l.add(unit);
+            if(w.isBlockFullCube(l))
+            {
+                break;
+            }
+        }
+        return l;   
+    }
+    
+    public static BlockPos getPlayerTarget(EntityPlayer p)
+    {
+        return getPlayerTarget(p, 20);
+    }  
+    
+    public static EntityPlayerMP getPlayerByName(String name) throws PlayerNotFoundException
+    {
+        return KajetansMod.server.getPlayerList().getPlayers().stream()
+                    .filter(pl -> pl.getName().contains(name))
+                    .findFirst().orElseThrow(() -> new PlayerNotFoundException(name));
+    }
+        
+    // -------------------------------------------------------------------------
+    // Spawn
+    // -------------------------------------------------------------------------
+    
+    public static Location getSpawn()
+    {
+        // Player changeDimension, WorldServer, MinecraftServer
+        return KajetansMod.conf.getLocation("spawn");
+    }
+
+    public static void setSpawn(World w, Vec3d v, float yaw, float pitch)
+    {          
+        SimpleConfig conf = KajetansMod.conf;
+        conf.setLocation("spawn", new Location(w, v, yaw, pitch));
+        conf.save();
+        w.setSpawnPoint(new BlockPos(v.xCoord, v.yCoord, v.zCoord));
+    }
+    
+    // -------------------------------------------------------------------------
+    // Warps
+    // -------------------------------------------------------------------------
+    
+    public static Location getWarp(Module m, String name)
+    {
+        SimpleConfig conf = new SimpleConfig(m, "warp/" + name, true);
+        if(conf.exists())
+        {
+            return conf.getLocation("loc");
+        }
+        return null;
+    }
+    
+    // -------------------------------------------------------------------------
+    // Blocks
+    // -------------------------------------------------------------------------
+    
+    public static Block getSameNearbyBlock(World w, BlockPos pos, Block b)
+    {           
+        Block bcheck = Location.getRelativeBlock(w, pos, 1, 0, 0).getBlock();
+        if(bcheck == b)
+        {
+            return bcheck;
+        }
+        
+        bcheck = Location.getRelativeBlock(w, pos, -1, 0, 0).getBlock();
+        if(bcheck == b)
+        {
+            return bcheck;
+        }
+        
+        bcheck = Location.getRelativeBlock(w, pos, 0, 0, 1).getBlock();;  
+        if(bcheck == b)
+        {
+            return bcheck;
+        }
+
+        bcheck = Location.getRelativeBlock(w, pos, 0, 0, -1).getBlock();
+        if(bcheck == b)
+        {
+            return bcheck;
+        }
+        
+        return null;
+    }
+       
+    public static boolean shouldBeProtected(Block b)
+    {
+        return b instanceof BlockDoor || 
+               !(b instanceof BlockPistonMoving) ||
+               b instanceof BlockContainer ||
+               b == Blocks.LEVER || 
+               b instanceof BlockButton || 
+               b instanceof BlockTrapDoor;   
+    }
+    
+    // -------------------------------------------------------------------------
+    // Roman Numbers
+    // -------------------------------------------------------------------------
+    
+    public static String intToRoman(int i)
+    {
+        switch(i)
+        {
+            case 1: return "I";
+            case 2: return "II";
+            case 3: return "III";
+            case 4: return "IV";
+            case 5: return "V";
+            case 6: return "VI";
+            case 7: return "VII";
+            case 8: return "VIII";
+            case 9: return "IX";
+            case 10: return "X";
+            case 11: return "XI";
+            case 12: return "XII";
+            case 13: return "XIII";
+            case 14: return "XIV";
+            case 15: return "XV";
+            case 16: return "XVI";
+            case 17: return "XVII";
+            case 18: return "XVIII";
+            case 19: return "XIX";
+            case 20: return "XX";
+        }
+        return "I";
+    }
+    
+    public static int romanToInt(String s)
+    {
+        switch(s)
+        {
+            case "I": return 1;
+            case "II": return 2;
+            case "III": return 3;
+            case "IV": return 4;
+            case "V": return 5;
+            case "VI": return 6;
+            case "VII": return 7;
+            case "VIII": return 8;
+            case "IX": return 9;
+            case "X": return 10;
+            case "XI": return 11;
+            case "XII": return 12;
+            case "XIII": return 13;
+            case "XIV": return 14;
+            case "XV": return 15;
+            case "XVI": return 16;
+            case "XVII": return 17;
+            case "XVIII": return 18;
+            case "XIX": return 19;
+            case "XX": return 20;
+        }
+        return 1;
+    }
+}
+

src/main/java/me/hammerle/km/blocks/BlockBase.java → src/main/java/me/km/blocks/BlockBase.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.blocks;
+package me.km.blocks;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.block.*;
 import net.minecraft.block.material.Material;
 import net.minecraft.creativetab.CreativeTabs;

src/main/java/me/hammerle/km/blocks/ModBlocks.java → src/main/java/me/km/blocks/ModBlocks.java

@@ -1,7 +1,7 @@
-package me.hammerle.km.blocks;
+package me.km.blocks;
 
-import me.hammerle.km.fluids.BlockFluidBase;
-import me.hammerle.km.fluids.ModFluids;
+import me.km.fluids.BlockFluidBase;
+import me.km.fluids.ModFluids;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.item.ItemBlock;

src/main/java/me/km/commands/CommandAddUser.java

@@ -0,0 +1,51 @@
+package me.km.commands;
+
+import com.mojang.authlib.GameProfile;
+import java.util.UUID;
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+
+public class CommandAddUser extends ModuleCommand
+{
+    public CommandAddUser(Module m) 
+    {
+        super("adduser", m);
+        super.setDescription("Fügt einen Spieler der Datenbank hinzu");
+        super.setUsage("/adduser <uuid>");
+        super.setPermission(Permissions.ADD_USER);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        GameProfile op;
+        try
+        {
+            op = KajetansMod.server.getPlayerProfileCache().getProfileByUUID(UUID.fromString(arg[0]));
+        } 
+        catch(IllegalArgumentException ex)
+        {
+            this.getModule().send(cs, "Das ist keine gültige UUID.");
+            return true;
+        }
+        if(op == null)
+        {
+            this.getModule().send(cs, "Das ist kein gültiger Spieler");
+            return true;
+        }
+        if(KajetansMod.playerbank.getDataBank().add(op))
+        {
+            this.getModule().send(cs, op.getName() + " wurde hinzugefügt.");
+            return true;
+        }
+        this.getModule().send(cs, op.getName() + " ist schon in der Datenbank.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandBack.java

@@ -0,0 +1,38 @@
+package me.km.commands;
+
+import me.km.KajetansTools;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.playerbank.TeleportEvent;
+
+public class CommandBack extends ModuleCommand
+{
+    public CommandBack(Module m) 
+    {
+        super("back", m);
+        this.setDescription("Teleportiert dich zu deiner letzten Position");
+        this.setUsage("/back");
+        this.setPermission("kt.back");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;    
+        Location l = KajetansTools.playerbank.getEvent(TeleportEvent.class).getLastLocation(p);
+        if(l != null)
+        {
+            p.getWorld().loadChunk(l.getBlockX(), l.getBlockZ());
+            p.teleport(l);
+            return true;
+        }
+        this.getModule().send(cs, "Es gibt noch keinen Ort, wo du zurückkehren könntest.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandBan.java

@@ -0,0 +1,50 @@
+package me.km.commands;
+
+import com.mojang.authlib.GameProfile;
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import java.util.Date;
+import me.km.KajetansMod;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.management.UserListBansEntry;
+
+public class CommandBan extends ModuleCommand
+{
+    public CommandBan(Module m) 
+    {
+        super("ban", m);
+        super.setDescription("Bannt einen Spiele dauerhaft");
+        super.setUsage("/ban <name> <reason>");
+        super.setPermission(Permissions.BAN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length <= 1)
+        {
+            return false;
+        }
+        GameProfile affectedPlayer = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[0]);
+        if(affectedPlayer == null)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        String message = Utils.connectSpaces(arg, 1);
+        this.getModule().sendBroadcast("§4" + affectedPlayer.getName() + " §cwurde von §4" + cs.getName() + "§c gebannt, weil: §4" + message);    
+        
+        UserListBansEntry bans = new UserListBansEntry(affectedPlayer, null, cs.getName(), null, message);
+        KajetansMod.server.getPlayerList().getBannedPlayers().addEntry(bans);
+        EntityPlayerMP p = KajetansMod.server.getPlayerList().getPlayerByUUID(affectedPlayer.getId());
+        if(p != null)
+        {
+            p.connection.disconnect("§4Du §cwurdest von §4" + cs.getName() + "§c gebannt, weil: §4" + message);
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandBed.java

@@ -0,0 +1,66 @@
+package me.km.commands;
+
+import me.kt.KajetansTools;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.playerbank.PlayerBank;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandBed extends ModuleCommand
+{
+    public CommandBed(Module m) 
+    {
+        super("bed", m);
+        this.setDescription("Teleportiert einen Spieler zu einem Bett");
+        this.setUsage("/bed [player]");
+        this.setPermission("kt.bed");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;
+        
+        Location l; 
+        if(arg.length == 0 || !p.hasPermission("kt.bed.other"))
+        {
+            l = p.getBedSpawnLocation();
+            if(l == null)
+            {
+                this.getModule().send(cs, "Du hast keinen Bettspawn gesetzt.");
+                return true;
+            }
+            p.teleport(l.add(1.5, 0.57, 1.5));
+            this.getModule().send(cs, "Du wurdest zu deinem Bett teleportiert.");
+            return true;
+        }
+
+        String uuid = KajetansTools.playerbank.getDataBank(PlayerBank.class).getUUID(arg[0]);
+        if(uuid == null)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        OfflinePlayer affectedPlayer = Bukkit.getOfflinePlayer(UUID.fromString(uuid));  
+        l = affectedPlayer.getBedSpawnLocation();
+        if(l == null)
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " hat keinen Bettspawn gesetzt.");
+            return true;
+        } 
+        p.teleport(l.add(1.5, 0.57, 1.5));
+        this.getModule().send(cs, "Du wurdest zum Bett von " + affectedPlayer.getName() + " teleportiert.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandBook.java

@@ -0,0 +1,77 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.chatmanager.ChatManager;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BookMeta;
+
+public class CommandBook extends ModuleCommand
+{
+    public CommandBook(Module m) 
+    {
+        super("book", m);
+        this.setDescription("Diverse Befehle für Bücher");
+        this.setUsage("/book für die Hilfe");
+        this.setPermission("kt.book");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Module m = this.getModule();
+        Player p = (Player) cs;
+        
+        if(arg.length >= 1)
+        {
+            ItemStack stack = p.getInventory().getItemInMainHand();
+            if(stack.getType() != Material.WRITTEN_BOOK)
+            {
+                m.send(cs, "Du hast kein signiertes Buch in der Hand.");
+                return true;
+            }
+            BookMeta bmeta = (BookMeta) stack.getItemMeta();
+            
+            switch(arg[0])
+            {
+                case "open":
+                {
+                    ItemStack newItem = new ItemStack(Material.BOOK_AND_QUILL, stack.getAmount());
+                    newItem.setItemMeta(bmeta);
+                    p.getInventory().setItemInMainHand(newItem);
+                    return true;
+                }
+                case "author":
+                {       
+                    bmeta.setAuthor(ChatManager.colorMessage(Utils.connectSpaces(arg, 1), p));
+                    p.getInventory().getItemInMainHand().setItemMeta(bmeta);
+                    p.updateInventory();
+                    return true;
+                }
+                case "title":
+                {       
+                    bmeta.setTitle(ChatManager.colorMessage(Utils.connectSpaces(arg, 1), p));
+                    p.getInventory().getItemInMainHand().setItemMeta(bmeta);
+                    p.updateInventory();
+                    return true;
+                }
+            }
+        }
+        
+        m.send(cs, "/book ...");
+        m.sendHelpListElement(cs, "open", "Öffnet dein Buch erneut");
+        m.sendHelpListElement(cs, "author <name>", "Setzt den Autor des Buches");    
+        m.sendHelpListElement(cs, "title <name>", "Setzt den Titel des Buches");    
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandCoords.java

@@ -0,0 +1,48 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.world.World;
+
+public class CommandCoords extends ModuleCommand
+{
+    public CommandCoords(Module m) 
+    {
+        super("coords", m);
+        super.setDescription("Ändert den Typ eines Spawners");
+        super.setUsage("/coords");
+        super.setPermission(Permissions.COORDS);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        World w = cs.getEntityWorld();
+        BlockPos pos = Utils.getPlayerTarget(p);
+        if(w.isAirBlock(pos))
+        {
+            this.getModule().send(cs, "Du musst auf einen Block gerichtet sein.");
+            return true;
+        }
+        Module m = this.getModule();
+        cs.sendMessage(new TextComponentString(GlobalText.Spacer()));
+        m.send(cs, "Block: " + w.getBlockState(pos).getBlock());
+        m.send(cs, "Welt: " + w.getWorldInfo().getWorldName());
+        m.send(cs, "Koordinaten: " + pos.getX() + " | " + pos.getY() + " | " + pos.getZ());
+        m.send(cs, "Material-Data: " + w.getBlockState(pos));
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandDelHome.java

@@ -0,0 +1,41 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.SimpleConfig;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandDelHome extends ModuleCommand
+{
+    public CommandDelHome(Module m) 
+    {
+        super("delhome", m);
+        super.setDescription("Löscht einen Home");
+        super.setUsage("/delhome <name>");
+        super.setPermission(Permissions.DEL_HOME);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        if(new SimpleConfig(this.getModule(), "home/" + ((EntityPlayer) cs).getUniqueID() + "/" + arg[0], false).delete())
+        {
+            this.getModule().send(cs, "Der Home " + arg[0] + " wurde gelöscht.");
+            return true;
+        }
+        this.getModule().send(cs, "Der Home " + arg[0] + " existiert nicht.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandDelWarp.java

@@ -0,0 +1,34 @@
+package me.km.commands;
+
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.SimpleConfig;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+
+public class CommandDelWarp extends ModuleCommand
+{
+    public CommandDelWarp(Module m) 
+    {
+        super("delwarp", m);
+        super.setDescription("Löscht einen Warp");
+        super.setUsage("/delwarp <warpname>");
+        super.setPermission(Permissions.DEL_WARP);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        if(new SimpleConfig(this.getModule(), "warp/" + arg[0], false).delete())
+        {
+            this.getModule().send(cs, "Der Warp " + arg[0] + " wurde gelöscht.");
+            return true;
+        }
+        this.getModule().send(cs, "Der Warp " + arg[0] + " existiert nicht.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandEnchant.java

@@ -0,0 +1,71 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.api.SimpleTabCompleter;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class CommandEnchant extends ModuleCommand
+{
+    public CommandEnchant(Module m) 
+    {
+        super("enchant", m);
+        this.setDescription("Erzeugt Custom-Enchants");
+        this.setUsage("/enchant <enchant> <level>");
+        this.setPermission("kt.enchant");       
+        
+        m.registerTabCompleter("enchant", new SimpleTabCompleter(
+            Arrays.asList(Enchantment.values()).stream().map(n -> n.getName()).collect(Collectors.toList()), 1));
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;
+        ItemStack hand = p.getInventory().getItemInMainHand();
+        if(hand.getType() == Material.AIR)
+        {
+            this.getModule().send(cs, "Du musst ein Item in der Hand halten.");
+            return true;
+        }
+        if(arg.length < 2)
+        {
+            return false;
+        }
+        Enchantment ench = Enchantment.getByName(arg[0]);
+        if(ench == null)
+        {
+            this.getModule().send(cs, "Das gegebene Enchantment existiert nicht.");
+            return true;
+        }       
+        try
+        {
+            int i = Integer.parseInt(arg[1]);
+            if(i < 1)
+            {
+                throw new NumberFormatException();
+            } 
+            hand.addUnsafeEnchantment(ench, i);
+            p.getInventory().setItemInMainHand(hand);
+            this.getModule().send(cs, "Das Enchantment wurde hinzugefügt.");
+            return true;
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(cs, GlobalText.noPositiveNaturalNumber());            
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandEnderChest.java

@@ -0,0 +1,45 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandEnderChest extends ModuleCommand
+{
+    public CommandEnderChest(Module m) 
+    {
+        super("enderchest", m);
+        super.setDescription("Zeigt dir die Enderchest eines Spielers");
+        super.setUsage("/enderchest [player]");
+        super.setPermission(Permissions.ENDERCHEST);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        try
+        {
+            p.displayGUIChest(Utils.getPlayerByName(arg[0]).getInventoryEnderChest());
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            p.displayGUIChest(p.getInventoryEnderChest());
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandExp.java

@@ -0,0 +1,184 @@
+package me.km.commands;
+
+import me.km.permissions.Permissions;
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandExp extends ModuleCommand
+{
+    public CommandExp(Module m) 
+    {
+        super("exp", m);
+        super.setDescription("Befehle um die EXP eines Spielers zu verändern");
+        super.setUsage("/exp für die Hilfe");
+        super.setPermission(Permissions.EXP);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        Module m = this.getModule();
+        if(arg.length >= 1)
+        {
+            switch(arg[0])
+            {
+                case "show":
+                {
+                    EntityPlayer p;
+                    try
+                    {
+                        p = Utils.getPlayerByName(arg[1]);    
+                        m.send(cs, p.getName() + " hat " + p.experienceTotal + " XP (Level: " + p.experienceLevel + ").");
+                    }
+                    catch(PlayerNotFoundException ex)
+                    {
+                        m.send(cs, GlobalText.cantFindPlayer(arg[1]));
+                        return true;
+                    }
+                    catch(IndexOutOfBoundsException ex)
+                    {
+                        if(!(cs instanceof EntityPlayer))
+                        {
+                            m.send(cs, GlobalText.missingParameter());
+                            return true;
+                        }     
+                        p = (EntityPlayer) cs;
+                        m.send(cs, "Du hast " + p.experienceTotal + " XP (Level: " + p.experienceLevel + ").");
+                    }
+                    return true;
+                }
+                case "set":
+                {       
+                    if(arg.length >= 2)
+                    {
+                        EntityPlayer p;
+                        try
+                        {
+                            p = Utils.getPlayerByName(arg[2]);    
+                            try
+                            {         
+                                int i = Integer.parseInt(arg[1]);
+                                if(i < 0)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                p.experienceLevel = 0;
+                                p.experience = 0;
+                                p.experienceTotal = 0;
+                                p.addExperience(i);
+                                m.send(cs, p.getName() + " hat nun " + arg[1] +  " XP.");
+                                m.send(p, "Deine XP wurden auf " + arg[1] +  " gesetzt.");
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            } 
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            p = (EntityPlayer) cs;
+                            try
+                            {         
+                                int i = Integer.parseInt(arg[1]);
+                                if(i <= 0)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                p.experienceLevel = 0;
+                                p.experience = 0;
+                                p.experienceTotal = 0;
+                                p.addExperience(i);     
+                                m.send(p, "Deine XP wurden auf " + arg[1] +  " gesetzt.");
+                            }
+                            catch(NumberFormatException ex2)
+                            {
+                                m.send(cs, GlobalText.noPositiveNaturalNumber());
+                                return true;
+                            }
+                        }
+                        return true;
+                    }
+                }
+                case "give":
+                {       
+                    if(arg.length >= 2)
+                    {
+                        EntityPlayer p;
+                        try
+                        {
+                            p = Utils.getPlayerByName(arg[2]);    
+                            try
+                            {         
+                                int i = Integer.parseInt(arg[1]);
+                                if(i <= 0)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                p.addExperience(i);   
+                                m.send(cs, p.getName() + " wurden " + arg[1] +  " XP gegeben.");
+                                m.send(p, "Dir wurden " + arg[1] + " XP gegeben.");
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noPositiveNaturalNumber());
+                                return true;
+                            } 
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            p = (EntityPlayer) cs;
+                            try
+                            {         
+                                int i = Integer.parseInt(arg[1]);
+                                if(i <= 0)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                p.addExperience(i);    
+                                m.send(p, "Dir wurden " + arg[1] + " XP gegeben.");
+                            }
+                            catch(NumberFormatException ex2)
+                            {
+                                m.send(cs, GlobalText.noPositiveNaturalNumber());
+                                return true;
+                            }
+                        }
+                        return true;
+                    }
+                }
+            }
+        }
+        
+        m.send(cs, "/exp ...");
+        m.sendHelpListElement(cs, "show [player]", "Zeigt die EXP eines Spielers");
+        m.sendHelpListElement(cs, "set <amount> [player]", "Setzt die EXP eines Spielers");    
+        m.sendHelpListElement(cs, "give <amount> [player]", "Gibt dem Spieler EXP");    
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandFeed.java

@@ -0,0 +1,52 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.exceptions.PlayerNotFoundException;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandFeed extends ModuleCommand
+{
+    public CommandFeed(Module m) 
+    {
+        super("feed", m);
+        this.setDescription("Sättigt den Hunger eines Spielers");
+        this.setUsage("/feed [player]");
+        this.setPermission("kt.feed");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        Player affectedPlayer;
+        Module m = this.getModule();
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);    
+            m.send(cs, "Der Hunger von " + affectedPlayer.getName() + " wurde gesättigt.");
+            m.send(affectedPlayer, "Dein Hunger wurde gesättigt.");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            m.send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof Player))
+            {
+                m.send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (Player) cs;
+            m.send(affectedPlayer, "Dein Hunger wurde gesättigt.");
+        }
+        affectedPlayer.setFoodLevel(20);
+        affectedPlayer.setExhaustion(16);
+        affectedPlayer.setSaturation(16);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandFly.java

@@ -0,0 +1,81 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandFly extends ModuleCommand
+{
+    public CommandFly(Module m) 
+    {
+        super("fly", m);
+        super.setDescription("Lässt einen Spieler fliegen");
+        super.setUsage("/fly [player] [on|off]");
+        super.setPermission(Permissions.FLY);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        EntityPlayer affectedPlayer;
+        try
+        {
+            if(arg.length >= 1 && !Permission.hasPermission(cs, Permissions.FLY_OTHER))
+            {
+                this.getModule().send(cs, "Du darfst nur deinen eigenen Fly setzen.");
+                return true;
+            }
+            affectedPlayer = Utils.getPlayerByName(arg[0]);      
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+        }
+
+        boolean fly = !affectedPlayer.capabilities.allowFlying;
+        if(arg.length >= 2)
+        {
+            if(arg[1].equals("on"))
+            {
+                fly = true;
+            }
+            else if(arg[1].equals("off"))
+            {
+                fly = false;
+            }
+        }
+
+        affectedPlayer.capabilities.allowFlying = fly;
+        if(fly)
+        {
+            this.getModule().send(affectedPlayer, "Du kannst nun fliegen.");
+            if(!cs.equals(affectedPlayer))
+            {
+                this.getModule().send(cs, affectedPlayer.getName() + " kann nun fliegen.");
+            }
+            return true;
+        }
+        this.getModule().send(affectedPlayer, "Du kannst nicht mehr fliegen.");
+        if(!cs.equals(affectedPlayer))
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " kann nicht mehr fliegen.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandGameMode.java

@@ -0,0 +1,97 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.GameType;
+
+public class CommandGameMode extends ModuleCommand
+{
+    public CommandGameMode(Module m) 
+    {
+        super("gamemode", m);
+        super.setDescription("Ändert den GameMode eines Spielers");
+        super.setUsage("/gamemode <mode> [player]");
+        super.setPermission(Permissions.GAMEMODE);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        
+        EntityPlayer affectedPlayer;
+        try
+        {
+            if(arg.length >= 2 && !Permission.hasPermission(cs, Permissions.GAMEMODE_OTHER))
+            {
+                this.getModule().send(cs, "Du darfst nur deinen eigenen GameMode setzen.");
+                return true;
+            }
+            affectedPlayer = Utils.getPlayerByName(arg[1]);      
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[1]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+        }
+
+        String mode;
+        switch (arg[0].toLowerCase()) 
+        {
+            case "survival":
+            case "s":
+            case "0":  
+                affectedPlayer.setGameType(GameType.SURVIVAL);
+                mode = "Survival";
+                break;
+            case "creative":
+            case "c":        
+            case "1":  
+                affectedPlayer.setGameType(GameType.CREATIVE);
+                mode = "Creative";
+                break;
+            case "adventure":         
+            case "a":         
+            case "2":  
+                affectedPlayer.setGameType(GameType.ADVENTURE);
+                mode = "Adventure";
+                break;
+            case "specator":         
+            case "w":         
+            case "3":  
+                affectedPlayer.setGameType(GameType.SPECTATOR);
+                mode = "Spectator";
+                break;  
+            default:
+                affectedPlayer.setGameType(GameType.CREATIVE);
+                mode = "Creative";
+                break;
+        }
+
+        this.getModule().send(affectedPlayer, "Du hast nun Gamemode " + mode + ".");
+        if(!cs.equals(affectedPlayer))
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " hat nun Gamemode " + mode + ".");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandGod.java

@@ -0,0 +1,66 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.playerbank.PlayerBank;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandGod extends ModuleCommand
+{
+    public CommandGod(Module m) 
+    {
+        super("god", m);
+        super.setDescription("Setzt einen Spieler auf God-Mode");
+        super.setUsage("/god [player]");
+        super.setPermission(Permissions.GOD);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        EntityPlayer affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);    
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+        }
+        
+        PlayerBank pb = KajetansMod.playerbank.getDataBank();
+        if(pb.getTag(affectedPlayer, "god") == 1)
+        {
+            pb.setTag(affectedPlayer, "god", 0);
+            this.getModule().send(affectedPlayer, "Du bist nicht mehr unsterblich.");
+            if(!affectedPlayer.equals(cs))
+            {
+                this.getModule().send(cs, affectedPlayer.getName() + " ist nicht mehr unsterblich.");
+            }
+            return true;
+        }
+        pb.setTag(affectedPlayer, "god", 1);
+        this.getModule().send(affectedPlayer, "Du bist nun unsterblich.");
+        if(!affectedPlayer.equals(cs))
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " ist nun unsterblich.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandGrow.java

@@ -0,0 +1,58 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import org.bukkit.CropState;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.material.Crops;
+
+public class CommandGrow extends ModuleCommand
+{
+    public CommandGrow(Module m) 
+    {
+        super("grow", m);
+        this.setDescription("Lässt die Pflanzen in deiner Umgebung wachsen");
+        this.setUsage("/grow");
+        this.setPermission("kt.grow");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Block l = ((Player) cs).getLocation().getBlock();
+        Block b;
+        for(int x = -3; x < 4; x++)
+        {
+            for(int y = -3; y < 4; y++)
+            {
+                for(int z = -3; z < 4; z++)
+                {
+                    b = l.getRelative(x, y, z);
+                    if(!(b.getState().getData() instanceof Crops))
+                    {
+                        continue;                  
+                    }
+                    if(((Crops) b.getState().getData()).getState() != CropState.RIPE)
+                    {
+                        BlockState state = b.getState();
+                        Crops crop = ((Crops) state.getData());
+                        crop.setState(CropState.RIPE);
+                        state.setData(crop);
+                        state.update();
+                    }                        
+                }
+            }
+        }
+        this.getModule().send(cs, "Die Pflanzen in deiner Umgebung sind gewachsen.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandHat.java

@@ -0,0 +1,47 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.ItemStack;
+
+public class CommandHat extends ModuleCommand
+{
+    public CommandHat(Module m) 
+    {
+        super("hat", m);
+        super.setDescription("Setzt dir einen Hut auf");
+        super.setUsage("/hat");
+        super.setPermission(Permissions.HAT);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        ItemStack stack = p.getHeldItemMainhand();
+        if(stack == null || stack.getItem() == Items.AIR)
+        {
+            this.getModule().send(cs, "Du musst ein Item in der Hand halten.");
+            return true;
+        }
+        if(p.getItemStackFromSlot(EntityEquipmentSlot.HEAD) == ItemStack.EMPTY)
+        {
+            p.setItemStackToSlot(EntityEquipmentSlot.HEAD, stack);
+            this.getModule().send(cs, "Du trägst nun einen Hut.");
+            return true;
+        }        
+        this.getModule().send(cs, "Du trägst bereits einen Hut.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandHeal.java

@@ -0,0 +1,56 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.potion.PotionEffect;
+
+public class CommandHeal extends ModuleCommand
+{
+    public CommandHeal(Module m) 
+    {
+        super("heal", m);
+        super.setDescription("Heilt einen Spieler");
+        super.setUsage("/heal [player]");
+        super.setPermission(Permissions.HEAL);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        EntityPlayer affectedPlayer;
+        Module m = this.getModule();
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);    
+            m.send(cs, affectedPlayer.getName() + " wurde geheilt.");
+            m.send(affectedPlayer, "Du wurdest geheilt.");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            m.send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                m.send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+            m.send(affectedPlayer, "Du wurdest geheilt.");
+        }
+        affectedPlayer.setHealth(affectedPlayer.getMaxHealth());
+        for(PotionEffect eff : affectedPlayer.getActivePotionEffects())
+        {
+            affectedPlayer.removePotionEffect(eff.getPotion());
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandHome.java

@@ -0,0 +1,103 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.SimpleConfig;
+import java.io.File;
+import java.util.List;
+import me.km.api.Location;
+import me.km.api.Utils;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandHome extends ModuleCommand
+{
+    public CommandHome(Module m) 
+    {
+        super("home", m);
+        super.setDescription("Teleportiert einen Spieler zu einem Home-Punkt");
+        super.setUsage("/home [name / player:name]");
+        super.setPermission(Permissions.HOME);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        
+        String playeruuid = p.getUniqueID().toString();
+        String homename = "";
+        
+        if(arg.length >= 1)
+        {
+            homename = arg[0];          
+            if(arg[0].contains(":") && Permission.hasPermission(cs, Permissions.HOME_OTHER))
+            {               
+                String[] split = homename.split(":");
+                String uuid = KajetansMod.playerbank.getDataBank().getUUID(split[0]);
+                if(uuid != null && split.length >= 2)
+                {
+                    homename = split[1];
+                    playeruuid = uuid;
+                }         
+                else if(split.length == 1 && uuid != null)
+                {
+                    homename = "";
+                    playeruuid = uuid;
+                }
+            }    
+        }
+
+        Module m = this.getModule();
+        List<File> homes = SimpleConfig.getFiles("home/" + playeruuid);
+        if(homes.isEmpty())
+        {
+            String name = KajetansMod.playerbank.getDataBank().getName(playeruuid);
+            if(name.equals(p.getName()))
+            {
+                m.send(cs, "Du hast keine Homepunkte gesetzt.");
+                return true;
+            }
+            m.send(cs, name + " hat keine Homepunkte gesetzt.");      
+            return true;
+        }
+        if(arg.length == 0 || homename.equals(""))
+        {
+            m.send(cs, "Folgende Homepunkte stehen zur Verfügung:");      
+            homes.stream().forEach(h -> {m.sendListElement(cs, h.getName().replaceAll(".yml", ""));});
+            return true;
+        }
+                  
+        try
+        {
+            SimpleConfig sc = new SimpleConfig(this.getModule(), "home/" + playeruuid + "/" + homename, true);
+            Location l = sc.getLocation("home");
+            if(l.getWorld() == null)
+            {
+                throw new NullPointerException();
+            }    
+            Utils.teleportEntity(p, l);
+            m.send(cs, "Du wurdest zum Home-Punkt " + homename + " teleportiert.");
+        }
+        catch(IllegalArgumentException ex)
+        {
+            m.send(cs, "Der Homepunkt wurde nicht gefunden.");    
+            return true;
+        }
+        catch(NullPointerException ex)
+        {
+            m.send(cs, "Die Welt des Homepunktes wurde nicht gefunden.");    
+            return true;
+        }            
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandInvSee.java

@@ -0,0 +1,45 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandInvSee extends ModuleCommand
+{
+    public CommandInvSee(Module m) 
+    {
+        super("invsee", m);
+        super.setDescription("Zeigt dir den Inventar eines Spielers");
+        super.setUsage("/invsee <player>");
+        super.setPermission(Permissions.INVSEE);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        try
+        {
+            p.displayGUIChest(Utils.getPlayerByName(arg[0]).inventory);
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandItemInfo.java

@@ -0,0 +1,53 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.nms.NmsUtilities;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class CommandItemInfo extends ModuleCommand
+{
+    public CommandItemInfo(Module m) 
+    {
+        super("iteminfo", m);
+        this.setDescription("Gibt Information über ein Item aus");
+        this.setUsage("/iteminfo");
+        this.setPermission("kt.iteminfo");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Module m = this.getModule();
+        Player p = (Player) cs;
+        ItemStack stack = p.getInventory().getItemInMainHand();
+        if(stack == null || stack.getType() == Material.AIR)
+        {
+            m.send(cs, "Du musst ein Item in der Hand halten.");
+            return true;
+        }
+        cs.sendMessage(GlobalText.Spacer());
+        m.send(cs, "DV: §6" + stack.getDurability());
+        m.send(cs, "Spigotname: §6" + stack.getType().toString().toLowerCase());
+        m.send(cs, "Mojangname: §6" + NmsUtilities.getStackType(stack));
+        try
+        {
+            m.send(cs, "Meta: §6" + stack.getItemMeta().toString());
+        }
+        catch(java.lang.NullPointerException ex)
+        {
+            m.send(cs, "Meta: §cFehler beim Lesen");
+        }
+        NmsUtilities.sendCopyableText(p, NmsUtilities.getNbtString(stack).replace("\"", "'"));
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandKick.java

@@ -0,0 +1,45 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CommandKick extends ModuleCommand
+{
+    public CommandKick(Module m) 
+    {
+        super("kick", m);
+        super.setDescription("Kickt einen Spieler");
+        super.setUsage("/kick <name> <reason>");
+        super.setPermission(Permissions.KICK);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length <= 1)
+        {
+            return false;
+        }
+        EntityPlayerMP affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);                   
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }                      
+        String message = Utils.connectSpaces(arg, 1);
+        this.getModule().sendBroadcast("§4" + affectedPlayer.getName() + " §cwurde von §4" + cs.getName() + "§c gekickt, weil: §4" + message);  
+        affectedPlayer.connection.disconnect("§4Du §cwurdest von §4" + cs.getName() + "§c gekickt, weil: §4" + message);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandKill.java

@@ -0,0 +1,51 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandKill extends ModuleCommand
+{
+    public CommandKill(Module m) 
+    {
+        super("kill", m);
+        super.setDescription("Tötet einen Spieler");
+        super.setUsage("/kill [player]");
+        super.setPermission(Permissions.KILL);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length == 0 || !Permission.hasPermission(cs, Permissions.KILL_OTHER))
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }
+            EntityPlayer p = (EntityPlayer) cs;
+            p.onKillCommand();
+            this.getModule().send(cs, "Du hast dich selbst getötet.");
+            return true;
+        }
+        try
+        {
+            EntityPlayer affectedPlayer = Utils.getPlayerByName(arg[0]);   
+            affectedPlayer.onKillCommand();
+            this.getModule().send(cs, "Du hast " + affectedPlayer.getName() + " getötet.");
+            this.getModule().send(affectedPlayer, cs.getName() + " hat dich getötet.");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandLag.java

@@ -0,0 +1,40 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+
+public class CommandLag extends ModuleCommand
+{
+    public CommandLag(Module m) 
+    {
+        super("lag", m);
+        super.setDescription("Testet den Server auf Lags");
+        super.setUsage("/lag");
+        super.setPermission(Permissions.LAG);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        Module m = this.getModule();
+        m.send(cs, "Der Lagtest wird durchgeführt:");
+        long time = System.currentTimeMillis();
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            long diff = System.currentTimeMillis() - time;
+            m.sendListElement(cs, "5000 Millisekunden sind nach dem Scheduler vergangen");
+            m.sendListElement(cs, diff + " Millisekunden sind tatsächlich vergangen");
+            String s = String.valueOf((((double) diff / 50d) - 100d));
+            if(s.length() > 6)
+            {
+                s = s.substring(0, 5);
+            }
+            m.sendListElement(cs, "Dies entspricht einer Abweichung von " + s + "%");
+        }, 100);              
+        return true;
+    }
+    
+}

src/main/java/me/km/commands/CommandLastSeen.java

@@ -0,0 +1,87 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.playerbank.PlayerBank;
+import java.io.File;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import me.km.permissions.Permissions;
+import me.km.table.Table;
+import net.minecraft.command.ICommandSender;
+
+public class CommandLastSeen extends ModuleCommand
+{
+    public CommandLastSeen(Module m) 
+    {
+        super("lastseen", m);
+        super.setDescription("Zeigt an welche Spieler zuletzt online waren");
+        super.setUsage("/lastseen [amount]");
+        super.setPermission(Permissions.LASTSEEN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        File[] files = new File("./saves/world/playerdata/").listFiles();
+        String helper;
+        String name;
+        long longhelper;
+        Table table = new Table(2);
+        
+        PlayerBank pb = KajetansMod.playerbank.getDataBank();
+        for(File output : files)
+        {
+            helper = output.getName();
+            if(!helper.endsWith(".dat"))
+            {
+                continue;
+            }
+            longhelper = output.lastModified(); 
+            helper = helper.substring(0, helper.length() - 4);
+            name = pb.getName(helper);
+            if(name == null)
+            {
+                name = helper;
+            }
+            table.addRow(new Object[] {longhelper, name});
+        }
+        
+        table.sort();
+        table.reverse();
+        SimpleDateFormat ft = new SimpleDateFormat ("dd.MM.yyyy '§rum§7' HH:mm:ss");
+        
+        Module m = this.getModule();
+        int limit = 10;   
+        if(arg.length >= 1)
+        {
+            try
+            {
+                limit = Integer.parseInt(arg[0]);
+                if(limit < 1)
+                {
+                    throw new NumberFormatException();
+                }
+            }
+            catch(NumberFormatException ex)
+            {
+                m.send(cs, GlobalText.noPositiveNaturalNumber());
+                return true;
+            }
+        }
+        
+        if(table.getSize() < limit)
+        {
+            limit = table.getSize();
+        }
+        
+        m.send(cs, "Zuletzt waren folgende Spieler online:");
+        for(int i = 0; i < limit; i++)
+        {
+            m.sendListElement(cs, "§7" + table.getElement(i, 1) + "§r am §7" + ft.format(new Date((long) table.getElement(i, 0))));
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandLightUpdate.java

@@ -0,0 +1,33 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandLightUpdate extends ModuleCommand
+{
+    public CommandLightUpdate(Module m) 
+    {
+        super("lightupdate", m);
+        super.setDescription("Entfernt Lichtbugs");
+        super.setUsage("/lightupdate");
+        super.setPermission(Permissions.LIGHTUPDATE);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        this.getModule().send(cs, "Dieser Command macht momentan nichts.");
+        return true;
+    }
+    
+}

src/main/java/me/km/commands/CommandList.java

@@ -0,0 +1,49 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.chatmanager.ChatManager;
+import java.util.List;
+import java.util.stream.Collectors;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CommandList extends ModuleCommand
+{
+    public CommandList(Module m) 
+    {
+        super("list", m);
+        super.setDescription("Zeigt die online Spieler an");
+        super.setUsage("/list");
+        super.setPermission(Permissions.LIST);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        Module m = this.getModule();
+        List<EntityPlayerMP> players = KajetansMod.server.getPlayerList().getPlayers();
+        int number = players.size();
+        int max = KajetansMod.server.getMaxPlayers();      
+        switch(number) 
+        {
+            case 1:    
+                m.send(cs, "Es ist §7einer§r von maximal §7" + max + "§r Spielern online:");
+                break;
+            case 0:
+                m.send(cs, "Es sind §70§r von maximal §7" + max + "§r Spielern online.");
+                return true;
+            default:
+                m.send(cs, "Es sind §7" + number + "§r von maximal §7" + max + "§r Spielern online:");
+                break;
+        }
+        ChatManager man = KajetansMod.chatManager;
+        if(number > 0)
+        {
+            cs.sendMessage(players.stream().map(p -> man.getFullName(p)).collect(Collectors.joining("§7, §r")));
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandMemory.java

@@ -0,0 +1,26 @@
+package me.km.commands;
+
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import org.bukkit.command.CommandSender;
+
+public class CommandMemory extends ModuleCommand
+{
+    public CommandMemory(Module m) 
+    {
+        super("memory", m);
+        this.setDescription("Gibt RAM Information aus");
+        this.setUsage("/memory");
+        this.setPermission("kt.memory");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        Runtime runtime = Runtime.getRuntime();
+        long allocatedMemory = runtime.totalMemory() / 1048576;
+        long usedMemory = allocatedMemory - (runtime.freeMemory() / 1048576);
+        this.getModule().send(cs, "RAM-Belegung: " + usedMemory + " / " + allocatedMemory + " MB");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandMore.java

@@ -0,0 +1,41 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+
+public class CommandMore extends ModuleCommand
+{
+    public CommandMore(Module m) 
+    {
+        super("more", m);
+        super.setDescription("Stackt die Hand auf 64");
+        super.setUsage("/more");
+        super.setPermission(Permissions.MORE);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        ItemStack stack = p.getHeldItemMainhand();
+        if(stack == null || stack.getItem() == Items.AIR)
+        {
+            this.getModule().send(cs, "Du musst ein Item in der Hand halten.");
+            return true;
+        }
+        stack.setCount(64);
+        this.getModule().send(cs, "Das Item wurde auf 64 gestackt.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandMsg.java

@@ -0,0 +1,89 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.chatmanager.ChatManager;
+import me.kt.exceptions.PlayerNotFoundException;
+import java.util.HashMap;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandMsg extends ModuleCommand
+{
+    private final HashMap<String, String> answer; 
+    
+    public CommandMsg(Module m) 
+    {
+        super("msg", m);
+        this.setDescription("Schreibt dem Spieler eine Privatnachricht");
+        this.setUsage("/msg <player> <message> oder /r <message>");
+        this.setPermission("kt.msg");
+        
+        answer = new HashMap<>();
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!string.equalsIgnoreCase("r"))
+        {
+            if(arg.length <= 1)
+            {
+                return false;
+            }
+            Player affectedPlayer;
+            try
+            {
+                affectedPlayer = Utils.getPlayerByName(arg[0]);                   
+            }
+            catch(PlayerNotFoundException ex)
+            {
+                this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+                return true;
+            }
+            String message = ChatManager.colorMessage(Utils.connectSpaces(arg, 1), cs);
+            cs.sendMessage("§6[ -> §c" + affectedPlayer.getName() + "§6] §r" + message);
+            affectedPlayer.sendMessage("§6[§c" + cs.getName()+ "§6] §r" + message);
+            answer.put(cs.getName(), affectedPlayer.getName());
+            answer.put(affectedPlayer.getName(), cs.getName());
+            return true;
+        }
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        String s = answer.get(cs.getName());
+        if(s == null)
+        {
+            this.getModule().send(cs, "Du hast niemanden, dem du antworten könntest.");
+            return true;
+        }
+        CommandSender previous;
+        if(s.equals("CONSOLE"))
+        {
+            previous = Bukkit.getConsoleSender();
+        }
+        else
+        {
+            try
+            {
+                previous = Utils.getPlayerByName(s);            
+            }
+            catch(PlayerNotFoundException ex)
+            {
+                this.getModule().send(cs, "Du hast niemanden, dem du antworten könntest.");
+                return true;
+            }
+        }
+        
+        String message = ChatManager.colorMessage(Utils.connectSpaces(arg, 0), cs);
+        cs.sendMessage("§6[ -> §c" + previous.getName()+ "§6] §r" + message);
+        previous.sendMessage("§6[§c" + cs.getName()+ "§6] §r" + message);
+        answer.put(cs.getName(), previous.getName());
+        answer.put(previous.getName(), cs.getName());
+        return true;  
+    }
+}

src/main/java/me/km/commands/CommandPosition.java

@@ -0,0 +1,39 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandPosition extends ModuleCommand
+{
+    public CommandPosition(Module m) 
+    {
+        super("position", m);
+        this.setDescription("Zeigt deine Position an");
+        this.setUsage("/position");
+        this.setPermission("kt.position");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;
+        Module m = this.getModule();
+        m.send(cs, "Welt: " + p.getWorld().getName());
+        Location l = p.getLocation();
+        m.send(cs, "Koordinaten: " + l.getX() + " | " + l.getY() + " | " + l.getZ());
+        m.send(cs, "Yaw: " + l.getYaw());
+        m.send(cs, "Pitch: " + l.getPitch());
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandPotion.java

@@ -0,0 +1,86 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.api.SimpleTabCompleter;
+import java.util.Arrays;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public class CommandPotion extends ModuleCommand
+{
+    public CommandPotion(Module m) 
+    {
+        super("potion", m);
+        this.setDescription("Erzeugt Custom-Potions");
+        this.setUsage("/potion [clear] [effect] [duration] [amplifier]");
+        this.setPermission("kt.potion");
+        
+        m.registerTabCompleter("potion", new SimpleTabCompleter(Arrays.asList(new String[]{
+            "ABSORPTION", "BLINDNESS", "CONFUSION", "DAMAGE_RESISTANCE", "FAST_DIGGING",
+            "FIRE_RESISTANCE", "GLOWING", "HARM", "HEAL", "HEALTH_BOOST", "HUNGER",
+            "INCREASE_DAMAGE", "INVISIBILITY", "JUMP", "LEVITATION", "LUCK", "POISON",
+            "REGENERATION", "SATURATION", "SLOW", "SLOW_DIGGING", "SPEED", "UNLUCK",
+            "WATER_BREATHING", "WEAKNESS", "WITHER"}), 1));
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;
+        ItemStack hand = p.getInventory().getItemInMainHand();
+        if(hand.getType() != Material.SPLASH_POTION &&
+           hand.getType() != Material.POTION &&
+           hand.getType() != Material.LINGERING_POTION)
+        {
+            this.getModule().send(cs, "Du musst einen Trank in der Hand halten.");
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        PotionMeta meta = (PotionMeta) hand.getItemMeta();
+        if(arg[0].equals("clear"))
+        {
+            meta.clearCustomEffects();
+            hand.setItemMeta(meta);
+            p.getInventory().setItemInMainHand(hand);
+            this.getModule().send(cs, "Alle Custom-Effekte wurden entfernt");
+            return true;
+        }
+        try
+        {
+            meta.addCustomEffect(new PotionEffect(PotionEffectType.getByName(arg[0].toUpperCase()), Integer.parseInt(arg[1]), Integer.parseInt(arg[2])), true);
+            this.getModule().send(cs, "Der Effekt wurde hinzugefügt.");
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(cs, GlobalText.noIntegerNumber());
+            return true;
+        }
+        catch(IllegalArgumentException ex)
+        {
+            this.getModule().send(cs, "Der gegebene Potion-Effect existiert nicht.");
+            return true;
+        }
+        catch(ArrayIndexOutOfBoundsException ex)
+        {
+            return false;
+        }
+        hand.setItemMeta(meta);
+        p.getInventory().setItemInMainHand(hand);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandPvP.java

@@ -0,0 +1,71 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.playerbank.PlayerBank;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandPvP extends ModuleCommand
+{
+    public CommandPvP(Module m) 
+    {
+        super("pvp", m);
+        super.setDescription("Schaltet deine PVP-Einstellungen");
+        super.setUsage("/pvp [player]");
+        super.setPermission(Permissions.PVP);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        EntityPlayer affectedPlayer;
+        try
+        {
+            if(!Permission.hasPermission(cs, Permissions.PVP_OTHER))
+            {
+                throw new IndexOutOfBoundsException();
+            }
+            affectedPlayer = Utils.getPlayerByName(arg[0]);    
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+        }
+        
+        PlayerBank pb = KajetansMod.playerbank.getDataBank();
+        if(pb.getTag(affectedPlayer, "pvp") == 1)
+        {
+            pb.setTag(affectedPlayer, "pvp", 0);
+            this.getModule().send(affectedPlayer, "Du hast PVP nun aus.");
+            if(!affectedPlayer.equals(cs))
+            {
+                this.getModule().send(cs, affectedPlayer.getName() + " hat PVP nun aus.");
+            }
+            return true;
+        }
+        pb.setTag(affectedPlayer, "pvp", 1);
+        this.getModule().send(affectedPlayer, "Du hast PVP nun an.");
+        if(!affectedPlayer.equals(cs))
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " hat PVP nun an.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandRepair.java

@@ -0,0 +1,42 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+public class CommandRepair extends ModuleCommand
+{
+    public CommandRepair(Module m) 
+    {
+        super("repair", m);
+        super.setDescription("Repariert ein Item");
+        super.setUsage("/repair");
+        super.setPermission(Permissions.REPAIR);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        ItemStack stack = ((EntityPlayer) cs).getHeldItemMainhand();
+        if(stack == null || stack == ItemStack.EMPTY)
+        {
+            this.getModule().send(cs, "Du musst ein Item in der Hand halten.");
+            return true;
+        }
+        if(stack.getItemDamage() != 0)
+        {
+            stack.setItemDamage(0);
+        }
+        this.getModule().send(cs, "Das Item wurde repariert.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSay.java

@@ -0,0 +1,28 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.text.TextComponentString;
+
+public class CommandSay extends ModuleCommand
+{
+    public CommandSay(Module m) 
+    {
+        super("say", m);
+        super.setDescription("Lässt den Server sprechen");
+        super.setUsage("/say");
+        super.setPermission(Permissions.SAY);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        KajetansMod.server.getPlayerList().sendMessage(
+                new TextComponentString("[§cServer§r] " + Utils.connectSpaces(arg, 0)));
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSeen.java

@@ -0,0 +1,55 @@
+package me.km.commands;
+
+import me.kt.KajetansTools;
+import me.kt.api.Utils;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.playerbank.PlayerBank;
+import me.kt.exceptions.PlayerNotFoundException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandSeen extends ModuleCommand
+{
+    public CommandSeen(Module m) 
+    {
+        super("seen", m);
+        this.setDescription("Zeigt wann ein Spieler zuletzt online war");
+        this.setUsage("/seen <player>");
+        this.setPermission("kt.seen");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        try
+        {
+            Player p = Utils.getPlayerByName(arg[0]);  
+            this.getModule().send(cs, p.getName() + " ist gerade online.");
+            return true;
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            String uuid = KajetansTools.playerbank.getDataBank(PlayerBank.class).getUUID(arg[0]);
+            if(uuid == null)
+            {
+                this.getModule().send(cs, arg[0] + " war noch nie auf dem Server.");
+                return true;
+            }
+            OfflinePlayer offPlayer = Bukkit.getOfflinePlayer(UUID.fromString(uuid));           
+            Date date = new Date(offPlayer.getLastPlayed());
+            SimpleDateFormat ft = new SimpleDateFormat ("dd.MM.yyyy 'um' HH:mm:ss");
+            this.getModule().send(cs, arg[0] + " war zuletzt am " + ft.format(date) + " online.");
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            return false;
+        }
+    }
+}

src/main/java/me/km/commands/CommandSetBed.java

@@ -0,0 +1,43 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.math.BlockPos;
+
+public class CommandSetBed extends ModuleCommand
+{
+    public CommandSetBed(Module m) 
+    {
+        super("setbed", m);
+        super.setDescription("Setzt deinen Bettspawn");
+        super.setUsage("/setbed");
+        super.setPermission(Permissions.SET_BED);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        BlockPos pos = Utils.getPlayerTarget(p);
+        if(p.world.getBlockState(pos).getBlock() != Blocks.BED)
+        {
+            this.getModule().send(cs, "Du musst auf ein Bett gerichtet sein.");
+            return true;
+        }
+        p.setSpawnPoint(pos, false);
+        p.bedLocation = pos;
+        this.getModule().send(cs, "Dein Bett-Spawn wurde gesetzt.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSetHome.java

@@ -0,0 +1,56 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.SimpleConfig;
+import me.km.api.Utils;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandSetHome extends ModuleCommand
+{
+    public CommandSetHome(Module m) 
+    {
+        super("sethome", m);
+        super.setDescription("Erstellt einen neuen Home");
+        super.setUsage("/sethome <name>");
+        super.setPermission(Permissions.SET_HOME);
+    }
+
+    public boolean addHome(String name, String uuid, Location l)
+    {
+        SimpleConfig sc = new SimpleConfig(this.getModule(), "home/" + uuid + "/" + name, false);
+        if(sc.exists())
+        {
+            return false;
+        }
+        sc.setLocation("home", l);
+        sc.save();
+        return true;
+    }
+    
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        EntityPlayer p = ((EntityPlayer) cs);
+        if(addHome(arg[0], p.getUniqueID().toString(), Utils.getEntityLocation(p)))
+        {
+            this.getModule().send(cs, "Der Home " + arg[0] + " wurde erstellt.");
+            return true;
+        }
+        this.getModule().send(cs, "Der Home " + arg[0] + " existiert bereits.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSetSpawn.java

@@ -0,0 +1,34 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandSetSpawn extends ModuleCommand
+{
+    public CommandSetSpawn(Module m) 
+    {
+        super("setspawn", m);
+        super.setDescription("Setzt den Spawn neu an deiner Position");
+        super.setUsage("/setspawn");
+        super.setPermission(Permissions.SET_SPAWN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        this.getModule().send(cs, "Der neue Spawn wurde gesetzt.");
+        EntityPlayer p = (EntityPlayer) cs;
+        Utils.setSpawn(p.world, p.getPositionVector(), p.rotationYaw, p.rotationPitch);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSetWarp.java

@@ -0,0 +1,55 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.SimpleConfig;
+import me.km.api.Utils;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandSetWarp extends ModuleCommand
+{
+    public CommandSetWarp(Module m) 
+    {
+        super("setwarp", m);
+        super.setDescription("Erstellt einen neuen Warp");
+        super.setUsage("/setwarp <warpname>");
+        super.setPermission(Permissions.SET_WARP);
+    }
+
+    public boolean addWarp(String name, Location l)
+    {
+        SimpleConfig sc = new SimpleConfig(this.getModule(), "warp/" + name, false);
+        if(sc.exists())
+        {
+            return false;
+        }
+        sc.setLocation("warp", l);
+        sc.save();
+        return true;
+    }
+    
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        if(addWarp(arg[0], Utils.getEntityLocation((EntityPlayer) cs)))
+        {
+            this.getModule().send(cs, "Der Warp " + arg[0] + " wurde erstellt.");
+            return true;
+        }
+        this.getModule().send(cs, "Der Warp " + arg[0] + " existiert bereits.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSign.java

@@ -0,0 +1,76 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.chatmanager.ChatManager;
+import me.km.permissions.Permissions;
+import net.minecraft.block.Block;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.tileentity.TileEntitySign;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.world.World;
+
+public class CommandSign extends ModuleCommand
+{
+    public CommandSign(Module m) 
+    {
+        super("sign", m);
+        super.setDescription("Editiert ein Schild");
+        super.setUsage("/sign <1-4> [text]");
+        super.setPermission(Permissions.SIGN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        World w = p.getEntityWorld();
+        BlockPos pos = Utils.getPlayerTarget(p);
+        Block b = w.getBlockState(pos).getBlock();
+        if(b == Blocks.STANDING_SIGN || b == Blocks.WALL_SIGN)
+        {
+            TileEntitySign sign = (TileEntitySign) w.getTileEntity(pos);
+            if(sign == null)
+            {
+                this.getModule().send(cs, GlobalText.shouldNotHappen());
+                return true;
+            }
+            
+            int line;
+            try
+            {        
+                line = Integer.parseInt(arg[0]) - 1;
+                if(line > 3 || line < 0)
+                {
+                    throw new java.lang.NumberFormatException();
+                }
+            }
+            catch(java.lang.NumberFormatException ex)
+            {
+                this.getModule().send(cs, "Du musst eine Zahl von 1 bis 4 eingeben.");
+                return true;
+            }
+
+            String newText = Utils.connectSpaces(arg, 1); 
+            newText = ChatManager.colorMessage(newText, p);    
+            sign.signText[line] = new TextComponentString(newText);
+            return true;
+        } 
+        this.getModule().send(cs, "Du bist nicht auf ein Schild gerichtet.");          
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSilent.java

@@ -0,0 +1,35 @@
+package me.km.commands;
+
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+
+public class CommandSilent extends ModuleCommand
+{
+    public boolean silentjoin;
+    
+    public CommandSilent(Module m) 
+    {
+        super("silent", m);
+        super.setDescription("Stellt den Silent-Join an oder aus");
+        super.setUsage("/silent");
+        super.setPermission(Permissions.SILENT);
+        
+        silentjoin = false;
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(silentjoin)
+        {
+            silentjoin = false;
+            this.getModule().send(cs, "Silent Join ist nun aus.");
+            return true;
+        }
+        silentjoin = true;
+        this.getModule().send(cs, "Silent Join ist nun an.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSkull.java

@@ -0,0 +1,58 @@
+package me.km.commands;
+
+import com.mojang.authlib.GameProfile;
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.ItemStackBuilder;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.block.Block;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTUtil;
+import net.minecraft.tileentity.TileEntitySkull;
+
+public class CommandSkull extends ModuleCommand
+{
+    public CommandSkull(Module m) 
+    {
+        super("skull", m);
+        super.setDescription("Gibt dir den Kopf eines Spielers");
+        super.setUsage("/skull <owner>");
+        super.setPermission(Permissions.SKULL);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        ItemStack stack = new ItemStackBuilder(Items.SKULL, 1, 3).build();
+        
+        NBTTagCompound com = stack.getTagCompound();
+        if(com == null)
+        {
+            this.getModule().send(cs, GlobalText.shouldNotHappen());
+            return true;
+        }
+        GameProfile gameprofile = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[0]);
+        gameprofile = TileEntitySkull.updateGameprofile(gameprofile);
+        com.setTag("SkullOwner", NBTUtil.writeGameProfile(new NBTTagCompound(), gameprofile));
+         
+        Block.spawnAsEntity(p.getEntityWorld(), p.getPosition(), stack);
+        this.getModule().send(cs, "Dir wurde ein Kopf von " + arg[0] + " gegeben.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSpawn.java

@@ -0,0 +1,56 @@
+package me.km.commands;
+
+import me.km.api.GlobalText;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandSpawn extends ModuleCommand
+{
+    public CommandSpawn(Module m) 
+    {
+        super("spawn", m);
+        super.setDescription("Teleportiert einen Spieler zum Spawn.");
+        super.setUsage("/spawn [player]");
+        super.setPermission(Permissions.SPAWN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        EntityPlayer affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);    
+            this.getModule().send(affectedPlayer, "Du wurdest zum Spawn teleportiert.");
+            this.getModule().send(cs, affectedPlayer.getName() + " wurde zum Spawn teleportiert.");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayer) cs;
+            this.getModule().send(affectedPlayer, "Du wurdest zum Spawn teleportiert.");
+        }
+        Location l = Utils.getSpawn();
+        if(l.getWorld() == null)
+        {
+            this.getModule().send(affectedPlayer, "Es wurde kein Spawn gesetzt.");
+        }
+        Utils.teleportEntity(affectedPlayer, l);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSpawner.java

@@ -0,0 +1,65 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.block.Block;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.tileentity.TileEntityMobSpawner;
+import net.minecraft.util.math.BlockPos;
+
+public class CommandSpawner extends ModuleCommand
+{
+    public CommandSpawner(Module m) 
+    {
+        super("spawner", m);
+        super.setDescription("Ändert den Typ eines Spawners");
+        super.setUsage("/spawner <mob>");
+        super.setPermission(Permissions.SPAWN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        Class<? extends Entity> c;
+        try
+        {
+            c = (Class<? extends Entity>) Class.forName(arg[0]);
+        }
+        catch(ClassNotFoundException | ClassCastException ex)
+        {
+            this.getModule().send(cs, "Dieser Typ existiert nicht.");
+            return true;
+        }
+        
+        EntityPlayer p = (EntityPlayer) cs;
+        BlockPos pos = Utils.getPlayerTarget(p);
+        TileEntity tile = p.world.getTileEntity(pos);
+        if(!(tile instanceof TileEntityMobSpawner))
+        {
+            this.getModule().send(cs, "Du musst auf einen Spawner gerichtet sein.");
+            return true;
+        }
+        TileEntityMobSpawner spawner = (TileEntityMobSpawner) tile;
+        spawner.getSpawnerBaseLogic().setEntityId(EntityList.getKey(c));
+        String s = c.getSimpleName();
+        this.getModule().send(cs, "Der Spawner spawnt nun den Typ §6" + s.substring(0, s.length() - 6) + "§r.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSpeed.java

@@ -0,0 +1,77 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.exceptions.PlayerNotFoundException;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandSpeed extends ModuleCommand
+{
+    public CommandSpeed(Module m) 
+    {
+        super("speed", m);
+        this.setDescription("Setzt das Tempo eines Spielers");
+        this.setUsage("/speed <1-10> [player]");
+        this.setPermission("kt.speed");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        
+        int i;
+        try
+        {
+            i = Integer.parseInt(arg[0]);
+            if(i < 1)
+            {
+                throw new NumberFormatException();
+            }
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(cs, GlobalText.noPositiveNaturalNumber());
+            return true;
+        }        
+        if(i > 10)
+        {
+            i = 10;
+        }     
+        float f = i / 20f;
+        
+        Player affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[1]);  
+            affectedPlayer.setFlySpeed(f);
+            affectedPlayer.setWalkSpeed(f * 2);
+            this.getModule().send(affectedPlayer, "Du hast nun Tempo " + i + ".");
+            this.getModule().send(cs, affectedPlayer.getName() + " hat nun Tempo " + i + ".");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[1]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof Player))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (Player) cs;
+            affectedPlayer.setFlySpeed(f);
+            affectedPlayer.setWalkSpeed(f * 2);
+            this.getModule().send(affectedPlayer, "Du hast nun Tempo " + i + ".");
+        } 
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandSummon.java

@@ -0,0 +1,129 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.entity.EntityLiving;
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.JsonToNBT;
+import net.minecraft.nbt.NBTException;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.storage.AnvilChunkLoader;
+
+public class CommandSummon extends ModuleCommand
+{
+    public CommandSummon(Module m) 
+    {
+        super("summon", m);
+        super.setDescription("Spawnt ein Mob / Mobs");
+        super.setUsage("/summon <type> [amount] [data]");
+        super.setPermission(Permissions.SUMMON);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        EntityPlayer p = (EntityPlayer) cs;
+        int counter = 1;
+        if(arg.length >= 2)
+        {
+            try
+            {
+                counter = Integer.parseInt(arg[1]);
+            }
+            catch(NumberFormatException ex)
+            {
+            }
+        }
+        BlockPos target = Utils.getPlayerTarget(p).add(0, 1, 0);
+        int x = target.getX();
+        int y = target.getY();
+        int z = target.getZ();   
+
+        String s = arg[0];
+        double d0 = target.getX();
+        double d1 = target.getY();
+        double d2 = target.getZ();
+
+        World world = p.getEntityWorld();
+
+        try
+        {
+            if (!world.isBlockLoaded(target))
+            {
+                this.getModule().send(cs, "Der Spawnpunkt ist außerhalb der Welt.");
+                return true;
+            }
+            else if (EntityList.LIGHTNING_BOLT.equals(new ResourceLocation(s)))
+            {
+                world.addWeatherEffect(new EntityLightningBolt(world, d0, d1, d2, false));
+            }
+            else
+            {
+                NBTTagCompound nbttagcompound = new NBTTagCompound();
+                boolean flag = false;
+
+                if (arg.length >= 3)
+                {
+                    ITextComponent itextcomponent = getChatComponentFromNthArg(cs, arg, 2);
+                    try
+                    {
+                        nbttagcompound = JsonToNBT.getTagFromJson(itextcomponent.getUnformattedText());
+                        flag = true;
+                    }
+                    catch (NBTException nbtexception)
+                    {
+                        this.getModule().send(cs, "Der Tag ist ungültig.");
+                        return true;
+                    }
+                }
+
+                nbttagcompound.setString("id", s);
+                for(int i = 0; i < counter; i++)
+                {
+                    Entity entity = AnvilChunkLoader.readWorldEntityPos(nbttagcompound, world, d0, d1, d2, true);
+
+                    if (entity == null)
+                    {
+                        this.getModule().send(cs, "Die Entity lässt sich nicht spawnen.");
+                        return true;
+                    }
+                    else
+                    {
+                        entity.setLocationAndAngles(d0, d1, d2, entity.rotationYaw, entity.rotationPitch);
+
+                        if (!flag && entity instanceof EntityLiving)
+                        {
+                            ((EntityLiving) entity).onInitialSpawn(world.getDifficultyForLocation(new BlockPos(entity)), null);
+                        }
+                    }
+                }
+            }
+        }
+        catch(CommandException ex)
+        {
+            this.getModule().send(cs, "Die Parameter konnten nicht gelesen werden.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTeleport.java

@@ -0,0 +1,73 @@
+package me.km.commands;
+
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.exception.PlayerNotFoundException;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.GameType;
+
+public class CommandTeleport extends ModuleCommand
+{
+    public CommandTeleport(Module m) 
+    {
+        super("teleport", m);
+        super.setDescription("Teleportiert einen Spieler zu einem anderen");
+        super.setUsage("/tp [player] <to-player>");
+        super.setPermission(Permissions.TELEPORT);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        EntityPlayer affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]);                   
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }       
+        EntityPlayer affectedPlayer2;
+        try
+        {
+            affectedPlayer2 = Utils.getPlayerByName(arg[1]);                   
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[1]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof EntityPlayer))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }
+            Utils.teleportEntity((EntityPlayer) cs, affectedPlayer);
+            this.getModule().send(cs, "Du wurdest zu " + affectedPlayer.getName() + " teleportiert.");
+            if(!((EntityPlayer) cs).isSpectator())
+            {
+                this.getModule().send(affectedPlayer, cs.getName() + " hat sich zu dir teleportiert.");
+            }
+            return true;
+        }
+        Utils.teleportEntity(affectedPlayer, affectedPlayer2);
+        this.getModule().send(affectedPlayer, "Du wurdest zu " + affectedPlayer2.getName() + " teleportiert.");
+        if(!affectedPlayer.isSpectator())
+        {
+            this.getModule().send(affectedPlayer2, affectedPlayer.getName() + " hat sich zu dir teleportiert.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTeleportAccept.java

@@ -0,0 +1,53 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import java.util.HashMap;
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandTeleportAccept extends ModuleCommand
+{
+    public HashMap<UUID, UUID> tpaccept;
+    
+    public CommandTeleportAccept(Module m) 
+    {
+        super("teleportaccept", m);
+        this.setDescription("Akzeptiert eine Teleportanfrage");
+        this.setUsage("/teleportaccept");
+        this.setPermission("kt.teleportaccept");
+        
+        tpaccept = new HashMap<>();
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(!(cs instanceof Player))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        Player p = (Player) cs;
+        if(!tpaccept.containsKey(p.getUniqueId()))
+        {
+            this.getModule().send(cs, "Du hast keine ausstehenden Teleportanfragen.");
+            return true;
+        }
+        Player affectedPlayer = Bukkit.getPlayer(tpaccept.get(p.getUniqueId()));
+        if(affectedPlayer == null)
+        {
+            this.getModule().send(cs, "Der Spieler ist nicht mehr online.");
+            tpaccept.remove(p.getUniqueId());
+            return true;
+        }            
+        tpaccept.remove(p.getUniqueId());
+        affectedPlayer.teleport(p);
+        this.getModule().send(affectedPlayer, "Du wurdest zu " + p.getName() + " teleportiert.");
+        this.getModule().send(p, affectedPlayer.getName() + " hat sich zu dir teleportiert.");
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTempBan.java

@@ -0,0 +1,80 @@
+package me.km.commands;
+
+import com.mojang.authlib.GameProfile;
+import me.km.api.Utils;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import java.util.Date;
+import me.km.KajetansMod;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.management.UserListBansEntry;
+
+public class CommandTempBan extends ModuleCommand
+{
+    public CommandTempBan(Module m) 
+    {
+        super("tempban", m);
+        super.setDescription("Bannt einen Spiele temporär");
+        super.setUsage("/tempban <name> <days> <hours> <minutes> <reason>");
+        super.setPermission(Permissions.TEMP_BAN);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(arg.length <= 4)
+        {
+            return false;
+        }
+        Date date = new Date(System.currentTimeMillis());
+        try
+        {
+            long days = Integer.parseInt(arg[1]) * 86400000;
+            long hours = Integer.parseInt(arg[2]) * 3600000;
+            long minutes = Integer.parseInt(arg[3]) * 60000;
+            if(days < 0 || hours < 0 || minutes < 0)
+            {
+                throw new NumberFormatException();
+            }
+            date.setTime(date.getTime() + days + hours + minutes);
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(cs, GlobalText.noNaturalNumber());
+            return true;
+        }    
+        GameProfile affectedPlayer = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[0]);
+        if(affectedPlayer == null)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        String time = arg[1] + " Tage, " + arg[2] + " Stunden und " + arg[3] + " Minuten";
+        if(arg[1].equals("1"))
+        {
+            time = time.replace("Tage", "Tag");
+        }
+        if(arg[2].equals("1"))
+        {
+            time = time.replace("Stunden", "Stunde");
+        }
+        if(arg[3].equals("1"))
+        {
+            time = time.replace("Minuten", "Minute");
+        }
+        String message = Utils.connectSpaces(arg, 4);
+        this.getModule().sendBroadcast("§4" + affectedPlayer.getName() + " §cwurde von §4" + cs.getName() + "§c für " + time + " gebannt, weil: §4" + message);    
+        
+        UserListBansEntry bans = new UserListBansEntry(affectedPlayer, null, cs.getName(), date, message);
+        KajetansMod.server.getPlayerList().getBannedPlayers().addEntry(bans);
+        EntityPlayerMP p = KajetansMod.server.getPlayerList().getPlayerByUUID(affectedPlayer.getId());
+        if(p != null)
+        {
+            p.connection.disconnect("§4Du §cwurdest von §4" + cs.getName() + "§c für " + time + " gebannt, weil: §4" + message);
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTest.java

@@ -0,0 +1,36 @@
+package me.km.commands;
+
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.permissions.Permissions;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class CommandTest extends ModuleCommand
+{
+    public CommandTest(Module m) 
+    {
+        super("test", m);
+        super.setDescription("Für Tests");
+        super.setUsage("/test");
+        super.setPermission(Permissions.TEST);
+    }   
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        this.getModule().send(cs, "Das ist ein Test.");
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            this.getModule().send(cs, "TIMERTEST");
+        }, 100);
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTime.java

@@ -0,0 +1,82 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandTime extends ModuleCommand
+{
+    public CommandTime(Module m) 
+    {
+        super("time", m);
+        this.setDescription("Setzt die Tageszeit in einer Welt");
+        this.setUsage("/time <day|night|ticks_as_number> [world]");
+        this.setPermission("kt.time");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(arg.length == 0)
+        {
+            return false;
+        }
+        
+        World w;
+        if(arg.length < 2)
+        {
+            if(cs instanceof Player)
+            {
+                w = ((Player) cs).getWorld();
+            }
+            else
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }
+        }
+        else
+        {
+            w = Bukkit.getWorld(arg[1]);
+            if(w == null)
+            {
+                this.getModule().send(cs, "Die angegebene Welt wurde nicht gefunden.");
+                return true;
+            }
+        }
+        
+        if(arg[0].equals("day"))
+        {
+            w.setTime(0);
+            this.getModule().send(cs, "Die Tageszeit wurde auf 0 gesetzt.");
+            return true;
+        }
+        else if(arg[0].equals("night"))
+        {
+            w.setTime(14000);
+            this.getModule().send(cs, "Die Tageszeit wurde auf 14000 gesetzt.");
+            return true;
+        }
+        try
+        {
+            int time = Integer.parseInt(arg[0]);
+            if(time < 0)
+            {
+                this.getModule().send(cs, GlobalText.noNaturalNumber());
+                return true;
+            }
+            w.setTime(time);
+            this.getModule().send(cs, "Die Tageszeit wurde auf " + arg[0] + " gesetzt.");
+            return true;
+        }
+        catch(Exception ex)
+        {
+            this.getModule().send(cs, GlobalText.noNaturalNumber());
+            return true;
+        }
+    }
+}

src/main/java/me/km/commands/CommandTop.java

@@ -0,0 +1,52 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.playerbank.PlayerBank;
+import me.kt.exceptions.PlayerNotFoundException;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandTop extends ModuleCommand
+{
+    public CommandTop(Module m) 
+    {
+        super("top", m);
+        this.setDescription("Teleportiert einen Spieler nach oben");
+        this.setUsage("/top [player]");
+        this.setPermission("kt.top");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        Player affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[0]); 
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof Player))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (Player) cs;
+        }
+        affectedPlayer.teleport(affectedPlayer.getWorld().getHighestBlockAt(affectedPlayer.getLocation()).getLocation().add(0.5, 0, 0.5));
+        this.getModule().send(cs, "Du wurdest nach oben teleportiert.");
+        if(!cs.equals(affectedPlayer))
+        {
+            this.getModule().send(cs, affectedPlayer.getName() + " wurde nach oben teleportiert.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandTpPos.java

@@ -0,0 +1,78 @@
+package me.km.commands;
+
+import me.kt.api.Utils;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.exceptions.PlayerNotFoundException;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandTpPos extends ModuleCommand
+{
+    public CommandTpPos(Module m) 
+    {
+        super("tppos", m);
+        this.setDescription("Teleportiert einen Spieler zu Koordinaten");
+        this.setUsage("/tppos <x> <y> <z> [world] [player]");
+        this.setPermission("kt.tppos");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(arg.length < 3)
+        {
+            return false;
+        }
+        Player affectedPlayer;  
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[4]);                   
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[4]));
+            return true;
+        }   
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof Player))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }
+            affectedPlayer = (Player) cs;
+        } 
+        
+        try
+        {
+            World w;
+            if(arg.length >= 4 && Bukkit.getWorld(arg[3]) != null)
+            {
+                w = Bukkit.getWorld(arg[3]);
+            }
+            else
+            {
+                w = affectedPlayer.getWorld();
+            }
+            Location l = new Location(w, Double.parseDouble(arg[0]), Double.parseDouble(arg[1]), Double.parseDouble(arg[2]));
+            affectedPlayer.teleport(l);
+            String s = " zu " + l.getBlockX() + ", " + l.getBlockY() + ", " + l.getBlockZ() + " teleportiert.";
+            this.getModule().send(affectedPlayer, "Du wurdest" + s);
+            if(!cs.equals(affectedPlayer))
+            {
+                this.getModule().send(cs, affectedPlayer.getName() + " wurde" + s);
+            }
+            return true;
+        }
+        catch(Exception ex)
+        {
+            this.getModule().send(cs, GlobalText.noIntegerNumber());
+            return true;
+        }  
+    }
+}

src/main/java/me/km/commands/CommandUser.java

@@ -0,0 +1,49 @@
+package me.km.commands;
+
+import me.kt.KajetansTools;
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandUser extends ModuleCommand
+{
+    public CommandUser(Module m) 
+    {
+        super("user", m);
+        this.setDescription("Gibt Informationen über einen Spieler");
+        this.setUsage("/user <name>");
+        this.setPermission("kt.user");
+    }
+
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(arg.length < 1)
+        {
+            return false;
+        }
+        
+        Module m = this.getModule();
+        OfflinePlayer op = KajetansTools.playerbank.getDataBank().getOfflinePlayer(arg[0]);
+        if(op == null)
+        {
+            m.send(cs, GlobalText.cantFindPlayer(arg[0]));
+            return true;
+        }
+        
+        cs.sendMessage(GlobalText.Spacer());
+        m.send(cs, op.getName());
+        m.sendHelpListElement(cs, "UUID", op.getUniqueId().toString());
+        m.sendHelpListElement(cs, "Gebannt", String.valueOf(op.isBanned()));
+        m.sendHelpListElement(cs, "Whitelisted", String.valueOf(op.isWhitelisted()));
+        if(op.isOnline())
+        {
+            Player p = op.getPlayer();
+            m.sendHelpListElement(cs, "IP", p.getAddress().getAddress().toString().substring(1));
+        }
+        return true;
+    }
+}

src/main/java/me/km/commands/CommandWarp.java

@@ -0,0 +1,73 @@
+package me.km.commands;
+
+import me.kt.api.GlobalText;
+import me.kt.api.Module;
+import me.kt.api.ModuleCommand;
+import me.kt.api.SimpleConfig;
+import me.kt.api.Utils;
+import me.kt.exceptions.PlayerNotFoundException;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.bukkit.Location;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class CommandWarp extends ModuleCommand
+{
+    public CommandWarp(Module m) 
+    {
+        super("warp", m);
+        this.setDescription("Teleportiert einen Spieler zum Warp");
+        this.setUsage("/warp <warpname> [player]");
+        this.setPermission("kt.warp");
+    }
+
+    public List<String> getWarps()
+    {
+        return SimpleConfig.getFiles("warp").stream().map(w -> w.getName().replace(".yml", "")).collect(Collectors.toList());
+    }
+    
+    @Override
+    public boolean execute(CommandSender cs, String string, String[] arg) 
+    {
+        if(arg.length < 1)
+        {
+            this.getModule().send(cs, "Die folgenden Warps stehen zur Verfügung:");
+            this.getModule().send(cs, String.join("§7, §r", getWarps()));   
+            return true;
+        }
+        
+        Location l = Utils.getWarp(arg[0]);
+        if(l == null)
+        {
+            this.getModule().send(cs, "Der Warp existiert nicht bzw. seine Welt.");
+            return true;
+        }
+        
+        Player affectedPlayer;
+        try
+        {
+            affectedPlayer = Utils.getPlayerByName(arg[1]);    
+            affectedPlayer.teleport(l);
+            this.getModule().send(affectedPlayer, "Du wurdest zum Warp " + arg[0] + " teleportiert.");
+            this.getModule().send(cs, affectedPlayer.getName() + " wurde zum Warp " + arg[0] + " teleportiert.");
+        }
+        catch(PlayerNotFoundException ex)
+        {
+            this.getModule().send(cs, GlobalText.cantFindPlayer(arg[1]));
+            return true;
+        }
+        catch(IndexOutOfBoundsException ex)
+        {
+            if(!(cs instanceof Player))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (Player) cs;
+            affectedPlayer.teleport(l);
+            this.getModule().send(cs, "Du wurdest zum Warp " + arg[0] + " teleportiert.");
+        }
+        return true;
+    }
+}

src/main/java/me/km/databank/DataBank.java

@@ -0,0 +1,66 @@
+package me.km.databank;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import me.km.api.Module;
+import net.minecraft.util.text.TextFormatting;
+
+public class DataBank extends Module
+{
+    private Connection c;
+    
+    public DataBank(String mname, String prefix, TextFormatting color) 
+    {
+        super(mname, prefix, color);
+    }
+    
+    public boolean openDataBankConnection(String user, String password)
+    {
+        c = null;
+        try 
+        {
+            // The newInstance() call is a work around for some broken Java implementations
+            Class.forName("com.mysql.jdbc.Driver").newInstance();
+            c = DriverManager.getConnection("jdbc:mysql://localhost/minecraft?autoReconnect=true", user, password);
+            this.sendToConsole("Die Verbindung wurde erfolgreich aufgebaut.");
+            return true;
+        } 
+        catch(SQLException | ClassNotFoundException | InstantiationException | IllegalAccessException ex) 
+        {
+            this.sendWarningToConsole(ex.getMessage());
+            return false;
+        }
+    }
+    
+    public void closeDataBankConnection()
+    {
+        try 
+        {
+            c.close();
+            this.sendToConsole("Die Verbindung wurde erfolgreich unterbrochen.");
+        } 
+        catch (SQLException ex) 
+        {
+            this.sendWarningToConsole(ex.getMessage());
+        }
+        catch (NullPointerException ex) 
+        {
+        }
+    }
+    
+    public Connection getConnection()
+    {
+        /*try 
+        {
+            if(c.isClosed())
+            {
+                openDataBankConnection();
+            }
+        }
+        catch(SQLException ex) 
+        {
+        }*/
+        return c;
+    } 
+}

src/main/java/me/km/databank/SimpleDataBank.java

@@ -0,0 +1,315 @@
+package me.km.databank;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import me.km.api.Module;
+import me.km.table.Table;
+
+public abstract class SimpleDataBank 
+{
+    private final Connection c;
+    private final Module m;
+    
+    public SimpleDataBank(Module m, Connection c)
+    {
+        this.c = c;
+        this.m = m;
+        
+        init();
+    }
+    
+    public Module getModule()
+    {
+        return m;
+    }
+    
+    protected abstract void init();
+    
+    /** Führt den gegebenen Query aus und gibt den Erfolg zurück.
+     *
+     * @param query ein Query, irgendetwas mit "INSERT, UPDATE, ..."
+     * @param ignore gibt keine Fehlermeldung aus, falls auf <code> true </code>
+     * @return <code> true </code> falls kein Error auftrat, sonst <code> false </code>
+     */
+    
+    public boolean update(String query, boolean ignore)
+    {
+        try(Statement stmt = c.createStatement()) 
+        {
+            stmt.executeUpdate(query);
+            return true;
+        }
+        catch(SQLException ex) 
+        {
+            if(!ignore)
+            {
+                m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+                m.sendWarningToConsole(query);
+                m.sendWarningToConsole(ex.toString());
+            }
+            return false;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt die erste Spalte der ersten Reihe zurück.
+     *
+     * @param <T> die Klasse der Rückgabe
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @param r die Klasse der Rückgabe
+     * @return das gewünschte Objekt, null falls ein Fehler auftrat oder der ResultSet leer ist
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T getFirst(String query, Class<T> r)
+    {
+        //System.out.println(query);
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            if(rs.next())
+            {
+                return (T) rs.getObject(1);
+            }
+            return null;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt die erste Spalte der ersten Reihe zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return der gewünschte Byte, null falls ein Fehler auftrat oder der ResultSet leer ist
+     */
+    public Byte getFirstByte(String query)
+    {
+        //System.out.println(query);
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            if(rs.next())
+            {
+                return rs.getByte(1);
+            }
+            return null;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt alle Spalten der ersten Reihe zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return alle Spalten als Liste, bei einem Error kann sie null sein
+     */
+    @SuppressWarnings("unchecked")
+    public ArrayList<Object> getFirstRow(String query)
+    {
+        //System.out.println(query);
+        ArrayList<Object> list = new ArrayList();
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            if(rs.next())
+            {
+                int i = 1;
+                while(true)
+                {
+                    list.add(rs.getObject(i));
+                    i++;
+                }
+            }
+            return list;
+        }
+        catch(SQLException ex) 
+        {
+            if(!ex.getLocalizedMessage().startsWith("Column Index"))
+            {
+                m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+                m.sendWarningToConsole(query);
+                m.sendWarningToConsole(ex.toString());
+                return null;
+            }
+            return list;
+        }
+    }
+
+    /** Führt den gegebenen Query aus und gibt alle Zeilen der ersten Spalte zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return alle Spalten als Liste, bei einem Error kann sie null sein
+     */
+    @SuppressWarnings("unchecked")
+    public ArrayList<Object> getFirstColumn(String query)
+    {
+        //System.out.println(query);
+        ArrayList<Object> list = new ArrayList();
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            while(rs.next())
+            {
+                list.add(rs.getObject(1));
+            }
+            return list;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+        catch(IllegalStateException ex) 
+        {
+            return list;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt alle Zeilen der ersten Spalte zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return alle Spalten als Liste, bei einem Error kann sie null sein
+     */
+    @SuppressWarnings("unchecked")
+    public ArrayList<Byte> getFirstByteColumn(String query)
+    {
+        //System.out.println(query);
+        ArrayList<Byte> list = new ArrayList();
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            while(rs.next())
+            {
+                list.add(rs.getByte(1));
+            }
+            return list;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+        catch(IllegalStateException ex) 
+        {
+            return list;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt alle Spalten als Liste in einer Liste zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return alle Spalten als Liste in einer Liste, bei einem Error kann sie null sein
+     */
+    @SuppressWarnings("unchecked")
+    public ArrayList<ArrayList<Object>> get(String query)
+    {
+        //System.out.println(query);
+        ArrayList<ArrayList<Object>> list = new ArrayList();
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            while(rs.next())
+            {
+                ArrayList<Object> columns = new ArrayList();
+                try
+                {
+                    int i = 1;
+                    while(true)
+                    {
+                        columns.add(rs.getObject(i));
+                        i++;
+                    }
+                }
+                catch(SQLException ex) 
+                {
+                    if(!ex.getLocalizedMessage().startsWith("Column Index"))
+                    {
+                        m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+                        m.sendWarningToConsole(query);
+                        m.sendWarningToConsole(ex.toString());
+                        return null;
+                    }
+                }
+                list.add(columns);
+            }
+            return list;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+        catch(IllegalStateException ex) 
+        {
+            return list;
+        }
+    }
+    
+    /** Führt den gegebenen Query aus und gibt zwei Spalten als Table zurück.
+     *
+     * @param query ein Query, irgendetwas mit "SELECT"
+     * @return zwei Spalten als List-Map, bei einem Error kann sie null sein
+     */
+    public Table getTable(String query)
+    {
+        Table table = new Table(2);
+        try(Statement stmt = c.createStatement();)
+        {
+            ResultSet rs = stmt.executeQuery(query);
+            while(rs.next())
+            {
+                //TODO
+                table.addRow(new Object[] {rs.getString(1), /*QuestUtils.convertInput(*/rs.getString(2)/*)*/});
+            }
+            return table;
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole(query);
+            m.sendWarningToConsole(ex.toString());
+            return null;
+        }
+        catch(IllegalStateException ex) 
+        {
+            return table;
+        }
+    }
+    
+    /** Gibt zurück, ob eine Tabelle existiert oder nicht.
+     *
+     * @param table der Name der Tabelle
+     * @return <code> true </code> falls die Tabelle existiert, sonst <code> false </code>
+     */
+    public boolean doesTableExist(String table)
+    {
+        try(Statement stmt = c.createStatement();)
+        {
+            return stmt.executeQuery("SHOW TABLES IN minecraft LIKE '" + table + "';").next();
+        }
+        catch(SQLException ex) 
+        {
+            m.sendWarningToConsole("Der folgende Query hat einen Error ausgelöst:");
+            m.sendWarningToConsole("SHOW TABLES LIKE '" + table + "';");
+            m.sendWarningToConsole(ex.toString());
+            return false;
+        }
+    }
+}

src/main/java/me/hammerle/km/entities/EntityBlackBear.java → src/main/java/me/km/entities/EntityBlackBear.java

@@ -1,4 +1,4 @@
-package me.hammerle.km.entities;
+package me.km.entities;
 
 import net.minecraft.entity.monster.EntityPolarBear;
 import net.minecraft.world.World;

src/main/java/me/hammerle/km/entities/EntityBrownBear.java → src/main/java/me/km/entities/EntityBrownBear.java

@@ -1,4 +1,4 @@
-package me.hammerle.km.entities;
+package me.km.entities;
 
 import net.minecraft.entity.monster.EntityPolarBear;
 import net.minecraft.world.World;

src/main/java/me/hammerle/km/entities/ModEntities.java → src/main/java/me/km/entities/ModEntities.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.entities;
+package me.km.entities;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.entity.Entity;
 import net.minecraft.util.ResourceLocation;

src/main/java/me/hammerle/km/entities/RenderBlackBear.java → src/main/java/me/km/entities/RenderBlackBear.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.entities;
+package me.km.entities;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelPolarBear;
 import net.minecraft.client.renderer.GlStateManager;

src/main/java/me/hammerle/km/entities/RenderBrownBear.java → src/main/java/me/km/entities/RenderBrownBear.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.entities;
+package me.km.entities;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelPolarBear;
 import net.minecraft.client.renderer.GlStateManager;

src/main/java/me/km/exception/CodeTooLongException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class CodeTooLongException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/EndIfWithoutIfException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class EndIfWithoutIfException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/EntityNotFoundException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class EntityNotFoundException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/GoHigherAtRootTreeException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class GoHigherAtRootTreeException extends Exception
+{
+    
+}

src/main/java/me/km/exception/GotoLabelNotFoundException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class GotoLabelNotFoundException extends IllegalStringException
+{
+    public GotoLabelNotFoundException(String s) 
+    {
+        super(s);
+    }  
+}

src/main/java/me/km/exception/HoldCodeException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class HoldCodeException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/IfWithoutEndIfException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class IfWithoutEndIfException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/IfWithoutStatementException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class IfWithoutStatementException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/IllegalItemStackStringException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class IllegalItemStackStringException extends IllegalStringException
+{
+    public IllegalItemStackStringException(String s) 
+    {
+        super(s);
+    }
+}

src/main/java/me/km/exception/IllegalStringException.java

@@ -0,0 +1,16 @@
+package me.km.exception;
+
+public class IllegalStringException extends RuntimeException
+{
+    private final String s;
+    
+    public IllegalStringException(String s)
+    {
+        this.s = s;
+    }
+    
+    public String getBadString()
+    {
+        return s;
+    }
+}

src/main/java/me/km/exception/IllegalStringLocationException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class IllegalStringLocationException extends IllegalStringException
+{
+    public IllegalStringLocationException(String s) 
+    {
+        super(s);
+    }
+}

src/main/java/me/km/exception/NoChildTreeException.java

@@ -0,0 +1,6 @@
+package me.km.exception;
+
+public class NoChildTreeException extends RuntimeException
+{
+    
+}

src/main/java/me/km/exception/NoSuchMethodException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class NoSuchMethodException extends IllegalStringException
+{ 
+    public NoSuchMethodException(String s) 
+    {
+        super(s);
+    } 
+}

src/main/java/me/km/exception/PlayerNotFoundException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class PlayerNotFoundException extends IllegalStringException
+{    
+    public PlayerNotFoundException(String s) 
+    {
+        super(s);
+    }   
+}

src/main/java/me/km/exception/PrescriptException.java

@@ -0,0 +1,9 @@
+package me.km.exception;
+
+public class PrescriptException extends IllegalStringException
+{
+    public PrescriptException(String s) 
+    {
+        super(s);
+    }
+}

src/main/java/me/hammerle/km/fluids/BlockFluidBase.java → src/main/java/me/km/fluids/BlockFluidBase.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.fluids;
+package me.km.fluids;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.block.material.Material;
 import net.minecraftforge.fluids.BlockFluidClassic;
 import net.minecraftforge.fluids.Fluid;

src/main/java/me/hammerle/km/fluids/ModFluids.java → src/main/java/me/km/fluids/ModFluids.java

@@ -1,6 +1,6 @@
-package me.hammerle.km.fluids;
+package me.km.fluids;
 
-import me.hammerle.km.KajetansMod;
+import me.km.KajetansMod;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.fluids.Fluid;
 import net.minecraftforge.fluids.FluidRegistry;