Refactor Stuffs

src/de/leafbla/meinkraft/Main.java

@@ -2,16 +2,10 @@ package de.leafbla.meinkraft;
 
 import de.leafbla.meinkraft.roleplay.RoleCommand;
 import de.leafbla.meinkraft.roleplay.RoleManager;
-import de.leafbla.meinkraft.roleplay.bomber.BomberListener;
-import de.leafbla.meinkraft.roleplay.fighter.FighterListener;
-import de.leafbla.meinkraft.roleplay.ninja.NinjaListener;
-import de.leafbla.meinkraft.roleplay.thief.ThiefListener;
-import de.leafbla.meinkraft.roleplay.wizard.WizardListener;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
 public class Main extends JavaPlugin {
 
@@ -19,20 +13,14 @@ public class Main extends JavaPlugin {
 
     @Override
     public void onDisable() {
-        Bukkit.getLogger().log(Level.INFO, "Plugin disabled");
+        Bukkit.getLogger().log(Level.INFO, "MeinKraft disabled");
         roleManager.unsetAll();
     }
 
     @Override
     public void onEnable() {
+        Bukkit.getLogger().log(Level.INFO, "MeinKraft enabled");
         this.roleManager = new RoleManager(this);
-        Bukkit.getLogger().log(Level.INFO, "Plugin enabled");
-        getServer().getPluginManager().registerEvents(new ThiefListener(this), this);
-        getServer().getPluginManager().registerEvents(new NinjaListener(this), this);
-        getServer().getPluginManager().registerEvents(new BomberListener(this), this);
-        getServer().getPluginManager().registerEvents(new FighterListener(this), this);
-        getServer().getPluginManager().registerEvents(new WizardListener(this), this);
-
         this.getCommand("role").setExecutor(new RoleCommand(this.roleManager));
     }
 }

src/de/leafbla/meinkraft/roleplay/PlayerRole.java

@@ -1,31 +1,119 @@
 package de.leafbla.meinkraft.roleplay;
 
 import de.leafbla.meinkraft.Main;
+import de.leafbla.meinkraft.roleplay.wizard.ProjectileBlockHit;
+import de.leafbla.meinkraft.roleplay.wizard.ProjectileEntityHit;
+import de.leafbla.meinkraft.util.Pair;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Snowball;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.projectiles.ProjectileSource;
 
-public abstract class PlayerRole {
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 
+public abstract class PlayerRole implements Listener {
+
+    protected final Map<Integer, Pair<ProjectileEntityHit, ProjectileBlockHit>> projectiles = new HashMap<>();
+    protected final Map<Pair<Material, String>, Runnable> rightClickActions = new HashMap<>();
     protected final Player player;
-    protected final Main plugin;
+    public final Main plugin;
     private final Role role;
+    private final RoleManager roleManager;
 
     public Player getPlayer() {
         return player;
     }
 
     public PlayerRole(Main plugin, Player player, Role role) {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
         this.player = player;
         this.plugin = plugin;
         this.role = role;
+        this.roleManager = plugin.roleManager;
     }
 
     public Role getRole() {
         return this.role;
     }
 
-    public abstract void start();
-
-    public abstract void end();
+    public abstract void onStart();
 
+    public abstract void onEnd();
 
+    public void end() {
+        this.onEnd();
+        rightClickActions.keySet().forEach(pair -> player.getInventory().remove(pair.getLeft()));
+        HandlerList.unregisterAll(this);
+    }
+
+    public Snowball launchProjectile(Material material, ProjectileEntityHit entityHit, ProjectileBlockHit blockHit) {
+        Snowball snowball = Utils.launchProjectile(player, material);
+        this.projectiles.put(snowball.getEntityId(), new Pair<>(entityHit, blockHit));
+        return snowball;
+    }
+
+    public boolean matchesRole(Player player) {
+        PlayerRole playerRole = this.roleManager.getPlayerRole(player);
+        if (playerRole == null) return false;
+        return playerRole.getRole() == this.role;
+    }
+
+    public void registerRightClickAction(Material material, String name, Runnable action) {
+        player.getInventory().addItem(Utils.namedItem(material, name));
+        Bukkit.broadcastMessage(String.format("registering RCA %s %s", material.name(), name));
+        rightClickActions.put(new Pair<>(material, name), action);
+    }
+
+    @EventHandler
+    public void onInteractRightClickHandItem(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        if (!this.matchesRole(player)) return;
+        if (event.getHand() != EquipmentSlot.HAND) return;
+        if (!event.getAction().name().contains("RIGHT")) return;
+        ItemStack itemStack = player.getInventory().getItemInMainHand();
+        if (!itemStack.hasItemMeta()) return;
+        Material material = itemStack.getType();
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        if (itemMeta == null) return;
+        if (!itemMeta.hasDisplayName()) return;
+        String displayName = itemMeta.getDisplayName();
+        Pair<Material, String> pair = new Pair<>(material, displayName);
+        if (!rightClickActions.containsKey(pair)) return;
+        Runnable runnable = rightClickActions.get(pair);
+        runnable.run();
+    }
+
+
+    @EventHandler
+    public void onRegisteredProjectileHit(ProjectileHitEvent event) {
+        ProjectileSource shooter = event.getEntity().getShooter();
+        if (!(shooter instanceof Player)) return;
+        Player player = (Player) shooter;
+        if (!this.matchesRole(player)) return;
+        Projectile projectile = event.getEntity();
+        if (this.projectiles.containsKey(projectile.getEntityId())) {
+            ProjectileBlockHit projectileBlockHit = this.projectiles.get(projectile.getEntityId()).getRight();
+            ProjectileEntityHit projectileEntityHit = this.projectiles.get(projectile.getEntityId()).getLeft();
+            if (event.getHitEntity() != null) {
+                projectileEntityHit.onHit(event, projectile, event.getHitEntity(), player);
+            } else if (event.getHitBlock() != null) {
+                Entity hitEntity = event.getHitEntity();
+                projectileBlockHit.onHit(event, projectile, event.getHitBlock(), event.getHitBlockFace(), player);
+            }
+            this.projectiles.remove(projectile.getEntityId());
+        }
+    }
 }

src/de/leafbla/meinkraft/roleplay/RoleManager.java

@@ -26,7 +26,7 @@ public class RoleManager {
             return;
         }
         this.classes.put(player, thePlayerRole);
-        thePlayerRole.start();
+        thePlayerRole.onStart();
         player.sendMessage(
                 String.format("§eYou are now a §6%s§e!", StringUtils.capitalize(theclass.name()))
         );

src/de/leafbla/meinkraft/roleplay/Utils.java

@@ -6,6 +6,7 @@ import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Snowball;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
 
 public class Utils {
 
@@ -18,4 +19,13 @@ public class Utils {
     public static Snowball launchProjectile(Player player, Material material) {
         return launchProjectile(player, new ItemStack(material));
     }
+
+    public static ItemStack namedItem(Material material, String name) {
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        itemMeta.setDisplayName(name);
+        itemStack.setItemMeta(itemMeta);
+        return itemStack;
+    }
+
 }

src/de/leafbla/meinkraft/roleplay/bomber/BomberListener.java

@@ -1,121 +0,0 @@
-package de.leafbla.meinkraft.roleplay.bomber;
-
-import de.leafbla.meinkraft.Main;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Sound;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_16_R2.entity.CraftSnowball;
-import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Snowball;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class BomberListener implements Listener {
-    private final Main plugin;
-
-    private final Map<Location, Player> mines = new HashMap<>();
-    private final Map<Player, Location> c4 = new HashMap<>();
-
-    public BomberListener(Main main) {
-        this.plugin = main;
-    }
-
-    @EventHandler
-    public void onPlace(BlockPlaceEvent event) {
-        if (event.getBlockPlaced().getType() == Material.STONE_PRESSURE_PLATE) {
-            mines.put(event.getBlockPlaced().getLocation(), event.getPlayer());
-        }
-        if (event.getBlockPlaced().getType() == Material.TURTLE_EGG) {
-            if (c4.containsKey(event.getPlayer())) {
-                Location old = c4.get(event.getPlayer());
-                old.getBlock().setType(Material.AIR);
-            }
-            c4.put(event.getPlayer(), event.getBlockPlaced().getLocation());
-        }
-    }
-
-    @EventHandler
-    public void onPlace(PlayerInteractEvent event) {
-        if (event.getAction() == Action.PHYSICAL)
-            if (event.getClickedBlock().getType() == Material.STONE_PRESSURE_PLATE) {
-                World w = event.getClickedBlock().getWorld();
-                Location loc = event.getClickedBlock().getLocation();
-                if (mines.containsKey(loc)) {
-                    Player source = mines.get(loc);
-                    w.createExplosion(loc, 2f, false, false, source);
-                    mines.remove(loc);
-                    new BukkitRunnable() {
-                        @Override
-                        public void run() {
-                            loc.getBlock().setType(Material.AIR);
-                        }
-                    }.runTask(this.plugin);
-                    //mines.remove(loc);
-                }
-            }
-        if (event.getAction().name().contains("RIGHT")) {
-            if (event.getPlayer().getItemInHand().getType() == Material.REDSTONE_TORCH) {
-                World w = event.getPlayer().getWorld();
-                if (c4.containsKey(event.getPlayer())) {
-                    Location loc = c4.get(event.getPlayer());
-                    w.createExplosion(loc, 2f, false, false, event.getPlayer());
-                    w.getBlockAt(loc).setType(Material.AIR);
-                    c4.remove(event.getPlayer());
-                }
-            }
-            if (event.getPlayer().getItemInHand().getType() == Material.SLIME_BALL) {
-                ItemStack oneknife = new ItemStack(Material.SLIME_BALL, 1);
-                Snowball ball = event.getPlayer().launchProjectile(Snowball.class);
-                grenades.put(ball, event.getPlayer());
-                ball.setVelocity(ball.getVelocity().multiply(.75));
-                ball.setBounce(true);
-                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
-
-                ItemStack balls = event.getPlayer().getItemInHand();
-                int amt = balls.getAmount();
-                balls.setAmount(amt);
-                event.getPlayer().setItemInHand(balls);
-            }
-        }
-    }
-
-    Map<Snowball, Player> grenades = new HashMap<>();
-
-    @EventHandler
-    public void onLand(ProjectileHitEvent event) {
-        if (event.getEntity() instanceof Snowball) {
-            Snowball ball = (Snowball) event.getEntity();
-            ItemStack item =
-                    CraftItemStack.asBukkitCopy(
-                            ((CraftSnowball) ball).getHandle().getItem()
-                    );
-            if (item.getType() == Material.SLIME_BALL) {
-                if (grenades.containsKey(ball)) {
-                    Player thrower = grenades.get(ball);
-                    Location loc = event.getEntity().getLocation();
-                    World w = event.getEntity().getWorld();
-                    w.playSound(event.getEntity().getLocation(), Sound.ENTITY_CREEPER_PRIMED, 2, 1);
-
-                    new BukkitRunnable() {
-                        @Override
-                        public void run() {
-                            w.createExplosion(loc, 3f, false, false, thrower);
-                        }
-                    }.runTaskLater(this.plugin, 30);
-                }
-
-            }
-        }
-    }
-}

src/de/leafbla/meinkraft/roleplay/bomber/BomberRole.java

@@ -3,21 +3,39 @@ package de.leafbla.meinkraft.roleplay.bomber;
 import de.leafbla.meinkraft.Main;
 import de.leafbla.meinkraft.roleplay.PlayerRole;
 import de.leafbla.meinkraft.roleplay.Role;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_16_R2.entity.CraftSnowball;
+import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Snowball;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.HashMap;
+import java.util.Map;
 
 public class BomberRole extends PlayerRole {
 
+    private final Map<Location, Player> mines = new HashMap<>();
+    private final Map<Player, Location> c4 = new HashMap<>();
     public BomberRole(Main plugin, Player player) {
         super(plugin, player, Role.BOMBER);
     }
 
     @Override
-    public void start() {
+    public void onStart() {
         player.setLevel(42);
     }
 
     @Override
-    public void end() {
+    public void onEnd() {
         player.setLevel(0);
     }
 
@@ -25,4 +43,90 @@ public class BomberRole extends PlayerRole {
     public Role getRole() {
         return Role.BOMBER;
     }
+
+
+    public void onPlace(BlockPlaceEvent event) {
+        if (event.getBlockPlaced().getType() == Material.STONE_PRESSURE_PLATE) {
+            mines.put(event.getBlockPlaced().getLocation(), event.getPlayer());
+        }
+        if (event.getBlockPlaced().getType() == Material.TURTLE_EGG) {
+            if (c4.containsKey(event.getPlayer())) {
+                Location old = c4.get(event.getPlayer());
+                old.getBlock().setType(Material.AIR);
+            }
+            c4.put(event.getPlayer(), event.getBlockPlaced().getLocation());
+        }
+    }
+
+    public void onPlace(PlayerInteractEvent event) {
+        if (event.getAction() == Action.PHYSICAL)
+            if (event.getClickedBlock().getType() == Material.STONE_PRESSURE_PLATE) {
+                World w = event.getClickedBlock().getWorld();
+                Location loc = event.getClickedBlock().getLocation();
+                if (mines.containsKey(loc)) {
+                    Player source = mines.get(loc);
+                    w.createExplosion(loc, 2f, false, false, source);
+                    mines.remove(loc);
+                    new BukkitRunnable() {
+                        @Override
+                        public void run() {
+                            loc.getBlock().setType(Material.AIR);
+                        }
+                    }.runTask(this.plugin);
+                    //mines.remove(loc);
+                }
+            }
+        if (event.getAction().name().contains("RIGHT")) {
+            if (event.getPlayer().getItemInHand().getType() == Material.REDSTONE_TORCH) {
+                World w = event.getPlayer().getWorld();
+                if (c4.containsKey(event.getPlayer())) {
+                    Location loc = c4.get(event.getPlayer());
+                    w.createExplosion(loc, 2f, false, false, event.getPlayer());
+                    w.getBlockAt(loc).setType(Material.AIR);
+                    c4.remove(event.getPlayer());
+                }
+            }
+            if (event.getPlayer().getItemInHand().getType() == Material.SLIME_BALL) {
+                ItemStack oneknife = new ItemStack(Material.SLIME_BALL, 1);
+                Snowball ball = event.getPlayer().launchProjectile(Snowball.class);
+                grenades.put(ball, event.getPlayer());
+                ball.setVelocity(ball.getVelocity().multiply(.75));
+                ball.setBounce(true);
+                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
+
+                ItemStack balls = event.getPlayer().getItemInHand();
+                int amt = balls.getAmount();
+                balls.setAmount(amt);
+                event.getPlayer().setItemInHand(balls);
+            }
+        }
+    }
+
+    Map<Snowball, Player> grenades = new HashMap<>();
+
+    public void onLand(ProjectileHitEvent event) {
+        if (event.getEntity() instanceof Snowball) {
+            Snowball ball = (Snowball) event.getEntity();
+            ItemStack item =
+                    CraftItemStack.asBukkitCopy(
+                            ((CraftSnowball) ball).getHandle().getItem()
+                    );
+            if (item.getType() == Material.SLIME_BALL) {
+                if (grenades.containsKey(ball)) {
+                    Player thrower = grenades.get(ball);
+                    Location loc = event.getEntity().getLocation();
+                    World w = event.getEntity().getWorld();
+                    w.playSound(event.getEntity().getLocation(), Sound.ENTITY_CREEPER_PRIMED, 2, 1);
+
+                    new BukkitRunnable() {
+                        @Override
+                        public void run() {
+                            w.createExplosion(loc, 3f, false, false, thrower);
+                        }
+                    }.runTaskLater(this.plugin, 30);
+                }
+
+            }
+        }
+    }
 }

src/de/leafbla/meinkraft/roleplay/fighter/FighterListener.java

@@ -1,36 +0,0 @@
-package de.leafbla.meinkraft.roleplay.fighter;
-
-import de.leafbla.meinkraft.Main;
-import de.leafbla.meinkraft.roleplay.Role;
-import de.leafbla.meinkraft.roleplay.RoleListener;
-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.player.PlayerInteractEvent;
-
-public class FighterListener extends RoleListener<FighterRole> {
-
-    public FighterListener(Main main) {
-        super(Role.FIGHTER, main);
-    }
-
-    @EventHandler
-    public void onDamage(EntityDamageByEntityEvent event) {
-        if (!(event.getDamager() instanceof Player)) return;
-        Player player = (Player) event.getDamager();
-        if (!this.matchesRole(player)) return;
-        FighterRole role = this.getRole(player);
-        if (event.getCause() != EntityDamageEvent.DamageCause.ENTITY_ATTACK) return;
-
-        role.attackEntity(event.getEntity(), event);
-    }
-
-    @EventHandler
-    public void onAttack(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        if (!this.matchesRole(player)) return;
-        FighterRole role = this.getRole(player);
-        role.onInteract(event);
-    }
-}

src/de/leafbla/meinkraft/roleplay/fighter/FighterRole.java

@@ -11,8 +11,10 @@ import org.bukkit.Sound;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.scheduler.BukkitRunnable;
@@ -26,32 +28,22 @@ public class FighterRole extends PlayerRole implements ManaAble {
     private int mana;
     private boolean powerfist;
 
-    BukkitRunnable refillMana;
-
     public FighterRole(Main plugin, Player player) {
         super(plugin, player, Role.FIGHTER);
     }
 
     @Override
-    public void start() {
+    public void onStart() {
         this.setMana(0);
         this.player.setWalkSpeed(0.3f);
         this.powerfist = false;
         this.player.setGravity(true);
-        refillMana = new BukkitRunnable() {
-            @Override
-            public void run() {
-                addMana(1);
-            }
-        };
-        refillMana.runTaskTimer(plugin, 0, 5);
     }
 
     @Override
-    public void end() {
-        player.setExp(0.5f);
+    public void onEnd() {
+        player.setExp(0);
         this.player.setWalkSpeed(0.2f);
-        refillMana.cancel();
     }
 
     @Override
@@ -250,4 +242,20 @@ public class FighterRole extends PlayerRole implements ManaAble {
         }.runTaskTimer(plugin, 0, 1);
     }
 
+    @EventHandler
+    public void onDamage(EntityDamageByEntityEvent event) {
+        if (!(event.getDamager() instanceof Player)) return;
+        Player player = (Player) event.getDamager();
+        if (!this.matchesRole(player)) return;
+        if (event.getCause() != EntityDamageEvent.DamageCause.ENTITY_ATTACK) return;
+
+        this.attackEntity(event.getEntity(), event);
+    }
+
+    @EventHandler
+    public void onAttack(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        if (!this.matchesRole(player)) return;
+        this.onInteract(event);
+    }
 }

src/de/leafbla/meinkraft/roleplay/ninja/NinjaListener.java

@@ -1,126 +0,0 @@
-package de.leafbla.meinkraft.roleplay.ninja;
-
-import de.leafbla.meinkraft.Main;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.Particle;
-import org.bukkit.craftbukkit.v1_16_R2.entity.CraftSnowball;
-import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Snowball;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.ShapedRecipe;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.scheduler.BukkitRunnable;
-
-public class NinjaListener implements Listener {
-    private Main plugin;
-
-    public NinjaListener(Main main) {
-        this.plugin = main;
-        addKnife();
-        addDarts();
-    }
-
-    private void addDarts() {
-        ItemStack item = new ItemStack(Material.STICK);
-        ItemMeta im = item.getItemMeta();
-        im.setDisplayName("Blowpipe");
-        item.setItemMeta(im);
-        NamespacedKey key = new NamespacedKey(plugin, "blowpipe");
-        ShapedRecipe recipe = new ShapedRecipe(key, item);
-        recipe.shape("D", "D");
-        recipe.setIngredient('D', Material.DIRT);
-        Bukkit.addRecipe(recipe);
-    }
-
-    private void addKnife() {
-        ItemStack item = new ItemStack(Material.IRON_INGOT);
-        ItemMeta im = item.getItemMeta();
-        im.setDisplayName("Throwing Knife");
-        item.setItemMeta(im);
-        NamespacedKey key = new NamespacedKey(plugin, "throwing_knife");
-        ShapedRecipe recipe = new ShapedRecipe(key, item);
-        recipe.shape("DD", "DD");
-        recipe.setIngredient('D', Material.DIRT);
-        Bukkit.addRecipe(recipe);
-    }
-
-    public void onInteract(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        if (event.getAction().name().contains("RIGHT")) {
-            ItemStack knife = event.getPlayer().getInventory().getItemInMainHand();
-            if (knife.getType() == Material.IRON_INGOT) {
-                ItemStack oneknife = knife.clone();
-                oneknife.setAmount(1);
-                Snowball ball = player.launchProjectile(Snowball.class);
-                ball.setVelocity(ball.getVelocity().multiply(1.2));
-                ball.setBounce(false);
-                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
-
-                int amt = knife.getAmount();
-                knife.setAmount(amt - 1);
-                player.setItemInHand(knife);
-            } else if (knife.getType() == Material.STICK) {
-                ItemStack oneknife = new ItemStack(Material.FEATHER, 1);
-                Snowball ball = player.launchProjectile(Snowball.class);
-                ball.setVelocity(ball.getVelocity().multiply(3));
-                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
-
-                int amt = knife.getAmount();
-                flying = true;
-                new BukkitRunnable() {
-                    int i = 0;
-
-                    @Override
-                    public void run() {
-                        if (flying)
-                            ball.getWorld().spawnParticle(Particle.FLAME, ball.getLocation(), 0);
-                        else
-                            this.cancel();
-                    }
-                }.runTaskTimerAsynchronously(this.plugin, 0, 1);
-                //knife.setAmount(amt - 1);
-                //player.setItemInHand(knife);
-            }
-        }
-    }
-
-    private boolean flying = false;
-
-    @EventHandler
-    public void onLand(ProjectileHitEvent event) {
-        if (event.getEntity() instanceof Snowball) {
-            Snowball ball = (Snowball) event.getEntity();
-            ItemStack item =
-                    CraftItemStack.asBukkitCopy(
-                            ((CraftSnowball) ball).getHandle().getItem()
-                    );
-            if (item.getType() == Material.IRON_INGOT) {
-                if (event.getHitEntity() == null)
-                    event.getEntity().getWorld().dropItem(event.getEntity().getLocation(), item);
-                else {
-                    if (event.getHitEntity() instanceof LivingEntity)
-                        ((LivingEntity) event.getHitEntity()).damage(8);
-                }
-            } else if (item.getType() == Material.FEATHER) {
-                flying = false;
-                if (event.getHitEntity() != null) {
-                    if (event.getHitEntity() instanceof LivingEntity) {
-                        LivingEntity len = ((LivingEntity) event.getHitEntity());
-                        Bukkit.broadcastMessage(String.format("hit %s", len.getName()));
-                        len.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 5 * 20, 0, true, true));
-                    }
-                }
-            }
-        }
-    }
-}

src/de/leafbla/meinkraft/roleplay/ninja/NinjaRole.java

@@ -3,26 +3,216 @@ package de.leafbla.meinkraft.roleplay.ninja;
 import de.leafbla.meinkraft.Main;
 import de.leafbla.meinkraft.roleplay.PlayerRole;
 import de.leafbla.meinkraft.roleplay.Role;
-import org.bukkit.entity.Player;
+import de.leafbla.meinkraft.roleplay.Utils;
+import de.leafbla.meinkraft.roleplay.wizard.ProjectileBlockHit;
+import de.leafbla.meinkraft.roleplay.wizard.ProjectileEntityHit;
+import org.bukkit.*;
+import org.bukkit.entity.*;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.PotionData;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.potion.PotionType;
+import org.bukkit.projectiles.ProjectileSource;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.util.RayTraceResult;
+import org.bukkit.util.Vector;
+
+import java.util.Date;
+import java.util.EventListener;
+import java.util.Objects;
 
 public class NinjaRole extends PlayerRole {
 
+    private BukkitRunnable stealth;
+    private Date lastMove;
+    private final long STEALTHDELAY = 1000;
+    private boolean stealthed = false;
+
     public NinjaRole(Main plugin, Player player) {
         super(plugin, player, Role.NINJA);
     }
 
     @Override
-    public void start() {
+    public void onStart() {
+        this.registerRightClickAction(Material.STICK, "Blasrohr", this::blasrohr);
+        this.registerRightClickAction(Material.SLIME_BALL, "Lingering Poison Potion", this::poisonCloud);
+        this.registerRightClickAction(Material.BONE, "Dash Attack", this::dash);
 
+        stealth = new BukkitRunnable() {
+            @Override
+            public void run() {
+                Date now = new Date();
+                if (stealthed) {
+                    player.removePotionEffect(PotionEffectType.INVISIBILITY);
+                    player.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 20 * 20, 0, false, false));
+                } else {
+                    if (now.getTime() - lastMove.getTime() > STEALTHDELAY) {
+                        stealthed = true;
+                        player.playSound(player.getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, 1, 1);
+                        player.removePotionEffect(PotionEffectType.INVISIBILITY);
+                        player.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 20 * 20, 0, false, false));
+                    }
+                }
+            }
+        };
+        stealth.runTaskTimer(plugin, 0, 10);
+        lastMove = new Date();
     }
 
     @Override
-    public void end() {
-
+    public void onEnd() {
+        stealth.cancel();
+        player.removePotionEffect(PotionEffectType.INVISIBILITY);
     }
 
-    @Override
-    public Role getRole() {
-        return Role.NINJA;
+
+    private void blasrohr() {
+        Snowball ball = this.launchProjectile(Material.ARROW, (event, projectile, target, shooter) -> {
+            if (!(target instanceof LivingEntity)) return;
+            LivingEntity livingEntity = (LivingEntity) target;
+            livingEntity.removePotionEffect(PotionEffectType.POISON);
+            livingEntity.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 3 * 20, 0, true));
+        }, (event, projectile, target, targetFace, shooter) -> {
+
+        });
+        ball.setVelocity(ball.getVelocity().multiply(2));
+    }
+
+    private void poisonCloud() {
+        ThrownPotion thownPotion = player.launchProjectile(ThrownPotion.class);
+        ItemStack lingeringPotion = new ItemStack(Material.LINGERING_POTION);
+        PotionMeta potionMeta = (PotionMeta) lingeringPotion.getItemMeta();
+        potionMeta.setBasePotionData(new PotionData(PotionType.POISON, true, false));
+        lingeringPotion.setItemMeta(potionMeta);
+        thownPotion.setItem(lingeringPotion);
+    }
+
+    public void onMove2(PlayerMoveEvent event) {
+        if (event.getFrom().getBlock().equals(event.getTo().getBlock())) return; // not really moved, huh?
+        this.lastMove = new Date();
+        if (stealthed) {
+            player.setWalkSpeed(0.15f);
+            if (event.getPlayer().isSneaking()) return;
+            this.stealthed = false;
+            player.removePotionEffect(PotionEffectType.INVISIBILITY);
+            player.playSound(player.getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, 1, 1);
+        } else {
+            player.setWalkSpeed(0.2f);
+        }
+    }
+
+    final int DASHLENGTH = 20;
+
+    public void dash() {
+        RayTraceResult blockTraceResult = player.getWorld().rayTraceBlocks(player.getEyeLocation(), player.getEyeLocation().getDirection(), DASHLENGTH);
+        RayTraceResult entityTraceResult = player.getWorld().rayTraceEntities(player.getEyeLocation(), player.getEyeLocation().getDirection(), DASHLENGTH, e -> (e instanceof LivingEntity) && (!e.equals(player)));
+        if (blockTraceResult != null && (blockTraceResult.getHitBlock() != null && entityTraceResult != null)) {
+            double blockDistance = blockTraceResult.getHitPosition().distance(player.getEyeLocation().toVector());
+            double entityDistance = entityTraceResult.getHitPosition().distance(player.getEyeLocation().toVector());
+            if (blockDistance < entityDistance) {
+                player.sendMessage("obstructed");
+                return;
+            }
+        }
+        //player.sendMessage(String.format("e: %s, b: %s", entityTraceResult.getHitEntity(), entityTraceResult.getHitBlock()));
+        if (entityTraceResult == null) return;
+        Entity hit = entityTraceResult.getHitEntity();
+        if (!(hit instanceof LivingEntity)) return;
+        LivingEntity entity = (LivingEntity) hit;
+        Location entityLocation = entity.getEyeLocation();
+        entityLocation.setPitch(0);
+        Vector behindEntity = entityLocation.getDirection().normalize().multiply(-1);
+        Location newLocation = entity.getLocation().add(behindEntity);
+        Vector facingEntity = newLocation.toVector().subtract(entity.getLocation().toVector()).multiply(-1);
+        newLocation.setDirection(facingEntity);
+        player.teleport(newLocation);
+        player.attack(entity);
+    }
+
+    public void projectileHit(ProjectileHitEvent event) {
+        assert Objects.equals(event.getEntity().getShooter(), player);
+        Projectile projectile = event.getEntity();
+        if (this.projectiles.containsKey(projectile.getEntityId())) {
+            ProjectileBlockHit projectileBlockHit = this.projectiles.get(projectile.getEntityId()).getRight();
+            ProjectileEntityHit projectileEntityHit = this.projectiles.get(projectile.getEntityId()).getLeft();
+            if (event.getHitEntity() != null) {
+                projectileEntityHit.onHit(event, projectile, event.getHitEntity(), player);
+            } else if (event.getHitBlock() != null) {
+                Entity hitEntity = event.getHitEntity();
+                projectileBlockHit.onHit(event, projectile, event.getHitBlock(), event.getHitBlockFace(), player);
+            }
+            this.projectiles.remove(projectile.getEntityId());
+        }
+    }
+
+    public void lingeringPotionSplash(LingeringPotionSplashEvent event) {
+        event.getAreaEffectCloud().setDuration(5 * 20);
+    }
+
+    public void effectCloudApply(AreaEffectCloudApplyEvent event) {
+        event.setCancelled(true);
+        //player.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, 20, 0));
+    }
+
+    @EventHandler
+    public void onMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+        if (!this.matchesRole(player)) return;
+        this.onMove2(event);
+    }
+
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        if (!this.matchesRole(player)) return;
+    }
+
+    @EventHandler
+    public void onPoison(EntityDamageEvent event) {
+        if (!(event.getEntity() instanceof Player)) return;
+        Player player = (Player) event.getEntity();
+        if (!this.matchesRole(player)) return;
+        if (event.getCause() == EntityDamageEvent.DamageCause.POISON)
+            event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onLand(ProjectileHitEvent event) {
+        ProjectileSource shooter = event.getEntity().getShooter();
+        if (!(shooter instanceof Player)) return;
+        Player player = (Player) shooter;
+        if (!this.matchesRole(player)) return;
+        this.projectileHit(event);
+    }
+
+    @EventHandler
+    public void onPoisonLaydown(LingeringPotionSplashEvent event) {
+        ProjectileSource shooter = event.getEntity().getShooter();
+        if (!(shooter instanceof Player)) return;
+        Player player = (Player) shooter;
+        if (!this.matchesRole(player)) return;
+        this.lingeringPotionSplash(event);
+    }
+
+    @EventHandler
+    public void onCloudApply(AreaEffectCloudApplyEvent event) {
+        ProjectileSource shooter = event.getEntity().getSource();
+        if (!(shooter instanceof Player)) return;
+        Player player = (Player) shooter;
+        if (!this.matchesRole(player)) return;
+        this.effectCloudApply(event);
     }
 }

src/de/leafbla/meinkraft/roleplay/wizard/WizardListener.java

@@ -1,129 +0,0 @@
-package de.leafbla.meinkraft.roleplay.wizard;
-
-import de.leafbla.meinkraft.Main;
-import de.leafbla.meinkraft.roleplay.Role;
-import de.leafbla.meinkraft.roleplay.RoleListener;
-import de.leafbla.meinkraft.roleplay.fighter.FighterRole;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
-import org.bukkit.Particle;
-import org.bukkit.craftbukkit.v1_16_R2.entity.CraftSnowball;
-import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Snowball;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerItemHeldEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.ShapedRecipe;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.projectiles.ProjectileSource;
-import org.bukkit.scheduler.BukkitRunnable;
-
-public class WizardListener extends RoleListener<WizardRole> {
-
-    public WizardListener(Main main) {
-        super(Role.WIZARD, main);
-    }
-
-    @EventHandler
-    public void onHold(PlayerItemHeldEvent event) {
-        Player player = event.getPlayer();
-        if (!this.matchesRole(player)) return;
-        WizardRole role = this.getRole(player);
-        role.onItemHeld(event);
-    }
-
-    @EventHandler
-    public void onAttack(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        if (!this.matchesRole(player)) return;
-        WizardRole role = this.getRole(player);
-        role.onInteract(event);
-    }
-
-    public void onInteract(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        if (event.getAction().name().contains("RIGHT")) {
-            ItemStack knife = event.getPlayer().getInventory().getItemInMainHand();
-            if (knife.getType() == Material.IRON_INGOT) {
-                ItemStack oneknife = knife.clone();
-                oneknife.setAmount(1);
-                Snowball ball = player.launchProjectile(Snowball.class);
-                ball.setVelocity(ball.getVelocity().multiply(1.2));
-                ball.setBounce(false);
-                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
-
-                int amt = knife.getAmount();
-                knife.setAmount(amt - 1);
-                player.setItemInHand(knife);
-            } else if (knife.getType() == Material.STICK) {
-                ItemStack oneknife = new ItemStack(Material.FEATHER, 1);
-                Snowball ball = player.launchProjectile(Snowball.class);
-                ball.setVelocity(ball.getVelocity().multiply(3));
-                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
-
-                int amt = knife.getAmount();
-                flying = true;
-                new BukkitRunnable() {
-                    int i = 0;
-
-                    @Override
-                    public void run() {
-                        if (flying)
-                            ball.getWorld().spawnParticle(Particle.FLAME, ball.getLocation(), 0);
-                        else
-                            this.cancel();
-                    }
-                }.runTaskTimerAsynchronously(this.plugin, 0, 1);
-                //knife.setAmount(amt - 1);
-                //player.setItemInHand(knife);
-            }
-        }
-    }
-
-    private boolean flying = false;
-
-    @EventHandler
-    public void onLand(ProjectileHitEvent event) {
-        Bukkit.getLogger().info("PHE");
-        ProjectileSource shooter = event.getEntity().getShooter();
-        if (!(shooter instanceof Player)) return;
-        Bukkit.getLogger().info("shooter was player");
-        Player player = (Player) shooter;
-        if (!this.matchesRole(player)) return;
-        WizardRole role = this.getRole(player);
-        Bukkit.getLogger().info("PHE");
-        role.projectileHit(event);
-        //if (event.getEntity() instanceof Snowball) {
-        //    Snowball ball = (Snowball) event.getEntity();
-        //    ItemStack item =
-        //            CraftItemStack.asBukkitCopy(
-        //                    ((CraftSnowball) ball).getHandle().getItem()
-        //            );
-        //    if (item.getType() == Material.IRON_INGOT) {
-        //        if (event.getHitEntity() == null)
-        //            event.getEntity().getWorld().dropItem(event.getEntity().getLocation(), item);
-        //        else {
-        //            if (event.getHitEntity() instanceof LivingEntity)
-        //                ((LivingEntity) event.getHitEntity()).damage(8);
-        //        }
-        //    } else if (item.getType() == Material.FEATHER) {
-        //        flying = false;
-        //        if (event.getHitEntity() != null) {
-        //            if (event.getHitEntity() instanceof LivingEntity) {
-        //                LivingEntity len = ((LivingEntity) event.getHitEntity());
-        //                Bukkit.broadcastMessage(String.format("hit %s", len.getName()));
-        //                len.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 5 * 20, 0, true, true));
-        //            }
-        //        }
-        //    }
-        //}
-    }
-}

src/de/leafbla/meinkraft/roleplay/wizard/WizardRole.java

@@ -8,24 +8,30 @@ import de.leafbla.meinkraft.roleplay.Utils;
 import de.leafbla.meinkraft.util.Pair;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.craftbukkit.v1_16_R2.entity.CraftSnowball;
+import org.bukkit.craftbukkit.v1_16_R2.inventory.CraftItemStack;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
 import org.bukkit.entity.Snowball;
+import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.ProjectileHitEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerItemHeldEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.projectiles.ProjectileSource;
+import org.bukkit.scheduler.BukkitRunnable;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 
-public class WizardRole extends PlayerRole implements ManaAble {
+public class WizardRole extends PlayerRole implements ManaAble, EventListener {
+
+    BukkitRunnable refillMana;
+    Set<Player> transmorphedPlayers = new HashSet<>();
 
-    private final Map<Integer, Pair<ProjectileEntityHit, ProjectileBlockHit>> projectiles = new HashMap<>();
     private int mana;
 
     public WizardRole(Main plugin, Player player) {
@@ -50,32 +56,34 @@ public class WizardRole extends PlayerRole implements ManaAble {
     }
 
     @Override
-    public void start() {
-        setupInventory();
-        this.currentSpell = WizardSpell.values()[0];
-        this.mana = 0;
-    }
+    public void onStart() {
+        for (WizardSpell wizardSpell : WizardSpell.values())
+            this.registerRightClickAction(wizardSpell.getIcon(), wizardSpell.displayName(), () -> wizardSpell.cast(this));
 
-    private ItemStack namedItem(Material material, String name) {
-        ItemStack itemStack = new ItemStack(material);
-        ItemMeta itemMeta = itemStack.getItemMeta();
-        itemMeta.setDisplayName(name);
-        itemStack.setItemMeta(itemMeta);
-        return itemStack;
+        this.currentSpell = WizardSpell.values()[0];
+        this.mana = 33;
+        refillMana = new BukkitRunnable() {
+            @Override
+            public void run() {
+                addMana(1);
+            }
+        };
+        refillMana.runTaskTimer(plugin, 0, 5);
     }
 
     private void setupInventory() {
         ItemStack wand = new ItemStack(Material.STICK);
         player.getInventory().clear();
         player.getInventory().setHeldItemSlot(0);
-        player.getInventory().addItem(namedItem(Material.STICK, "Wand"));
+        player.getInventory().addItem(Utils.namedItem(Material.STICK, "Wand"));
         for (WizardSpell wizardSpell : WizardSpell.values()) {
-            player.getInventory().addItem(namedItem(wizardSpell.getIcon(), wizardSpell.displayName()));
+            player.getInventory().addItem(Utils.namedItem(wizardSpell.getIcon(), wizardSpell.displayName()));
         }
     }
 
     @Override
-    public void end() {
+    public void onEnd() {
+        refillMana.cancel();
     }
 
     @Override
@@ -83,62 +91,48 @@ public class WizardRole extends PlayerRole implements ManaAble {
         return Role.WIZARD;
     }
 
-    public Snowball launchProjectile(Material material, ProjectileEntityHit entityHit, ProjectileBlockHit blockHit) {
-        Snowball snowball = Utils.launchProjectile(player, material);
-        this.projectiles.put(snowball.getEntityId(), new Pair<>(entityHit, blockHit));
-        return snowball;
+
+
+    public void onInteractOldTestStuffs(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        if (event.getAction().name().contains("RIGHT")) {
+            ItemStack knife = event.getPlayer().getInventory().getItemInMainHand();
+            if (knife.getType() == Material.IRON_INGOT) {
+                ItemStack oneknife = knife.clone();
+                oneknife.setAmount(1);
+                Snowball ball = player.launchProjectile(Snowball.class);
+                ball.setVelocity(ball.getVelocity().multiply(1.2));
+                ball.setBounce(false);
+                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
+
+                int amt = knife.getAmount();
+                knife.setAmount(amt - 1);
+                player.setItemInHand(knife);
+            } else if (knife.getType() == Material.STICK) {
+                ItemStack oneknife = new ItemStack(Material.FEATHER, 1);
+                Snowball ball = player.launchProjectile(Snowball.class);
+                ball.setVelocity(ball.getVelocity().multiply(3));
+                ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(oneknife));
+
+                int amt = knife.getAmount();
+                flying = true;
+                new BukkitRunnable() {
+                    int i = 0;
+
+                    @Override
+                    public void run() {
+                        if (flying)
+                            ball.getWorld().spawnParticle(Particle.FLAME, ball.getLocation(), 0);
+                        else
+                            this.cancel();
+                    }
+                }.runTaskTimerAsynchronously(this.plugin, 0, 1);
+                //knife.setAmount(amt - 1);
+                //player.setItemInHand(knife);
+            }
+        }
     }
 
-    public void onInteract(PlayerInteractEvent event) {
-        ItemStack itemStack = event.getPlayer().getInventory().getItemInMainHand();
-        if (itemStack.getType() != Material.STICK) return;
-        if (!itemStack.hasItemMeta()) return;
-        if (!event.getAction().name().startsWith("RIGHT")) return;
-        if (event.getHand() == EquipmentSlot.OFF_HAND) return;
-        this.castSpell();
-    }
+    private boolean flying = false;
 
-    private void castSpell() {
-        this.currentSpell.cast(this);
-    }
-
-    public void onItemHeld(PlayerItemHeldEvent event) {
-        int newslot = event.getNewSlot();
-        if (newslot == 0) return; // self caused or irrelevant
-        callSpellSlot(newslot - 1);
-        event.setCancelled(true);
-        player.getInventory().setHeldItemSlot(0);
-        event.setCancelled(true);
-    }
-
-    private void callSpellSlot(int newslot) {
-        if (newslot >= WizardSpell.values().length) return;
-        this.currentSpell = WizardSpell.values()[newslot];
-        ItemMeta itemMeta = player.getInventory().getItemInMainHand().getItemMeta();
-        itemMeta.setDisplayName(this.currentSpell.displayName());
-        player.getInventory().getItemInMainHand().setItemMeta(itemMeta);
-        player.sendMessage(String.format("§eEquipped Spell §6%s§e.", this.currentSpell.displayName()));
-    }
-
-    /**
-     * Called when a projectile hits something that originates from the player
-     *
-     * @param event
-     */
-    public void projectileHit(ProjectileHitEvent event) {
-        assert Objects.equals(event.getEntity().getShooter(), player);
-        Projectile projectile = event.getEntity();
-        if (this.projectiles.containsKey(projectile.getEntityId())) {
-            Bukkit.getLogger().info("Known projectile");
-            ProjectileBlockHit projectileBlockHit = this.projectiles.get(projectile.getEntityId()).getRight();
-            ProjectileEntityHit projectileEntityHit = this.projectiles.get(projectile.getEntityId()).getLeft();
-            if (event.getHitEntity() != null) {
-                projectileEntityHit.onHit(event, projectile, event.getHitEntity(), player);
-            } else if (event.getHitBlock() != null) {
-                Entity hitEntity = event.getHitEntity();
-                projectileBlockHit.onHit(event, projectile, event.getHitBlock(), event.getHitBlockFace(), player);
-            }
-            this.projectiles.remove(projectile.getEntityId());
-        }
-    }
 }

src/de/leafbla/meinkraft/roleplay/wizard/WizardSpell.java

@@ -1,39 +1,120 @@
 package de.leafbla.meinkraft.roleplay.wizard;
 
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
 import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.EntityType;
 import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
 
 enum WizardSpell {
-    PUFF_OF_MAGIC("Puff of Magic", Material.NETHER_STAR) {
+    PUFF_OF_MAGIC("Puff of Magic", Material.NETHER_STAR, 5) {
         @Override
-        void cast(WizardRole wizardRole) {
+        public void _cast(WizardRole wizardRole) {
             wizardRole.launchProjectile(Material.NETHER_STAR,
                     (event, projectile, target, shooter) -> {
                         if (!(target instanceof LivingEntity)) return;
                         LivingEntity livingEntity = (LivingEntity) target;
-                        livingEntity.addPotionEffect(new PotionEffect(PotionEffectType.GLOWING, 5 * 20, 0));
+                        if (livingEntity.hasPotionEffect(PotionEffectType.GLOWING)) {
+                            livingEntity.removePotionEffect(PotionEffectType.GLOWING);
                             livingEntity.damage(2);
+                            livingEntity.setVelocity(livingEntity.getVelocity().add(projectile.getVelocity()));
+                        } else {
+                            livingEntity.addPotionEffect(new PotionEffect(PotionEffectType.GLOWING, 5 * 20, 0));
+                            livingEntity.damage(1);
+                        }
                     },
                     (event, projectile, target, targetFace, shooter) -> {
-                        target.breakNaturally();
                     });
         }
     },
-    SPELL2("Fireball", Material.FIRE_CHARGE),
-    SPELL3("Something Something", Material.CLAY);
+    TRANSMORPH("Transmorgify", Material.FEATHER, 30) {
+        @Override
+        public void _cast(WizardRole wizardRole) {
+            wizardRole.launchProjectile(Material.FEATHER,
+                    (event, projectile, target, shooter) -> {
+                        if (!(target instanceof Player)) return;
+                        if (target.equals(shooter)) return;
+                        wizardRole.addMana(this.getManaCost());
+                        Player player = (Player) target;
+                        GameMode previousGamemode = player.getGameMode();
+                        player.setGameMode(GameMode.SPECTATOR);
+                        Chicken chicken = (Chicken) player.getWorld().spawnEntity(player.getLocation(), EntityType.CHICKEN);
+                        int duration = 4 * 20;
+                        chicken.setNoDamageTicks(duration);
+
+                        new BukkitRunnable() {
+                            @Override
+                            public void run() {
+                                player.setSpectatorTarget(chicken);
+                                player.playSound(player.getLocation(), Sound.ENTITY_CHICKEN_AMBIENT, 1, 1);
+                                wizardRole.transmorphedPlayers.add(player);
+                            }
+                        }.runTask(wizardRole.plugin);
+
+                        BukkitRunnable undo = new BukkitRunnable() {
+                            @Override
+                            public void run() {
+                                player.setSpectatorTarget(null);
+                                player.setGameMode(previousGamemode);
+                                chicken.remove();
+                                player.playSound(player.getLocation(), Sound.ENTITY_CHICKEN_DEATH, 1, 1);
+                                wizardRole.transmorphedPlayers.remove(player);
+                            }
+                        };
+                        undo.runTaskLater(wizardRole.plugin, duration);
+                        new BukkitRunnable() {
+                            int time = 0;
+
+                            @Override
+                            public void run() {
+                                time += 2;
+                                if (time >= duration) {
+                                    this.cancel();
+                                }
+                                player.setSpectatorTarget(chicken);
+                            }
+                        }.runTaskTimer(wizardRole.plugin, 0, 2);
+                    },
+                    (event, projectile, target, targetFace, shooter) -> {
+                    });
+        }
+    };
 
     private final String displayName;
     private final Material icon;
+    private final int manaCost;
 
-    WizardSpell(String displayName, Material iconMaterial) {
+    WizardSpell(String displayName, Material iconMaterial, int manaCost) {
         this.displayName = displayName;
         this.icon = iconMaterial;
+        this.manaCost = manaCost;
     }
 
-    void cast(WizardRole wizardRole) {
-        wizardRole.getPlayer().sendMessage(String.format("§eCasting §6%s§e.", this.displayName));
+    public int getManaCost() {
+        return this.manaCost;
+    }
+
+    public void _cast(WizardRole wizardRole) {
+    }
+
+    public void insufficientMana(WizardRole wizardRole) {
+        Player player = wizardRole.getPlayer();
+        player.playSound(player.getLocation(), Sound.BLOCK_FIRE_EXTINGUISH, 1, 1);
+    }
+
+    public void cast(WizardRole wizardRole) {
+        if (wizardRole.getMana() >= this.manaCost) {
+            wizardRole.addMana(-this.manaCost);
+            this._cast(wizardRole);
+        } else {
+            this.insufficientMana(wizardRole);
+        }
     }
 
     public String displayName() {

src/de/leafbla/meinkraft/util/Pair.java

@@ -1,8 +1,8 @@
 package de.leafbla.meinkraft.util;
 
 public class Pair<L, R> {
-    private L l;
-    private R r;
+    private final L l;
+    private final R r;
 
     public Pair(L l, R r) {
         this.l = l;
@@ -16,4 +16,16 @@ public class Pair<L, R> {
     public L getLeft() {
         return this.l;
     }
+
+    @Override
+    public int hashCode() {
+        return l.hashCode() * r.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!(o instanceof Pair)) return false;
+        Pair other = (Pair) o;
+        return this.l.equals(other.l) && this.r.equals(other.r);
+    }
 }