Fortsetzung der Plots

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

@@ -12,10 +12,13 @@ import me.km.effects.EffectUtils;
 import me.km.entities.ModEntities;
 import me.km.fluids.ModFluids;
 import me.km.items.ModItems;
+import me.km.jobsystem.JobAPI;
 import me.km.playerbank.PlayerBank;
 import me.km.playerbank.PlayerManager;
+import me.km.plots.ProtectionBank;
 import me.km.scheduler.SnuviScheduler;
 import me.km.scoreboard.ScoreboardAPI;
+import me.km.skills.SkillManager;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.fml.common.FMLCommonHandler;
@@ -26,6 +29,9 @@ 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;
+// event classes
+//import net.minecraftforge.common.ForgeHooks;
+//import net.minecraftforge.event.ForgeEventFactory;
 
 @Mod(modid = KajetansMod.MODID, version = KajetansMod.VERSION, name = KajetansMod.NAME)
 public class KajetansMod
@@ -38,15 +44,15 @@ public class KajetansMod
     public static Module generalCommands;
     public static ChatManager chatManager;
     public static Module afkManager;
-    //public static Module plots;
+    public static Module plots;
     public static Module blocks;
     public static Module datatools;
     public static WorldData worldManager;
-    //public static Module environment;
+    public static Module environment;
     //public static QuestAPI quest;
-    //public static JobAPI jobs;
+    public static JobAPI jobs;
     public static EffectUtils effects;
-    //public static SkillManager skills;
+    public static SkillManager skills;
     //public static Module scrolls;
     //public static Customs customs;
     //public static PiercingAPI piercing;
@@ -113,10 +119,10 @@ public class KajetansMod
         afkManager.registerEvents("me.km.afk");
         
         // Plot-System
-        /*plots = new Module("Plots", "Plots", TextFormatting.GOLD);
+        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");*/
+        plots.registerCommands(e, "me.km.plots");          
+        plots.registerEvents("me.km.plots");
         
         // Chests- und Co-Protections
         blocks = new Module("BlockProtections", "Blocks", TextFormatting.BLUE);
@@ -142,20 +148,20 @@ public class KajetansMod
         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"); */
+        jobs = new JobAPI("JobSystem", "Jobs", TextFormatting.GREEN);
+        // databank is initialized in JobAPI in order to have a reference
+        jobs.registerCommands(e, "me.km.jobsystem");      
+        jobs.registerEvents("me.km.jobsystem"); 
         
         // Effectsystem
         effects = new EffectUtils("Effects", "Effects", TextFormatting.BLUE);
         effects.registerCommands(e, "me.km.effects"); 
         effects.registerEvents("me.km.effects.passive"); 
         
-        // Skillshopsystem
-        /*skills = new SkillManager("SkillSystem", "Skills", TextFormatting.BLUE);
-        skills.registerCommands(e, "me.kt.skills"); 
-        skills.registerEvents("me.kt.skills"); */
+        // Skills
+        skills = new SkillManager("SkillSystem", "Skills", TextFormatting.BLUE);
+        skills.registerCommands(e, "me.km.skills"); 
+        skills.registerEvents("me.km.skills");
         
         // Scrollsystem
         /*scrolls = new Module("Scrolls", "Scrolls", TextFormatting.BLUE);
@@ -163,9 +169,9 @@ public class KajetansMod
         scrolls.registerEvents("me.kt.scrolls");    */ 
         
         // Environment
-        /*environment = new Module("Environment", "Environment", TextFormatting.GREEN);
-        environment.registerCommands(e, "me.kt.environment");      
-        environment.registerEvents("me.kt.environment");  */
+        environment = new Module("Environment", "Environment", TextFormatting.GREEN);
+        environment.registerCommands(e, "me.km.environment");      
+        environment.registerEvents("me.km.environment");
         
         // Scoreboard
         scoreboard = new ScoreboardAPI("Scoreboard", "Scoreboard", TextFormatting.GOLD);

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

@@ -24,6 +24,7 @@ import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.init.Blocks;
 import net.minecraft.init.Items;
 import net.minecraft.init.MobEffects;
+import net.minecraft.inventory.IInventory;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemAxe;
 import net.minecraft.item.ItemHoe;
@@ -298,18 +299,8 @@ public class Utils
     /*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
     // -------------------------------------------------------------------------

src/main/java/me/km/datatools/CommandVillager.java

@@ -8,8 +8,8 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import me.km.permissions.Permissions;
-import me.km.utils.EntityInventory;
-import me.km.utils.InventoryUtils;
+import me.km.inventory.EntityInventory;
+import me.km.inventory.InventoryUtils;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.passive.EntityVillager;
 import net.minecraft.entity.player.EntityPlayerMP;

src/main/java/me/km/datatools/DataToolsEvents.java

@@ -2,8 +2,8 @@ package me.km.datatools;
 
 import me.km.api.Module;
 import me.km.api.ModuleListener;
-import me.km.utils.EntityInventory;
-import me.km.utils.InventoryUtils;
+import me.km.inventory.EntityInventory;
+import me.km.inventory.InventoryUtils;
 import me.km.utils.ReflectionUtils;
 import net.minecraft.entity.passive.EntityVillager;
 import net.minecraft.inventory.ContainerChest;

src/main/java/me/km/inventory/CustomContainer.java

@@ -0,0 +1,56 @@
+package me.km.inventory;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.ClickType;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.SPacketOpenWindow;
+
+public class CustomContainer extends ContainerChest
+{
+    public CustomContainer(String title, int slotCount, EntityPlayer p) 
+    {
+        super(p.inventory, new EntityInventory(title, slotCount, p), p);
+    }
+    
+    public EntityInventory getShownInventory()
+    {
+        return (EntityInventory) this.getLowerChestInventory();
+    }
+    
+    public void openForPlayer(EntityPlayerMP p)
+    {
+        if(p.openContainer != p.inventoryContainer)
+        {
+            p.closeScreen();
+        }
+        p.getNextWindowId();
+        IInventory inv = this.getLowerChestInventory();
+        p.connection.sendPacket(new SPacketOpenWindow(p.currentWindowId, "minecraft:container", inv.getDisplayName(), inv.getSizeInventory()));
+        p.openContainer = this;
+        p.openContainer.windowId = p.currentWindowId;
+        p.openContainer.addListener(p);
+    }
+    
+    public boolean noClicking()
+    {
+        return true;
+    }
+    
+    @Override
+    public final ItemStack slotClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer player) 
+    {
+        if(noClicking())
+        {
+            onCanceledClick(slotId, dragType, clickTypeIn, player);
+            return ItemStack.EMPTY;
+        }
+        return super.slotClick(slotId, dragType, clickTypeIn, player);
+    }  
+    
+    public void onCanceledClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer player)
+    {
+    }
+}

src/main/java/me/km/inventory/EntityInventory.java

@@ -0,0 +1,36 @@
+package me.km.inventory;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.inventory.InventoryBasic;
+import net.minecraft.item.ItemStack;
+
+public class EntityInventory extends InventoryBasic
+{
+    private final Entity ent;
+    
+    public EntityInventory(String title, int slotCount, Entity ent) 
+    {
+        super(title, true, slotCount);
+        this.ent = ent;
+    }
+    
+    public Entity getEntity()
+    {
+        return ent;
+    }
+    
+    public void setContents(Iterable<? extends ItemStack> stacks)
+    {
+        int counter = 0;
+        int size = super.getSizeInventory();
+        for(ItemStack stack : stacks)
+        {
+            this.setInventorySlotContents(counter, stack);
+            counter++;
+            if(counter >= size)
+            {
+                return;
+            }
+        }
+    }
+}

src/main/java/me/km/inventory/InventoryUtils.java

@@ -0,0 +1,107 @@
+package me.km.inventory;
+
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.InventoryBasic;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+public class InventoryUtils
+{       
+    public static InventoryBasic getInventory(EntityVillager v)
+    {
+        EntityInventory real = new EntityInventory("Villager", 9, v);
+        InventoryBasic old = v.getVillagerInventory();
+        for(int i = 0; i < 9; i++)
+        {
+            real.setInventorySlotContents(i, old.getStackInSlot(i).copy());
+        }
+        return real;
+    }
+    
+    public static void setInventory(EntityInventory inv)
+    {
+        if(inv.getEntity() instanceof EntityVillager)
+        {
+            EntityVillager v = (EntityVillager) inv.getEntity();
+            InventoryBasic vInv = v.getVillagerInventory();
+            for(int i = 0; i < 9; i++)
+            {
+                vInv.setInventorySlotContents(i, inv.getStackInSlot(i).copy());
+            }
+        }
+    }
+    
+    public static boolean doItemStacksMatch(ItemStack first, ItemStack second)
+    {
+        int count = first.getCount();
+        first.setCount(second.getCount());
+        boolean b = ItemStack.areItemStacksEqual(first, second);
+        first.setCount(count);
+        return b;
+    }
+
+    public static int searchInventoryFor(IInventory inv, ItemStack searchfor, boolean useData)
+    {
+        int counter = 0;
+        if(useData)
+        {
+            int size = inv.getSizeInventory();
+            ItemStack stack;
+            for(int i = 0; i < size; i++)
+            {
+                stack = inv.getStackInSlot(i);
+                if(doItemStacksMatch(stack, searchfor))
+                {
+                    counter += stack.getCount();
+                }
+            }
+        }
+        else
+        {
+            int size = inv.getSizeInventory();
+            Item item = searchfor.getItem();
+            ItemStack stack;
+            for(int i = 0; i < size; i++)
+            {
+                stack = inv.getStackInSlot(i);
+                if(stack.getItem() == item)
+                {
+                    counter += stack.getCount();
+                }
+            }
+        }
+        return counter;
+    }
+    
+    public static int removeFromInventory(IInventory inv, ItemStack searchfor)
+    {
+        ItemStack stack;
+        int sub;
+        int amount = searchfor.getCount();
+        for(int i = 0; i < inv.getSizeInventory(); i++)
+        {
+            stack = inv.getStackInSlot(i);
+            if(doItemStacksMatch(stack, searchfor))
+            {
+                sub = stack.getCount();
+                if(amount > sub)
+                {
+                    amount -= sub;
+                    inv.setInventorySlotContents(i, ItemStack.EMPTY);
+                }
+                else if(amount == sub)
+                {
+                    inv.setInventorySlotContents(i, ItemStack.EMPTY);
+                    return 0;
+                }
+                else
+                {
+                    stack.setCount(sub - amount);
+                    return 0;
+                }
+            }
+        }
+        return amount;
+    }
+}

src/main/java/me/km/jobsystem/CommandJob.java

@@ -0,0 +1,258 @@
+package me.km.jobsystem;
+
+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;
+
+public class CommandJob extends ModuleCommand
+{   
+    public CommandJob(Module m) 
+    {
+        super("job", m);
+        super.setDescription("Alles zur Verwaltung bei den Jobs");
+        super.setUsage("/job für die Hilfe");
+        super.setPermission(Permissions.JOB);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        Module m = this.getModule();
+        m.send(cs, GlobalText.notImplementedYet());
+        /*if(arg.length >= 1)
+        {
+            switch(arg[0].toLowerCase())
+            {
+                case "setxp":
+                {
+                    if(arg.length >= 2)
+                    {
+                        Player affectedPlayer;
+                        try
+                        {
+                            affectedPlayer = Utilities.getPlayerByName(arg[2]);    
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof Player))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            affectedPlayer = (Player) cs;
+                        }
+                        try
+                        {
+                            KajetansTools.jobs.setJobXP(affectedPlayer, Integer.parseInt(arg[1]), KajetansTools.jobs.getJob(affectedPlayer));
+                            m.send(affectedPlayer, "Deine Job-XP wurden auf " + arg[1] + " gesetzt.");
+                            if(!cs.equals(affectedPlayer))
+                            {
+                                m.send(affectedPlayer, "Die Job-XP von " + affectedPlayer.getName() + " wurden auf " + arg[1] + " gesetzt.");
+                            }
+                        }
+                        catch(NumberFormatException ex)
+                        {
+                            m.send(cs, GlobalText.noIntegerNumber());
+                        }
+                        return true;
+                    }
+                    break;
+                }
+                case "givexp":
+                {
+                    if(arg.length >= 2)
+                    {
+                        Player affectedPlayer;
+                        try
+                        {
+                            affectedPlayer = Utilities.getPlayerByName(arg[2]);    
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof Player))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            affectedPlayer = (Player) cs;
+                        }
+                        try
+                        {
+                            KajetansTools.jobs.addXP(affectedPlayer, Integer.parseInt(arg[1]));
+                            m.send(affectedPlayer, "Dir wurden " + arg[1] + " Job-XP gegeben.");
+                            if(!cs.equals(affectedPlayer))
+                            {
+                                m.send(affectedPlayer, affectedPlayer.getName() +  " wurden " + arg[1] + " Job-XP gegeben.");
+                            }
+                        }
+                        catch(NumberFormatException ex)
+                        {
+                            m.send(cs, GlobalText.noIntegerNumber());
+                        }
+                        return true;
+                    }
+                    break;
+                }
+                case "setlevel":
+                {
+                    if(arg.length >= 2)
+                    {
+                        Player affectedPlayer;
+                        try
+                        {
+                            affectedPlayer = Utilities.getPlayerByName(arg[2]);    
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof Player))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            affectedPlayer = (Player) cs;
+                        }
+                        try
+                        {
+                            byte b = Byte.parseByte(arg[1]);
+                            if(b < 1)
+                            {
+                                throw new NumberFormatException();
+                            }
+                            KajetansTools.jobs.setJobLevel(affectedPlayer, KajetansTools.jobs.getJob(affectedPlayer), b);
+                            m.send(affectedPlayer, "Dein Job-level wurde auf " + arg[1] + " gesetzt.");
+                            if(!cs.equals(affectedPlayer))
+                            {
+                                m.send(affectedPlayer, "Das Job-Level von " + affectedPlayer.getName() + " wurde auf " + arg[1] + " gesetzt.");
+                            }
+                        }
+                        catch(NumberFormatException ex)
+                        {
+                            m.send(cs, GlobalText.noPositiveNaturalNumber());
+                        }
+                        return true;
+                    }
+                    break;
+                }
+                case "info":
+                {
+                    Player affectedPlayer;
+                    try
+                    {
+                        affectedPlayer = Utilities.getPlayerByName(arg[2]);    
+                    }
+                    catch(PlayerNotFoundException ex)
+                    {
+                        m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                        return true;
+                    }
+                    catch(IndexOutOfBoundsException ex)
+                    {
+                        if(!(cs instanceof Player))
+                        {
+                            m.send(cs, GlobalText.missingParameter());
+                            return true;
+                        }     
+                        affectedPlayer = (Player) cs;
+                    }
+                    if(cs.equals(affectedPlayer))
+                    {
+                        byte job = KajetansTools.jobs.getJob(affectedPlayer);
+                        this.getModule().send(cs, "Du bist momentan " + KajetansTools.jobs.getJobName(job) + ".");
+                        byte level = KajetansTools.jobs.getJobLevel(affectedPlayer, job);
+                        if(level < 20)
+                        {
+                            this.getModule().send(cs, "Du hast " + KajetansTools.jobs.getCurrentPercent(affectedPlayer, job) + 
+                                    "% für Level " + (level + 1) + ".");
+                            return true;
+                        }
+                        this.getModule().send(cs, "Du hast Level 20 erreicht.");
+                        return true;
+                    }
+                    byte job = KajetansTools.jobs.getJob(affectedPlayer);
+                    this.getModule().send(cs, affectedPlayer.getName() + " ist momentan " + KajetansTools.jobs.getJobName(job) + ".");
+                    byte level = KajetansTools.jobs.getJobLevel(affectedPlayer, job);
+                    if(level < 20)
+                    {
+                        this.getModule().send(cs, affectedPlayer.getName() + " hat " + KajetansTools.jobs.getCurrentPercent(affectedPlayer, job) + 
+                            "% für Level " + (level + 1) + ".");
+                        return true;
+                    }
+                    this.getModule().send(cs, affectedPlayer.getName() + " hat Level 20 erreicht.");
+                    return true;
+                }
+                case "cj":
+                case "changejob":
+                {
+                    if(arg.length >= 2)
+                    {
+                        Player affectedPlayer;
+                        try
+                        {
+                            affectedPlayer = Utilities.getPlayerByName(arg[2]);    
+                        }
+                        catch(PlayerNotFoundException ex)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[2]));
+                            return true;
+                        }
+                        catch(IndexOutOfBoundsException ex)
+                        {
+                            if(!(cs instanceof Player))
+                            {
+                                m.send(cs, GlobalText.missingParameter());
+                                return true;
+                            }     
+                            affectedPlayer = (Player) cs;
+                        }
+                        try
+                        {
+                            byte jt = KajetansTools.jobs.getIdByKey(arg[1]);
+                            if(jt == 0)
+                            {
+                                throw new IllegalArgumentException();
+                            }
+                            KajetansTools.jobs.setJob(affectedPlayer, jt);   
+                            this.getModule().send(affectedPlayer, "Du bist nun " + KajetansTools.jobs.getJobName(jt) + ".");
+                            if(!cs.equals(affectedPlayer))
+                            {
+                                m.send(affectedPlayer, affectedPlayer.getName() + " ist nun " + KajetansTools.jobs.getJobName(jt) + ".");
+                            }
+                        }
+                        catch(IllegalArgumentException ex3)
+                        {
+                            m.send(cs, "Der Job " + arg[1] + " existiert nicht.");
+                        }
+                        return true;
+                    }
+                    break;
+                }
+            }
+        }*/
+
+        /*m.send(cs, "/job ...");
+        m.send(cs, "... ist momentan deaktiviert.");
+        m.sendHelpListElement(cs, "setxp <xp> [player]", "Setzt die Job-XP eines Spielers");
+        m.sendHelpListElement(cs, "givexp <xp> [player]", "Gibt einem Spieler Job-XP");
+        m.sendHelpListElement(cs, "setlevel <level> [player]", "Setzt das Job-Level eines Spielers");
+        m.sendHelpListElement(cs, "info [player]", "Gibt Job-Infos über einen Spieler");
+        m.sendHelpListElement(cs, "changejob <job> [player]", "Ändert den Job eines Spielers");*/
+        return true;
+    }
+}

