Implement Wizard Spells

src/de/leafbla/meinkraft/Main.java

@@ -6,6 +6,7 @@ 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;
 
@@ -30,6 +31,7 @@ public class Main extends JavaPlugin {
         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/ManaAble.java

@@ -0,0 +1,21 @@
+package de.leafbla.meinkraft.roleplay;
+
+public interface ManaAble {
+
+    int getMana();
+    void setManaRaw(int mana);
+    void onUpdateMana();
+
+    default int getMaxMana() {
+        return 100;
+    }
+
+    default void addMana(int newmana) {
+        this.setMana(this.getMana() + newmana);
+    }
+
+    default void setMana(int newmana) {
+        this.setManaRaw(Math.min(Math.max(0, newmana), this.getMaxMana()));
+        this.onUpdateMana();
+    }
+}

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

@@ -7,16 +7,25 @@ public abstract class PlayerRole {
 
     protected final Player player;
     protected final Main plugin;
+    private final Role role;
 
-    public PlayerRole(Main plugin, Player player) {
+    public Player getPlayer() {
+        return player;
+    }
+
+    public PlayerRole(Main plugin, Player player, Role role) {
         this.player = player;
         this.plugin = plugin;
+        this.role = role;
+    }
+
+    public Role getRole() {
+        return this.role;
     }
 
     public abstract void start();
 
     public abstract void end();
 
-    public abstract Role getRole();
 
 }

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

@@ -6,6 +6,7 @@ import org.bukkit.entity.Player;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.logging.Logger;
 
 public class RoleManager {
@@ -43,7 +44,8 @@ public class RoleManager {
     }
 
     public void unsetAll() {
-        classes.keySet().forEach(this::unsetClass);
+        Set<Player> players = classes.keySet();
+        for (Player p: players) unsetClass(p);
     }
 
     public PlayerRole getPlayerRole(Player player) {

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

@@ -0,0 +1,21 @@
+package de.leafbla.meinkraft.roleplay;
+
+import org.bukkit.Material;
+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.inventory.ItemStack;
+
+public class Utils {
+
+    public static Snowball launchProjectile(Player player, ItemStack itemStack) {
+        Snowball ball = player.launchProjectile(Snowball.class);
+        ((CraftSnowball) ball).getHandle().setItem(CraftItemStack.asNMSCopy(itemStack));
+        return ball;
+    }
+
+    public static Snowball launchProjectile(Player player, Material material) {
+        return launchProjectile(player, new ItemStack(material));
+    }
+}

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

@@ -8,7 +8,7 @@ import org.bukkit.entity.Player;
 public class BomberRole extends PlayerRole {
 
     public BomberRole(Main plugin, Player player) {
-        super(plugin, player);
+        super(plugin, player, Role.BOMBER);
     }
 
     @Override

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

@@ -1,6 +1,7 @@
 package de.leafbla.meinkraft.roleplay.fighter;
 
 import de.leafbla.meinkraft.Main;
+import de.leafbla.meinkraft.roleplay.ManaAble;
 import de.leafbla.meinkraft.roleplay.PlayerRole;
 import de.leafbla.meinkraft.roleplay.Role;
 import org.bukkit.Bukkit;
@@ -20,13 +21,15 @@ import org.bukkit.util.Vector;
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class FighterRole extends PlayerRole {
+public class FighterRole extends PlayerRole implements ManaAble {
 
     private int mana;
     private boolean powerfist;
 
+    BukkitRunnable refillMana;
+
     public FighterRole(Main plugin, Player player) {
-        super(plugin, player);
+        super(plugin, player, Role.FIGHTER);
     }
 
     @Override
@@ -35,32 +38,35 @@ public class FighterRole extends PlayerRole {
         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);
         this.player.setWalkSpeed(0.2f);
-
-    }
-
-    public void addMana(int mana) {
-        this.setMana(this.mana + mana);
-    }
-
-    private void setMana(int mana) {
-        mana = Math.min(Math.max(0, mana), 100);
-        this.mana = mana;
-        this.updateExp();
-    }
-
-    private void updateExp() {
-        player.setExp((this.mana * 1.0f) / 100f);
+        refillMana.cancel();
     }
 
     @Override
-    public Role getRole() {
-        return Role.FIGHTER;
+    public int getMana() {
+        return this.mana;
+    }
+
+    @Override
+    public void setManaRaw(int mana) {
+        this.mana = mana;
+    }
+
+    @Override
+    public void onUpdateMana() {
+        player.setExp((this.mana * 1.0f) / 100f);
     }
 
     boolean inAir = false;

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

@@ -54,7 +54,6 @@ public class NinjaListener implements Listener {
         Bukkit.addRecipe(recipe);
     }
 
-    @EventHandler
     public void onInteract(PlayerInteractEvent event) {
         Player player = event.getPlayer();
         if (event.getAction().name().contains("RIGHT")) {

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

@@ -8,7 +8,7 @@ import org.bukkit.entity.Player;
 public class NinjaRole extends PlayerRole {
 
     public NinjaRole(Main plugin, Player player) {
-        super(plugin, player);
+        super(plugin, player, Role.NINJA);
     }
 
     @Override

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

@@ -0,0 +1,12 @@
+package de.leafbla.meinkraft.roleplay.wizard;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.entity.ProjectileHitEvent;
+
+@FunctionalInterface
+public interface ProjectileBlockHit {
+    void onHit(ProjectileHitEvent event, Projectile projectile, Block target, BlockFace targetFace, Player shooter);
+}

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

@@ -0,0 +1,11 @@
+package de.leafbla.meinkraft.roleplay.wizard;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.entity.ProjectileHitEvent;
+
+@FunctionalInterface
+public interface ProjectileEntityHit {
+    void onHit(ProjectileHitEvent event, Projectile projectile, Entity target, Player shooter);
+}

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

@@ -0,0 +1,129 @@
+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

@@ -1,35 +1,144 @@
 package de.leafbla.meinkraft.roleplay.wizard;
 
 import de.leafbla.meinkraft.Main;
+import de.leafbla.meinkraft.roleplay.ManaAble;
 import de.leafbla.meinkraft.roleplay.PlayerRole;
 import de.leafbla.meinkraft.roleplay.Role;
+import de.leafbla.meinkraft.roleplay.Utils;
+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.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;
 
-public class WizardRole extends PlayerRole {
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+public class WizardRole extends PlayerRole implements ManaAble {
+
+    private final Map<Integer, Pair<ProjectileEntityHit, ProjectileBlockHit>> projectiles = new HashMap<>();
+    private int mana;
 
     public WizardRole(Main plugin, Player player) {
-        super(plugin, player);
+        super(plugin, player, Role.WIZARD);
+    }
+
+    private WizardSpell currentSpell;
+
+    @Override
+    public int getMana() {
+        return this.mana;
+    }
+
+    @Override
+    public void setManaRaw(int mana) {
+        this.mana = mana;
+    }
+
+    @Override
+    public void onUpdateMana() {
+        player.setExp((this.mana * 1.0f) / 100f);
     }
 
     @Override
     public void start() {
+        setupInventory();
+        this.currentSpell = WizardSpell.values()[0];
+        this.mana = 0;
+    }
+
+    private ItemStack namedItem(Material material, String name) {
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        itemMeta.setDisplayName(name);
+        itemStack.setItemMeta(itemMeta);
+        return itemStack;
+    }
+
+    private void setupInventory() {
         ItemStack wand = new ItemStack(Material.STICK);
-        ItemMeta im = wand.getItemMeta();
-        im.setDisplayName("Wand");
-        wand.setItemMeta(im);
-        player.setItemInHand(wand);
+        player.getInventory().clear();
+        player.getInventory().setHeldItemSlot(0);
+        player.getInventory().addItem(namedItem(Material.STICK, "Wand"));
+        for (WizardSpell wizardSpell : WizardSpell.values()) {
+            player.getInventory().addItem(namedItem(wizardSpell.getIcon(), wizardSpell.displayName()));
+        }
     }
 
     @Override
     public void end() {
-
     }
 
     @Override
     public Role getRole() {
         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 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 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

@@ -0,0 +1,51 @@
+package de.leafbla.meinkraft.roleplay.wizard;
+
+import org.bukkit.Material;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+enum WizardSpell {
+    PUFF_OF_MAGIC("Puff of Magic", Material.NETHER_STAR) {
+        @Override
+        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));
+                        livingEntity.damage(2);
+                    },
+                    (event, projectile, target, targetFace, shooter) -> {
+                        target.breakNaturally();
+                    });
+        }
+    },
+    SPELL2("Fireball", Material.FIRE_CHARGE),
+    SPELL3("Something Something", Material.CLAY);
+
+    private final String displayName;
+    private final Material icon;
+
+    WizardSpell(String displayName, Material iconMaterial) {
+        this.displayName = displayName;
+        this.icon = iconMaterial;
+    }
+
+    void cast(WizardRole wizardRole) {
+        wizardRole.getPlayer().sendMessage(String.format("§eCasting §6%s§e.", this.displayName));
+    }
+
+    public String displayName() {
+        return this.displayName;
+    }
+
+    public Material getIcon() {
+        return this.icon;
+    }
+
+    public boolean canConsumeMana(WizardRole wizardRole) {
+        //if (wizardRole.getMana())
+        return true;
+    }
+}

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

@@ -0,0 +1,19 @@
+package de.leafbla.meinkraft.util;
+
+public class Pair<L, R> {
+    private L l;
+    private R r;
+
+    public Pair(L l, R r) {
+        this.l = l;
+        this.r = r;
+    }
+
+    public R getRight() {
+        return this.r;
+    }
+
+    public L getLeft() {
+        return this.l;
+    }
+}