Portierung aktiver Effekte, passive teilweise

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

@@ -1,5 +1,6 @@
 package me.km.api;
 
+import com.mojang.authlib.GameProfile;
 import java.io.File;
 import me.km.utils.ItemStackBuilder;
 import java.util.ArrayList;
@@ -21,12 +22,13 @@ import net.minecraft.block.BlockPistonMoving;
 import net.minecraft.block.BlockTrapDoor;
 import net.minecraft.block.properties.IProperty;
 import net.minecraft.block.state.IBlockState;
-import net.minecraft.entity.IProjectile;
+import net.minecraft.enchantment.EnchantmentHelper;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.entity.projectile.EntityArrow;
 import net.minecraft.entity.projectile.EntityFireball;
 import net.minecraft.entity.projectile.EntityThrowable;
 import net.minecraft.init.Blocks;
+import net.minecraft.init.Enchantments;
 import net.minecraft.init.Items;
 import net.minecraft.init.MobEffects;
 import net.minecraft.item.Item;
@@ -40,13 +42,68 @@ import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemSword; 
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTUtil;
 import net.minecraft.potion.Potion;
+import net.minecraft.tileentity.TileEntitySkull;
 import net.minecraft.util.DamageSource;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.world.WorldServer;
 
 public class Utils 
 {    
+    public static void breakBlock(World w, BlockPos pos, EntityPlayer p)
+    {
+        IBlockState state = w.getBlockState(pos);
+        state.getBlock().dropBlockAsItem(w, pos, state, EnchantmentHelper.getEnchantmentLevel(Enchantments.FORTUNE, p.getHeldItemMainhand()));
+        w.setBlockToAir(pos);
+    }
+    
+    private static ItemStack getPlayerHead(GameProfile gameprofile)
+    {
+        ItemStack stack = new ItemStack(Items.SKULL, 1, 3);
+        NBTTagCompound com = stack.getTagCompound();
+        if(com == null)
+        {
+            return stack;
+        }
+        gameprofile = TileEntitySkull.updateGameprofile(gameprofile);
+        com.setTag("SkullOwner", NBTUtil.writeGameProfile(new NBTTagCompound(), gameprofile));
+        return stack;
+    }
+    
+    public static ItemStack getPlayerHead(String name)
+    {
+        return getPlayerHead(KajetansMod.playerbank.getDataBank().getOfflinePlayer(name));
+    }
+    
+    public static ItemStack getPlayerHead(EntityPlayer p)
+    {
+        return getPlayerHead(p.getGameProfile());
+    }
+    
+    public static void setVelocity(Entity ent, double x, double y, double z)
+    {
+        ent.motionX = x;
+        ent.motionY = y;
+        ent.motionZ = z;
+    }
+    
+    public static void addVelocity(Entity ent, double x, double y, double z)
+    {
+        ent.motionX += x;
+        ent.motionY += y;
+        ent.motionZ += z;
+    }
+    
+    public static void scaleVelocity(Entity ent, double scale)
+    {
+        ent.motionX *= scale;
+        ent.motionY *= scale;
+        ent.motionZ *= scale;
+    }
+    
+    
     public static boolean hasPlayedBefore(EntityPlayer p)
     {
         return new File("./saves/world/playerdata/" + p.getUniqueID() + ".dat").exists();

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

@@ -1,20 +1,13 @@
 package me.km.commands;
 
-import com.mojang.authlib.GameProfile;
-import me.km.KajetansMod;
 import me.km.api.GlobalText;
-import me.km.utils.ItemStackBuilder;
 import me.km.api.Module;
 import me.km.api.ModuleCommand;
+import me.km.api.Utils;
 import me.km.permissions.Permissions;
 import net.minecraft.block.Block;
 import net.minecraft.command.ICommandSender;
 import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.Items;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTUtil;
-import net.minecraft.tileentity.TileEntitySkull;
 
 public class CommandSkull extends ModuleCommand
 {
@@ -39,19 +32,7 @@ public class CommandSkull extends ModuleCommand
             return false;
         }
         EntityPlayer p = (EntityPlayer) cs;
-        ItemStack stack = new ItemStackBuilder(Items.SKULL, 1, 3).build();
-        
-        NBTTagCompound com = stack.getTagCompound();
-        if(com == null)
-        {
-            this.getModule().send(cs, GlobalText.shouldNotHappen());
-            return true;
-        }
-        GameProfile gameprofile = KajetansMod.playerbank.getDataBank().getOfflinePlayer(arg[0]);
-        gameprofile = TileEntitySkull.updateGameprofile(gameprofile);
-        com.setTag("SkullOwner", NBTUtil.writeGameProfile(new NBTTagCompound(), gameprofile));
-         
-        Block.spawnAsEntity(p.getEntityWorld(), p.getPosition(), stack);
+        Block.spawnAsEntity(p.getEntityWorld(), p.getPosition(), Utils.getPlayerHead(arg[0]));
         this.getModule().send(cs, "Dir wurde ein Kopf von " + arg[0] + " gegeben.");
         return true;
     }

src/main/java/me/km/effects/ActiveEffectBase.java

@@ -3,7 +3,7 @@ package me.km.effects;
 import me.km.KajetansMod;
 import me.km.environment.EnvironmentAPI;
 import me.km.snuviscript.QuestsEvents;
-import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 
 public abstract class ActiveEffectBase 
 {
@@ -14,7 +14,7 @@ public abstract class ActiveEffectBase
         return 0;
     }
     
-    public boolean run(EntityPlayer p, int power, int manaFactor, EffectCause cause)
+    public boolean run(EntityPlayerMP p, int power, int manaFactor, EffectCause cause)
     {
         if(cause != EffectCause.NOTHING)
         {
@@ -84,9 +84,9 @@ public abstract class ActiveEffectBase
         return false;
     }
     
-    protected abstract boolean executeEffect(EntityPlayer p, int power);
+    protected abstract boolean executeEffect(EntityPlayerMP p, int power);
     
-    public static boolean executeEffect(Class<? extends ActiveEffectBase> c, EntityPlayer p, int power, int manaFactor, EffectCause cause)
+    public static boolean executeEffect(Class<? extends ActiveEffectBase> c, EntityPlayerMP p, int power, int manaFactor, EffectCause cause)
     {
         if(c == null)
         {

src/main/java/me/km/effects/Effect.java

@@ -1,6 +1,7 @@
 package me.km.effects;
 
 import java.util.ArrayList;
+import me.km.effects.active.*;
 import me.km.skills.Skill;
 
 public enum Effect
@@ -57,11 +58,10 @@ public enum Effect
     GOLD_WASHER             (false),
     GOLD_RUSH               (false),
     USE_WAND                (false),
-    LESS_ITEM_LOSS          (false);
+    LESS_ITEM_LOSS          (false),
     
-    // TODO
     // active effects
-    /*ARCANE_SHOT             (true, ArcaneShot.class),
+    ARCANE_SHOT             (true, ArcaneShot.class),
     BLINDING_SHOT           (true, BlindingShot.class),
     BUNNY_HOP               (true, BunnyHop.class),
     CALL_BACK               (true, CallBack.class),
@@ -98,7 +98,6 @@ public enum Effect
     NAIL_TRAP               (true, NailTrap.class),
     NET_TRAP                (true, NetTrap.class),
     NIGHT                   (true, Night.class),
-    P_HEAL                  (true, PHeal.class),
     POISON                  (true, Poison.class),
     POISONED_BLADE          (true, PoisonedBlade.class),
     POISON_VOLLEY           (true, PoisonVolley.class),
@@ -123,7 +122,7 @@ public enum Effect
     THOR                    (true, Thor.class),
     UNLUCKY                 (true, Unlucky.class),
     VINE_TRAP               (true, VineTrap.class),
-    WORKBENCH               (true, Workbench.class);*/
+    WORKBENCH               (true, Workbench.class);
     
     private final ArrayList<Skill> skills;
     private final Class<? extends ActiveEffectBase> c;

src/main/java/me/km/effects/EffectBlockChanger.java

@@ -3,6 +3,7 @@ package me.km.effects;
 import me.km.KajetansMod;
 import java.util.ArrayList;
 import java.util.function.Consumer;
+import me.km.api.Location;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.util.math.BlockPos;
@@ -43,9 +44,9 @@ public class EffectBlockChanger
         return w;
     }
     
-    public void forEachBlockPos(Consumer<? super BlockPos> c)
+    public void forEachLocation(Consumer<? super Location> c)
     {
-        list.stream().map(l -> l.pos).forEach(c);
+        list.stream().map(l -> new Location(w, l.pos)).forEach(c);
     }
     
     private class ChangeBlock

src/main/java/me/km/effects/EffectUtils.java

@@ -1,22 +1,30 @@
 package me.km.effects;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.stream.Collectors;
 import me.km.KajetansMod;
 import me.km.api.Module;
 import me.km.api.Utils;
 import me.km.jobsystem.JobAPI;
+import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityAreaEffectCloud;
 import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.item.EntityEnderPearl;
+import net.minecraft.entity.item.EntityExpBottle;
 import net.minecraft.entity.passive.EntityAnimal;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.*;
+import net.minecraft.init.Items;
 import net.minecraft.init.SoundEvents;
+import net.minecraft.item.ItemStack;
 import net.minecraft.network.play.server.SPacketParticles;
 import net.minecraft.network.play.server.SPacketSoundEffect;
 import net.minecraft.potion.Potion;
 import net.minecraft.potion.PotionEffect;
 import net.minecraft.potion.PotionType;
+import net.minecraft.potion.PotionUtils;
 import net.minecraft.util.EnumParticleTypes;
 import net.minecraft.util.SoundCategory;
 import net.minecraft.util.SoundEvent;
@@ -28,11 +36,65 @@ import net.minecraft.world.WorldServer;
 
 public class EffectUtils extends Module
 {
+    private final HashMap<Integer, EntityData> entityData;
+    
     public EffectUtils(String mname, String prefix, TextFormatting color) 
     {
         super(mname, prefix, color);
+        entityData = new HashMap<>();
+    }
+    
+    // -----------------------------------------------------------------------------------
+    // Entity-Data
+    // -----------------------------------------------------------------------------------
+    
+    private class EntityData
+    {
+        private final String s;
+        private final Object data;
+        
+        public EntityData(String s, Object data)
+        {
+            this.s = s;
+            this.data = data;
+        }
+    }
+    
+    public void addEntityData(Entity ent, String key, Object data)
+    {
+        entityData.put(ent.getEntityId(), new EntityData(key, data));
+        removeInvalidData(ent);
+    }
+    
+    public void addEntityData(Entity ent, String key)
+    {
+        addEntityData(ent, key, true);
+    }
+    
+    private void removeInvalidData(Entity ent)
+    {
+        if(ent.isDead)
+        {
+            entityData.remove(ent.getEntityId());
+            return;
+        }
+        KajetansMod.scheduler.scheduleTask(() -> removeInvalidData(ent), 100);
+    }
+    
+    public Object hasEntityData(Entity ent, String key)
+    {
+        EntityData data = entityData.get(ent.getEntityId());
+        if(data == null)
+        {
+            return null;
+        }
+        return data.data;
     }
     
+    // -----------------------------------------------------------------------------------
+    // Entity-Level
+    // -----------------------------------------------------------------------------------
+    
     /** Returns the level of a players effect
      *
      * @param p a player
@@ -143,7 +205,7 @@ public class EffectUtils extends Module
         spawnParticle(p.getServerWorld(), EnumParticleTypes.SPELL, (float) p.posX, (float) p.posY + 1, (float) p.posZ, 0.5f, 0.5f, 0.5f, 1, 10 + level, new int[0]);
     }
     
-    public static <T> void playEffectCircleWithData(WorldServer w, Vec3d v, EnumParticleTypes particle, double radius, int counter)
+    public static <T> void playEffectCircleWithData(WorldServer w, Vec3d v, EnumParticleTypes particle, double radius, int counter, int... data)
     {
         double x = v.xCoord;
         float y = (float) v.yCoord;
@@ -151,10 +213,15 @@ public class EffectUtils extends Module
         double angle = 2 * Math.PI / counter;
         for(int i = 0; i < counter; i++)
         {
-            spawnParticle(w, particle, (float) (x + Math.cos(i * angle) * radius), y, (float) (z + Math.sin(i * angle) * radius), 1);
+            spawnParticle(w, particle, (float) (x + Math.cos(i * angle) * radius), y, (float) (z + Math.sin(i * angle) * radius), 0, 0, 0, 1, 1, data);
         }                
     }
     
+    public static <T> void playEffectCircle(WorldServer w, Vec3d v, EnumParticleTypes particle, double radius, int counter)
+    {
+        playEffectCircleWithData(w, v, particle, radius, counter, new int[0]);              
+    }
+    
     // -----------------------------------------------------------------------------------
     // Sounds
     // -----------------------------------------------------------------------------------
@@ -169,6 +236,11 @@ public class EffectUtils extends Module
     {
         playSound(p.getServerWorld(), se, sc, p.posX, p.posY, p.posZ);
     }
+    
+    public static void playSound(EntityPlayerMP p, SoundEvent se)
+    {
+        playSound(p.getServerWorld(), se, SoundCategory.PLAYERS, p.posX, p.posY, p.posZ);
+    }
 
     // -----------------------------------------------------------------------------------
     // Potions
@@ -183,22 +255,107 @@ public class EffectUtils extends Module
         ent.addPotionEffect(new PotionEffect(potion, duration, amplifier));
     }
     
-    public static void spawnPotionCloud(Vec3d v, EntityPlayerMP p, PotionType potion, int duration, float radius)
+    public static void spawnPotionCloud(Vec3d v, EntityPlayerMP p, Potion potion, int pduration, int amplifier, int duration, float radius)
     {
         EntityAreaEffectCloud cloud = new EntityAreaEffectCloud(p.getServerWorld(), v.xCoord, v.yCoord, v.zCoord);
         cloud.setDuration(duration);
         cloud.setRadius(radius);
         cloud.setOwner(p);
         cloud.setWaitTime(5);
-        cloud.setPotion(potion);
+        cloud.setPotion(new PotionType(new PotionEffect(potion, pduration, amplifier)));
         p.getServerWorld().spawnEntity(cloud);
     }
     
-    public static void spawnPotionCloud(Vec3d v, EntityPlayerMP p, PotionType potion, int level)
+    public static void spawnPotionCloud(EntityPlayerMP p, Potion potion, int level)
     {
         BlockPos pos = getPlayerTarget(p, level);
-        spawnPotionCloud(new Vec3d(pos.getX(), pos.getY(), pos.getZ()), p, potion, 40 * level, 0.5f + level / 4f);
+        spawnPotionCloud(new Vec3d(pos.getX(), pos.getY(), pos.getZ()), p, potion, 20 * level, (level / 4), 40 * level, 0.5f + level / 4f);
         playSpell(p, level);
         playSound(p, SoundEvents.ENTITY_FIREWORK_BLAST, SoundCategory.PLAYERS);
     }
+    
+    // -----------------------------------------------------------------------------------
+    // Projectiles
+    // -----------------------------------------------------------------------------------
+    
+    public static <T> T launchProjectile(EntityPlayer p, Class<? extends T> projectile, double scale, Object data) 
+    {
+        World w = p.world;
+        Entity launch = null;
+
+        if(EntitySnowball.class == projectile) 
+        {
+            launch = new EntitySnowball(w, p);
+            ((EntitySnowball) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
+        } 
+        else if(EntityEgg.class == projectile)
+        {
+            launch = new EntityEgg(w, p);
+            ((EntityEgg) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
+        } 
+        else if(EntityEnderPearl.class == projectile) 
+        {
+            launch = new EntityEnderPearl(w, p);
+            ((EntityEnderPearl) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, 0.0f, 1.5f, 1.0f);
+        } 
+        else if(EntityPotion.class == projectile) 
+        {
+            launch = new EntityPotion(w, p, (ItemStack) data);
+            ((EntityPotion) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, -20.0f, 0.5f, 1.0f);
+        } 
+        else if(EntityExpBottle.class == projectile) 
+        {
+            launch = new EntityExpBottle(w, p);
+            ((EntityExpBottle) launch).setHeadingFromThrower(p, p.rotationPitch, p.rotationYaw, -20.0f, 0.7f, 1.0f);
+        } 
+        else if(EntityArrow.class.isAssignableFrom(projectile)) 
+        {
+            if(EntityTippedArrow.class == projectile) 
+            {
+                launch = new EntityTippedArrow(w, p);
+                ((EntityTippedArrow) launch).setPotionEffect((ItemStack) data);
+            } 
+            else if(EntitySpectralArrow.class == projectile) 
+            {
+                launch = new EntitySpectralArrow(w, p);
+            } 
+            else 
+            {
+                launch = new EntityTippedArrow(w, p);
+            }
+            ((EntityArrow) launch).setAim(p, p.rotationPitch, p.rotationYaw, 0.0F, 3.0F, 1.0F);
+        } 
+        else if(EntityFireball.class.isAssignableFrom(projectile)) 
+        {
+            Vec3d v = p.getLookVec().scale(10);
+            if (EntitySmallFireball.class == projectile) 
+            {
+                launch = new EntitySmallFireball(w, p, v.xCoord, v.yCoord, v.zCoord);
+            } 
+            else if (EntityWitherSkull.class == projectile) 
+            {
+                launch = new EntityWitherSkull(w, p, v.xCoord, v.yCoord, v.zCoord);
+            } 
+            else if (EntityDragonFireball.class == projectile) 
+            {
+                launch = new EntityDragonFireball(w, p, v.xCoord, v.yCoord, v.zCoord);
+            } 
+            else 
+            {
+                launch = new EntityLargeFireball(w, p, v.xCoord, v.yCoord, v.zCoord);
+            }
+        } 
+
+        Utils.scaleVelocity(launch, scale);
+        w.spawnEntity(launch);
+        return (T) launch;
+    }
+    
+    public static EntityTippedArrow launchTippedArrow(EntityPlayer p, double scale, Potion potion, int duration, int amplifier) 
+    {
+        ItemStack stack = new ItemStack(Items.TIPPED_ARROW);
+        PotionUtils.addPotionToItemStack(stack, new PotionType(new PotionEffect(potion, duration, amplifier)));
+        EntityTippedArrow arrow = launchProjectile(p, EntityTippedArrow.class, scale, stack);
+        return arrow;
+    }
 }

src/main/java/me/km/effects/active/ArcaneShot.java

@@ -0,0 +1,26 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+
+public class ArcaneShot extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityArrow arrow = EffectUtils.launchProjectile(p, EntityArrow.class, power / 4f, null);
+        arrow.setDamage(0.1);
+        arrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+        KajetansMod.effects.addEntityData(p, "arcaneshot");
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/BlindingShot.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityTippedArrow;
+import net.minecraft.init.MobEffects;
+
+public class BlindingShot extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityTippedArrow arrow = EffectUtils.launchTippedArrow(p, power / 2d, MobEffects.BLINDNESS, power * 600, 0);
+        arrow.setDamage(0.1);
+        arrow.pickupStatus = EntityTippedArrow.PickupStatus.DISALLOWED;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 2 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/BunnyHop.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class BunnyHop extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.JUMP_BOOST, 300, power * 2);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 7 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/CallBack.java

@@ -0,0 +1,33 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.playerbank.PlayerData;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class CallBack extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        PlayerData data = KajetansMod.playerbank.getData(p);
+        if(data.hasData("callback"))
+        {
+            p.fallDistance = 0;
+            Utils.teleportEntity(p, data.getData("callback", Location.class));
+            data.removeData("callback");
+            return true;
+        }
+        Location l = new Location(p);
+        data.addGoodTimedData("callback", l, 100 * power, "R: §r" + ((int) p.posX) + "§7:§r" + ((int) p.posY) + "§7:§r" + ((int) p.posZ), 51);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/ClusterBomb.java

@@ -0,0 +1,26 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+
+public class ClusterBomb extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityArrow arrow = EffectUtils.launchProjectile(p, EntityArrow.class, power / 4f, null);
+        arrow.setDamage(0.1);
+        arrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+        KajetansMod.effects.addEntityData(p, "clusterbomb", power);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Day.java

@@ -0,0 +1,20 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Day extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.world.setWorldTime(0);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 20;
+    }
+}

src/main/java/me/km/effects/active/Doomed.java

@@ -0,0 +1,47 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.math.Vec3d;
+
+public class Doomed extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityPlayer p2 = Utils.getTargetedEntity(p, 8, EntityPlayer.class);
+        if(p2 == null)
+        {
+            return false;
+        }
+        
+        Vec3d v1 = p2.getPositionVector();
+        Vec3d v2 = p.getPositionVector();
+        
+        Utils.setVelocity(p, (v1.xCoord - v2.xCoord) * 0.2, (v1.yCoord - v2.yCoord) * 0.2 + 0.9, (v1.zCoord - v2.zCoord) * 0.2);
+
+         KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            Vec3d v3 = p2.getPositionVector();
+            Vec3d v4 = p.getPositionVector();
+            Utils.setVelocity(p, (v3.xCoord - v4.xCoord) * 0.2, (v3.yCoord - v4.yCoord) * 0.2, (v3.zCoord - v4.zCoord) * 0.2);
+        }, 12);
+        int duration = 20 * power;
+        KajetansMod.playerbank.getData(p2).addBadTimedData("doomed", p, duration, "Todgeweiht", 52);
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            p2.attackEntityFrom(DamageSource.causeMobDamage(p), power);
+        }, duration);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Earthquake.java

@@ -0,0 +1,37 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EnumParticleTypes;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.WorldServer;
+
+public class Earthquake extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int[] data = new int[]{4};
+        WorldServer w = p.getServerWorld();
+        Vec3d v = p.getPositionVector();
+        EffectUtils.playEffectCircleWithData(w, v, EnumParticleTypes.BLOCK_CRACK, 5, 12, data);
+        EffectUtils.playEffectCircleWithData(w, v, EnumParticleTypes.BLOCK_CRACK, 4, 12, data);
+        EffectUtils.playEffectCircleWithData(w, v, EnumParticleTypes.BLOCK_CRACK, 3, 12, data);
+        EffectUtils.playEffectCircleWithData(w, v, EnumParticleTypes.BLOCK_CRACK, 2, 12, data);
+        EffectUtils.playEffectCircleWithData(w, v, EnumParticleTypes.BLOCK_CRACK, 1, 12, data);
+        DamageSource ds = DamageSource.causeMobDamage(p);
+        EffectUtils.getEntsOfNotGuild(p, 5).stream().forEach((m) -> 
+        {
+            m.attackEntityFrom(ds, power * 4);                           
+        });
+        return true;
+    } 
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 8 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Elevation.java

@@ -0,0 +1,38 @@
+package me.km.effects.active;
+
+import java.util.Collection;
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.util.EnumParticleTypes;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+
+public class Elevation extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        BlockPos target = EffectUtils.getPlayerTarget(p, power);    
+        Vec3d v = new Vec3d(target.getX(), target.getY(), target.getZ());
+        EffectUtils.playSound(p, SoundEvents.ENTITY_FIREWORK_TWINKLE_FAR);
+        EffectUtils.playSpell(p, power); 
+        Collection<EntityLivingBase> list = EffectUtils.getEntsOfNotGuild(p, p.world, v, 3);
+        EffectUtils.playEffectCircle(p.getServerWorld(), v, EnumParticleTypes.SPELL, 3, 30);
+        double shootPower = 1 + power / 20d;
+        list.stream().forEach((en) -> 
+        {
+            Utils.setVelocity(en, 0, shootPower, 0);
+        });
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/ElvishHorn.java

@@ -0,0 +1,36 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.util.EnumParticleTypes;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.WorldServer;
+
+public class ElvishHorn extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int time = 600 * power;
+        EffectUtils.playSound(p, SoundEvents.ENTITY_GHAST_SCREAM);
+        WorldServer w = p.getServerWorld();
+        Vec3d v = p.getPositionVector();
+        for(int i = 1; i <= power + 2; i++)
+        {
+            EffectUtils.playEffectCircle(w, v, EnumParticleTypes.NOTE, i, 6 * i);
+        }
+        EffectUtils.getPlayersOfGuild(p, power + 2).forEach(pl -> 
+        {
+        });
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Enderchest.java

@@ -0,0 +1,20 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Enderchest extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.displayGUIChest(p.getInventoryEnderChest());
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10;
+    }
+}

src/main/java/me/km/effects/active/Explosion.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.WorldServer;
+
+public class Explosion extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        BlockPos target = EffectUtils.getPlayerTarget(p, power);
+        WorldServer w = p.getServerWorld();
+        w.createExplosion(null, target.getX(), target.getY(), target.getZ(), power / 4f, true);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 12 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/FallImmunity.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class FallImmunity extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!KajetansMod.playerbank.getData(p).hasData("fallimmunity"))
+        {
+            KajetansMod.playerbank.getData(p).addGoodTimedData("fallimmunity", 0, 40 * power, "Fallschaden", 53);
+            return true;
+        }
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Fire.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Fire extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int time = power * 100;
+        EffectUtils.getEntsOfNotGuild(p, 1 + power * 2).stream().forEach((m) -> 
+        {
+            m.setFire(time);
+        });
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/FireShot.java

@@ -0,0 +1,24 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+
+public class FireShot extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityArrow arrow = EffectUtils.launchProjectile(p, EntityArrow.class, power / 4f, null);
+        arrow.setFire(Integer.MAX_VALUE);
+        arrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 2 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Fireball.java

@@ -0,0 +1,23 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityLargeFireball;
+
+public class Fireball extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityLargeFireball fireball = EffectUtils.launchProjectile(p, EntityLargeFireball.class, 1, p);
+        fireball.explosionPower = power / 2;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 8 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Flying.java

@@ -0,0 +1,27 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.util.math.Vec3d;
+
+public class Flying extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.playSound(p, SoundEvents.ENTITY_FIREWORK_LAUNCH);
+        EffectUtils.playSpell(p, power);
+        Vec3d v = p.getLookVec().scale(1 + (power / 20f));
+        Utils.setVelocity(p, v.xCoord, v.yCoord, v.zCoord);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Freeze.java

@@ -0,0 +1,27 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Freeze extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int time = power * 200;
+        EffectUtils.getEntsOfNotGuild(p, 1 + power * 2).stream().forEach((m) -> 
+        {
+            EffectUtils.addPotionTo(m, MobEffects.SLOWNESS, time, 200);
+            EffectUtils.addPotionTo(m, MobEffects.WEAKNESS, time, 200);
+        });
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 6 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/GrapplingHook.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class GrapplingHook extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!KajetansMod.playerbank.getData(p).hasData("grapplinghook"))
+        {
+            KajetansMod.playerbank.getData(p).addGoodData("grapplinghook", 0, "Pfeilhaken", 54);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Gravity.java

@@ -0,0 +1,37 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.playerbank.PlayerData;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Gravity extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        PlayerData data = KajetansMod.playerbank.getData(p);
+        Integer id = data.getData("gravity", Integer.class);
+        if(id != null)
+        {
+            KajetansMod.scheduler.cancelTask(id);
+            p.setNoGravity(false);
+            data.removeData("gravity");
+            return true;
+        }
+        power *= 100;
+        p.setNoGravity(true);
+        int cancel = KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            p.setNoGravity(false);
+        }, power);
+        data.addGoodTimedData("gravity", cancel, power, "Schwerelos", 59);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Harm.java

@@ -0,0 +1,22 @@
+ package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Harm extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.spawnPotionCloud(p, MobEffects.INSTANT_DAMAGE, power);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Harvest.java

@@ -0,0 +1,48 @@
+ package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.block.BlockCrops;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class Harvest extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int radius = 1 + 2 * power;
+        World w = p.world;
+        BlockPos pos = p.getPosition();
+        BlockPos pos2;
+        IBlockState b;
+        for(int x = -radius; x <= radius; x++)
+        {
+            for(int y = -radius; y <= radius; y++)
+            {
+                for(int z = -radius; z <= radius; z++)
+                {
+                    pos2 = pos.add(x, y, z);
+                    b = w.getBlockState(pos2);
+                    if(b.getBlock() instanceof BlockCrops && b.getValue(BlockCrops.AGE) == 7)
+                    {
+                        b.getBlock().dropBlockAsItem(w, pos2, b, 0);
+                        w.setBlockState(pos2, b.withProperty(BlockCrops.AGE, 0));               
+                    }      
+                }
+            }
+        }
+        KajetansMod.effects.send(p, "Die Pflanzen in deiner Umgebung wurden geerntet!");
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Heal.java

@@ -0,0 +1,20 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Heal extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.heal(power);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/HealRain.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class HealRain extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.spawnPotionCloud(p, MobEffects.INSTANT_HEALTH, power);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/HeartSeeker.java

@@ -0,0 +1,33 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.DamageSource;
+
+public class HeartSeeker extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityLivingBase liv = Utils.getTargetedEntity(p, 4, EntityLivingBase.class);
+        if(liv == null)
+        {
+            return false;
+        }
+        int damage = power;
+        if(liv.getHealth() <= liv.getMaxHealth() / 2)
+        {
+            damage *= 2;
+        }
+        liv.attackEntityFrom(DamageSource.causeMobDamage(p), damage);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Hearts.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.EffectUtils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Hearts extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.HEALTH_BOOST, 6000, power - 1);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Immortality.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Immortality extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.RESISTANCE, power * 100, 4);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Invisibility.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Invisibility extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.INVISIBILITY, 200 + 200 * power, 0);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Jump.java

@@ -0,0 +1,31 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.Vec3d;
+
+public class Jump extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!p.onGround)
+        {
+            return false;
+        }
+        Vec3d v = p.getLookVec();
+        double groundLength = Math.sqrt(v.xCoord * v.xCoord + v.zCoord * v.zCoord);
+        Vec3d goal = new Vec3d(v.xCoord, groundLength * 1.732050807568877, v.zCoord); // 60° shot
+        goal = goal.normalize();
+        goal = goal.scale(Math.sqrt((power + 0.85d) / 0.26) / 4);
+        Utils.setVelocity(p, goal.xCoord, goal.yCoord, goal.zCoord);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 2 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Kick.java

@@ -0,0 +1,32 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraft.potion.PotionEffect;
+import net.minecraft.util.math.Vec3d;
+
+public class Kick extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityLivingBase liv = Utils.getTargetedEntity(p, 4, EntityLivingBase.class);
+        if(liv == null)
+        {
+            return false;
+        }
+        Vec3d v = liv.getPositionVector().subtract(p.getPositionVector()).normalize().scale(2).addVector(0, 0.4, 0);
+        Utils.setVelocity(liv, v.xCoord, v.yCoord, v.zCoord);
+        liv.addPotionEffect(new PotionEffect(MobEffects.NAUSEA, 120, 10));
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/LeafCocoon.java

@@ -0,0 +1,92 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectBlockChanger;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.MobEffects;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.WorldServer;
+
+public class LeafCocoon extends ActiveEffectBase
+{
+    @Override
+    public int getCoolDown() 
+    {
+        return 100;
+    }
+    
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.RESISTANCE, power * 60, 4);
+        EffectUtils.addPotionTo(p, MobEffects.REGENERATION, power * 20, 4);
+        
+        WorldServer w = p.getServerWorld();
+        EffectBlockChanger list = new EffectBlockChanger(w);
+        BlockPos l = p.getPosition();
+        
+        // Ebene 1
+        list.addBlock(l.add(0, 0, -3), Blocks.LEAVES);
+        list.addBlock(l.add(1, 0, -2), Blocks.LEAVES);
+        list.addBlock(l.add(0, 0, -2), Blocks.LOG, 9);
+        list.addBlock(l.add(-1, 0, -2), Blocks.LEAVES);
+        list.addBlock(l.add(-2, 0, -2), Blocks.SPRUCE_FENCE);
+        list.addBlock(l.add(2, 0, -1), Blocks.SPRUCE_FENCE);
+        list.addBlock(l.add(1, 0, -1), Blocks.LEAVES);
+        list.addBlock(l.add(0, 0, -1), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 0, -1), Blocks.LEAVES);
+        list.addBlock(l.add(-2, 0, -1), Blocks.LEAVES);
+        list.addBlock(l.add(2, 0, 0), Blocks.LEAVES);
+        list.addBlock(l.add(1, 0, 0), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 0, 0), Blocks.LEAVES);
+        list.addBlock(l.add(-2, 0, 0), Blocks.LEAVES);
+        list.addBlock(l.add(2, 0, 1), Blocks.LEAVES);
+        list.addBlock(l.add(1, 0, 1), Blocks.LEAVES);
+        list.addBlock(l.add(0, 0, 1), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 0, 1), Blocks.LEAVES);
+        list.addBlock(l.add(3, 0, 2), Blocks.OAK_FENCE);
+        list.addBlock(l.add(2, 0, 2), Blocks.LOG, 9);
+        list.addBlock(l.add(1, 0, 2), Blocks.LEAVES);
+        list.addBlock(l.add(0, 0, 2), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 0, 2), Blocks.OAK_FENCE);
+        list.addBlock(l.add(1, 0, 3), Blocks.LEAVES);
+        
+        // Ebene 2
+        list.addBlock(l.add(0, 1, -2), Blocks.LOG, 1);
+        list.addBlock(l.add(1, 1, -1), Blocks.LEAVES);
+        list.addBlock(l.add(0, 1, -1), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 1, -1), Blocks.LEAVES);
+        list.addBlock(l.add(2, 1, 0), Blocks.LOG, 1);
+        list.addBlock(l.add(1, 1, 0), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 1, 0), Blocks.LEAVES);
+        list.addBlock(l.add(-2, 1, 0), Blocks.LOG, 1);
+        list.addBlock(l.add(1, 1, 1), Blocks.LEAVES);
+        list.addBlock(l.add(0, 1, 1), Blocks.LEAVES);
+        list.addBlock(l.add(0, 1, 2), Blocks.OAK_FENCE);
+        
+        // Ebene 3
+        list.addBlock(l.add(0, 2, -1), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 2, -1), Blocks.LOG, 1);
+        list.addBlock(l.add(1, 2, 0), Blocks.LEAVES);
+        list.addBlock(l.add(0, 2, 0), Blocks.LEAVES);
+        list.addBlock(l.add(-1, 2, 0), Blocks.LEAVES);
+        list.addBlock(l.add(1, 2, 1), Blocks.OAK_FENCE);
+        list.addBlock(l.add(0, 2, 1), Blocks.LOG, 1);
+        
+        // Ebene 4
+        list.addBlock(l.add(0, 3, 1), Blocks.SPRUCE_FENCE);
+        list.addBlock(l.add(0, 3, 0), Blocks.LEAVES);
+        list.addBlock(l.add(0, 3, -1), Blocks.OAK_FENCE);
+        
+        list.run(160);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 15 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/LockPick.java

@@ -0,0 +1,21 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.text.TextComponentString;
+
+public class LockPick extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.sendMessage(new TextComponentString("LockPick"));
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Lucky.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraft.potion.PotionEffect;
+
+public class Lucky extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.addPotionEffect(new PotionEffect(MobEffects.LUCK, 200 + 200 * power, 9));
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Musket.java

@@ -0,0 +1,29 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.SoundEvents;
+
+public class Musket extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {  
+        EffectUtils.playSound(p, SoundEvents.ENTITY_FIREWORK_BLAST);
+        double spread = 0.2d - power * 0.01d;
+        if(spread < 0)
+        {
+            spread = 0;
+        }
+        // TODO
+        //Utils.shootItem(p, new ItemStack(Material.STONE_BUTTON), 2.5d, power * 2, 0.5d, 0.5d, 0.5d, spread);
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/NailDown.java

@@ -0,0 +1,32 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraft.init.SoundEvents;
+
+public class NailDown extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityLivingBase liv = Utils.getTargetedEntity(p, 4, EntityLivingBase.class);
+        if(liv == null)
+        {
+            return false;
+        }
+        EffectUtils.addPotionTo(liv, MobEffects.SLOWNESS, 20 * power, 50);
+        EffectUtils.addPotionTo(liv, MobEffects.JUMP_BOOST, 30 * power, 128);
+        EffectUtils.playSound(p, SoundEvents.BLOCK_ANVIL_PLACE);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/NailTrap.java

@@ -0,0 +1,24 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.passive.TrapEffects;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class NailTrap extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        KajetansMod.effects.getEvent(TrapEffects.class).addNailTraps(Location.rounded(p), KajetansMod.playerbank.getGuildId(p));
+        KajetansMod.skills.send(p, "Du hast 9 Trittnagelfallen platziert.");
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/NetTrap.java

@@ -0,0 +1,24 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.passive.TrapEffects;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class NetTrap extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        KajetansMod.effects.getEvent(TrapEffects.class).addNetTrap(Location.rounded(p), KajetansMod.playerbank.getGuildId(p));
+        KajetansMod.skills.send(p, "Du hast eine Netzfalle platziert.");
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10 + manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Night.java

@@ -0,0 +1,20 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Night extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.world.setWorldTime(14000);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 20;
+    }
+}

src/main/java/me/km/effects/active/Poison.java

@@ -0,0 +1,22 @@
+ package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Poison extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.spawnPotionCloud(p, MobEffects.POISON, power);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 6 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/PoisonVolley.java

@@ -0,0 +1,35 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityTippedArrow;
+import net.minecraft.init.MobEffects;
+
+public class PoisonVolley extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        shoot(p, power);
+        for(int i = 1; i <= 5; i++)
+        {
+            KajetansMod.scheduler.scheduleTask(() -> shoot(p, power), 10 * i);
+        }
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+    
+    private void shoot(EntityPlayerMP p, int power)
+    {
+        EntityTippedArrow arrow = EffectUtils.launchTippedArrow(p, power / 2d, MobEffects.POISON, power * 60, 1);
+        arrow.setDamage(0.1);
+        arrow.pickupStatus = EntityTippedArrow.PickupStatus.DISALLOWED;
+    }
+}

src/main/java/me/km/effects/active/PoisonedBlade.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class PoisonedBlade extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!KajetansMod.playerbank.getData(p).hasData("poisonedblade"))
+        {
+            KajetansMod.playerbank.getData(p).addGoodTimedData("poisonedblade", 0, 60 * power, "Gift", 55);
+            return true;
+        }
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Power.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Power extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.STRENGTH, 1800, power - 1);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/PowerAttack.java

@@ -0,0 +1,26 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class PowerAttack extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!KajetansMod.playerbank.getData(p).hasData("powerattack"))
+        {
+            double d = power / 20d;
+            KajetansMod.playerbank.getData(p).addGoodData("powerattack", d + 1, " + " + (d * 100) + "% Schaden", 56);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Pull.java

@@ -0,0 +1,28 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.Vec3d;
+
+public class Pull extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        Vec3d v = p.getPositionVector();
+        EffectUtils.getEntsOfNotGuild(p, power + 2).stream().forEach(ent -> 
+        {
+            Vec3d v2 = v.subtract(ent.getPositionVector()).normalize();
+            Utils.setVelocity(ent, v2.xCoord, v2.yCoord, v2.zCoord);
+        });
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Push.java

@@ -0,0 +1,28 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.Vec3d;
+
+public class Push extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        Vec3d v = p.getPositionVector();
+        EffectUtils.getEntsOfNotGuild(p, power + 2).stream().forEach(ent -> 
+        {
+            Vec3d v2 = ent.getPositionVector().subtract(v).normalize();
+            Utils.setVelocity(ent, v2.xCoord, v2.yCoord, v2.zCoord);
+        });
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/QuickShot.java

@@ -0,0 +1,23 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+
+public class QuickShot extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityArrow arrow = EffectUtils.launchProjectile(p, EntityArrow.class, power / 4f, null);
+        arrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Rain.java

@@ -0,0 +1,23 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.world.storage.WorldInfo;
+
+public class Rain extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        WorldInfo worldinfo = p.world.getWorldInfo();
+        worldinfo.setRaining(true);
+        worldinfo.setRainTime(10000);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 15;
+    }
+}

src/main/java/me/km/effects/active/RapidFire.java

@@ -0,0 +1,34 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+
+public class RapidFire extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        shoot(p, power);
+        for(int i = 1; i <= 10; i++)
+        {
+            KajetansMod.scheduler.scheduleTask(() -> shoot(p, power), 10 * i);
+        }
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+    
+    private void shoot(EntityPlayerMP p, int power)
+    {
+        EntityArrow arrow = EffectUtils.launchProjectile(p, EntityArrow.class, power / 4f, p);
+        KajetansMod.effects.addEntityData(p, "rapidfire");
+        arrow.pickupStatus = EntityArrow.PickupStatus.DISALLOWED;
+    }
+}

src/main/java/me/km/effects/active/Rooting.java

@@ -0,0 +1,27 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityTippedArrow;
+import net.minecraft.init.MobEffects;
+import net.minecraft.potion.PotionEffect;
+
+public class Rooting extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityTippedArrow arrow = EffectUtils.launchTippedArrow(p, power / 2f, MobEffects.SLOWNESS, power * 30, 50);
+        arrow.setDamage(0.1);
+        arrow.addEffect(new PotionEffect(MobEffects.JUMP_BOOST, power * 30, 128));
+        arrow.pickupStatus = EntityTippedArrow.PickupStatus.DISALLOWED;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 2 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Shadow.java

@@ -0,0 +1,27 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Shadow extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int duration = power * 80;
+        p.setInvisible(true);
+        KajetansMod.playerbank.getData(p).addGoodTimedData("shadow", 0, duration, "Schatten", 57);
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            p.setInvisible(false);
+        }, duration);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/ShadowHit.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class ShadowHit extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        if(!KajetansMod.playerbank.getData(p).hasData("shadowhit"))
+        {
+            KajetansMod.playerbank.getData(p).addGoodData("shadowhit", 0, "Schattenhieb", 58);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/ShadowStep.java

@@ -0,0 +1,36 @@
+package me.km.effects.active;
+
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class ShadowStep extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int radius;
+        if(p.isInvisible())
+        {
+            radius = (power + 2) * 2;
+        }
+        else
+        {
+            radius = power + 2;
+        }
+        EntityLivingBase liv = Utils.getTargetedEntity(p, radius, EntityLivingBase.class);
+        if(liv == null)
+        {
+            return false;
+        }
+        Utils.teleportEntity(p, liv);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Silence.java

@@ -0,0 +1,28 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Utils;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Silence extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityPlayer affectedPlayer = Utils.getTargetedEntity(p, 4, EntityPlayer.class);
+        if(affectedPlayer == null)
+        {
+            return false;
+        }
+        KajetansMod.playerbank.getData(affectedPlayer).addBadTimedData("silence", 0, 60 * power, "Silence", 50);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 4 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/SlowingShot.java

@@ -0,0 +1,25 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityTippedArrow;
+import net.minecraft.init.MobEffects;
+
+public class SlowingShot extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntityTippedArrow arrow = EffectUtils.launchTippedArrow(p, power / 2d, MobEffects.SLOWNESS, power * 100, 3);
+        arrow.setDamage(0.1);
+        arrow.pickupStatus = EntityTippedArrow.PickupStatus.DISALLOWED;
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 2 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/SmokeBomb.java

@@ -0,0 +1,24 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntitySnowball;
+
+public class SmokeBomb extends ActiveEffectBase
+{  
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EntitySnowball ball = EffectUtils.launchProjectile(p, EntitySnowball.class, power / 4f, p);
+        KajetansMod.effects.addEntityData(p, "smokebomb");
+        return false;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/Sprint.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+
+public class Sprint extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.addPotionTo(p, MobEffects.SLOWNESS, 600 * power, 1);
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Stone.java

@@ -0,0 +1,29 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.SoundEvents;
+
+public class Stone extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        EffectUtils.playSound(p, SoundEvents.ENTITY_ARROW_SHOOT, null);
+        double spread = 0.3d - power * 0.015d;
+        if(spread < 0)
+        {
+            spread = 0;
+        }
+        // TODO
+        //Utils.shootItem(p, new ItemStack(Material.COBBLESTONE), 0.9d, power * 2, 0.2d, 0.5d, 0.2d, spread);
+        return true;
+    }
+    
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Sun.java

@@ -0,0 +1,20 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Sun extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.world.getWorldInfo().setRaining(false);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 15;
+    }
+}

src/main/java/me/km/effects/active/TeleportBlock.java

@@ -0,0 +1,42 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.passive.BlockClickEffects;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.WorldServer;
+
+public class TeleportBlock extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        WorldServer w = p.getServerWorld();
+        BlockPos b = p.getPosition();
+        for(int x = -1; x <= 1; x++)
+        {
+            for(int y = -1; y <= 1; y++)
+            {
+                if(x == 0 && y == 0)
+                {
+                    continue;
+                }
+                if(w.isAirBlock(b.add(x, 0, y)))
+                {
+                    KajetansMod.effects.getEvent(BlockClickEffects.class).registerTeleportBlock(new Location(w, b.add(x, 0, y)), p, 60 * power);
+                    return true;
+                }
+            }
+        }
+        KajetansMod.skills.send(p, "Es wurde kein freier Platz gefunden.");
+        return false;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 1;
+    }
+}

src/main/java/me/km/effects/active/TeleportPlayer.java

@@ -0,0 +1,31 @@
+package me.km.effects.active;
+
+import java.util.List;
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import me.km.inventory.TeleportContainer;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class TeleportPlayer extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        List<EntityPlayer> players = p.world.playerEntities;  
+        if(players.size() <= 1)
+        {
+            KajetansMod.skills.send(p, "Es ist kein anderer Spieler in deiner Welt.");
+            return false;
+        } 
+        TeleportContainer inv = new TeleportContainer(p, players);
+        inv.openForPlayer(p);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 20;
+    }
+}

src/main/java/me/km/effects/active/Thor.java

@@ -0,0 +1,26 @@
+package me.km.effects.active;
+
+import net.minecraft.entity.effect.EntityLightningBolt;
+import net.minecraft.world.WorldServer;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.BlockPos;
+
+public class Thor extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        BlockPos pos = EffectUtils.getPlayerTarget(p, power);
+        WorldServer w = p.getServerWorld();
+        w.addWeatherEffect(new EntityLightningBolt(w, pos.getX(), pos.getY(), pos.getZ(), false));
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 20 + manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Unlucky.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraft.potion.PotionEffect;
+
+public class Unlucky extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        p.addPotionEffect(new PotionEffect(MobEffects.UNLUCK, 200 + 200 * power, 9));
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 3 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/VineTrap.java

@@ -0,0 +1,49 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Utils;
+import me.km.effects.EffectBlockChanger;
+import me.km.effects.ActiveEffectBase;
+import me.km.effects.passive.TrapEffects;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+public class VineTrap extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        int i = KajetansMod.playerbank.getGuildId(p);
+        
+        TrapEffects e = KajetansMod.effects.getEvent(TrapEffects.class);
+        BlockPos l = Utils.getPlayerTarget(p, power + 7).add(0, 1, 0);
+        
+        World w = p.world;
+        EffectBlockChanger list = new EffectBlockChanger(w);
+        list.addBlock(l, Blocks.LOG, 1);
+        list.addBlock(l.add(1, 0, 0), Blocks.VINE, 4);
+        list.addBlock(l.add(-1, 0, 0), Blocks.VINE, 1);
+        list.addBlock(l.add(0, 0, 1), Blocks.VINE, 8);
+        list.addBlock(l.add(0, 0, -1), Blocks.VINE, 2);
+        
+        list.forEachLocation(lo -> e.addVineTrap(lo, i));
+        list.run(160);
+        KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            list.forEachLocation(lo -> 
+            {
+                e.removeVineTrap(lo);
+            });
+        }, 160);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 5 * manaFactor;
+    }
+}

src/main/java/me/km/effects/active/Workbench.java

@@ -0,0 +1,22 @@
+package me.km.effects.active;
+
+import me.km.KajetansMod;
+import me.km.effects.ActiveEffectBase;
+import net.minecraft.block.BlockWorkbench;
+import net.minecraft.entity.player.EntityPlayerMP;
+
+public class Workbench extends ActiveEffectBase
+{
+    @Override
+    protected boolean executeEffect(EntityPlayerMP p, int power) 
+    {
+        KajetansMod.scheduler.scheduleTask(() -> p.displayGui(new BlockWorkbench.InterfaceCraftingTable(p.world, p.getPosition())), 0);
+        return true;
+    }
+
+    @Override
+    protected int getManaCost(int manaFactor) 
+    {
+        return 10;
+    }
+}

src/main/java/me/km/effects/passive/Anvil.java

@@ -0,0 +1,33 @@
+package me.km.effects.passive;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+import me.km.effects.Effect;
+import me.km.effects.EffectUtils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.ContainerRepair;
+import net.minecraftforge.event.entity.player.PlayerContainerEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class Anvil extends ModuleListener
+{
+    public Anvil(Module m)
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent
+    public void inAnvilMenuClick(PlayerContainerEvent.Open e)
+    { 
+        if(e.getContainer() instanceof ContainerRepair)
+        {
+            EntityPlayer p = e.getEntityPlayer();
+            if(KajetansMod.worldManager.getWorldPreferences(p.world).skills &&
+                EffectUtils.getEffectLevel(p, Effect.SMITH) < 1)
+            {
+                p.closeScreen();
+            }
+        }
+    }
+}

src/main/java/me/km/effects/passive/ArrowEffects.java

@@ -0,0 +1,166 @@
+package me.km.effects.passive;
+
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+import me.km.api.Utils;
+import me.km.effects.Effect;
+import me.km.effects.EffectBlockChanger;
+import me.km.effects.EffectUtils;
+import me.km.events.ArrowHitGroundEvent;
+import me.km.events.ArrowLaunchEvent;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.entity.projectile.EntitySnowball;
+import net.minecraft.entity.projectile.EntityThrowable;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.MobEffects;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.EnumParticleTypes;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.WorldServer;
+import net.minecraftforge.event.entity.ThrowableImpactEvent;
+import net.minecraftforge.event.entity.living.LivingHurtEvent;
+import net.minecraftforge.event.entity.player.ArrowLooseEvent;
+import net.minecraftforge.fml.common.eventhandler.EventPriority;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class ArrowEffects extends ModuleListener
+{
+    public ArrowEffects(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent
+    public void saveArrows(ArrowLooseEvent e)
+    {       
+        if(KajetansMod.worldManager.getWorldPreferences(e.getWorld()).skills &&
+            EffectUtils.getEffectLevel(e.getEntityPlayer(), Effect.ARROW_SAVER) >= Utils.randomInt(1, 5))
+        {
+            e.setCanceled(true);
+        }
+    }
+    
+    @SubscribeEvent
+    public void onArrowLaunch(ArrowLaunchEvent e)
+    {       
+        if(KajetansMod.worldManager.getWorldPreferences(e.getWorld()).skills)
+        {
+            int fast = EffectUtils.getEffectLevel(e.getEntityPlayer(), Effect.FASTER_ARROWS);
+            if(fast >= 1)
+            {           
+                Utils.scaleVelocity(e.getEntityArrow(), (fast / 5f) + 1);
+            }
+        }
+    }
+    
+    @SubscribeEvent(receiveCanceled = false, priority = EventPriority.LOW)
+    public void handleHurtShots(LivingHurtEvent e)
+    {        
+        Entity ent = e.getEntity();
+        if(!KajetansMod.worldManager.getWorldPreferences(ent.world).skills)
+        {
+            return;
+        }
+        EntityPlayer p = Utils.getDamager(e.getSource());
+        if(p != null)
+        {
+            if(KajetansMod.effects.hasEntityData(ent, "arcaneshot") != null)
+            {
+                Utils.teleportEntity(ent, p);
+            }
+            else if(KajetansMod.effects.hasEntityData(ent, "rapidfire") != null)
+            {
+                p.heal(2);
+            }
+        }
+    }
+    
+    private void runArrowEffects(EntityArrow arrow)
+    {
+        EntityPlayer player = Utils.getPlayerFromProjectile(arrow);
+        if(player == null || !(player instanceof EntityPlayerMP))
+        {
+            return;
+        }
+        EntityPlayerMP p = (EntityPlayerMP) player;
+        WorldServer w = p.getServerWorld();
+        Integer fromList = (Integer) KajetansMod.effects.hasEntityData(p, "clusterbomb");
+        if(fromList != null)
+        {
+            int power = fromList * 600;
+            int damage = fromList * 3;
+            Vec3d v = arrow.getPositionVector();
+            EffectUtils.spawnParticle(w, EnumParticleTypes.EXPLOSION_LARGE, v, 1);
+            EffectUtils.playEffectCircle(w, v, EnumParticleTypes.EXPLOSION_LARGE, 3, 9);
+            DamageSource ds = DamageSource.causeMobDamage(p);
+            EffectUtils.getEntsOfNotGuild(p, w, v, 4).forEach(e -> 
+            {
+                e.attackEntityFrom(ds, damage);
+                EffectUtils.addPotionTo(e, MobEffects.BLINDNESS, power, 0);
+            });
+            arrow.setDead();
+        }
+        else if(KajetansMod.effects.hasEntityData(p, "grapplinghook") != null)
+        {
+            EffectBlockChanger list = new EffectBlockChanger(w);
+            BlockPos pos = arrow.getPosition();
+            for(int x = -1; x <= 1; x++)
+            {
+                for(int y = -1; y <= 1; y++)
+                {
+                    list.addBlock(pos, Blocks.GLASS);
+                }
+            }
+            list.run(600);
+            Utils.teleportEntity(p, new Location(p.world, pos.add(0, 1, 0)));
+        } 
+    }
+    
+    @SubscribeEvent
+    public void handleHitShots(ArrowHitGroundEvent e)
+    {       
+        if(KajetansMod.worldManager.getWorldPreferences(e.getEntityArrow().world).skills)
+        {
+            runArrowEffects(e.getEntityArrow());
+        }
+    }
+    
+    @SubscribeEvent
+    public void handleHitShots(LivingHurtEvent e)
+    {       
+        Entity ent = e.getSource().getSourceOfDamage();
+        if(ent != null && ent instanceof EntityArrow && KajetansMod.worldManager.getWorldPreferences(ent.world).skills)
+        {
+            runArrowEffects((EntityArrow) ent);
+        }
+        
+    }
+    
+    @SubscribeEvent
+    public void handleSmokeBomb(ThrowableImpactEvent e)
+    {       
+        EntityThrowable pro = e.getEntityThrowable();
+        if(pro instanceof EntitySnowball || !(pro.getThrower() instanceof EntityPlayerMP) ||
+            KajetansMod.effects.hasEntityData(pro, "smokebomb") == null || 
+            !KajetansMod.worldManager.getWorldPreferences(pro.world).skills)
+        {
+            return;
+        }
+        EntityPlayerMP p = (EntityPlayerMP) pro.getThrower();
+        if(p == null)
+        {
+            return;
+        }
+        EffectUtils.spawnParticle(p.getServerWorld(), EnumParticleTypes.EXPLOSION_LARGE, pro.getPositionVector(), 1);
+        EffectUtils.getEntsOfNotGuild(p, p.getServerWorld(), pro.getPositionVector(), 3).forEach(ent -> 
+        {
+            EffectUtils.addPotionTo(ent, MobEffects.BLINDNESS, 200, 0);
+        });
+    }
+}

src/main/java/me/km/effects/passive/BlockBreakEffects.java

@@ -0,0 +1,126 @@
+package me.km.effects.passive;
+
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+import me.km.api.Utils;
+import me.km.effects.Effect;
+import me.km.effects.EffectUtils;
+import me.km.utils.ItemStackBuilder;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockCrops;
+import net.minecraft.block.BlockFalling;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.Enchantments;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class BlockBreakEffects extends ModuleListener
+{
+    public BlockBreakEffects(Module m) 
+    {
+        super(m);
+    }
+    
+    @SubscribeEvent(receiveCanceled = false)
+    public void onBlockBreakSkills(BlockEvent.BreakEvent e)    
+    {              
+        if(!KajetansMod.worldManager.getWorldPreferences(e.getWorld()).skills)
+        {
+            return;
+        }
+        EntityPlayer p = e.getPlayer();
+        BlockPos pos = e.getPos(); 
+        World w = e.getWorld();
+        IBlockState state = w.getBlockState(pos);
+        Block b = state.getBlock();
+        ItemStack hand = p.getHeldItemMainhand();
+
+        // ---------------------------------------------------------------------
+        // Gravel-Sand-Digger
+        // ---------------------------------------------------------------------
+        
+        if(b instanceof BlockFalling)
+        {
+            int level = EffectUtils.getEffectLevel(p, Effect.GRAVEL_SAND_DIGGER);
+            if(level >= 1)
+            {
+                BlockPos dig;
+                for(int i = 0; i < level; i++)
+                {
+                    dig = pos.add(0, i, 0);
+                    state = w.getBlockState(dig);
+                    if(state.getBlock() instanceof BlockFalling)
+                    {
+                        Utils.breakBlock(w, dig, p);
+                        continue;
+                    }            
+                    break;
+                }
+            }
+            return;
+        }
+        
+        // ---------------------------------------------------------------------
+        // More Minerals
+        // ---------------------------------------------------------------------
+        
+        
+        if(EnchantmentHelper.getEnchantmentLevel(Enchantments.SILK_TOUCH, hand) >= 1)
+        {
+            if(b == Blocks.DIAMOND_ORE || b == Blocks.REDSTONE_ORE ||
+                b == Blocks.LAPIS_ORE || b == Blocks.COAL_ORE)
+            {
+                if(Utils.randomBoolean() && EffectUtils.getEffectLevel(p, Effect.MORE_MINERALS) >= 1)
+                {
+                    b.dropBlockAsItem(w, pos, state, 0);
+                }
+            }
+        }
+        
+        // ---------------------------------------------------------------------
+        // More Crops
+        // ---------------------------------------------------------------------
+        
+        if(b instanceof BlockCrops && state.getValue(BlockCrops.AGE) == 7)
+        {
+            int moreCrops = EffectUtils.getEffectLevel(p, Effect.MORE_CROPS);
+            if(moreCrops >= 1)
+            {                                         
+                b.getDrops(w, pos, state, 0).stream().filter(s -> Utils.randomBoolean()).forEach((stack) -> 
+                {
+                    new ItemStackBuilder(stack, Utils.randomInt(1, moreCrops)).drop(w, pos);
+                });
+            }
+        }
+        
+        // ---------------------------------------------------------------------
+        // Tree Picker und More Saplings
+        // ---------------------------------------------------------------------
+        
+        if((b == Material.LEAVES || b == Material.LEAVES_2) && hand.getType() != Material.SHEARS)
+        {
+            if(Utils.randomInt(1, 25) <= EffectUtils.getEffectLevel(p, Effect.TREE_PICKER))
+            {
+                Utils.dropRandomTreeItem(b);
+            }
+            if(Utils.randomInt(1, 25) <=  EffectUtils.getEffectLevel(p, Effect.MORE_SAPLINGS))
+            {
+                if(m == Material.LEAVES)
+                {
+                    new ItemStackBuilder(Material.SAPLING, 1, (short) (b.getState().getData().toItemStack().getDurability() % 4)).drop(l);
+                }
+                else
+                {
+                    new ItemStackBuilder(Material.SAPLING, 1, (short) ((b.getState().getData().toItemStack().getDurability() % 4) + 4)).drop(l);
+                }
+            }
+        }
+    }
+}

src/main/java/me/km/effects/passive/BlockClickEffects.java

@@ -0,0 +1,95 @@
+package me.km.effects.passive;
+
+import java.util.HashMap;
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+import me.km.api.Utils;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
+import net.minecraftforge.event.entity.player.PlayerInteractEvent;
+import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class BlockClickEffects extends ModuleListener
+{
+    private final HashMap<Location, Data> blocks;
+    
+    private class Data
+    {
+        protected EntityPlayerMP p;
+        protected int guild;
+        protected int taskId;
+        
+        public Data(EntityPlayerMP p, int taskId)
+        {
+            this.p = p;
+            this.guild = KajetansMod.playerbank.getGuildId(p);
+            this.taskId = taskId;
+        }
+    }
+    
+    public BlockClickEffects(Module m) 
+    {
+        super(m);
+        blocks = new HashMap<>();
+    }
+    
+    public void registerTeleportBlock(Location l, EntityPlayerMP p, int time)
+    {
+        int i = KajetansMod.scheduler.scheduleTask(() -> 
+        {
+            blocks.remove(l);
+            l.getWorld().setBlockToAir(l.getBlockPos());
+        }, time);
+        blocks.put(l, new Data(p, i));
+        l.getWorld().setBlockState(l.getBlockPos(), Blocks.SEA_LANTERN.getDefaultState());
+        
+    }
+    
+    @SubscribeEvent
+    public void interact(BlockEvent.BreakEvent e)
+    {       
+        Block b = e.getWorld().getBlockState(e.getPos()).getBlock();
+        if(b == Blocks.SEA_LANTERN ||
+            !KajetansMod.worldManager.getWorldPreferences(e.getWorld()).skills)
+        {
+            return;
+        }
+        if(blocks.containsKey(new Location(e.getWorld(), e.getPos())))
+        {
+            e.setCanceled(true);
+        }
+    }
+    
+    @SubscribeEvent
+    public void interact(PlayerInteractEvent.RightClickBlock e)
+    {       
+        Block b = e.getWorld().getBlockState(e.getPos()).getBlock();
+        if(b == Blocks.SEA_LANTERN ||
+            !KajetansMod.worldManager.getWorldPreferences(e.getWorld()).skills)
+        {
+            return;
+        }
+        Location l = new Location(e.getWorld(), e.getPos());
+        Data data = blocks.get(l);
+        if(data == null)
+        {
+            return;
+        }
+        EntityPlayer p = e.getEntityPlayer();
+        if(data.guild == KajetansMod.playerbank.getGuildId(p))
+        {
+            if(data.p.isEntityAlive())
+            {
+                Utils.teleportEntity(p, data.p);
+            }
+            blocks.remove(l);
+            KajetansMod.scheduler.cancelTask(data.taskId);
+            l.getWorld().setBlockToAir(l.getBlockPos());
+        }
+    }
+}

src/main/java/me/km/effects/passive/BlockDamageEffects.java

@@ -0,0 +1,51 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.BlockDamageEvent;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public class BlockDamageEffects extends ModuleListener
+{
+    public BlockDamageEffects(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockDamage(BlockDamageEvent e)
+    {       
+        Player p = (Player) e.getPlayer();
+        if(!KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills)
+        {
+            return;
+        }
+        
+        Block b = (Block) e.getBlock();
+        
+        // OP-Effekt aus Prinzip entfernen
+        if(p.hasPotionEffect(PotionEffectType.FAST_DIGGING))
+        {           
+            if(p.getActivePotionEffects().stream()
+                .anyMatch(pe -> pe.getType().equals(PotionEffectType.FAST_DIGGING) && 
+                                pe.getDuration() > 20000))
+            {
+                p.removePotionEffect(PotionEffectType.FAST_DIGGING);
+            }
+        }
+               
+        // Speed up with prefered Blocks of current job
+        int digging = EffectUtils.getEffectLevel(p, Effect.FAST_DIGGING);
+        if(digging >= 1 && KajetansTools.jobs.isPreferedMaterial(p, b.getType()))
+        {
+            p.addPotionEffect(new PotionEffect(PotionEffectType.FAST_DIGGING, 999999, digging - 1), true);
+        }
+    }
+}

src/main/java/me/km/effects/passive/Breeding.java

@@ -0,0 +1,79 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+
+public class Breeding extends ModuleListener
+{
+    public Breeding(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void onEntityBreed(PlayerInteractEntityEvent e)    
+    {              
+        Player p = (Player) e.getPlayer();  
+        if(!KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills)
+        {
+            return;
+        }
+        switch(e.getRightClicked().getType())
+        {
+            case COW:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_COW) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+            case PIG:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_PIG) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+            case SHEEP:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_SHEEP) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+            case RABBIT:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_RABBIT) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+            case CHICKEN:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_CHICKEN) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+            case HORSE:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_HORSE) < 1)
+                {
+                    switch(p.getInventory().getItemInMainHand().getType())
+                    {
+                        case GOLDEN_APPLE:
+                        case GOLDEN_CARROT:
+                            e.setCancelled(true);
+                            break;
+                    }
+                }
+                break;
+            case MUSHROOM_COW:
+                if(EffectUtils.getEffectLevel(p, Effect.BREED_MUSHROOMCOW) < 1)
+                {
+                    e.setCancelled(true);
+                }
+                break;
+        }
+    }
+}

src/main/java/me/km/effects/passive/Brewing.java

@@ -0,0 +1,44 @@
+package me.km.effects.passive;
+
+import java.util.Collection;
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.inventory.BrewEvent;
+
+public class Brewing extends ModuleListener
+{
+    public Brewing(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void Brewing(BrewEvent e)
+    {  
+        Location l = e.getBlock().getLocation();
+        if(!KajetansTools.worldManager.getWorldPreferences(l.getWorld()).skills)
+        {
+            return;
+        }
+        e.setCancelled(true);
+        Collection<Player> players = Utils.getNearbyEntities(l, 4, Player.class);
+        if(!players.isEmpty())
+        {
+            for(Player p : players)
+            {
+                if(EffectUtils.getEffectLevel(p, Effect.BREWING) >= 1)
+                {
+                    e.setCancelled(false);
+                    return;
+                }
+            }
+        }
+    } 
+}

src/main/java/me/km/effects/passive/CakeEating.java

@@ -0,0 +1,47 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+
+public class CakeEating extends ModuleListener
+{
+    public CakeEating(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void eatCake(PlayerInteractEvent e)
+    {
+        if(!KajetansTools.worldManager.getWorldPreferences(e.getPlayer().getWorld()).skills)
+        {
+            return;
+        }
+        Block b = e.getClickedBlock();
+        if(b == null || b.getType() != Material.CAKE_BLOCK || e.getHand() == EquipmentSlot.OFF_HAND)
+        {
+            return;
+        }    
+        Player p = e.getPlayer();
+        if(p.getFoodLevel() >= 20)
+        {                             
+            return;
+        }
+        if(EffectUtils.getEffectLevel(p, Effect.CAKE_POWER) >= Utils.randomInt(1, 5))
+        {           
+            e.setCancelled(true);
+            p.setFoodLevel(p.getFoodLevel() + 2);
+            p.setSaturation(p.getSaturation() + (float) 0.4);
+        }        
+    }
+}

src/main/java/me/km/effects/passive/CauldronFilling.java

@@ -0,0 +1,47 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import me.kt.skills.Skill;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.material.Cauldron;
+
+public class CauldronFilling extends ModuleListener
+{
+    public CauldronFilling(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void useCauldron(PlayerInteractEvent e)
+    {
+        Block b = e.getClickedBlock();
+        if(b == null || b.getType() != Material.CAULDRON || !KajetansTools.worldManager.getWorldPreferences(b.getWorld()).skills)
+        {
+            return;
+        }    
+        Player p = e.getPlayer();
+        if(EffectUtils.getEffectLevel(p, Effect.CAULDRON_FILLING) < 1)
+        {
+            return;
+        }
+        BlockState state = b.getState();
+        Cauldron cauldron = (Cauldron) state.getData();   
+        if(cauldron.isEmpty());
+        {
+            ItemStack stack = new ItemStack(Material.CAULDRON, 1, (byte) 3);
+            state.setData(stack.getData());
+            state.update();
+        }
+    }
+}

src/main/java/me/km/effects/passive/Crafting.java

@@ -0,0 +1,33 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.inventory.PrepareItemCraftEvent;
+import org.bukkit.inventory.CraftingInventory;
+import org.bukkit.inventory.ItemStack;
+
+public class Crafting extends ModuleListener
+{
+    public Crafting(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void PreCrafting(PrepareItemCraftEvent e)
+    {  
+        CraftingInventory inv = e.getInventory();
+        if(inv.getResult() != null && 
+            e.getViewers().size() >= 1 &&
+            e.getViewers().get(0) instanceof Player &&
+            !KajetansTools.worldManager.getWorldPreferences(e.getInventory().getLocation().getWorld()).defaultProducing &&
+            !KajetansTools.jobs.hasRecipe((Player) e.getViewers().get(0), inv.getResult().getType()))
+        {
+            inv.setResult(new ItemStack(Material.AIR));
+        }  
+    } 
+}

src/main/java/me/km/effects/passive/EnderpearlEffects.java

@@ -0,0 +1,75 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class EnderpearlEffects extends ModuleListener 
+{
+    public EnderpearlEffects(Module m)
+    {
+        super(m);
+    }
+       
+    @EventHandler(ignoreCancelled = true)
+    public void preventEnderPearlDamage(EntityDamageByEntityEvent e)
+    {
+        Entity ent = e.getEntity();
+        if(e.getCause() == EntityDamageEvent.DamageCause.FALL &&
+            ent instanceof Player && 
+            e.getDamager().getType() == EntityType.ENDER_PEARL &&
+            KajetansTools.worldManager.getWorldPreferences(ent.getWorld()).skills &&
+            EffectUtils.getEffectLevel((Player) ent, Effect.NO_ENDERPEARL_DAMAGE) >= 1)
+        {
+            e.setCancelled(true);
+        }
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void PlayerUsesEnderPearlEvent(ProjectileLaunchEvent e)
+    {
+        Projectile pro = e.getEntity();
+        if(Utils.randomBoolean() ||
+            pro.getType() != EntityType.ENDER_PEARL || 
+            !(pro.getShooter() instanceof Player) ||
+            !KajetansTools.worldManager.getWorldPreferences(pro.getWorld()).skills)
+        {
+            return;
+        }
+        Player p = (Player) pro.getShooter();
+        if(EffectUtils.getEffectLevel(p, Effect.PEARL_SAVER) >= 1)
+        {     
+            ItemStack stack = p.getInventory().getItemInMainHand(); 
+            stack.setAmount(stack.getAmount() + 1); 
+            p.getInventory().setItemInMainHand(stack);
+        }
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void EnderPearlSpeedEvent(ProjectileLaunchEvent e)
+    {       
+        Projectile pro = e.getEntity();
+        if(pro.getType() == EntityType.ENDER_PEARL &&
+            pro.getShooter() instanceof Player &&
+            KajetansTools.worldManager.getWorldPreferences(pro.getWorld()).skills)
+        {
+            int speed = EffectUtils.getEffectLevel((Player) pro.getShooter(), Effect.FAST_ENDERPEARL_SHOOT);
+            if(speed >= 1)
+            {
+                pro.setVelocity(pro.getVelocity().multiply(speed + 1));
+            }
+        }
+    }
+}

src/main/java/me/km/effects/passive/EntityDamageEffects.java

@@ -0,0 +1,146 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import me.kt.nms.NmsUtilities;
+import me.kt.playerbank.PlayerData;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public class EntityDamageEffects extends ModuleListener
+{
+    public EntityDamageEffects(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void damageHandler(EntityDamageEvent e)
+    {           
+        if(!(e.getEntity() instanceof Player) || 
+            !KajetansTools.worldManager.getWorldPreferences(e.getEntity().getWorld()).skills)
+        {
+            return;
+        } 
+        Player p = (Player) e.getEntity();
+        PlayerData data = KajetansTools.playerbank.getData(p);
+        
+        int reducer = EffectUtils.getEffectLevel(p, Effect.LESS_DAMAGE);
+        if(reducer > 0)
+        {
+            e.setDamage(e.getFinalDamage() / (reducer + 1));
+        }
+        
+        if(data.hasData("shadow"))
+        {
+            NmsUtilities.setInvisible(false, p);
+            data.removeData("shadow");
+        } 
+        
+        DamageCause cause = e.getCause();
+        if(cause == DamageCause.POISON && 
+            EffectUtils.getEffectLevel(p, Effect.NO_POISON) >= 1)
+        {
+            e.setCancelled(true);
+        } 
+        else if(e.getCause() == DamageCause.FALL)
+        {
+            if(data.hasData("fallimmunity"))
+            {
+                e.setCancelled(true);
+                return;
+            }
+            int fall = EffectUtils.getEffectLevel(p, Effect.LESS_FALL_DAMAGE);
+            if(fall >= 1)
+            {
+                e.setDamage(e.getDamage() / (fall * 2 + 1));
+            }
+        }
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void onEntityDamage(EntityDamageByEntityEvent e)
+    {           
+        if(!(e.getDamager() instanceof Player) || 
+            e.getCause() != EntityDamageEvent.DamageCause.ENTITY_ATTACK ||
+            !KajetansTools.worldManager.getWorldPreferences(e.getEntity().getWorld()).skills)
+        {
+            return;
+        }  
+        Player p = (Player) e.getDamager();
+        Utils.ToolTypes tt = Utils.getToolType(p.getInventory().getItemInMainHand());
+        double damageBonus = 1;
+        if(tt != null)
+        {
+            switch(tt)
+            {
+                case AXE:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_AXE_DAMAGE);
+                    break;
+                case HOE:  
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_HOE_DAMAGE);
+                    break;
+                case PICKAXE:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_PICKAXE_DAMAGE);
+                    break;
+                case SHOVEL:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_SHOVEL_DAMAGE);
+                    break;
+                case SWORD:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_SWORD_DAMAGE);
+                    break;
+                case DAGGER:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_DAGGER_DAMAGE);
+                    break;
+                case HAMMER:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_HAMMER_DAMAGE);
+                    break;
+                case STICK:
+                    damageBonus += 0.1d * EffectUtils.getEffectLevel(p, Effect.MORE_STICK_DAMAGE);
+                    break;
+            }
+        }
+        
+        PlayerData data = KajetansTools.playerbank.getData(p);
+
+        if(data.removeData("shadowhit"))
+        {
+            p.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, 40, 1), true);
+            p.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 40, 0), true);
+        }
+        
+        if(e.getEntity() instanceof Player)
+        {
+            Player victim = (Player) e.getEntity();
+            Player damager = KajetansTools.playerbank.getData(victim).getData("doomed", Player.class);
+            if(damager != null && damager.equals(p))
+            {
+                damageBonus *= 1.2d;
+            }
+        }
+        
+        if(e.getEntity() instanceof LivingEntity && data.hasData("poisonedblade"))
+        {
+            ((LivingEntity) e.getEntity()).addPotionEffect(new PotionEffect(PotionEffectType.POISON, 80, 1), true);
+        }
+        
+        double powerAttack = data.getDouble("powerattack");
+        if(powerAttack != 0)
+        {
+            damageBonus *= powerAttack;
+            data.removeData("powerattack");
+        }
+        
+        e.setDamage(e.getDamage() * damageBonus);
+    }
+}

src/main/java/me/km/effects/passive/EntityDeath.java

@@ -0,0 +1,60 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.ItemStackBuilder;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class EntityDeath extends ModuleListener
+{
+    public EntityDeath(Module m) 
+    {
+        super(m);
+    }
+    
+    // High, da die Drops vorher noch durch SnuviScript geändert werden können
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onEntityDeath(EntityDeathEvent e)
+    {
+        LivingEntity ent = e.getEntity();
+        if(!KajetansTools.worldManager.getWorldPreferences(ent.getWorld()).skills)
+        {
+            return;
+        }
+        Player p = ent.getKiller();              
+        if(p == null)
+        {
+            return;
+        }
+        int xp = EffectUtils.getEffectLevel(p, Effect.XP_COLLECTOR);
+        if(xp >= 1)
+        {
+            float i = e.getDroppedExp();
+            i *= 1 + xp / 5f;
+            e.setDroppedExp((int) i);
+        }
+
+        int drops = EffectUtils.getEffectLevel(p, Effect.MORE_DROPS);
+        if(drops >= 1)
+        {
+            int random;
+            for(ItemStack stack : e.getDrops())
+            {
+                random = Utils.randomInt(-2, drops);
+                if(random >= 1)
+                {
+                    new ItemStackBuilder(stack, random).drop(e.getEntity().getLocation());
+                }
+            }
+        }
+    }
+}

src/main/java/me/km/effects/passive/Fishing.java

@@ -0,0 +1,180 @@
+package me.km.effects.passive;
+
+import java.util.NoSuchElementException;
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerFishEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffectType;
+
+public class Fishing extends ModuleListener
+{
+    public Fishing(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void onFishing(PlayerFishEvent e)
+    {
+        Player p = e.getPlayer();
+        if(!KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills)
+        {
+            return;
+        }
+        int fishing = EffectUtils.getEffectLevel(p, Effect.FISHING);
+        if(fishing < 1)
+        {
+            return;
+        }
+        Entity ent = e.getCaught();
+        if(ent == null || !(ent instanceof Item))
+        {
+            return;
+        }
+        
+        ItemStack tool = p.getInventory().getItemInMainHand();
+        Item item = (Item) ent;
+        Location l = item.getLocation();        
+        int random = Utils.randomInt(0, fishing);
+        Item addDrop;
+        for(int i = 0; i < random; i++)
+        {
+            addDrop = l.getWorld().dropItem(p.getLocation(), generateFish(tool, p));
+            addDrop.setVelocity(item.getVelocity());
+        }
+    }
+    
+    private ItemStack generateFish(ItemStack tool, Player p)
+    {
+        int luck = 0;
+        try
+        {
+            luck = p.getActivePotionEffects().stream()
+                    .filter((pe) -> (pe.getType().equals(PotionEffectType.LUCK)))
+                    .findFirst().get().getAmplifier() + 1;
+        }
+        catch(NoSuchElementException ex)
+        {
+        }
+        try
+        {
+            luck -= p.getActivePotionEffects().stream()
+                    .filter((pe) -> (pe.getType().equals(PotionEffectType.UNLUCK)))
+                    .findFirst().get().getAmplifier() + 1;
+        }
+        catch(NoSuchElementException ex)
+        {
+        }
+        luck *= 10;
+        
+        int luckOfSea = tool.getEnchantmentLevel(Enchantment.LUCK);
+        int junk = 100 - 20 * luckOfSea - 2 * luck;
+        int treasure = 50 + 21 * luckOfSea + 2 * luck;
+        int fish = 850 - luck;
+        if(treasure < 0)
+        {
+            treasure = 0;
+        }
+        if(junk < 0)
+        {
+            junk = 0;
+        }
+        if(fish < 0)
+        {
+            fish = 0;
+        }
+        
+        int random = Utils.randomInt(1, junk + treasure + fish);     
+        if(random <= junk) //Junk
+        {
+            random = Utils.randomInt(1, 92);
+            if(random <= 10)
+            {
+                return new ItemStack(Material.BOWL);
+            }
+            else if(random <= 12)
+            {
+                return new ItemStack(Material.FISHING_ROD, 1, (short) Utils.randomInt(6, 64));
+            }
+            else if(random <= 22)
+            {
+                return new ItemStack(Material.LEATHER);
+            }
+            else if(random <= 32)
+            {
+                return new ItemStack(Material.LEATHER_BOOTS, 1, (short) Utils.randomInt(6, 66));
+            }
+            else if(random <= 42)
+            {
+                return new ItemStack(Material.ROTTEN_FLESH);
+            }
+            else if(random <= 47)
+            {
+                return new ItemStack(Material.STICK);
+            }
+            else if(random <= 52)
+            {
+                return new ItemStack(Material.STRING);
+            }
+            else if(random <= 62)
+            {
+                return new ItemStack(Material.POTION);
+            }
+            else if(random <= 72)
+            {
+                return new ItemStack(Material.BONE);
+            }
+            else if(random <= 82)
+            {
+                return new ItemStack(Material.INK_SACK);
+            }
+            return new ItemStack(Material.TRIPWIRE_HOOK);
+        }
+        else if(random <= junk + treasure) // Treasure
+        {
+            random = Utils.randomInt(1, 6);
+            switch(random)
+            {
+                case 1:
+                    return Utils.randomEnchantment(new ItemStack(Material.BOW, 1, (short) Utils.randomInt(288, 384))); 
+                case 2:
+                    return Utils.randomEnchantment(new ItemStack(Material.ENCHANTED_BOOK)); 
+                case 3:
+                    return Utils.randomEnchantment(new ItemStack(Material.FISHING_ROD, 1, (short) Utils.randomInt(48, 64))); 
+                case 4:
+                    return new ItemStack(Material.NAME_TAG);
+                case 5:
+                    return new ItemStack(Material.SADDLE);
+                case 6:
+                    return new ItemStack(Material.WATER_LILY);
+            }
+        }
+        
+        random = Utils.randomInt(1, 100);
+        if(random <= 13)
+        {
+            return new ItemStack(Material.RAW_FISH, 1, (short) 3);
+        }
+        else if(random <= 15)
+        {
+            return new ItemStack(Material.RAW_FISH, 1, (short) 2);
+        }
+        else if(random <= 40)
+        {
+            return new ItemStack(Material.RAW_FISH, 1, (short) 1);
+        }
+        return new ItemStack(Material.RAW_FISH);
+    }
+}

src/main/java/me/km/effects/passive/GoldRiverEffects.java

@@ -0,0 +1,77 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.ItemStackBuilder;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import me.kt.plots.ProtectionBank;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+
+public class GoldRiverEffects extends ModuleListener
+{    
+    public GoldRiverEffects(Module m)
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void GoldWashingEvent(PlayerInteractEvent e)
+    {
+        if(e.getHand() == EquipmentSlot.OFF_HAND || e.getAction() != Action.RIGHT_CLICK_BLOCK)
+        {
+            return;
+        }
+        Block b = e.getClickedBlock();
+        Player p = e.getPlayer();
+        if(b == null || 
+            b.getType() != Material.GOLD_ORE || 
+            !b.getRelative(0, 1, 0).isLiquid() ||
+            p.getInventory().getItemInMainHand().getType() != Material.BOWL || 
+            !KajetansTools.worldManager.getWorldPreferences(b.getWorld()).skills ||
+            EffectUtils.getEffectLevel(p, Effect.GOLD_WASHER) < 1 || 
+            !KajetansTools.plots.getDataBank(ProtectionBank.class).hasTag(b.getLocation(), "gold"))
+        {
+            return;
+        }
+        new ItemStackBuilder(Material.GOLD_NUGGET, Utils.randomInt(1, 2)).drop(b.getLocation().add(0, 1, 0));
+        this.getModule().send(p, "Du hast Gold gefunden!");
+        if(Utils.randomInt(1, 4) == 1)
+        {
+            this.getModule().send(p, "Die Goldader ist erschöpft!");
+            b.setType(Material.STONE);                
+        }            
+    }
+    
+    @EventHandler
+    public void GoldWashingRespawnEvent(PlayerInteractEvent e)
+    {
+        if(e.getHand() == EquipmentSlot.OFF_HAND || e.getAction() != Action.RIGHT_CLICK_BLOCK)
+        {
+            return;
+        }
+        Block b = e.getClickedBlock();
+        Player p = e.getPlayer();
+        if(b == null || 
+            b.getType() != Material.STONE || 
+            !b.getRelative(0, 1, 0).isLiquid() ||
+            Utils.getToolType(p.getInventory().getItemInMainHand()) != Utils.ToolTypes.SHOVEL ||
+            !KajetansTools.worldManager.getWorldPreferences(b.getWorld()).skills ||
+            EffectUtils.getEffectLevel(p, Effect.GOLD_RUSH) < 1 ||
+            !KajetansTools.plots.getDataBank(ProtectionBank.class).hasTag(b.getLocation(), "gold"))
+        {
+            return;
+        }
+        this.getModule().send(p, "Du hast eine neue Goldader gefunden!");     
+        b.setType(Material.GOLD_ORE); 
+        Utils.damageItemInHand(p, 15);
+    }
+}

src/main/java/me/km/effects/passive/LeaveDecay.java

@@ -0,0 +1,59 @@
+package me.km.effects.passive;
+
+import java.util.Collection;
+import me.kt.KajetansTools;
+import me.kt.api.ItemStackBuilder;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.LeavesDecayEvent;
+
+public class LeaveDecay extends ModuleListener
+{
+    public LeaveDecay(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void onLeaveDecay(LeavesDecayEvent e)
+    {
+        Location l = e.getBlock().getLocation();
+        if(!KajetansTools.worldManager.getWorldPreferences(l.getWorld()).skills)
+        {
+            return;
+        }
+        Collection<Player> players = Utils.getNearbyEntities(l, 15, Player.class);
+        if(players.isEmpty())
+        {
+            return;
+        }
+        Block b = e.getBlock();
+        players.stream().filter((p) -> Utils.randomInt(1, 25) <= EffectUtils.getEffectLevel(p, Effect.TREE_PICKER)).forEach((p) -> 
+        {
+            Utils.dropRandomTreeItem(b);
+        });
+        Material m = b.getType();
+        if(m == Material.LEAVES)
+        {
+            players.stream().filter((p) -> Utils.randomInt(1, 25) <= EffectUtils.getEffectLevel(p, Effect.MORE_SAPLINGS)).forEach((p) -> 
+            {
+                new ItemStackBuilder(Material.SAPLING, 1, (short) (b.getState().getData().toItemStack().getDurability() % 4)).drop(l);
+            }); 
+        }
+        else if(m == Material.LEAVES_2)
+        {
+            players.stream().filter((p) -> Utils.randomInt(1, 25) <= EffectUtils.getEffectLevel(p, Effect.MORE_SAPLINGS)).forEach((p) -> 
+            {
+                new ItemStackBuilder(Material.SAPLING, 1, (short) ((b.getState().getData().toItemStack().getDurability() % 4) + 4)).drop(l);
+            });        
+        }
+    }      
+}

src/main/java/me/km/effects/passive/LessItemLoss.java

@@ -0,0 +1,46 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.inventory.PlayerInventory;
+
+public class LessItemLoss extends ModuleListener
+{
+    public LessItemLoss(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void onDeathEvent(PlayerDeathEvent e)
+    {  
+        Player p = e.getEntity();
+        if(!e.getKeepInventory() && KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills)
+        {
+            int level = EffectUtils.getEffectLevel(p, Effect.LESS_ITEM_LOSS);
+            if(level > 0)
+            {
+                e.setKeepInventory(true);
+                PlayerInventory pinv = p.getInventory();
+                World w = p.getWorld();
+                Location l = p.getLocation();
+                for(int i = level; i < 36; i++)
+                {
+                    if(pinv.getItem(i) != null)
+                    {
+                        w.dropItem(l, pinv.getItem(i));
+                        pinv.clear(i);
+                    }
+                }
+            }
+        }  
+    } 
+}

src/main/java/me/km/effects/passive/MagicWands.java

@@ -0,0 +1,83 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Utils;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.effects.ActiveEffectBase;
+import java.util.List;
+import me.kt.custom.CustomItemUtils;
+import me.kt.custom.CustomMaterial;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectCause;
+import me.kt.effects.EffectUtils;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+public class MagicWands extends ModuleListener
+{          
+    public MagicWands(Module m)
+    {
+        super(m);
+    }
+   
+    @EventHandler
+    public void PlayerUsesWand(PlayerInteractEvent e)
+    {
+        Player p = e.getPlayer();
+        if(e.getHand() == EquipmentSlot.OFF_HAND ||
+            (e.getAction() != Action.RIGHT_CLICK_AIR && e.getAction() != Action.RIGHT_CLICK_BLOCK) ||
+            !KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills)
+        {
+            return;
+        }
+        ItemStack stack = p.getInventory().getItemInMainHand();
+        CustomMaterial cm = CustomMaterial.getCustomMaterial(stack);
+        if(cm != null && cm.getToolType() == Utils.ToolTypes.WAND)
+        {
+            int wand = EffectUtils.getEffectLevel(p, Effect.USE_WAND);
+            if(wand < 1)
+            {
+                this.getModule().send(p, "Du kannst keine Zauberstäbe benutzen.");
+                return;
+            }
+            ItemMeta meta = stack.getItemMeta();
+            List<String> lore = meta.getLore();
+            for(String s : lore)
+            {
+                if(s.startsWith("Effect") && s.length() > 8)
+                {
+                    Class<? extends ActiveEffectBase> c = EffectUtils.getEffectClass(s.substring(8));
+                    if(c == null)
+                    { 
+                        this.getModule().send(p, "Der Zauberstab ist korrupt.");
+                        return;
+                    }
+                    int power;
+                    switch(cm)
+                    {
+                        case WOOD_WAND:     power = 1; break;
+                        case STONE_WAND:    power = 2; break; 
+                        case REDSTONE_WAND: power = 3; break;
+                        case IRON_WAND:     power = 3; break;
+                        case LAPIS_WAND:    power = 4; break;
+                        case GOLD_WAND:     power = 5; break;
+                        case DIAMOND_WAND:  power = 5; break;
+                        case EMERALD_WAND:  power = 6; break;
+                        default:            power = 1; break;
+                    }
+                    if(ActiveEffectBase.executeEffect(c, p, power, power, EffectCause.WAND))
+                    {
+                        CustomItemUtils.lowerDurability(p, 1);
+                    }
+                }
+            }
+        }
+    }    
+}
+

src/main/java/me/km/effects/passive/Mugging.java

@@ -0,0 +1,175 @@
+package me.km.effects.passive;
+
+import java.util.ArrayList;
+import java.util.stream.Collectors;
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.custom.CustomItemUtils;
+import me.kt.custom.CustomMaterial;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Villager;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffectType;
+
+public class Mugging extends ModuleListener
+{
+    public Mugging(Module m) 
+    {
+        super(m);
+    }
+    
+    private boolean checkForDagger(Player p)
+    {
+        CustomMaterial cm = CustomMaterial.getCustomMaterial(p.getInventory().getItemInMainHand());
+        if(cm == null)
+        {
+            return false;
+        }
+        switch(cm)
+        {
+            case WOOD_DAGGER:
+            case STONE_DAGGER:
+            case GOLD_DAGGER:
+            case IRON_DAGGER:
+            case DIAMOND_DAGGER:
+                return true;
+        }
+        return false;
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void mugging(PlayerInteractEntityEvent e)
+    {
+        Player p = e.getPlayer();
+        if(e.getHand() == EquipmentSlot.OFF_HAND || 
+            !KajetansTools.worldManager.getWorldPreferences(p.getWorld()).skills ||
+            !checkForDagger(p))
+        {
+            return;
+        }
+        int mugging = EffectUtils.getEffectLevel(p, Effect.MUGGING);
+        if(mugging < 1)
+        {
+            return;
+        }
+        e.setCancelled(true);
+        Entity ent = e.getRightClicked();          
+        if(ent instanceof Monster)
+        {
+            if(p.getInventory().firstEmpty() == -1)
+            {
+                this.getModule().send(p, "Dein Inventar ist zu voll für einen Diebstahl.");
+                return;
+            }
+            Monster m = (Monster) ent;
+            if(mugging < Utils.randomInt(1, 5))
+            {
+                this.getModule().send(p, "Der Diebstahl hat fehlgeschlagen.");
+                if(!p.hasPotionEffect(PotionEffectType.INVISIBILITY))
+                {
+                    m.setTarget(p);
+                }
+                CustomItemUtils.lowerDurability(p, 15);
+                return;
+            }
+            ArrayList<Integer> loot = new ArrayList<>();
+            EntityEquipment equ = m.getEquipment();
+            if(equ.getHelmet().getType() != Material.AIR)
+            {
+                loot.add(0);
+            }
+            if(equ.getChestplate().getType() != Material.AIR)
+            {
+                loot.add(1);
+            }
+            if(equ.getLeggings().getType() != Material.AIR)
+            {
+                loot.add(2);
+            }
+            if(equ.getBoots().getType() != Material.AIR)
+            {
+                loot.add(3);
+            }   
+            if(equ.getItemInMainHand().getType() != Material.AIR)
+            {
+                loot.add(4);
+            } 
+            if(equ.getItemInOffHand().getType() != Material.AIR)
+            {
+                loot.add(5);
+            } 
+            
+            if(loot.isEmpty())
+            {
+                this.getModule().send(p, "Hier gibt es nichts zum stehlen.");
+                return;
+            }
+            
+            switch(loot.get(Utils.randomInt(0, loot.size() - 1)))
+            {
+                case 0:
+                    p.getInventory().addItem(equ.getHelmet());
+                    equ.setHelmet(new ItemStack(Material.AIR));
+                    break;
+                case 1:
+                    p.getInventory().addItem(equ.getChestplate());
+                    equ.setChestplate(new ItemStack(Material.AIR));
+                    break;
+                case 2:
+                    p.getInventory().addItem(equ.getLeggings());
+                    equ.setLeggings(new ItemStack(Material.AIR));
+                    break;
+                case 3:
+                    p.getInventory().addItem(equ.getBoots());
+                    equ.setBoots(new ItemStack(Material.AIR));
+                    break;
+                case 4:
+                    p.getInventory().addItem(equ.getItemInMainHand());
+                    equ.setItemInMainHand(new ItemStack(Material.AIR));
+                    break;
+                case 5:
+                    p.getInventory().addItem(equ.getItemInOffHand());
+                    equ.setItemInOffHand(new ItemStack(Material.AIR));
+                    break;
+            }
+            this.getModule().send(p, "Der Diebstahl war erfolgreich.");
+        }      
+        else if(ent instanceof Villager)
+        {           
+            if(p.getInventory().firstEmpty() == -1)
+            {
+                this.getModule().send(p, "Dein Inventar ist zu voll für einen Diebstahl.");
+                return;
+            }
+            Villager v = (Villager) ent;
+            if(mugging < Utils.randomInt(1, 5))
+            {
+                this.getModule().send(p, "Der Diebstahl hat fehlgeschlagen.");
+                Utils.damageItemInHand(p, 15);
+                if(!p.hasPotionEffect(PotionEffectType.INVISIBILITY))
+                {
+                    p.sendMessage("§7[§c" + v.getName() + "§7] §rWas machst du da?");
+                    p.damage(Utils.randomInt(6, 12), v);
+                    return;
+                }
+                p.sendMessage("§7[§c" + v.getName() + "§7] §rHuch, was war das?");
+                return;
+            }
+            ArrayList<ItemStack> loot = new ArrayList<>(v.getRecipes().stream().map(r -> r.getResult()).collect(Collectors.toList()));
+            loot.add(new ItemStack(Material.BREAD));
+            p.getInventory().addItem(loot.get(Utils.randomInt(0, loot.size() - 1)));
+            this.getModule().send(p, "Der Diebstahl war erfolgreich.");
+        } 
+    }
+}

src/main/java/me/km/effects/passive/PotionShooting.java

@@ -0,0 +1,43 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import me.kt.skills.Skill;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class PotionShooting extends ModuleListener
+{
+    public PotionShooting(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void PotionUse(ProjectileLaunchEvent e)
+    {       
+        Projectile pro = e.getEntity();
+        if((pro.getType() == EntityType.SPLASH_POTION ||
+            pro.getType() == EntityType.LINGERING_POTION) &&
+            pro.getShooter() instanceof Player &&
+            KajetansTools.worldManager.getWorldPreferences(pro.getWorld()).skills)
+        {
+            Player p = (Player) pro.getShooter();
+            int saver = EffectUtils.getEffectLevel(p, Effect.POTION_SAVER);
+            if(saver >= 1 && saver >= Utils.randomInt(1, 5))
+            {
+                ItemStack item = p.getInventory().getItemInMainHand();
+                item.setAmount(item.getAmount() + 1);
+                p.getInventory().setItemInMainHand(item);
+            }
+        }  
+    }
+}

src/main/java/me/km/effects/passive/Smelting.java

@@ -0,0 +1,45 @@
+package me.km.effects.passive;
+
+import java.util.Collection;
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.inventory.FurnaceSmeltEvent;
+
+public class Smelting extends ModuleListener
+{
+    public Smelting(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler
+    public void Furnace(FurnaceSmeltEvent e)
+    {  
+        Location l = e.getBlock().getLocation();
+        if(KajetansTools.worldManager.getWorldPreferences(l.getWorld()).defaultProducing)
+        {
+            return;
+        }
+        e.setCancelled(true);
+        Collection<Player> players = Utils.getNearbyEntities(l, 3, Player.class);
+        if(players.isEmpty())
+        {
+            return;
+        }
+        final Material result = e.getResult().getType();
+        if(players.stream().anyMatch(p -> 
+                EffectUtils.getEffectLevel(p, Effect.SMELTING) >= 1 &&
+                KajetansTools.jobs.hasRecipe(p, result)))
+        {
+            e.setCancelled(false);
+        }
+    } 
+}

src/main/java/me/km/effects/passive/TargetEntity.java

@@ -0,0 +1,43 @@
+package me.km.effects.passive;
+
+import me.kt.KajetansTools;
+import me.kt.api.Module;
+import me.kt.api.ModuleListener;
+import me.kt.api.Utils;
+import me.kt.effects.Effect;
+import me.kt.effects.EffectUtils;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityTargetEvent;
+import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
+import org.bukkit.potion.PotionEffectType;
+
+public class TargetEntity extends ModuleListener
+{
+    public TargetEntity(Module m) 
+    {
+        super(m);
+    }
+    
+    @EventHandler(ignoreCancelled = true)
+    public void avoidTargetting(EntityTargetLivingEntityEvent e)
+    {
+        Entity ent = e.getTarget();
+        if(ent == null || e.getReason() != EntityTargetEvent.TargetReason.CLOSEST_PLAYER || 
+            !(ent instanceof Player) || !KajetansTools.worldManager.getWorldPreferences(ent.getWorld()).skills)
+        {
+            return;
+        }
+        Player p = (Player) ent;  
+        if(EffectUtils.getEffectLevel(p, Effect.SNEAKING) >= 1 && p.hasPotionEffect(PotionEffectType.INVISIBILITY))
+        {       
+            e.setCancelled(true);
+        }
+        else if(EffectUtils.getEffectLevel(p, Effect.SCENT) >= 1 && e.getEntity() instanceof Monster)
+        {      
+            this.getModule().send(p, "Ein " + Utils.formatString(e.getEntity().getName()) + " hat dich bemerkt!");
+        }
+    }
+}

src/main/java/me/km/effects/passive/TrapEffects.java

@@ -0,0 +1,116 @@
+package me.km.effects.passive;
+
+import java.util.HashMap;
+import me.km.KajetansMod;
+import me.km.api.Location;
+import me.km.api.Module;
+import me.km.api.ModuleListener;
+import me.km.api.Utils;
+import me.km.effects.EffectBlockChanger;
+import me.km.effects.EffectUtils;
+import me.km.events.PlayerMoveEvent;
+import me.km.snuviscript.QuestUtils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.init.MobEffects;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.math.BlockPos;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+
+public class TrapEffects extends ModuleListener
+{    
+    private final HashMap<Location, Integer> netTraps;    
+    private final HashMap<Location, Integer> vineTraps;   
+    private final HashMap<Location, Integer> nailTraps;
+    
+    public TrapEffects(Module m)
+    {
+        super(m);
+        netTraps = new HashMap<>();
+        vineTraps = new HashMap<>();
+        nailTraps = new HashMap<>();
+    }
+    
+    public void addNailTraps(Location l, int id)
+    {
+        l = QuestUtils.roundLocation(l);
+        for(int x = -1; x <= 1; x++)
+        {
+            for(int y = -1; y <= 1; y++)
+            {
+                nailTraps.put(l.add(x, 0, y), id);
+            }
+        }
+    }
+    
+    public void addNetTrap(Location l, int id)
+    {
+        netTraps.put(QuestUtils.roundLocation(l), id);
+    }
+    
+    public void addVineTrap(Location l, int id)
+    {
+        vineTraps.put(QuestUtils.roundLocation(l), id);
+    }
+    
+    public void removeVineTrap(Location l)
+    {
+        vineTraps.remove(QuestUtils.roundLocation(l));
+    }
+    
+    @SubscribeEvent
+    public void executeTrap(PlayerMoveEvent e)
+    {       
+        EntityPlayer p = e.getEntityPlayer();
+        Location l = Location.rounded(p);
+        if(netTraps.containsKey(l))
+        {
+            Integer i = netTraps.get(l);
+            if(!(i < 0 && i == -KajetansMod.playerbank.getDataBank().getIdByUUID(p.getUniqueID().toString())) && 
+                    i != KajetansMod.playerbank.getGuildId(p))
+            {
+                netTraps.remove(l);
+                BlockPos b = l.getBlockPos();
+                EffectBlockChanger changer = new EffectBlockChanger(l.getWorld());
+                for(int x = -3; x <= 3; x++)
+                {
+                    for(int y = 0; y <= 3; y++)
+                    {
+                        for(int z = -3; z <= 3; z++)
+                        {
+                            if((Math.abs(x) == 3 ? 1 : 0) + (Math.abs(y) == 3 ? 1 : 0) + (Math.abs(z) == 3 ? 1 : 0) >= 2)
+                            {
+                                continue;
+                            }
+                            if(Utils.randomInt(1, 10) >= 3)
+                            {
+                                changer.addBlock(b.add(x, y, z), Blocks.WEB);
+                            }
+                        }
+                    }
+                }
+                changer.run(120);
+            }
+        }
+        if(vineTraps.containsKey(l))
+        {
+            Integer i = vineTraps.get(l);
+            if(!(i < 0 && i == -KajetansMod.playerbank.getDataBank().getIdByUUID(p.getUniqueID().toString())) && 
+                    i != KajetansMod.playerbank.getGuildId(p))
+            {
+                EffectUtils.addPotionTo(p, MobEffects.POISON, 60, 2);
+            }
+        }
+        if(nailTraps.containsKey(l))
+        {
+            Integer i = nailTraps.get(l);
+            if(!(i < 0 && i == -KajetansMod.playerbank.getDataBank().getIdByUUID(p.getUniqueID().toString())) && 
+                    i != KajetansMod.playerbank.getGuildId(p))
+            {
+                nailTraps.remove(l);
+                p.attackEntityFrom(DamageSource.GENERIC, 6);
+                EffectUtils.addPotionTo(p, MobEffects.SLOWNESS, 200, 1);
+            }
+        }
+    }
+}

src/main/java/me/km/events/ArrowHitGroundEvent.java

@@ -0,0 +1,20 @@
+package me.km.events;
+
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraftforge.event.entity.EntityEvent;
+
+public class ArrowHitGroundEvent extends EntityEvent
+{
+    private final EntityArrow arrow;
+    
+    public ArrowHitGroundEvent(EntityArrow arrow) 
+    {
+        super(arrow);
+        this.arrow = arrow;
+    }
+
+    public EntityArrow getEntityArrow() 
+    {
+        return arrow;
+    }
+}

src/main/java/me/km/events/ArrowLaunchEvent.java

@@ -0,0 +1,29 @@
+package me.km.events;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraft.world.World;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+
+public class ArrowLaunchEvent extends PlayerEvent
+{
+    private final EntityArrow arrow;
+    private final World world;
+    
+    public ArrowLaunchEvent(EntityPlayer player, EntityArrow arrow, World world) 
+    {
+        super(player);
+        this.arrow = arrow;
+        this.world = world;
+    }
+
+    public EntityArrow getEntityArrow() 
+    {
+        return arrow;
+    }
+
+    public World getWorld() 
+    {
+        return world;
+    }
+}

src/main/java/me/km/events/CustomEventCaller.java

@@ -0,0 +1,57 @@
+package me.km.events;
+
+import java.util.ArrayList;
+import me.km.KajetansMod;
+import me.km.api.Utils;
+import me.km.effects.Effect;
+import me.km.effects.EffectUtils;
+import me.km.utils.ReflectionUtils;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.projectile.EntityArrow;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
+import net.minecraftforge.event.entity.living.LivingEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+
+public class CustomEventCaller 
+{
+    private static ArrayList<EntityArrow> arrows = new ArrayList<>();
+    
+    @SubscribeEvent
+    public void onPlayerMove(LivingEvent.LivingUpdateEvent e)
+    {      
+        if(!(e.getEntityLiving() instanceof EntityPlayer))
+        {
+            return;
+        }
+        EntityPlayer p = (EntityPlayer) e.getEntityLiving();
+        if(p.lastTickPosX != p.posX || p.lastTickPosY != p.posY || p.lastTickPosZ != p.posZ)
+        {
+            MinecraftForge.EVENT_BUS.post(new PlayerMoveEvent(p));
+        }  
+    } 
+    
+    @SubscribeEvent
+    public void onArrowLaunch(EntityJoinWorldEvent e)
+    {       
+        Entity ent = e.getEntity();
+        if(ent instanceof EntityArrow)
+        {
+            EntityArrow arrow = (EntityArrow) ent;
+            if(arrow.shootingEntity instanceof EntityPlayer)
+            {
+                arrows.add(arrow);
+                MinecraftForge.EVENT_BUS.post(new ArrowLaunchEvent((EntityPlayer) arrow.shootingEntity, arrow, e.getWorld()));
+            }
+        }
+    }
+    
+    @SubscribeEvent
+    public void tickServer(TickEvent.ServerTickEvent e) 
+    {       
+        arrows.removeIf(arrow -> ReflectionUtils.getArrowTimeInGround(arrow) > 1);
+        arrows.forEach(arrow -> MinecraftForge.EVENT_BUS.post(new ArrowHitGroundEvent(arrow)));
+    }
+}

src/main/java/me/km/events/PlayerMoveEvent.java

@@ -0,0 +1,12 @@
+package me.km.events;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+
+public class PlayerMoveEvent extends PlayerEvent
+{
+    public PlayerMoveEvent(EntityPlayer player) 
+    {
+        super(player);
+    }
+}

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

@@ -6,24 +6,25 @@ import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.inventory.ClickType;
 import net.minecraft.inventory.ContainerChest;
 import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.InventoryBasic;
 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) 
+    public CustomContainer(String title, int slotCount, EntityPlayerMP p) 
     {
         super(p.inventory, new EntityInventory(title, slotCount, p), p);
     }
     
-    public CustomContainer(SnuviInventory inv, EntityPlayer p) 
+    public CustomContainer(SnuviInventory inv, EntityPlayerMP p) 
     {
         super(p.inventory, inv, p);
     }
     
-    public EntityInventory getShownInventory()
+    public InventoryBasic getShownInventory()
     {
-        return (EntityInventory) this.getLowerChestInventory();
+        return (InventoryBasic) this.getLowerChestInventory();
     }
     
     public void openForPlayer(EntityPlayerMP p)
@@ -40,23 +41,27 @@ public class CustomContainer extends ContainerChest
         p.openContainer.addListener(p);
     }
     
-    public boolean noClicking(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer player)
+    public boolean noClicking(int slotId, int dragType, ClickType clickTypeIn, EntityPlayerMP player)
     {
         return true;
     }
     
     @Override
-    public final ItemStack slotClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer player) 
+    public final ItemStack slotClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer p) 
     {
-        if(noClicking(slotId, dragType, clickTypeIn, player))
+        if(p instanceof EntityPlayerMP)
         {
-            onCanceledClick(slotId, dragType, clickTypeIn, player);
-            return ItemStack.EMPTY;
+            EntityPlayerMP player = (EntityPlayerMP) p;
+            if(noClicking(slotId, dragType, clickTypeIn, player))
+            {
+                onCanceledClick(slotId, dragType, clickTypeIn, player);
+                return ItemStack.EMPTY;
+            }
         }
-        return super.slotClick(slotId, dragType, clickTypeIn, player);
+        return super.slotClick(slotId, dragType, clickTypeIn, p);
     }  
     
-    public void onCanceledClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayer player)
+    public void onCanceledClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayerMP player)
     {
     }
 }

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

@@ -0,0 +1,50 @@
+package me.km.inventory;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+import me.km.KajetansMod;
+import me.km.api.Module;
+import me.km.api.Utils;
+import me.km.commands.CommandTeleportAccept;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.ClickType;
+import net.minecraft.inventory.InventoryBasic;
+
+public class TeleportContainer extends CustomContainer
+{
+    private final List<EntityPlayer> players;
+    
+    public TeleportContainer(EntityPlayerMP p, List<EntityPlayer> list) 
+    {
+        super("Teleport to Player ...", list.size() % 9 == 0 ? list.size() : ((list.size() / 9) + 1) * 9, p);
+        this.players = list;
+        this.players.remove(p);
+        
+        InventoryBasic inv = super.getShownInventory();
+        int counter = 0;
+        for(EntityPlayer player : players) 
+        {
+            inv.setInventorySlotContents(counter, Utils.getPlayerHead(player).setStackDisplayName("§6" + player.getName()));
+            counter++;
+        }     
+    }
+
+    @Override
+    public void onCanceledClick(int slotId, int dragType, ClickType clickTypeIn, EntityPlayerMP p) 
+    {
+        if(slotId >= players.size())
+        {
+            return;
+        }
+        Module m = KajetansMod.effects;
+        EntityPlayer p2 = players.get(slotId);
+        m.send(p, "Die Anfrage wurde an '" + p2.getName() + "' geschickt.");
+        m.send(p2, p.getName() + " möchte sich zu dir teleportieren.");
+        m.send(p2, "Du kannst mit /tpa akzeptieren.");
+        HashMap<UUID, UUID> tpaccept = KajetansMod.generalCommands.getCommand(CommandTeleportAccept.class).tpaccept;
+        tpaccept.put(p2.getUniqueID(), p.getUniqueID());
+        p.closeScreen();
+    }
+}

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

@@ -17,7 +17,7 @@ public class PlayerBank extends SimpleDataBank
     @Override
     protected void init() 
     {
-        // Spielerdatenbank
+        // Player-Databank
         if(!this.doesTableExist("players"))
         {
             this.getModule().sendToConsole("Die Spielerdatenbank wurde nicht gefunden, erstelle ...");
@@ -36,28 +36,7 @@ public class PlayerBank extends SimpleDataBank
             this.getModule().sendToConsole("Die Spielerdatenbank wurde gefunden.");
         }
         
-        // Skilldatenbank
-        /*if(!this.doesTableExist("skills"))
-        {
-            this.getModule().sendToConsole("Die Skilldatenbank wurde nicht gefunden, erstelle ...");
-            if(this.update("CREATE TABLE IF NOT EXISTS skills ("
-                + "id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, "
-                + "player_id INT NOT NULL, "
-                + "skill_name VARCHAR(20) NOT NULL, "
-                + "amount INT NOT NULL, "
-                + "INDEX (player_id), "
-                + "UNIQUE INDEX (player_id,skill_name), "
-                + "FOREIGN KEY (player_id) REFERENCES minecraft.players(id) ON DELETE RESTRICT);", false))
-            {
-                this.getModule().sendToConsole("Die Skilldatenbank wurde erstellt.");
-            }
-        }
-        else
-        {
-            this.getModule().sendToConsole("Die Skilldatenbank wurde gefunden.");
-        }*/
-        
-        // PlayerTags-Datenbank
+        // Player-Tags-Databank
         if(!this.doesTableExist("playertags"))
         {
             this.getModule().sendToConsole("Die Player-Tags-Datenbank wurde nicht gefunden, erstelle ...");
@@ -88,77 +67,7 @@ public class PlayerBank extends SimpleDataBank
     {
         this.update("UPDATE players SET name='" + p.getName() + "' WHERE uuid='" + p.getUniqueID()+ "';", false);
     }
-    
-    /*public boolean addSkill(Player p, Skill skill, int maxLevel)
-    {
-        Integer skillLevel = getSkillAmount(p, skill);
-        if(skillLevel == null)
-        {
-            this.update("INSERT INTO skills (player_id,skill_name,amount) "
-                    + "SELECT id, '" + skill.toString() + "', 1 "
-                    + "FROM players WHERE uuid='" + p.getUniqueID() + "';", false);
-            return true;
-        }
-        if(skillLevel >= maxLevel)
-        {
-            return false;
-        }
-        skillLevel++;
-        this.update("UPDATE skills "
-                + "LEFT JOIN players ON players.id = skills.player_id "
-                + "SET amount=" + skillLevel
-                + " WHERE players.uuid = '" + p.getUniqueID() + "' AND "
-                + "skills.skill_name='" + skill.toString() + "';", false);
-        return true;
-    }
-    
-    public boolean subSkill(Player p, Skill skill)
-    {
-        Integer skillLevel = getSkillAmount(p, skill);
-        if(skillLevel == null || skillLevel <= 0)
-        {
-            return false;
-        }
-        skillLevel--;
-        this.update("UPDATE skills "
-                + "LEFT JOIN players ON players.id = skills.player_id "
-                + "SET amount=" + skillLevel
-                + " WHERE players.uuid = '" + p.getUniqueID() + "' AND "
-                + "skills.skill_name='" + skill.toString() + "';", false);
-        return true;
-    }
-    
-    private Integer getSkillAmount(Player p, Skill skill)
-    {
-        return this.getFirst("SELECT amount from skills "
-                + "LEFT JOIN players ON players.id = skills.player_id "
-                + "WHERE players.uuid = '" + p.getUniqueID() + "' AND "
-                + "skills.skill_name='" + skill.toString() + "';", Integer.class);
-    }
-    
-    public HashMap<Skill, Byte> getSkills(Player p)
-    {
-        HashMap<Skill, Byte> map = new HashMap<>();
-        this.get("SELECT skill_name,amount from skills "
-                + "LEFT JOIN players ON players.id = skills.player_id "
-                + "WHERE minecraft.players.uuid = '" + p.getUniqueID() + "';").stream().forEach(li -> 
-                {
-                    try
-                    {
-                        Integer i = (Integer) li.get(1);
-                        if(i <= 0)
-                        {
-                            return;
-                        }
-                        map.put(Skill.valueOf(li.get(0).toString()), i.byteValue());
-                    }
-                    catch(IllegalArgumentException | NullPointerException ex)
-                    {
-                    }
-                });
-        return map;
-    }   */
-    
+ 
     public void setTag(String uuid, String tag, int amount)
     {
         this.update("INSERT INTO playertags (player_id,tag,amount) "
@@ -198,11 +107,6 @@ public class PlayerBank extends SimpleDataBank
     
     public GameProfile getOfflinePlayer(String name)
     {
-        name = getUUID(name);
-        if(name == null)
-        {
-            return null;
-        }
         return KajetansMod.server.getPlayerProfileCache().getGameProfileForUsername(name);
     }