src/main/java/me/km/jobsystem/CommandRecipe.java

@@ -0,0 +1,56 @@
+
+package me.km.jobsystem;
+
+import me.km.api.GlobalText;
+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 me.km.skills.SkillMenuUtilities;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CommandRecipe extends ModuleCommand
+{   
+    public CommandRecipe(Module m) 
+    {
+        super("recipe", m);
+        super.setDescription("Zeigt deine Rezepte");
+        super.setUsage("/recipe [player]");
+        super.setPermission(Permissions.RECIPE);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayerMP))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayerMP p = (EntityPlayerMP) cs;
+        
+        EntityPlayerMP 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 EntityPlayerMP))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayerMP) cs;
+        }
+        SkillMenuUtilities.openRecipes(affectedPlayer, p);
+        return true;
+    }
+}

src/main/java/me/km/jobsystem/Job.java

@@ -0,0 +1,138 @@
+package me.km.jobsystem;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import me.km.skills.Skill;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+
+public class Job 
+{
+    private final HashSet<Block> preferedBlocks;
+    private final HashMap<Item, Byte> craftingRecipes;
+    private final String name;
+    private final HashMap<Skill, TreeMap<Byte, Byte>> skillmap;
+    
+    public Job(String name)
+    {
+        this.name = name;
+        
+        preferedBlocks = new HashSet<>();
+        skillmap = new HashMap<>();
+        craftingRecipes = new HashMap<>();
+    }
+    
+    // -------------------------------------------------------------------------
+    // Allgemeines
+    // -------------------------------------------------------------------------
+    
+    public String getName()
+    {
+        return name;
+    }
+    
+    // -------------------------------------------------------------------------
+    // Materialien
+    // -------------------------------------------------------------------------
+    
+    public void registerPreferedBlock(Block b)
+    {
+        if(b == null)
+        {
+            throw new NullPointerException();
+        }
+        preferedBlocks.add(b);
+    }
+    
+    public HashSet<Block> getPreferedBlocks()
+    {
+        return preferedBlocks;
+    }
+    
+    public boolean hasPreferedMaterial(Block b)
+    {
+        return preferedBlocks.contains(b);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Rezepte
+    // -------------------------------------------------------------------------
+    
+    public void registerRecipe(Item item, byte b)
+    {
+        if(item == null)
+        {
+            throw new NullPointerException();
+        }
+        craftingRecipes.put(item, b);
+    }
+    
+    public Boolean hasRecipe(Item item, int level)
+    {
+        Byte b = craftingRecipes.get(item);
+        return !(b == null || b > level);
+    }
+    
+    public Set<Item> getRecipes(int level)
+    {
+        return craftingRecipes.entrySet().stream()
+                .filter(e -> e.getValue() <= level).map(e -> e.getKey())
+                .collect(Collectors.toSet());
+    }
+    
+    // -------------------------------------------------------------------------
+    // Skills
+    // -------------------------------------------------------------------------
+    
+    public void registerSkillOnLevel(Skill skill, byte skillLevel, byte level)
+    {
+        if(skill == null)
+        {
+            throw new NullPointerException();
+        }
+        TreeMap<Byte, Byte> map = skillmap.get(skill);
+        if(map == null)
+        {
+            map = new TreeMap<>();
+            skillmap.put(skill, map);
+        }
+        map.put(level, skillLevel);
+    }
+    
+    public byte getSkillLevel(Skill skill, byte level)
+    {
+        try
+        {
+            Byte b = skillmap.get(skill).floorEntry(level).getValue();
+            return b == null ? 0 : b;
+        }
+        catch(NullPointerException ex)
+        {
+            return 0;
+        }
+    }
+    
+    public HashMap<Skill, Byte> getSkillMap(byte level)
+    {
+        HashMap<Skill, Byte> map = new HashMap<>();
+        if(level < 1)
+        {
+            return map;
+        }
+        skillmap.entrySet().forEach(e -> 
+        {
+            Byte b = e.getValue().floorEntry(level).getValue();
+            if(b == null)
+            {
+            }
+            else if(b > 0)
+            {
+                map.put(e.getKey(), b);
+            }
+        });
+        return map;
+    } 
+}

src/main/java/me/km/jobsystem/JobAPI.java

@@ -0,0 +1,212 @@
+package me.km.jobsystem;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.skills.Skill;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.util.text.TextFormatting;
+
+public class JobAPI extends Module
+{   
+    private final JobBank bank;
+    private final HashMap<Byte, Job> jobs;
+    
+    public JobAPI(String mname, String prefix, TextFormatting color) 
+    {
+        super(mname, prefix, color);
+        bank = new JobBank(this, KajetansMod.databank.getConnection());
+        super.setDataBank(bank);
+        jobs = new HashMap<>();
+    }
+    
+    // -------------------------------------------------------------------------
+    // general
+    // -------------------------------------------------------------------------
+    
+    public void resetAll()
+    {
+        jobs.clear();
+    }
+    
+    public int getNumberOfJobs()
+    {
+        return jobs.size() - 1;
+    }
+          
+    public String getJobName(byte id)
+    {
+        return jobs.get(id).getName();
+    }
+
+    // -------------------------------------------------------------------------
+    // blocks
+    // -------------------------------------------------------------------------
+    
+    public void registerPreferedBlock(byte job, Block b)
+    {
+        jobs.get(job).registerPreferedBlock(b);
+    }
+    
+    public boolean isPreferedMaterial(EntityPlayer p, Block m)
+    {
+        return bank.getJobs(p).stream()
+                .map(b -> jobs.get(b))
+                .filter(j -> j != null)
+                .anyMatch(j -> j.hasPreferedMaterial(m));
+    }
+    
+    // -------------------------------------------------------------------------
+    // recipes
+    // -------------------------------------------------------------------------
+    
+    public void registerRecipe(byte job, Item item, byte level)
+    {
+        jobs.get(job).registerRecipe(item, level);
+    }
+    
+    public boolean hasRecipe(EntityPlayer p, Item item)
+    {
+        return bank.getJobs(p).stream().anyMatch((b) -> 
+        {
+            Job j = jobs.get(b);
+            if(j == null)
+            {
+                return false;
+            }
+            return jobs.get(b).hasRecipe(item, getLevel(p, b));
+        });
+    }
+    
+    public Set<Item> getRecipes(EntityPlayer p)
+    {
+        HashSet<Item> set = new HashSet<>();
+        bank.getJobs(p).forEach((b) -> 
+        {
+            Job j = jobs.get(b);
+            if(j == null)
+            {
+                return;
+            }
+            set.addAll(j.getRecipes(getLevel(p, b)));
+        });
+        return set;
+    }
+    
+    // -------------------------------------------------------------------------
+    // skills
+    // -------------------------------------------------------------------------
+    
+    public void registerSkill(byte job, Skill skill, byte skillLevel, byte level)
+    {
+        jobs.get(job).registerSkillOnLevel(skill, skillLevel, level);
+    }
+    
+    public int getSkillLevel(EntityPlayer p, Skill skill)
+    {
+        return bank.getJobs(p).stream().mapToInt((b) -> 
+        {
+            Job j = jobs.get(b);
+            if(j == null)
+            {
+                return 0;
+            }
+            return j.getSkillLevel(skill, getLevel(p, b));
+        }).sum();
+    }
+    
+    public HashMap<Skill, Byte> getSkillMap(EntityPlayer p)
+    {
+        HashMap<Skill, Byte> map = new HashMap<>();
+        bank.getJobs(p).forEach((b) -> 
+        {
+            Job j = jobs.get(b);
+            if(j == null)
+            {
+                return;
+            }
+            j.getSkillMap(getLevel(p, b)).forEach((k, v) -> 
+            {
+                map.merge(k, v, (b1, b2) -> (b1 > b2 ? b1 : b2));
+            });
+        });
+        return map;
+    }
+    
+    // -------------------------------------------------------------------------
+    // jobs
+    // -------------------------------------------------------------------------
+    
+    public void registerJob(byte job, String name)
+    {
+        jobs.put(job, new Job(name));
+    }
+    
+    public boolean hasJob(EntityPlayer p, byte job)
+    {
+        return bank.hasJob(p, job);
+    }
+  
+    public ArrayList<Byte> getJobs(EntityPlayer p)
+    {        
+        return bank.getJobs(p);
+    } 
+    
+    public void setJob(EntityPlayer p, byte job, boolean b)
+    {
+        bank.setJob(p, job, b);
+    }     
+    
+    // -------------------------------------------------------------------------
+    // job-xp
+    // -------------------------------------------------------------------------
+     
+    public int getXP(EntityPlayer p, byte job)
+    {
+        Integer i = bank.getXp(p, job);
+        if(i == null)
+        {
+            return 0;
+        }
+        return i;
+    }
+    
+    public void setXP(EntityPlayer p, byte job, int xp)
+    {
+        bank.setXp(p, job, xp);
+    }
+    
+    public void addXP(EntityPlayer p, int xp, byte job)
+    {     
+        setXP(p, job, getXP(p, job) + xp);
+    }
+    
+    // -------------------------------------------------------------------------
+    // job-level
+    // -------------------------------------------------------------------------
+    
+    public byte getLevel(EntityPlayer p, byte job)
+    {
+        Byte b = bank.getLevel(p, job);
+        if(b == null)
+        {
+            return 1;
+        }
+        return b;
+    }
+    
+    public void setLevel(EntityPlayer p, byte job, byte level)
+    {
+        bank.setLevel(p, job, level);
+    }
+    
+    public void addLevel(EntityPlayer p, byte job, byte level)
+    {
+        setLevel(p, job, (byte) (getXP(p, job) + level));
+    }
+}

src/main/java/me/km/jobsystem/JobBank.java

@@ -0,0 +1,134 @@
+package me.km.jobsystem;
+
+import me.km.api.Module;
+import me.km.databank.SimpleDataBank;
+import java.sql.Connection;
+import java.util.ArrayList;
+import net.minecraft.entity.player.EntityPlayer;
+
+public class JobBank extends SimpleDataBank
+{
+    public JobBank(Module m, Connection c) 
+    {
+        super(m, c);
+    }
+    
+    @Override
+    protected void init() 
+    {
+        // Speicher für den aktuellen Beruf
+        if(!this.doesTableExist("currentjob"))
+        {
+            this.getModule().sendToConsole("Der Speicher für die aktuellen Beruf wurde nicht gefunden, erstelle ...");
+            if(this.update("CREATE TABLE IF NOT EXISTS currentjob ("
+                + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
+                + "player_id INT NOT NULL, "
+                + "job TINYINT NOT NULL, "
+                + "INDEX (player_id), "
+                + "UNIQUE INDEX (player_id,job), "
+                + "FOREIGN KEY (player_id) REFERENCES minecraft.players(id) ON DELETE RESTRICT);", false))
+            {
+                this.getModule().sendToConsole("Der Speicher für die aktuellen Beruf wurde erstellt.");
+            }
+        }
+        else
+        {
+            this.getModule().sendToConsole("Der Speicher für die aktuellen Beruf wurde gefunden.");
+        }
+    
+        // Jobdatenbank
+        if(!this.doesTableExist("jobs"))
+        {
+            this.getModule().sendToConsole("Die Jobdatenbank wurde nicht gefunden, erstelle ...");
+            if(this.update("CREATE TABLE IF NOT EXISTS jobs ("
+                + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
+                + "player_id INT NOT NULL, "
+                + "job TINYINT NOT NULL, "
+                + "xp INT NOT NULL DEFAULT 0, "
+                + "level TINYINT NOT NULL DEFAULT 1, "
+                + "UNIQUE INDEX (player_id,job), "
+                + "FOREIGN KEY (player_id) REFERENCES minecraft.players(id) ON DELETE RESTRICT);", false))
+            {
+                this.getModule().sendToConsole("Die Jobdatenbank wurde erstellt.");
+            }
+        }
+        else
+        {
+            this.getModule().sendToConsole("Die Jobdatenbank wurde gefunden.");
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Job-Level
+    // -------------------------------------------------------------------------
+    
+    public Byte getLevel(EntityPlayer p, byte job)
+    {
+        return this.getFirstByte("SELECT level from jobs " +
+                "LEFT JOIN players ON players.id = jobs.player_id " +
+                "WHERE players.uuid = '" + p.getUniqueID() + "' AND " +
+                "jobs.job=" + job + ";");
+    }
+    
+    public void setLevel(EntityPlayer p, byte job, byte level)
+    {  
+        this.update("INSERT INTO jobs (player_id,job,level) "
+                + "SELECT id, " + job + ", " + level + " "
+                + "FROM players WHERE uuid='" + p.getUniqueID() + "' "
+                + "ON DUPLICATE KEY UPDATE level=" + level + ";", false);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Jobs
+    // -------------------------------------------------------------------------
+    
+    public boolean hasJob(EntityPlayer p, byte job)
+    {
+        return this.getFirstByte("SELECT job from currentjob " +
+                "LEFT JOIN players ON players.id = currentjob.player_id " +
+                "WHERE players.uuid = '" + p.getUniqueID() + "' AND " +
+                "currentjob.job=" + job + ";") != null;
+    }
+    
+    public ArrayList<Byte> getJobs(EntityPlayer p)
+    {
+        return this.getFirstByteColumn("SELECT job from currentjob " +
+                "LEFT JOIN players ON players.id = currentjob.player_id " +
+                "WHERE players.uuid = '" + p.getUniqueID() + "';");
+    }
+    
+    public void setJob(EntityPlayer p, byte job, boolean b)
+    {  
+        if(b)
+        {
+            this.update("INSERT INTO currentjob (player_id,job) " +
+                    "SELECT id, " + job + " " +
+                    "FROM players WHERE uuid='" + p.getUniqueID() + "' " +
+                    "ON DUPLICATE KEY UPDATE job=" + job + ";", false);
+            return;
+        }
+        this.update("DELETE currentjob FROM currentjob " +
+                "LEFT JOIN players ON players.id = currentjob.player_id " +
+                "WHERE players.uuid = '" + p.getUniqueID() + "' AND job=" + job + ";", false);
+    }
+    
+    // -------------------------------------------------------------------------
+    // Job-XP
+    // -------------------------------------------------------------------------
+    
+    public Integer getXp(EntityPlayer p, byte job)
+    {
+        return this.getFirst("SELECT xp from jobs " +
+                "LEFT JOIN players ON players.id = jobs.player_id " +
+                "WHERE players.uuid = '" + p.getUniqueID() + "' AND " +
+                "jobs.job=" + job + ";", Integer.class);
+    }
+    
+    public void setXp(EntityPlayer p, byte job, int xp)
+    {  
+        this.update("INSERT INTO jobs (player_id,job,xp) " +
+                    "SELECT id, " + job + ", " + xp + " " +
+                    "FROM players WHERE uuid='" + p.getUniqueID() + "' " +
+                    "ON DUPLICATE KEY UPDATE xp=" + xp + ";", false);
+    }    
+}

src/main/java/me/km/jobsystem/LimitedDataStorage.java

@@ -0,0 +1,20 @@
+package me.km.jobsystem;
+
+import java.util.LinkedHashSet;
+
+public class LimitedDataStorage<E> extends LinkedHashSet<E>
+{
+    public void addLimited(E e)
+    {
+        this.add(e);
+        
+        if(this.size() > 999)
+        {
+            E remove = this.stream().findFirst().orElse(null);
+            if(remove != null)
+            {
+                this.remove(remove);
+            }
+        }
+    }
+}

src/main/java/me/km/permissions/Permissions.java

@@ -27,7 +27,13 @@ public enum Permissions
     WAND,
     
     // Environment
-    HEAL_STATS, TEMPERATURE
+    HEAL_STATS, TEMPERATURE,
+    
+    // Jobs
+    JOB, RECIPE, ACTIVE_SKILLS, SKILLS,
+    
+    // Plots
+    PLOT, PLOT_CREATE, PLOT_INFO, PLOT_TAG, PLOT_SHARE, PLOT_SIGN, PLOT_BYPASS, PLOT_MARK
     
     // Special
 }

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

@@ -0,0 +1,550 @@
+package me.km.plots;
+
+import com.mojang.authlib.GameProfile;
+import java.util.HashMap;
+import java.util.UUID;
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.chatmanager.ChatManager;
+import me.km.dimensions.ModDimensions;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import me.km.playerbank.PlayerBank;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+
+public class CommandPlot extends ModuleCommand
+{
+    public final HashMap<UUID, BlockPos> coord1;
+    public final HashMap<UUID, BlockPos> coord2;
+    private final ProtectionBank bank;
+    
+    public CommandPlot(Module m) 
+    {
+        super("plot", m);
+        super.setDescription("Zeigt alles für die Plot-Verwaltung");
+        super.setUsage("/plot für die Hilfe");
+        super.setPermission(Permissions.PLOT);
+        
+        coord1 = new HashMap<>();
+        coord2 = new HashMap<>();
+        
+        bank = KajetansMod.plots.getDataBank(ProtectionBank.class);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        Module m = this.getModule();
+        
+        if(arg.length >= 1)
+        {
+            // Abkürzungen
+            switch(arg[0].toLowerCase())
+            {
+                case "a":
+                case "c":
+                case "create":
+                case "add":
+                {
+                    if(!Permission.hasPermission(cs, Permissions.PLOT_CREATE))
+                    {
+                        break;
+                    }
+                    if(!(cs instanceof EntityPlayer))
+                    {
+                        this.getModule().send(cs, GlobalText.onlyPlayer());
+                        return true;
+                    }
+                    EntityPlayer p = (EntityPlayer) cs;
+                    if(coord1.containsKey(p.getUniqueID()) && coord2.containsKey(p.getUniqueID()))
+                    {
+                        BlockPos l1 = coord1.get(p.getUniqueID());
+                        BlockPos l2 = coord2.get(p.getUniqueID());
+                        bank.addPlot(Math.min(l1.getX(), l2.getX()),
+                                    30,
+                                    Math.min(l1.getZ(), l2.getZ()),
+                                    Math.max(l1.getX(), l2.getX()),
+                                    255,
+                                    Math.max(l1.getZ(), l2.getZ()),
+                                    ModDimensions.getWorldName(p.world), p, arg.length >= 2 ? arg[1] : null);  
+                        return true;                                                    
+                    }
+                    m.send(cs, "Du musst zwei Punkte wählen. (Holzschwert + Creative)");
+                    return true;
+                }
+                case "create3d":
+                case "add3d":
+                {
+                    if(!Permission.hasPermission(cs, Permissions.PLOT_CREATE))
+                    {
+                        break;
+                    }
+                    if(!(cs instanceof EntityPlayer))
+                    {
+                        this.getModule().send(cs, GlobalText.onlyPlayer());
+                        return true;
+                    }
+                    EntityPlayer p = (EntityPlayer) cs;
+                    if(coord1.containsKey(p.getUniqueID()) && coord2.containsKey(p.getUniqueID()))
+                    {
+                        BlockPos l1 = coord1.get(p.getUniqueID());
+                        BlockPos l2 = coord2.get(p.getUniqueID());
+                        bank.addPlot(Math.min(l1.getX(), l2.getX()),
+                                    Math.min(l1.getY(), l2.getY()),
+                                    Math.min(l1.getZ(), l2.getZ()),
+                                    Math.max(l1.getX(), l2.getX()),
+                                    Math.max(l1.getY(), l2.getY()),
+                                    Math.max(l1.getZ(), l2.getZ()),
+                                    ModDimensions.getWorldName(p.world), p, arg.length >= 2 ? arg[1] : null);  
+                        return true;                                                    
+                    }
+                    m.send(cs, "Du musst zwei Punkte wählen. (Holzschwert + Creative)");
+                    return true;
+                }
+                case "e":
+                case "expand":
+                {
+                    if(!Permission.hasPermission(cs, Permissions.PLOT_CREATE) || arg.length < 2)
+                    {
+                        break;
+                    }
+                    if(!(cs instanceof EntityPlayer))
+                    {
+                        this.getModule().send(cs, GlobalText.onlyPlayer());
+                        return true;
+                    }
+                    EntityPlayer p = (EntityPlayer) cs;
+                    if(coord1.containsKey(p.getUniqueID()) && coord2.containsKey(p.getUniqueID()))
+                    {
+                        UUID uuid = p.getUniqueID();
+                        BlockPos l1 = coord1.get(uuid);
+                        BlockPos l2 = coord2.get(uuid);
+                        int x1 = l1.getX();
+                        int y1 = l1.getY();
+                        int z1 = l1.getZ();
+                        int x2 = l2.getX();
+                        int y2 = l2.getY();
+                        int z2 = l2.getZ();
+
+                        int helper;
+                        if(x1 > x2)
+                        {
+                            helper = x1;
+                            x1 = x2;
+                            x2 = helper;
+                        }
+                        if(y1 > y2)
+                        {
+                            helper = y1;
+                            y1 = y2;
+                            y2 = helper;
+                        }
+                        if(z1 > z2)
+                        {
+                            helper = z1;
+                            z1 = z2;
+                            z2 = helper;
+                        }
+
+                        float yaw = p.rotationYaw;
+                        float pitch = p.rotationPitch;
+
+                        int expandRate;
+                        try
+                        {
+                            expandRate = Integer.parseInt(arg[1]);
+                            if(expandRate <= 0)
+                            {
+                                throw new NumberFormatException();      
+                            }
+                        }
+                        catch(NumberFormatException ex)
+                        {
+                            m.send(cs, GlobalText.noPositiveNaturalNumber());
+                            return true;
+                        }
+
+                        String richtung = "FEHLER";
+                        if(pitch >= 75)
+                        {
+                            y1 -= expandRate;
+                            if( y1 < 0)
+                            {
+                                 y1 = 0;
+                            }
+                            richtung = "unten";
+                        }
+                        else if(pitch <= -75)
+                        {
+                            y2 += expandRate;
+                            if(y2 > 255)
+                            {
+                                y2 = 255;
+                            }
+                            richtung = "oben";
+                        }
+                        else if(yaw >= 45 && yaw < 135)
+                        {
+                            x1 -= expandRate;
+                            richtung = "Westen";
+                        }
+                        else if(yaw >= 135 && yaw < 225)
+                        {
+                            z1 -= expandRate;
+                            richtung = "Norden";
+                        }
+                        else if(yaw >= 225 && yaw < 315)
+                        {
+                            x2 += expandRate;
+                            richtung = "Osten";
+                        }
+                        else if(yaw >= 315 || yaw < 45)
+                        {
+                            z2 += expandRate;
+                            richtung = "Süden";
+                        }
+                        coord1.put(uuid, new BlockPos(x1, y1, z1));
+                        coord2.put(uuid, new BlockPos(x2, y2, z2));
+                        m.send(cs, "Der Plot wurde um " + expandRate + " nach " + richtung + " erweitert.");
+                        return true;                                             
+                    }
+                    m.send(cs, "Du musst zwei Punkte wählen. (Holzschwert + Creative)");
+                    return true;
+                }
+                case "name":
+                {
+                    if(!Permission.hasPermission(cs, Permissions.PLOT_CREATE) || arg.length < 2)
+                    {
+                        break;
+                    }
+                    int id;
+                    try
+                    {
+                        id = Integer.parseInt(arg[1]);
+                        if(id < 0)
+                        {
+                            m.send(cs, GlobalText.noNaturalNumber());   
+                            return true;
+                        }
+                        bank.changeName(id, ChatManager.colorMessage(Utils.connectSpaces(arg, 2), cs), cs);
+                    }
+                    catch(NumberFormatException ex)
+                    {
+                        if(!(cs instanceof EntityPlayer))
+                        {
+                            this.getModule().send(cs, GlobalText.missingParameter());
+                            return true;
+                        }
+                        EntityPlayer p = (EntityPlayer) cs;
+                        bank.changeName(bank.getFirstRegionId(p), ChatManager.colorMessage(Utils.connectSpaces(arg, 1), p), p);
+                    }
+                    return true;
+                }
+                case "i":
+                case "info":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_INFO))
+                    {
+                        if(!(cs instanceof EntityPlayer))
+                        {
+                            this.getModule().send(cs, GlobalText.onlyPlayer());
+                            return true;
+                        }
+                        EntityPlayer p = (EntityPlayer) cs;
+                        bank.printInfo(p);
+                        return true;
+                    }
+                    break;
+                }
+                case "r":
+                case "remove":
+                case "delete":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_CREATE))
+                    {
+                        Integer id;
+                        if(arg.length >= 2)
+                        {
+                            try
+                            {
+                                id = Integer.parseInt(arg[1]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        }
+                        else
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                this.getModule().send(cs, GlobalText.missingParameter());
+                                return true;
+                            }
+                            EntityPlayer p = (EntityPlayer) cs;
+                            id = bank.getFirstRegionId(p);
+                        }
+                        bank.removePlot(id, cs);
+                        return true;
+                    }
+                    break;
+                }
+                case "at":
+                case "addtag":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_TAG) && arg.length >= 2)
+                    {
+                        Integer id;
+                        if(arg.length >= 3)
+                        {
+                            try
+                            {
+                                id = Integer.parseInt(arg[2]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        }
+                        else
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                this.getModule().send(cs, GlobalText.missingParameter());
+                                return true;
+                            }
+                            EntityPlayer p = (EntityPlayer) cs;
+                            id = bank.getFirstRegionId(p);
+                        }
+                        bank.addTag(id, arg[1], cs);
+                        return true;
+                    }
+                    break;
+                }
+                case "rt":
+                case "removetag":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_TAG) && arg.length >= 2)
+                    {
+                        Integer id;
+                        if(arg.length >= 3)
+                        {
+                            try
+                            {
+                                id = Integer.parseInt(arg[2]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        }
+                        else
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                this.getModule().send(cs, GlobalText.missingParameter());
+                                return true;
+                            }
+                            EntityPlayer p = (EntityPlayer) cs;
+                            id = bank.getFirstRegionId(p);
+                        }
+                        bank.removeTag(id, arg[1], cs);
+                        return true;
+                    }
+                    break;
+                }
+                case "share":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_SHARE) && arg.length >= 2)
+                    {
+                        Integer id;
+                        if(arg.length >= 3)
+                        {
+                            try
+                            {
+                                id = Integer.parseInt(arg[2]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        }
+                        else
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                this.getModule().send(cs, GlobalText.missingParameter());
+                                return true;
+                            }
+                            EntityPlayer p = (EntityPlayer) cs;
+                            id = bank.getFirstRegionId(p);
+                        }
+                        GameProfile player = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[1]);
+                        if(player == null)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[1]));
+                            return true;
+                        }
+                        bank.addPlayer(id, player, cs);
+                        return true;
+                    }
+                    break;
+                }
+                case "kick":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_SHARE) && arg.length >= 2)
+                    {
+                        Integer id;
+                        if(arg.length >= 3)
+                        {
+                            try
+                            {
+                                id = Integer.parseInt(arg[2]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        }
+                        else
+                        {
+                            if(!(cs instanceof EntityPlayer))
+                            {
+                                this.getModule().send(cs, GlobalText.missingParameter());
+                                return true;
+                            }
+                            EntityPlayer p = (EntityPlayer) cs;
+                            id = bank.getFirstRegionId(p);
+                        }
+                        GameProfile player = KajetansMod.playerbank.getDataBank(PlayerBank.class).getOfflinePlayer(arg[1]);
+                        if(player == null)
+                        {
+                            m.send(cs, GlobalText.cantFindPlayer(arg[1]));
+                            return true;
+                        }
+                        bank.removePlayer(id, player, cs);
+                        return true;
+                    }
+                    break;
+                }
+                case "sign":
+                {
+                    if(Permission.hasPermission(cs, Permissions.PLOT_SIGN) && arg.length >= 3)
+                    {
+                        // TODO
+                        this.getModule().send(cs, GlobalText.notImplementedYet());
+                        /*if(!(cs instanceof EntityPlayer))
+                        {
+                            this.getModule().send(cs, GlobalText.onlyPlayer());
+                            return true;
+                        }
+                        EntityPlayer p = (EntityPlayer) cs;
+                        Block b = Utils.getPlayerTarget(p).getBlock();
+                        if(b.getType() == Material.SIGN_POST || b.getType() == Material.WALL_SIGN)
+                        {
+                            Sign sign = (Sign) b.getState();  
+                            sign.setLine(0, "§0[§6Plot§0]");
+                            try
+                            {
+                                Integer i = Integer.parseInt(arg[1]);
+                                if(i < 0)
+                                {
+                                    throw new NumberFormatException();
+                                }
+                                sign.setLine(1, "§2" + arg[1] + " Emeralds");
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.cantFindPlayer(GlobalText.noNaturalNumber()));   
+                                return true;
+                            }
+                            try
+                            {
+                                int id = Integer.parseInt(arg[2]);
+                                if(id < 0)
+                                {
+                                    throw new NumberFormatException();      
+                                }
+                                if(!bank.doesPlotExist(id))
+                                {
+                                    m.send(p, "Der Plot mit der ID '" + id + "' ist nicht vorhanden."); 
+                                    return true;
+                                }
+                                sign.setLine(2, arg[2]);
+                                sign.update();
+                                return true;
+                            }
+                            catch(NumberFormatException ex)
+                            {
+                                m.send(cs, GlobalText.noNaturalNumber());
+                                return true;
+                            }
+                        } */
+                        m.send(cs, "Du bist nicht auf ein Schild gerichtet.");   
+                        return true;
+                    }
+                    break;
+                }
+            }
+        }
+        // Help Menu
+        m.send(cs, "/plot ...");
+        if(Permission.hasPermission(cs, Permissions.PLOT_INFO))
+        {
+            m.sendHelpListElement(cs, "info", "Gibt Infos über die aktuelle Position");
+        }
+        if(Permission.hasPermission(cs, Permissions.PLOT_CREATE))
+        {
+            m.sendHelpListElement(cs, "create [player]", "Erstellt ein Plot (30 - 255)");
+            m.sendHelpListElement(cs, "create3D [player]", "Erstellt ein Plot");
+            m.sendHelpListElement(cs, "remove [id]", "Entfernt ein Plot");
+            m.sendHelpListElement(cs, "expand <blocks>", "Erweitert die aktuelle Auswahl");
+            m.sendHelpListElement(cs, "name [id] <name>", "Gibt einem Plot einen Namen");
+        }
+        if(Permission.hasPermission(cs, Permissions.PLOT_TAG))
+        {
+            m.sendHelpListElement(cs, "addtag <tag> [id]", "Fügt einen Tag hinzu");
+            m.sendHelpListElement(cs, "removetag <tag> [id]", "Entfernt einen Tag");
+        }
+        if(Permission.hasPermission(cs, Permissions.PLOT_SHARE))
+        {
+            m.sendHelpListElement(cs, "share <player> [id]", "Fügt einen Spieler hinzu");
+            m.sendHelpListElement(cs, "kick <player> [id]", "Entfernt einen Spieler");
+        }
+        if(Permission.hasPermission(cs, Permissions.PLOT_SIGN))
+        {
+            m.sendHelpListElement(cs, "sign <price> <id>", "Ändert ein Schild zum Verkaufsschild");
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,21 @@
+package me.km.plots;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+
+public class Protection extends ModuleListener
+{
+    private final ProtectionBank bank;
+    
+    public Protection(Module m) 
+    {
+        super(m);
+        bank = KajetansMod.plots.getDataBank(ProtectionBank.class);
+    }
+    
+    public ProtectionBank getProtectionBank()
+    {
+        return bank;
+    }
+}

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

@@ -0,0 +1,484 @@
+package me.km.plots;
+
+import com.mojang.authlib.GameProfile;
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.stream.Collectors;
+import me.km.KajetansMod;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.databank.SimpleDataBank;
+import me.km.dimensions.ModDimensions;
+import me.km.playerbank.PlayerBank;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLeashKnot;
+import net.minecraft.entity.item.EntityBoat;
+import net.minecraft.entity.item.EntityItemFrame;
+import net.minecraft.entity.item.EntityMinecart;
+import net.minecraft.entity.item.EntityPainting;
+import net.minecraft.entity.monster.EntitySnowman;
+import net.minecraft.entity.passive.EntityChicken;
+import net.minecraft.entity.passive.EntityCow;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityMooshroom;
+import net.minecraft.entity.passive.EntityOcelot;
+import net.minecraft.entity.passive.EntityPig;
+import net.minecraft.entity.passive.EntityRabbit;
+import net.minecraft.entity.passive.EntitySheep;
+import net.minecraft.entity.passive.EntitySquid;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class ProtectionBank extends SimpleDataBank
+{
+    private final HashSet<Class<? extends Entity>> protectetEntities;
+    
+    public boolean isProtected(Class<? extends Entity> et)
+    {
+        return protectetEntities.contains(et);
+    }
+    
+    public ProtectionBank(Module m, Connection c) 
+    {
+        super(m, c);
+        protectetEntities = new HashSet();
+        protectetEntities.add(EntityBoat.class);
+        protectetEntities.add(EntityChicken.class);
+        protectetEntities.add(EntityCow.class);
+        protectetEntities.add(EntityHorse.class);
+        protectetEntities.add(EntityItemFrame.class);
+        protectetEntities.add(EntityLeashKnot.class);
+        protectetEntities.add(EntityMinecart.class);
+        protectetEntities.add(EntityMooshroom.class);
+        protectetEntities.add(EntityPainting.class);
+        protectetEntities.add(EntityPig.class);
+        protectetEntities.add(EntityRabbit.class);
+        protectetEntities.add(EntitySheep.class);
+        protectetEntities.add(EntitySnowman.class);
+        protectetEntities.add(EntitySquid.class);
+        protectetEntities.add(EntityOcelot.class);
+        protectetEntities.add(EntityVillager.class);
+    }
+    
+    @Override
+    protected void init() 
+    {
+        // PlotBank
+        if(!this.doesTableExist("plots"))
+        {
+            this.getModule().sendToConsole("Die Plot-Bank wurde nicht gefunden, erstelle ...");
+            if(this.update("CREATE TABLE IF NOT EXISTS plots ("
+                    + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
+                    + "x1 int(11) NOT NULL, "
+                    + "y1 int(11) NOT NULL, "
+                    + "z1 int(11) NOT NULL, "
+                    + "x2 int(11) NOT NULL, "
+                    + "y2 int(11) NOT NULL, "
+                    + "z2 int(11) NOT NULL, "
+                    + "world_name varchar(20) NOT NULL, "
+                    + "name varchar(50) NOT NULL, "
+                    + "INDEX (x1, x2), "
+                    + "INDEX (y1, y2), "
+                    + "INDEX (z1, z2), "
+                    + "INDEX (world_name));", false))
+            {
+                this.getModule().sendToConsole("Die Plot-Bank wurde erstellt.");
+            }
+        }
+        else
+        {
+            this.getModule().sendToConsole("Die Plot-Bank wurde gefunden.");
+        }
+        
+        // PlotBank - Owners
+        if(!this.doesTableExist("plot_grant"))
+        {
+            this.getModule().sendToConsole("Die Plot-Owner-Bank wurde nicht gefunden, erstelle ...");
+            if(this.update("CREATE TABLE plot_grant ("
+                    + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
+                    + "plot_id int(11) NOT NULL, "
+                    + "player_id int(11) NOT NULL, "
+                    + "INDEX plot_id (plot_id), "
+                    + "UNIQUE KEY (plot_id, player_id), "
+                    + "CONSTRAINT plot_grant_ibfk_1 FOREIGN KEY (plot_id) REFERENCES plots (id) ON DELETE CASCADE);", false))
+            {
+                this.getModule().sendToConsole("Die Plot-Owner-Bank wurde erstellt.");
+            }
+        }
+        else
+        {
+            this.getModule().sendToConsole("Die Plot-Owner-Bank wurde gefunden.");
+        }
+        
+        // PlotBank - Tags
+        if(!this.doesTableExist("plot_tags"))
+        {
+            this.getModule().sendToConsole("Die Plot-Tag-Bank wurde nicht gefunden, erstelle ...");
+            if(this.update("CREATE TABLE plot_tags ("
+                    + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
+                    + "plot_id int(11) NOT NULL, "
+                    + "tag VARCHAR(20) NOT NULL, "
+                    + "INDEX plot_id (plot_id), "
+                    + "UNIQUE KEY (plot_id, tag), "
+                    + "CONSTRAINT plot_tags_ibfk_1 FOREIGN KEY (plot_id) REFERENCES plots (id) ON DELETE CASCADE);", false))
+            {
+                this.getModule().sendToConsole("Die Plot-Tag-Bank wurde erstellt.");
+            }
+        }
+        else
+        {
+            this.getModule().sendToConsole("Die Plot-Tag-Bank wurde gefunden.");
+        }
+    }
+
+    //--------------------------------------------------------------------------
+    // Allgemeine Texte
+    //--------------------------------------------------------------------------
+    
+    private void printError(ICommandSender cs)
+    {
+        this.getModule().sendWarning(cs, "Es ist ein Fehler aufgetreten.");
+    }
+    
+    private void noPlot(ICommandSender cs)
+    {
+        this.getModule().send(cs, "Du befindest dich auf keinem Plot.");
+    }
+    
+    private void doesNotExist(ICommandSender cs, int id)
+    {
+        this.getModule().send(cs, "Der Plot mit der ID '" + id + "' ist nicht vorhanden.");
+    }
+    
+    //--------------------------------------------------------------------------
+    // Plot-Methoden
+    //--------------------------------------------------------------------------
+    
+    public void addPlot(int x1, int y1, int z1, int x2, int y2, int z2, String world, ICommandSender sender, String pname)
+    {
+        Integer id;
+        pname = makeStringSafe(pname);
+        if(pname != null)
+        {
+            id = KajetansMod.playerbank.getDataBank().getIdByName(pname);
+            if(id == null)
+            {
+                this.getModule().send(sender, GlobalText.cantFindPlayer(pname));
+                return;  
+            }
+        }
+        else
+        {
+            if(!(sender instanceof EntityPlayer))
+            {
+                return;
+            }
+            EntityPlayer p = (EntityPlayer) sender;
+            id = KajetansMod.playerbank.getDataBank().getIdByUUID(p.getUniqueID().toString());
+            pname = p.getName();
+        }
+        if(this.update("INSERT INTO plots (x1,y1,z1,x2,y2,z2,world_name,name) "
+                + "VALUES (" + x1 + "," + y1 + "," + z1 + "," + x2 + "," + y2 + "," + z2 +
+                    ",'" + world + "','" + pname + "');", false) && 
+           this.update("INSERT INTO plot_grant (plot_id,player_id) VALUES (LAST_INSERT_ID(), " + id + ");", false))
+        {
+            this.getModule().send(sender, "Der Plot wurde hinzugefügt.");
+            return;
+        }
+        printError(sender);
+    }
+    
+    public void changeName(Integer id, String name, ICommandSender sender)
+    {
+        if(id == null)
+        {
+            noPlot(sender);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(sender, id);
+            return;
+        }
+        name = makeStringSafe(name);
+        if(this.update("UPDATE plots SET name='" + name + "' WHERE id=" + id + ";", false))
+        {
+            this.getModule().send(sender, "Der Name wurde auf '" + name + "§r' geändert.");
+            return;
+        }
+        printError(sender);
+    }
+    
+    public void addTag(Integer id, String tag, ICommandSender cs)
+    {
+        if(id == null)
+        {
+            noPlot(cs);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(cs, id);
+            return;
+        }
+        tag = makeStringSafe(tag);
+        String tags = this.getFirst("SELECT tag FROM plot_tags WHERE plot_id=" + id + " AND tag='" + tag + "';", String.class);
+        if(tags != null)
+        {
+            this.getModule().send(cs, "Der Tag '" + tag + "' ist bereits vorhanden.");
+            return;
+        }       
+        if(this.update("INSERT INTO plot_tags (plot_id,tag) VALUES(" + id + ",'" + tag + "');", false))
+        {
+            this.getModule().send(cs, "Der Tag '" + tag + "' wurde hinzugefügt.");
+            return;
+        }
+        printError(cs);
+    }
+    
+    public void removeTag(Integer id, String tag, ICommandSender sender)
+    {
+        if(id == null)
+        {
+            noPlot(sender);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(sender, id);
+            return;
+        }
+        tag = makeStringSafe(tag);
+        String tags = this.getFirst("SELECT tag FROM plot_tags WHERE plot_id=" + id + " AND tag='" + tag + "';", String.class);
+        if(tags == null)
+        {
+            this.getModule().send(sender, "Der Tag '" + tag + "' ist nicht vorhanden.");
+            return;
+        }
+        if(this.update("DELETE FROM plot_tags WHERE plot_id=" + id + " AND tag='" + tag + "';", false))
+        {
+            this.getModule().send(sender, "Der Tag '" + tag + "' wurde entfernt.");
+            return;
+        }
+        printError(sender);
+    }
+    
+    public boolean hasTag(World w, BlockPos pos, String tag)
+    {
+        return this.getFirst(
+                "SELECT tag FROM plot_tags " +
+                "LEFT JOIN plots ON plots.id = plot_tags.plot_id " +
+                "WHERE x1<=" + pos.getX() + " AND x2>=" + pos.getX() +
+                " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() +
+                " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+                " AND world_name='" + ModDimensions.getWorldName(w) + "' AND tag='" + tag + "';", String.class) != null;
+    }
+    
+    public void removePlayer(Integer id, GameProfile p, ICommandSender sender)
+    {
+        if(id == null)
+        {
+            noPlot(sender);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(sender, id);
+            return;
+        }
+        Integer playerID = this.getFirst("SELECT player_id FROM plot_grant " +
+            "LEFT JOIN players ON players.id = plot_grant.player_id " +
+            "WHERE plot_grant.plot_id=" + id + " AND players.uuid='" + p.getId().toString() + "';", Integer.class);
+        if(playerID == null)
+        {
+            this.getModule().send(sender, "Der Spieler '" + p.getName() + "' ist nicht vorhanden.");
+            return;
+        }       
+        playerID = KajetansMod.playerbank.getDataBank().getIdByUUID(p.getId().toString());
+        if(playerID == null)
+        {
+            this.getModule().send(sender, GlobalText.cantFindPlayer(p.getName()));
+            return;
+        }
+        if(this.update("DELETE FROM plot_grant WHERE plot_id=" + id + " AND player_id=" + playerID + ";", false))
+        {
+            this.getModule().send(sender, "Der Spieler '" + p.getName() + "' wurde entfernt.");
+            return;
+        }
+        printError(sender);
+    }
+    
+    public void addPlayer(Integer id, GameProfile p, ICommandSender sender)
+    {
+        if(id == null)
+        {
+            noPlot(sender);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(sender, id);
+            return;
+        }
+        Integer playerID = this.getFirst("SELECT player_id FROM plot_grant " +
+            "LEFT JOIN players ON players.id = plot_grant.player_id " +
+            "WHERE plot_grant.plot_id=" + id + " AND players.uuid='" + p.getId().toString() + "';", Integer.class);
+        if(playerID != null)
+        {
+            this.getModule().send(sender, "Der Spieler '" + p.getName() + "' ist bereits vorhanden.");
+            return;
+        }       
+        playerID = KajetansMod.playerbank.getDataBank().getIdByUUID(p.getId().toString());
+        if(playerID == null)
+        {
+            this.getModule().send(sender, GlobalText.cantFindPlayer(p.getName()));
+            return;
+        }
+        if(this.update("INSERT INTO plot_grant (plot_id,player_id) VALUES(" + id + "," + playerID + ");", false))
+        {
+            this.getModule().send(sender, "Der Spieler '" + p.getName() + "' wurde hinzugefügt.");
+            return;
+        }
+        printError(sender);
+    }
+    
+    private ProtectionStatus getProtectionStatus(World w, BlockPos pos, EntityPlayer p)
+    {
+        ArrayList<Object> list = this.getFirstColumn(
+            "SELECT id FROM plots WHERE " +
+            "x1<=" + pos.getX() + " AND x2>=" + pos.getX() +
+            " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() +
+            " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+            " AND world_name='" + ModDimensions.getWorldName(w) + "';");
+        if(list == null)
+        {
+            return ProtectionStatus.ERROR;
+        }
+        if(list.isEmpty())
+        {
+            return ProtectionStatus.NOTHING;
+        }
+        if(list.stream().anyMatch(li -> 
+            {
+                return this.getFirst("SELECT plot_grant.id FROM plot_grant " +
+                    "LEFT JOIN players ON players.id = plot_grant.player_id " +
+                    "WHERE plot_grant.plot_id=" + li + " AND " +
+                    "players.uuid='" + p.getUniqueID().toString() + "';", Integer.class) != null;
+            }))
+        {
+            return ProtectionStatus.OWNER;
+        }
+        return ProtectionStatus.STRANGER;     
+    }
+    
+    public boolean hasProtection(World w, BlockPos pos)
+    {
+        ArrayList<Object> list = this.getFirstColumn(
+            "SELECT id FROM plots WHERE " +
+            "x1<=" + pos.getX() + " AND x2>=" + pos.getX() +
+            " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() +
+            " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+            " AND world_name='" + ModDimensions.getWorldName(w) + "';");
+        if(list == null)
+        {
+            return true;
+        }
+        return !list.isEmpty(); 
+    }
+    
+    public boolean canBuild(World w, BlockPos pos, EntityPlayer p)
+    {
+        ProtectionStatus ps = getProtectionStatus(w, pos, p);
+        return !(ps == ProtectionStatus.STRANGER || ps == ProtectionStatus.ERROR);
+    }
+    
+    public void removePlot(Integer id, ICommandSender sender)
+    {
+        if(id == null)
+        {
+            noPlot(sender);
+            return;
+        }
+        if(!doesPlotExist(id))         
+        {            
+            doesNotExist(sender, id);
+            return;
+        } 
+        if(this.update("DELETE FROM plots WHERE id=" + id + ";", false))
+        {
+            this.getModule().send(sender, "Der Plot mit der ID '" + id + "' wurde gelöscht.");
+            return;
+        }
+        printError(sender);     
+    }
+    
+    public void printInfo(EntityPlayer p)
+    {
+        Module m = this.getModule();
+        BlockPos pos = p.getPosition();
+        ArrayList<ArrayList<Object>> list = this.get("SELECT id,name FROM plots WHERE " +
+            "x1<=" + pos.getX() + " AND x2>=" + pos.getX() + 
+            " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() + 
+            " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+            " AND world_name='" + ModDimensions.getWorldName(p.world) + "';");
+        if(list == null)
+        {
+            printError(p);
+            return;
+        }
+        if(list.isEmpty())
+        {
+            noPlot(p);
+            return;
+        }
+        m.send(p, "Du befindest dich auf folgenden Plots:");
+        PlayerBank pb = KajetansMod.playerbank.getDataBank();
+        list.stream().forEach(li -> 
+        {
+            String owner = this.getFirstColumn("SELECT player_id FROM plot_grant WHERE plot_id=" + (int) li.get(0) + ";").stream().map(id -> pb.getNameById((int) id)).collect(Collectors.joining(", "));
+            String tags = this.getFirstColumn("SELECT tag FROM plot_tags WHERE plot_id=" + (int) li.get(0) + ";").stream().map(tag -> tag.toString()).collect(Collectors.joining(", "));
+            m.sendHelpListElement(p, li.get(1).toString(), "(" + li.get(0).toString() + ") §7" + owner + " §7" + tags);
+        });
+    }
+    
+    public Integer getFirstRegionId(World w, BlockPos pos)
+    {
+        return this.getFirst("SELECT id FROM plots WHERE " +
+                "x1<=" + pos.getX() + " AND x2>=" + pos.getX() + 
+                " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() + 
+                " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+                " AND world_name='" + ModDimensions.getWorldName(w) + "';", Integer.class);
+    }
+    
+    public Integer getFirstRegionId(EntityPlayer p)
+    {
+        return getFirstRegionId(p.world, p.getPosition());
+    }
+    
+    public String getFirstRegionName(World w, BlockPos pos)
+    {
+        return this.getFirst("SELECT name FROM plots WHERE " +
+            "x1<=" + pos.getX() + " AND x2>=" + pos.getX() + 
+            " AND y1<=" + pos.getY() + " AND y2>=" + pos.getY() + 
+            " AND z1<=" + pos.getZ() + " AND z2>=" + pos.getZ() +
+            " AND world_name='" + ModDimensions.getWorldName(w) + "';", String.class);
+    }
+    
+    public boolean doesPlotExist(int id)
+    {
+        return this.getFirst("SELECT id FROM plots WHERE id=" + id + ";", Integer.class) != null;
+    }
+    
+    private String makeStringSafe(String s)
+    {
+        if(s == null)
+        {
+            return null;
+        }    
+        return s.replace("'", "").replace("\"", "");
+    }
+}

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

@@ -0,0 +1,91 @@
+package me.km.plots;
+
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.block.Block;
+import net.minecraft.init.Blocks;
+import net.minecraft.world.World;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionBlockAction extends Protection
+{
+    public ProtectionBlockAction(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onBlockPlace(BlockEvent.PlaceEvent e)
+    {
+        EntityPlayer p = e.getPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_BYPASS))
+        {
+            return;
+        }     
+        if(!this.getProtectionBank().canBuild(e.getWorld(), e.getPos(), p))
+        {
+            if(this.getProtectionBank().hasTag(e.getWorld(), e.getPos(), "place"))
+            {
+                return;
+            }
+            e.setCanceled(true);          
+        }
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onBlockBreak(BlockEvent.BreakEvent e)
+    {
+        EntityPlayer p = e.getPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_MARK) && p.getHeldItemMainhand().getItem() == Items.WOODEN_SWORD && p.isCreative())
+        {
+            e.setCanceled(true);
+            return;
+        }
+        if(Permission.hasPermission(p, Permissions.PLOT_BYPASS))
+        {
+            return;
+        }
+        BlockPos pos = e.getPos();
+        World w = e.getWorld();
+        Block b = e.getState().getBlock();       
+        if(!this.getProtectionBank().canBuild(w, pos, p))
+        {
+            if(b == Blocks.PUMPKIN || b == Blocks.MELON_BLOCK)
+            {
+                if(this.getProtectionBank().hasTag(w, pos, "farm"))
+                {
+                    return;
+                }
+            }
+            else if(b == Blocks.REEDS)
+            {
+                if(Location.getRelativeBlock(w, pos, 0, -1, 0).getBlock() == Blocks.REEDS)
+                {
+                    if(this.getProtectionBank().hasTag(w, pos, "farm"))
+                    {
+                        return;
+                    }
+                }
+            }
+            if(this.getProtectionBank().hasTag(w, pos, "break"))
+            {
+                return;
+            }
+            if(b == Blocks.SNOW_LAYER)
+            {
+                if(this.getProtectionBank().hasTag(w, pos, "snow"))
+                {
+                    return;
+                }
+            }
+            e.setCanceled(true);
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.boss.EntityDragon;
+import net.minecraft.entity.boss.EntityWither;
+import net.minecraft.world.DimensionType;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionBossMonster extends Protection
+{
+    public ProtectionBossMonster(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void WitherDragonProtection(EntityJoinWorldEvent e)
+    {
+        Class<? extends Entity> c = e.getEntity().getClass();
+        if(c == EntityWither.class && e.getWorld().provider.getDimensionType() != DimensionType.NETHER)
+        {
+            e.setCanceled(true);
+        }  
+        else if(c == EntityDragon.class && e.getWorld().provider.getDimensionType() != DimensionType.THE_END)
+        {
+            e.setCanceled(true);
+        } 
+    }
+}

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

@@ -0,0 +1,39 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraftforge.event.entity.player.FillBucketEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionBucketUse extends Protection
+{
+    public ProtectionBucketUse(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onBucketFill(FillBucketEvent e)
+    {
+        EntityPlayer p = e.getEntityPlayer(); 
+        RayTraceResult ray = e.getTarget();
+        if(ray == null || Permission.hasPermission(p, Permissions.PLOT_BYPASS))
+        {
+            return;
+        }
+        BlockPos pos = ray.getBlockPos();
+        if(pos == null)
+        {
+            return;
+        }
+        if(!this.getProtectionBank().canBuild(e.getWorld(), pos, p))
+        {
+            e.setCanceled(true);
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+package me.km.plots;
+
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.inventory.InventoryUtils;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntitySign;
+import net.minecraft.util.EnumHand;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionBuyPlot extends Protection
+{
+    public ProtectionBuyPlot(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent
+    public void markRegion(PlayerInteractEvent.RightClickBlock e)
+    {
+        if(e.getHand() == EnumHand.OFF_HAND)
+        {
+            return;
+        }
+        World w = e.getWorld();
+        IBlockState state = w.getBlockState(e.getPos());
+        Block b = state.getBlock();
+        if(b != Blocks.WALL_SIGN && b != Blocks.STANDING_SIGN)
+        {
+            return;
+        }
+        EntityPlayer p = e.getEntityPlayer();
+        TileEntitySign sign = (TileEntitySign) w.getTileEntity(e.getPos());
+        if(sign == null)
+        {
+            this.getModule().send(p, GlobalText.shouldNotHappen());
+            return;
+        }
+        System.out.println("SIGN::" + sign.signText[0].getFormattedText());
+        if(!sign.signText[0].getFormattedText().equals("[§6Plot§0]"))
+        {
+            return;
+        }
+        int costs;
+        try
+        {
+            String s = sign.signText[1].getUnformattedText();
+            if(!s.contains(" "))
+            {
+                throw new NumberFormatException();
+            }
+            costs = Integer.parseInt(s.substring(2, s.indexOf(" ")));
+            if(costs < 0)
+            {
+                throw new NumberFormatException();
+            }
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(p, "Die angegebenen Kosten sind ungültig.");  
+            return;
+        }
+        if(InventoryUtils.searchInventoryFor(p.inventory, new ItemStack(Items.EMERALD), false) < costs)
+        {
+            this.getModule().send(p, "Du hast zu wenig Emeralds dabei.");  
+            return;
+        }
+        try
+        {
+            int id = Integer.parseInt(sign.signText[2].getUnformattedText());
+            if(id < 0)
+            {
+                throw new NumberFormatException();      
+            }
+            if(!this.getProtectionBank().doesPlotExist(id))
+            {
+                this.getModule().send(p, "Der Plot mit der ID '" + id + "' ist nicht vorhanden."); 
+                return;
+            }
+            this.getProtectionBank().addPlayer(id, p.getGameProfile(), p);     
+            InventoryUtils.removeFromInventory(p.inventory, new ItemStack(Items.EMERALD, costs));
+            w.setBlockToAir(e.getPos());
+        }
+        catch(NumberFormatException ex)
+        {
+            this.getModule().send(p, GlobalText.noNaturalNumber());
+        } 
+    }
+}

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

@@ -0,0 +1,36 @@
+package me.km.plots;
+
+import me.kt.api.Module;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+
+public class ProtectionCommand extends Protection
+{
+    public ProtectionCommand(Module m) 
+    {
+        super(m);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void CommandProtection(PlayerCommandPreprocessEvent e)
+    {
+        if(e.getMessage().startsWith("/op") || e.getMessage().startsWith("/minecraft:op"))
+        {
+            e.setCancelled(true);   
+        }
+        else if(e.getMessage().startsWith("/fly"))
+        {
+            Player p = e.getPlayer();
+            if(p.hasPermission("kt.plot.bypass"))
+            {
+                return;
+            }
+            if(this.getProtectionBank().hasTag(p.getLocation(), "fly"))
+            {
+                e.setCancelled(true);
+            }       
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityPotion;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.ThrowableImpactEvent;
+import net.minecraftforge.event.entity.living.LivingAttackEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionEntity extends Protection
+{
+    public ProtectionEntity(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void EntityProtection(LivingAttackEvent e)
+    {  
+        EntityLivingBase ent = e.getEntityLiving();
+        if(!this.getProtectionBank().isProtected(ent.getClass()))
+        {
+            return;
+        }
+        World w = ent.world;
+        BlockPos pos = ent.getPosition();
+        if(!this.getProtectionBank().hasProtection(w, pos) || 
+            (ent instanceof EntityAnimal && this.getProtectionBank().hasTag(w, pos, "animal")))
+        {
+            return;
+        } 
+        
+        if(e.getSource().getSourceOfDamage() != null)
+        {
+            Entity source = e.getSource().getSourceOfDamage();
+            if(source instanceof EntityPlayer)
+            {
+                EntityPlayer p = (EntityPlayer) source;
+                if(Permission.hasPermission(p, Permissions.PLOT_BYPASS) || this.getProtectionBank().canBuild(w, pos, p))
+                {
+                    return;
+                }
+                e.setCanceled(true);
+            }
+        }   
+        e.setCanceled(true);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void EntityProtectionPotion(ThrowableImpactEvent e)
+    {
+        if(e.getEntityThrowable() instanceof EntityPotion)
+        {
+            EntityPotion potion = (EntityPotion) e.getEntityThrowable();
+            EntityLivingBase ent = potion.getThrower();
+            if(ent instanceof EntityPlayer && !Permission.hasPermission(ent, Permissions.PLOT_BYPASS) &&
+                !this.getProtectionBank().canBuild(potion.world, potion.getPosition(), (EntityPlayer) ent))
+            {
+                e.setCanceled(true);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package me.km.plots;
+
+import me.kt.api.Module;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockExplodeEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+
+public class ProtectionExplosion extends Protection
+{
+    public ProtectionExplosion(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void BlockExplosionProtection(BlockExplodeEvent e)
+    {
+        if(e.getBlock().getWorld().getEnvironment() != World.Environment.NETHER)
+        {
+            e.setCancelled(true);
+        } 
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void EntityExplosionProtection(EntityExplodeEvent e)
+    {
+        if(e.getLocation().getWorld().getEnvironment() != World.Environment.NETHER)
+        {
+            if(this.getProtectionBank().hasTag(e.getLocation(), "TNT"))
+            {
+                return;
+            } 
+            e.setCancelled(true);
+        }   
+    }
+}

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

@@ -0,0 +1,48 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionFire extends Protection
+{
+    public ProtectionFire(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void FireDestroyProtection(BlockEvent.BreakEvent e)
+    {
+        if(e.getBlock().getWorld().getEnvironment() != World.Environment.NETHER)
+        {
+            e.setCancelled(true);
+        }    
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void FireIgniteProtection(BlockIgniteEvent e)
+    {
+        if(e.getCause() == BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL)
+        {
+            return;
+        }
+        if(e.getBlock().getWorld().getEnvironment() != World.Environment.NETHER)
+        {
+            e.setCancelled(true);
+        }   
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void FireSpreadProtection(BlockSpreadEvent e)
+    {
+        if(e.getSource().getType() == Material.FIRE)
+        {
+            if(e.getBlock().getWorld().getEnvironment() != World.Environment.NETHER)
+            {
+                e.setCancelled(true);
+            } 
+        }  
+    }
+}

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

@@ -0,0 +1,67 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionInteract extends Protection
+{
+    public ProtectionInteract(Module m)
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onPlayerInteract(PlayerInteractEvent.LeftClickBlock e) 
+    {
+        EntityPlayer p = e.getEntityPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_BYPASS))
+        {
+            return;
+        }  
+        Block b = e.getWorld().getBlockState(e.getPos()).getBlock();
+        if (b == Blocks.FIRE && !this.getProtectionBank().canBuild(e.getWorld(), e.getPos(), p)) 
+        {
+            e.setCanceled(true);
+        }
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void onPlayerInteract(PlayerInteractEvent.RightClickBlock e) 
+    {
+        EntityPlayer p = e.getEntityPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_BYPASS))
+        {
+            return;
+        }    
+        Block b = e.getWorld().getBlockState(e.getPos()).getBlock();
+        if(b == Blocks.DAYLIGHT_DETECTOR || b == Blocks.DAYLIGHT_DETECTOR_INVERTED ||
+            b == Blocks.POWERED_REPEATER || b == Blocks.UNPOWERED_REPEATER ||
+            b == Blocks.POWERED_COMPARATOR || b == Blocks.UNPOWERED_COMPARATOR ||
+            b == Blocks.DRAGON_EGG)
+        {
+            if(!this.getProtectionBank().canBuild(e.getWorld(), e.getPos(), p))
+            {
+                e.setCanceled(true);
+            }
+        }
+    }
+    
+    @SubscribeEvent(priority = EventPriority.HIGHEST)
+    public void protectFromInteract(PlayerInteractEvent.EntityInteract e)
+    {      
+        EntityPlayer p = e.getEntityPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_BYPASS) || 
+            this.getProtectionBank().canBuild(e.getWorld(), e.getTarget().getPosition(), p))
+        {
+            return;
+        }
+        e.setCanceled(true);
+    }
+}

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

@@ -0,0 +1,61 @@
+package me.km.plots;
+
+import me.km.api.Module;
+import java.util.HashMap;
+import java.util.UUID;
+import me.km.KajetansMod;
+import me.km.permissions.Permission;
+import me.km.permissions.Permissions;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ProtectionMarkPlot extends Protection
+{
+    private final HashMap<UUID, BlockPos> coord1;
+    private final HashMap<UUID, BlockPos> coord2;
+    
+    public ProtectionMarkPlot(Module m) 
+    {
+        super(m);
+        coord1 = KajetansMod.plots.getCommand(CommandPlot.class).coord1;
+        coord2 = KajetansMod.plots.getCommand(CommandPlot.class).coord2;
+    }
+    
+    @SubscribeEvent
+    public void markRegionRightClick(PlayerInteractEvent.RightClickBlock e)
+    {
+        if(e.getHand() == EnumHand.OFF_HAND)
+        {
+            return;
+        }
+        EntityPlayer p = e.getEntityPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_MARK) && p.getHeldItemMainhand().getItem() == Items.WOODEN_SWORD && p.isCreative())
+        {
+            BlockPos pos = e.getPos();
+            coord2.put(p.getUniqueID(), pos);
+            this.getModule().send(p, "Punkt 2 wurde ausgewählt (" + pos.getX() + ", " + pos.getY() + ", " + pos.getZ() + ")");
+            e.setCanceled(true);
+        }
+    }
+    
+    @SubscribeEvent
+    public void markRegionLeftClick(PlayerInteractEvent.LeftClickBlock e)
+    {
+        if(e.getHand() == EnumHand.OFF_HAND)
+        {
+            return;
+        }
+        EntityPlayer p = e.getEntityPlayer();
+        if(Permission.hasPermission(p, Permissions.PLOT_MARK) && p.getHeldItemMainhand().getItem() == Items.WOODEN_SWORD && p.isCreative())
+        {
+            BlockPos pos = e.getPos();
+            coord1.put(p.getUniqueID(), pos);
+            this.getModule().send(p, "Punkt 1 wurde ausgewählt (" + pos.getX() + ", " + pos.getY() + ", " + pos.getZ() + ")");
+            e.setCanceled(true);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+package me.km.plots;
+
+public enum ProtectionStatus 
+{
+    NOTHING, SHARED, ERROR, OWNER, STRANGER
+}

src/main/java/me/km/skills/ActiveSkillContainer.java

@@ -0,0 +1,33 @@
+package me.km.skills;
+
+import java.util.List;
+import java.util.Map;
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectCause;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+public class ActiveSkillContainer extends SkillContainer
+{ 
+    public ActiveSkillContainer(String title, EntityPlayer p, List<ItemStack> stacks, List<Map.Entry<Skill, Byte>> list) 
+    {
+        super(title, p, stacks, list);
+    }
+
+    @Override
+    public boolean castClickedSkill() 
+    {
+        return true;
+    }
+
+    @Override
+    public void onCastSkill(EntityPlayer p, Skill s, byte level) 
+    {
+        if(ActiveEffectBase.executeEffect(s.getEffect().getEffectBase(), p, level, level, EffectCause.SKILL))
+        {
+            KajetansMod.skills.sendToPlayers(p.world, p.getPositionVector(), 20, "§3" + p.getName() + "§r hat §3" + s.getName() + "§r benutzt.");
+            p.closeScreen();
+        }
+    }
+}

src/main/java/me/km/skills/CommandActiveSkills.java

@@ -0,0 +1,39 @@
+package me.km.skills;
+
+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;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CommandActiveSkills extends ModuleCommand
+{
+    public CommandActiveSkills(Module m) 
+    {
+        super("activeskills", m);
+        super.setDescription("Zeigt dir deine aktiven Skills");
+        super.setUsage("/activeskills");
+        super.setPermission(Permissions.ACTIVE_SKILLS);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayer))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayerMP p = (EntityPlayerMP) cs;
+        if(KajetansMod.worldManager.getWorldPreferences(p.getEntityWorld()).skills)
+        {
+            SkillMenuUtilities.openActiveSkills(p);
+            return true;
+        }
+        this.getModule().send(cs, GlobalText.noSkills());
+        return true;
+    } 
+}

src/main/java/me/km/skills/CommandSkills.java

@@ -0,0 +1,54 @@
+package me.km.skills;
+
+import me.km.permissions.Permissions;
+import me.km.api.GlobalText;
+import me.km.api.Module;
+import me.km.api.ModuleCommand;
+import me.km.api.Utils;
+import me.km.exception.PlayerNotFoundException;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CommandSkills extends ModuleCommand
+{
+    public CommandSkills(Module m) 
+    {
+        super("skills", m);
+        super.setDescription("Zeigt die Skills eines Spielers");
+        super.setUsage("/skills [player]");
+        super.setPermission(Permissions.SKILLS);
+    }
+
+    @Override
+    public boolean execute(ICommandSender cs, String[] arg) 
+    {
+        if(!(cs instanceof EntityPlayerMP))
+        {
+            this.getModule().send(cs, GlobalText.onlyPlayer());
+            return true;
+        }
+        EntityPlayerMP p = (EntityPlayerMP) cs;
+        
+        EntityPlayerMP 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 EntityPlayerMP))
+            {
+                this.getModule().send(cs, GlobalText.missingParameter());
+                return true;
+            }     
+            affectedPlayer = (EntityPlayerMP) cs;
+        }
+        SkillMenuUtilities.openSkills(affectedPlayer, p);
+        return true;
+    } 
+}

src/main/java/me/km/skills/SkillContainer.java

@@ -0,0 +1,146 @@
+package me.km.skills;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import me.km.inventory.CustomContainer;
+import me.km.inventory.EntityInventory;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.ClickType;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public class SkillContainer extends CustomContainer
+{
+    private final List<Map.Entry<Skill, Byte>> skills;
+    private final ArrayList<List<ItemStack>> pages;
+    private int page;
+    
+    public SkillContainer(String title, EntityPlayer p, List<ItemStack> stacks, List<Map.Entry<Skill, Byte>> list) 
+    {
+        super(title, stacks.size() % 9 != 0 ? ((stacks.size() / 9) + 1) + 9 : stacks.size(), p);
+        
+        EntityInventory inv = super.getShownInventory();
+        if(inv.getSizeInventory() > 45)
+        {
+            inv.setContents(stacks.subList(0, 45));
+            placeButtons(inv);
+        }
+        else
+        {
+            inv.setContents(stacks);
+        }
+        
+        this.skills = list;
+        this.page = 0;
+        if(stacks.size() > 45)
+        {
+            this.pages = new ArrayList<>();
+            int size = stacks.size();
+            int counter = 0;
+            while(counter < size)
+            {
+                pages.add(stacks.subList(counter, Math.min(counter + 45, size)));
+                counter += 45;
+            }
+        }
+        else
+        {
+            this.pages = null;
+        }
+    }
+    
+    private List<ItemStack> getNextPage()
+    {
+        page++;
+        if(page >= pages.size())
+        {
+            page--;
+            return null;
+        }
+        return pages.get(page);
+    }
+    
+    private List<ItemStack> getPreviousPage()
+    {
+        page--;
+        if(page < 0)
+        {
+            page = 0;
+            return null;
+        }
+        return pages.get(page);
+    }
+    
+    private Map.Entry<Skill, Byte> getSkill(int slot)
+    {
+        slot += page * 45;
+        if(skills == null || slot >= skills.size())
+        {
+            return null;
+        }
+        return skills.get(slot);
+    }
+    
+    private void placeButtons(IInventory inv)
+    {
+        inv.setInventorySlotContents(45, new ItemStack(Items.IRON_DOOR).setStackDisplayName("§6Zurück"));
+        inv.setInventorySlotContents(53, new ItemStack(Items.OAK_DOOR).setStackDisplayName("§Vorwärts"));
+    }
+
+    public boolean castClickedSkill()
+    {
+        return false;
+    }
+    
+    public void onCastSkill(EntityPlayer p, Skill s, byte level)
+    {
+        
+    }
+    
+    @Override
+    public void onCanceledClick(int slot, int dragType, ClickType clickTypeIn, EntityPlayer p) 
+    {
+        if(slot >= 45)
+        {
+            if(slot == 45)
+            {
+                List<ItemStack> list = getPreviousPage();
+                if(list == null)
+                {
+                    return;
+                }
+                EntityInventory inv = getShownInventory();
+                getShownInventory().setContents(list);
+                placeButtons(inv);
+            }
+            else if(slot == 53)
+            {
+                List<ItemStack> list = getNextPage();
+                if(list == null)
+                {
+                    return;
+                }
+                EntityInventory inv = getShownInventory();
+                getShownInventory().setContents(list);
+                placeButtons(inv);
+            }
+            return;
+        }
+        if(castClickedSkill())
+        {
+            Map.Entry<Skill, Byte> entry = getSkill(slot);
+            if(entry == null)
+            {
+                return;
+            }
+            Skill s = entry.getKey();
+            if(s == null)
+            {
+                return;
+            }
+            onCastSkill(p, s, entry.getValue());
+        }
+    }
+}

src/main/java/me/km/skills/SkillManager.java

@@ -0,0 +1,46 @@
+package me.km.skills;
+
+import java.util.HashMap;
+import me.km.api.Module;
+import me.km.effects.Effect;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.text.TextFormatting;
+
+public class SkillManager extends Module
+{
+    private final HashMap<Integer, Skill> skills;
+    
+    public SkillManager(String mname, String prefix, TextFormatting color) 
+    {
+        super(mname, prefix, color);
+        skills = new HashMap<>();
+    }
+    
+    public void registerSkill(int id, ItemStack icon, Effect eff, String name, String explanation)
+    {
+        Skill skill = new Skill(icon, eff, name, explanation);
+        if(skills.put(id, skill) == null)
+        {
+            eff.addSkill(skill);
+        }
+    }
+    
+    public Skill getSkill(int id)
+    {
+        Skill skill = skills.get(id);
+        if(skill == null)
+        {
+            throw new NullPointerException("ID " + id + " has no skill.");
+        }
+        return skills.get(id);
+    }
+    
+    public void clearSkills()
+    {
+        skills.clear();
+        for(Effect c : Effect.values())
+        {
+            c.clearSkills();
+        }
+    }
+}

src/main/java/me/km/skills/SkillMenuUtilities.java

@@ -0,0 +1,34 @@
+package me.km.skills;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import me.km.KajetansMod;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+
+public class SkillMenuUtilities 
+{
+    public static void openActiveSkills(EntityPlayerMP p)
+    {
+        List<Map.Entry<Skill, Byte>> list = KajetansMod.jobs.getSkillMap(p).entrySet().stream().filter(e -> e.getKey().isActive()).collect(Collectors.toList());
+        List<ItemStack> stacks = list.stream().map(e -> e.getKey().getItemStack(e.getValue())).collect(Collectors.toList());
+        ActiveSkillContainer active = new ActiveSkillContainer("Aktive Skills", p, stacks, list);
+        active.openForPlayer(p);
+    }
+    
+    public static void openSkills(EntityPlayer p, EntityPlayerMP show)
+    {
+        List<ItemStack> stacks = KajetansMod.jobs.getSkillMap(p).entrySet().stream().map(e -> e.getKey().getItemStack(e.getValue())).collect(Collectors.toList());
+        SkillContainer skills = new SkillContainer("Skills", p, stacks, null);
+        skills.openForPlayer(show);
+    }
+    
+    public static void openRecipes(EntityPlayer p, EntityPlayerMP show)
+    {
+        List<ItemStack> stacks = KajetansMod.jobs.getRecipes(p).stream().map(m -> new ItemStack(m)).collect(Collectors.toList());
+        SkillContainer skills = new SkillContainer("Crafting-Rezepte", p, stacks, null);
+        skills.openForPlayer(show);
+    }
+}

src/main/java/me/km/utils/EntityInventory.java

@@ -1,20 +0,0 @@
-package me.km.utils;
-
-import net.minecraft.entity.Entity;
-import net.minecraft.inventory.InventoryBasic;
-
-public class EntityInventory extends InventoryBasic
-{
-    private final Entity ent;
-    
-    public EntityInventory(String title, int slotCount, Entity ent) 
-    {
-        super(title, true, slotCount);
-        this.ent = ent;
-    }
-    
-    public Entity getEntity()
-    {
-        return ent;
-    }
-}

src/main/java/me/km/utils/InventoryUtils.java

@@ -1,31 +0,0 @@
-package me.km.utils;
-
-import net.minecraft.entity.passive.EntityVillager;
-import net.minecraft.inventory.InventoryBasic;
-
-public class InventoryUtils
-{       
-    public static InventoryBasic getInventory(EntityVillager v)
-    {
-        EntityInventory real = new EntityInventory("Villager", 9, v);
-        InventoryBasic old = v.getVillagerInventory();
-        for(int i = 0; i < 9; i++)
-        {
-            real.setInventorySlotContents(i, old.getStackInSlot(i).copy());
-        }
-        return real;
-    }
-    
-    public static void setInventory(EntityInventory inv)
-    {
-        if(inv.getEntity() instanceof EntityVillager)
-        {
-            EntityVillager v = (EntityVillager) inv.getEntity();
-            InventoryBasic vInv = v.getVillagerInventory();
-            for(int i = 0; i < 9; i++)
-            {
-                vInv.setInventorySlotContents(i, inv.getStackInSlot(i).copy());
-            }
-        }
-    }
-}