Java Examples for org.bukkit.entity.Fireball

// -- ABILITIES -- //
@Ability(name = "Fireball", command = "fireball", info = "Bring fire to your enemies.", cost = 120, delay = 2000)
public AbilityResult fireballAbility(PlayerInteractEvent event) {
    Player player = event.getPlayer();
    LivingEntity targetEntity = TargetingUtil.autoTarget(player, 250);
    Location target;
    if (targetEntity != null) {
        target = targetEntity.getLocation();
    } else {
        target = TargetingUtil.directTarget(player);
    }
    shootFireball(player.getEyeLocation(), target, player);
    player.sendMessage(getGroup().getColor() + "*fhhoom*");
    return AbilityResult.SUCCESS;
}

private String getMessage(final EntityDamageEvent e) {
    final Entity damager = ((EntityDamageByEntityEvent) e).getDamager();
    if (damager instanceof Player) {
        Player d = (Player) damager;
        if (d.getItemInHand().getType() == Material.BOW || d.getItemInHand().getType() == Material.FISHING_ROD) {
            return ACHelper.getInstance().getDeathMessage("ranged") + d.getDisplayName();
        } else if (d.getItemInHand().getType() == Material.POTION) {
            return ACHelper.getInstance().getDeathMessage("potion") + d.getDisplayName();
        } else {
            return ACHelper.getInstance().getDeathMessage("melee") + d.getDisplayName();
        }
    } else if (damager instanceof TNTPrimed) {
        return ACHelper.getInstance().getDeathMessage("tnt");
    } else if (damager instanceof FallingBlock) {
        return ACHelper.getInstance().getDeathMessage("crushed");
    } else if (damager instanceof Zombie) {
        if (damager instanceof PigZombie) {
            return ACHelper.getInstance().getDeathMessage("pigzombie");
        }
        return ACHelper.getInstance().getDeathMessage("zombie");
    } else if (damager instanceof Skeleton) {
        if (((Skeleton) damager).getSkeletonType() == SkeletonType.WITHER) {
            return ACHelper.getInstance().getDeathMessage("witherskeleton");
        }
        return ACHelper.getInstance().getDeathMessage("skeleton");
    } else if (damager instanceof Spider) {
        return ACHelper.getInstance().getDeathMessage("spider");
    } else if (damager instanceof CaveSpider) {
        return ACHelper.getInstance().getDeathMessage("cavespider");
    } else if (damager instanceof Creeper) {
        return ACHelper.getInstance().getDeathMessage("creeper");
    } else if (damager instanceof MagmaCube) {
        return ACHelper.getInstance().getDeathMessage("magmacube");
    } else if (damager instanceof Blaze) {
        return ACHelper.getInstance().getDeathMessage("blaze");
    } else if (damager instanceof Ghast) {
        return ACHelper.getInstance().getDeathMessage("ghast");
    } else if (damager instanceof Slime) {
        return ACHelper.getInstance().getDeathMessage("slime");
    } else if (damager instanceof Silverfish) {
        return ACHelper.getInstance().getDeathMessage("silverfish");
    } else if (damager instanceof Giant) {
        return ACHelper.getInstance().getDeathMessage("giant");
    } else if (damager instanceof EnderDragon) {
        return ACHelper.getInstance().getDeathMessage("enderdragon");
    } else if (damager instanceof Wither) {
        return ACHelper.getInstance().getDeathMessage("wither");
    } else if (damager instanceof IronGolem) {
        return ACHelper.getInstance().getDeathMessage("irongolem");
    } else if (damager instanceof Enderman) {
        return ACHelper.getInstance().getDeathMessage("enderman");
    } else if (damager instanceof Wolf) {
        return ACHelper.getInstance().getDeathMessage("wolf");
    } else if (damager instanceof Player) {
        return ACHelper.getInstance().getDeathMessage("melee");
    } else if (damager instanceof Projectile) {
        if (damager instanceof Arrow) {
            if (((Arrow) damager).getShooter() == null) {
                return ACHelper.getInstance().getDeathMessage("arrow");
            } else if (((Arrow) damager).getShooter() instanceof Skeleton) {
                return ACHelper.getInstance().getDeathMessage("skeleton");
            } else if (((Arrow) damager).getShooter() instanceof Player) {
                return ACHelper.getInstance().getDeathMessage("ranged") + Users.getPlayerName((Player) ((Arrow) damager).getShooter());
            }
        } else if (damager instanceof Fireball) {
            if (((Fireball) damager).getShooter() == null) {
                return ACHelper.getInstance().getDeathMessage("fireball");
            } else if (((Fireball) damager).getShooter() instanceof Ghast) {
                return ACHelper.getInstance().getDeathMessage("ghast");
            } else if (((Fireball) damager).getShooter() instanceof Blaze) {
                return ACHelper.getInstance().getDeathMessage("blaze");
            }
        } else if (damager instanceof ThrownPotion) {
            if (((ThrownPotion) damager).getShooter() instanceof Player) {
                return ACHelper.getInstance().getDeathMessage("potion");
            } else if (((ThrownPotion) damager).getShooter() instanceof Witch) {
                return ACHelper.getInstance().getDeathMessage("witch");
            }
        }
    } else if (damager instanceof LivingEntity) {
        return ACHelper.getInstance().getDeathMessage("mob") + damager.getType().toString().toLowerCase();
    }
    return ACHelper.getInstance().getDeathMessage("default");
}

/**
     * Send a projectile from an entity's eye level.
     *
     * @param loc
     * @param dir
     * @param speed
     */
public static <T extends Projectile> T sendProjectileFromLocation(Location loc, Vector dir, float speed, Class<T> clazz) {
    loc = loc.clone();
    Vector actualDir = dir.clone().normalize();
    Vector finalVecLoc = loc.toVector().add(actualDir.multiply(2));
    loc.setX(finalVecLoc.getX());
    loc.setY(finalVecLoc.getY());
    loc.setZ(finalVecLoc.getZ());
    T projectile = loc.getWorld().spawn(loc, clazz);
    if (projectile instanceof Fireball) {
        ((Fireball) projectile).setDirection(dir.multiply(speed));
    } else {
        projectile.setVelocity(dir.multiply(speed));
    }
    return projectile;
}

public void onActivation(Event event, Map<String, Object> config) {
    // check if the handler (event part) is well configured
    if (!(event instanceof PlayerInteractEvent))
        return;
    // casting the event to have all necessary data
    PlayerInteractEvent castedEvent = (PlayerInteractEvent) event;
    // getting the player (to set the origin of the fireball and the direction)
    Player shooter = castedEvent.getPlayer();
    // getting the direction the player is looking at
    Vector playerLookingat = shooter.getEyeLocation().getDirection();
    // creating the fireball (and launching it ?)
    Fireball fireball = (Fireball) shooter.getWorld().spawn(shooter.getLocation(), Fireball.class);
    // setting up all never changing parameters
    fireball.setBounce(false);
    fireball.setDirection(playerLookingat);
    fireball.setShooter(shooter);
    // setting up all parameters set in the config
    // the radius of the explosion
    fireball.setYield((float) config.get("power"));
    // if the explosion must create fire
    fireball.setIsIncendiary((boolean) config.get("setOnFire"));
    fireball.setVelocity(new Vector(1, 1, 1).multiply((float) config.get("velocity")));
}

@Override
public boolean runCommand(final CommandSender cs, final Command cmd, final String label, final String[] args) {
    if (!(cs instanceof Player)) {
        cs.sendMessage(MessageColor.NEGATIVE + "This command is only available to players!");
        return true;
    }
    Player p = (Player) cs;
    //Fireball fb = p.launchProjectile(Fireball.class);
    Vector dir = p.getEyeLocation().getDirection().multiply(2);
    Fireball fb = p.getWorld().spawn(p.getEyeLocation().add(dir.getX(), dir.getY(), dir.getZ()), Fireball.class);
    fb.setDirection(dir);
    //fb.teleport(p.getEyeLocation().add(dir.getX(), dir.getY(), dir.getZ()));
    fb.setIsIncendiary(true);
    return true;
}

@EventHandler
public void onChunkProtect(ChunkLoadEvent e) {
    for (Entity entity : e.getChunk().getEntities()) {
        if (entity instanceof WitherSkull) {
            WitherSkull wither = (WitherSkull) entity;
            if (pl.getConfiguration().getDebugConfig().isEnabled()) {
                xEssentials.log("removed wither skull at: {" + wither.getWorld().getName() + ", " + wither.getLocation().getBlockX() + ", " + wither.getLocation().getBlockY() + ", " + wither.getLocation().getBlockZ() + "} to prevent lag", LogType.INFO);
            }
            wither.remove();
        } else if (entity instanceof Fireball) {
            Fireball fb = (Fireball) entity;
            if (pl.getConfiguration().getDebugConfig().isEnabled()) {
                xEssentials.log("removed fireball at: {" + fb.getWorld().getName() + ", " + fb.getLocation().getBlockX() + ", " + fb.getLocation().getBlockY() + ", " + fb.getLocation().getBlockZ() + "} to prevent lag", LogType.INFO);
            }
            fb.remove();
        }
    }
}

//when there's an explosion...
@EventHandler(priority = EventPriority.NORMAL)
public void onExplosion(EntityExplodeEvent event) {
    World world = event.getLocation().getWorld();
    if (!ExtraHardMode.instance.config_enabled_worlds.contains(world))
        return;
    Entity entity = event.getEntity();
    //FEATURE: bigger TNT booms, all explosions have 100% block yield
    if (ExtraHardMode.instance.config_betterTNT) {
        event.setYield(1);
        if (entity != null && entity.getType() == EntityType.PRIMED_TNT && !ExtraHardMode.instance.config_workAroundExplosionsBugs) {
            //create more explosions nearby
            long serverTime = world.getFullTime();
            int random1 = (int) (serverTime + entity.getLocation().getBlockZ()) % 8;
            int random2 = (int) (serverTime + entity.getLocation().getBlockX()) % 8;
            Location[] locations = new Location[4];
            locations[0] = entity.getLocation().add(random1, 1, random2);
            locations[1] = entity.getLocation().add(-random2, 0, random1 / 2);
            locations[2] = entity.getLocation().add(-random1 / 2, -1, -random2);
            locations[3] = entity.getLocation().add(random1 / 2, 0, -random2 / 2);
            for (int i = 0; i < locations.length; i++) {
                CreateExplosionTask task = new CreateExplosionTask(locations[i], 6F);
                ExtraHardMode.instance.getServer().getScheduler().scheduleSyncDelayedTask(ExtraHardMode.instance, task, 3L * (i + 1));
            }
        }
    }
    //FEATURE: ender dragon fireballs may summon minions and/or set fires
    if (entity != null && entity.getType() == EntityType.FIREBALL) {
        Fireball fireball = (Fireball) entity;
        Entity spawnedMonster = null;
        if (fireball.getShooter() != null && fireball.getShooter().getType() == EntityType.ENDER_DRAGON) {
            int random = ExtraHardMode.randomNumberGenerator.nextInt(100);
            if (random < 40) {
                spawnedMonster = entity.getWorld().spawnEntity(entity.getLocation(), EntityType.BLAZE);
                for (int x1 = -2; x1 <= 2; x1++) {
                    for (int z1 = -2; z1 <= 2; z1++) {
                        for (int y1 = 2; y1 >= -2; y1--) {
                            Block block = fireball.getLocation().add(x1, y1, z1).getBlock();
                            Material underType = block.getRelative(BlockFace.DOWN).getType();
                            if (block.getType() == Material.AIR && underType != Material.AIR && underType != Material.FIRE) {
                                block.setType(Material.FIRE);
                            }
                        }
                    }
                }
                Location location = fireball.getLocation().add(0, 1, 0);
                for (int i = 0; i < 10; i++) {
                    FallingBlock fire = world.spawnFallingBlock(location, Material.FIRE, (byte) 0);
                    Vector velocity = Vector.getRandom();
                    if (velocity.getY() < 0) {
                        velocity.setY(velocity.getY() * -1);
                    }
                    if (ExtraHardMode.randomNumberGenerator.nextBoolean()) {
                        velocity.setZ(velocity.getZ() * -1);
                    }
                    if (ExtraHardMode.randomNumberGenerator.nextBoolean()) {
                        velocity.setX(velocity.getX() * -1);
                    }
                    fire.setVelocity(velocity);
                }
            } else if (random < 70) {
                for (int i = 0; i < 2; i++) {
                    spawnedMonster = (Zombie) entity.getWorld().spawnEntity(entity.getLocation(), EntityType.ZOMBIE);
                    EntityEventHandler.markLootLess((LivingEntity) spawnedMonster);
                    Zombie zombie = (Zombie) spawnedMonster;
                    zombie.setVillager(true);
                }
            } else {
                spawnedMonster = entity.getWorld().spawnEntity(entity.getLocation(), EntityType.ENDERMAN);
            }
        }
        if (spawnedMonster != null) {
            EntityEventHandler.markLootLess((LivingEntity) spawnedMonster);
        }
    }
    //FEATURE: in hardened stone mode, TNT only softens stone to cobble
    if (ExtraHardMode.instance.config_superHardStone) {
        List<Block> blocks = event.blockList();
        for (int i = 0; i < blocks.size(); i++) {
            Block block = blocks.get(i);
            if (block.getType() == Material.STONE) {
                block.setType(Material.COBBLESTONE);
                blocks.remove(i--);
            }
            //FEATURE: more falling blocks
            ExtraHardMode.physicsCheck(block, 0, true);
        }
    }
    //FEATURE: more powerful ghast fireballs
    if (entity != null && entity instanceof Fireball && !ExtraHardMode.instance.config_workAroundExplosionsBugs) {
        Fireball fireball = (Fireball) entity;
        if (fireball.getShooter() != null && fireball.getShooter().getType() == EntityType.GHAST) {
            event.setCancelled(true);
            //same as vanilla TNT, plus fire
            entity.getWorld().createExplosion(entity.getLocation(), 4F, true);
        }
    }
    //FEATURE: bigger creeper explosions (for more-frequent cave-ins)
    if (entity != null && entity instanceof Creeper && !ExtraHardMode.instance.config_workAroundExplosionsBugs) {
        event.setCancelled(true);
        //same as vanilla TNT
        entity.getWorld().createExplosion(entity.getLocation(), 3F, false);
    }
}

private void createListeners() {
    final NullLogger devnull = new NullLogger();
    final EventRouter eventsHandler = new EventRouter(devnull);
    final MultiWorldConfStore confStore = new MultiWorldConfStore();
    eventsHandler.setConfStore(confStore);
    creeperListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, Creeper.class);
    tntListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, TNTPrimed.class);
    fireballListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, Fireball.class);
    netherCreeperListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, Creeper.class);
    netherTntListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, TNTPrimed.class);
    netherFireballListener = new ExplosionListener(plugin, devnull, eventsHandler, confStore, Fireball.class);
    justDefaultListeners = new ExplosionListener[] { creeperListener, tntListener, fireballListener };
    justNetherListeners = new ExplosionListener[] { netherCreeperListener, netherTntListener, netherFireballListener };
    allListeners = new ExplosionListener[] { creeperListener, tntListener, fireballListener, netherCreeperListener, netherTntListener, netherFireballListener };
}

@EventHandler
public void onProjectileHit(ProjectileHitEvent event) {
    if (event.getEntity() instanceof Fireball) {
        if (handleFireball(event.getEntity())) {
            EntityFireball fb = ((CraftFireball) event.getEntity()).getHandle();
            fb.isIncendiary = false;
            fb.yield = 0;
            //ByeBye
            fb.locY = 10000;
        }
    }
}

@Override
public void onInteract(PlayerInteractEvent event) {
    event.setCancelled(true);
    Player player = event.getPlayer();
    User user = Zephyrus.getUser(player);
    Block block = (Block) user.getTarget(this).getTarget();
    int delay = user.getDelay(getInternalName());
    if (delay > 0) {
        Language.sendError("item.delay", player, "[SECONDS]", delay + "");
        return;
    }
    if (Zephyrus.getHookManager().canBuild(player, block)) {
        if (getLevel(player.getItemInHand().getItemMeta().getLore()) > 5) {
            player.launchProjectile(Fireball.class);
        } else {
            player.launchProjectile(SmallFireball.class);
        }
        user.setDelay(getName(), levelToDelay(getLevel(player.getItemInHand().getItemMeta().getLore())));
        return;
    }
    Language.sendError("item.rodoffire.failure", player);
}

/* Used to separate mob damage from player damage.
     * This is the mob version. */
public void mobDamage(EntityDamageByEntityEvent event, LivingEntity damager, LivingEntity e, double evtdmg) {
    ZAMob zam = data.getZAMob(e);
    if (damager instanceof Fireball) {
        Fireball f = (Fireball) damager;
        if (instakillids.contains(f.getUniqueId())) {
            event.setDamage(zam.getEntity().getHealth() * 10);
        } else {
            // fireball damage
            double dmg = 40 - zam.getHitAbsorption();
            if (dmg <= MIN_FIREBALL_DMG) {
                dmg = MIN_FIREBALL_DMG;
            }
            event.setDamage(dmg);
        }
    } else if (damager instanceof Arrow) {
        Arrow a = (Arrow) damager;
        if (instakillids.contains(a.getUniqueId())) {
            event.setDamage(zam.getEntity().getHealth() * 10);
        } else {
            // arrow damage
            double dmg = 50 - zam.getHitAbsorption();
            if (dmg <= MIN_ARROW_DMG) {
                dmg = MIN_ARROW_DMG;
            }
            event.setDamage(dmg);
        }
    } else if (damager instanceof Player) {
        Player p = (Player) damager;
        if (data.isZAPlayer(p)) {
            ZAPlayer zap = data.getZAPlayer(p);
            List<PathNode> nodes = new Pathfinder(e.getLocation(), p.getLocation(), AblockalypseUtility.getGoals(p.getWorld(), .891D, 1.031D, 2D, 0)).calculate((Integer) Setting.MAX_PATHFINDER_NODES.getSetting()).getNodes();
            if (nodes.get(nodes.size() - 1).H > 10) {
                if (RAND.nextInt(99) + 1 < 5) {
                    zam.getTargetter().panic(120);
                } else if (!zap.isTargettedBy(zam)) {
                    zam.retarget();
                }
            }
            if (zap.hasInstaKill()) {
                event.setDamage(zam.getEntity().getHealth() * 5);
            } else {
                // regular hit damage
                double dmg = evtdmg - zam.getHitAbsorption();
                if (dmg <= MIN_HIT_DMG) {
                    dmg = MIN_HIT_DMG;
                }
                event.setDamage(dmg);
            }
        }
    } else if (data.isZAMob(damager) && damager instanceof Wolf) {
        event.setDamage((evtdmg - zam.getHitAbsorption()) / 2);
    }
}

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerInteract(PlayerInteractEvent event) {
    if (plugin.doCancelIfNeccessary(event)) {
        return;
    }
    final Player player = event.getPlayer();
    Block block = event.getClickedBlock();
    Material material = player.getItemInHand().getType();
    World world = player.getWorld();
    float pitch = player.getLocation().getPitch();
    float yaw = player.getLocation().getYaw();
    Location handLocation = LocationUtil.getHandLocation(player);
    Vector direction = handLocation.getDirection();
    Block blockShotAt = null;
    List<Block> blockList = player.getLastTwoTargetBlocks(null, 1000);
    if (blockList.size() == 2) {
        blockShotAt = blockList.get(1);
    }
    if (event.getAction() == Action.LEFT_CLICK_BLOCK && block.getType() == Material.DISPENSER) {
        switch(material) {
            case AIR:
                if (plugin.getPermissionHandler().canDisplay(player)) {
                    Cannon cannon = plugin.getCannon(block, false);
                    if (cannon == null) {
                        MessageUtils.send(player, "This is a normal dispenser not configured as a cannon");
                        if (plugin.getPermissionHandler().canConfigure(player)) {
                            MessageUtils.send(player, ChatColor.GREEN, plugin.getHelpText());
                        }
                    } else {
                        MessageUtils.send(player, cannon.toString());
                    }
                    event.setCancelled(true);
                }
                break;
            case TORCH:
                if (plugin.getPermissionHandler().canConfigure(player)) {
                    Cannon cannon = plugin.getCannon(block, true);
                    cannon.setOwner(player.getName());
                    if (cannon.equals(plugin.getCannon(player))) {
                        MessageUtils.send(player, ChatColor.RED, "Settings were not changed!");
                    } else {
                        cannon.copy(plugin.getCannon(player));
                        MessageUtils.send(player, ChatColor.GREEN, "Settings changed!");
                    }
                    MessageUtils.send(player, ChatColor.GREEN, cannon.toString());
                    event.setCancelled(true);
                }
                break;
            case REDSTONE:
                if (!plugin.getPermissionHandler().canToggle(player)) {
                    break;
                }
                if (plugin.isCannon(block)) {
                    plugin.removeCannon(block);
                    MessageUtils.send(player, ChatColor.GREEN, "This dispenser no longer is a cannon!");
                    event.setCancelled(true);
                } else {
                    Cannon cannon = plugin.getCannon(block, true);
                    MessageUtils.send(player, ChatColor.GREEN, "This dispenser is now a cannon!");
                    if (plugin.getPermissionHandler().canDisplay(player)) {
                        MessageUtils.send(player, ChatColor.GREEN, cannon.toString());
                    }
                    event.setCancelled(true);
                }
                break;
        }
    } else if (event.getAction() == Action.LEFT_CLICK_AIR && config.isGunItem(material)) {
        Gun gun = plugin.getGun(player);
        if (gun.getType() == Gun.Type.TOY || !plugin.getPermissionHandler().canShoot(player, gun)) {
            return;
        }
        Entity entity = null;
        switch(gun.getType()) {
            case CROSSBOW:
                entity = world.spawn(handLocation, Arrow.class);
                entity.setVelocity(direction.multiply(3));
                world.playEffect(handLocation, Effect.BOW_FIRE, 0);
                break;
            case REVOLVER:
                if (gun.getShotsFired() < 6) {
                    gun.fire();
                    entity = world.spawn(handLocation, Snowball.class);
                    entity.setVelocity(direction.multiply(3));
                }
                break;
            case SHOTGUN:
                if (gun.getShotsFired() < 1) {
                    gun.fire();
                    Location loc = handLocation.clone();
                    Random random = new Random((long) loc.lengthSquared() * new Date().getTime());
                    for (int n = 0; n < 20; n++) {
                        Snowball pellet = world.spawn(handLocation, Snowball.class);
                        pellet.setShooter(player);
                        loc.setPitch((float) (pitch + nextRandom(random)));
                        loc.setYaw((float) (yaw + nextRandom(random)));
                        Vector d = loc.getDirection();
                        pellet.setVelocity(d.multiply(4));
                        plugin.registerGunShot(pellet, gun, blockShotAt);
                    }
                    world.createExplosion(handLocation, 0);
                    InventoryUtil.removeItemNearItemHeldInHand(player, gun.getBulletMaterial());
                }
                break;
            case SNIPER:
                entity = world.spawn(handLocation, Snowball.class);
                entity.setVelocity(direction.multiply(8));
                break;
            case GATLIN:
                if (gun.getShotsFired() > 0) {
                    gun.setShotsFired(0);
                    return;
                }
                gun.fire();
                new Thread(new GatlinBurst(player, plugin)).start();
                break;
            case FLAME_THROWER:
            default:
                plugin.log(Level.SEVERE, "Gun not implemented: " + gun.getType());
                return;
        }
        if (entity != null) {
            ((Projectile) entity).setShooter(player);
            // plugin.log("Shot projectile: " + entity.getEntityId());
            plugin.registerGunShot(entity, gun, blockShotAt);
            if (entity instanceof Snowball) {
                world.createExplosion(handLocation, 0);
            }
            InventoryUtil.removeItemNearItemHeldInHand(player, gun.getBulletMaterial());
        }
    } else if (event.getAction() == Action.LEFT_CLICK_AIR) {
        Grenade grenade = config.getGrenade(material);
        if (grenade.getType() == Type.DUD || !grenade.isPlayerUse() || !plugin.getPermissionHandler().canEffect(player, grenade)) {
            return;
        }
        Entity entity = null;
        double speedFactor = 1.5;
        switch(grenade.getType()) {
            case MOLOTOV:
                entity = world.spawn(handLocation, Fireball.class);
                ((Fireball) entity).setShooter(player);
                break;
            case SNARE:
            case STUN:
            case EXPLOSIVE:
            case NUCLEAR:
            case WATER_BALLOON:
            case SPIDER_WEB:
                entity = world.spawn(handLocation, Snowball.class);
                entity.setVelocity(direction.multiply(speedFactor));
                break;
            case TNT:
                entity = world.spawn(handLocation, TNTPrimed.class);
                entity.setVelocity(direction.multiply(speedFactor));
                ((TNTPrimed) entity).setFuseTicks(plugin.getCannon(player).getFuse());
                break;
            case PIG:
                entity = world.spawn(handLocation, Pig.class);
                entity.setVelocity(direction.multiply(speedFactor));
                break;
            case SHEEP:
                entity = world.spawn(handLocation, Sheep.class);
                entity.setVelocity(direction.multiply(speedFactor));
                break;
            case COW:
                entity = world.spawn(handLocation, Cow.class);
                entity.setVelocity(direction.multiply(speedFactor));
                break;
            case DUD:
            default:
                return;
        }
        if (entity != null) {
            plugin.registerGrenade(entity, grenade);
            updateInventory(player, material, grenade.getUses());
        }
    }
}

private String getAttacker(Object attacker) {
    String msg = "";
    if (attacker instanceof Player) {
        Player aggressor = (Player) attacker;
    } else if (attacker instanceof Ghast || attacker instanceof Fireball) {
    } else if (attacker instanceof PigZombie) {
    } else if (attacker instanceof Zombie) {
    } else if (attacker instanceof Skeleton) {
    } else if (attacker instanceof Creeper) {
    } else if (attacker instanceof Spider) {
    } else if (attacker instanceof Slime) {
    } else if (attacker instanceof Giant) {
    } else if (attacker instanceof Wolf) {
    } else if (attacker instanceof CaveSpider) {
    } else if (attacker instanceof Enderman) {
    } else if (attacker instanceof Silverfish) {
    } else if (attacker instanceof MagmaCube) {
    } else if (attacker instanceof Blaze) {
    } else if (attacker instanceof Snowman) {
    } else if (attacker instanceof EnderDragon) {
    } else if (attacker == null) {
    }
    return msg;
}

@SuppressWarnings("null")
@Override
protected void execute(final Event e) {
    lastSpawned = null;
    final Number v = velocity != null ? velocity.getSingle(e) : DEFAULT_SPEED;
    if (v == null)
        return;
    final Direction dir = direction != null ? direction.getSingle(e) : Direction.IDENTITY;
    if (dir == null)
        return;
    for (final Object shooter : shooters.getArray(e)) {
        for (final EntityData<?> d : types.getArray(e)) {
            if (shooter instanceof LivingEntity) {
                final Vector vel = dir.getDirection(((LivingEntity) shooter).getLocation()).multiply(v.doubleValue());
                final Class<? extends Entity> type = d.getType();
                if (// fireballs explode in the shooter's face by default
                Fireball.class.isAssignableFrom(type)) {
                    final Fireball projectile = (Fireball) ((LivingEntity) shooter).getWorld().spawn(((LivingEntity) shooter).getEyeLocation().add(vel.clone().normalize().multiply(0.5)), type);
                    ProjectileUtils.setShooter(projectile, shooter);
                    projectile.setVelocity(vel);
                    lastSpawned = projectile;
                } else if (Projectile.class.isAssignableFrom(type)) {
                    @SuppressWarnings("unchecked") final Projectile projectile = ((LivingEntity) shooter).launchProjectile((Class<? extends Projectile>) type);
                    set(projectile, d);
                    projectile.setVelocity(vel);
                    lastSpawned = projectile;
                } else {
                    final Location loc = ((LivingEntity) shooter).getLocation();
                    loc.setY(loc.getY() + ((LivingEntity) shooter).getEyeHeight() / 2);
                    final Entity projectile = d.spawn(loc);
                    if (projectile != null)
                        projectile.setVelocity(vel);
                    lastSpawned = projectile;
                }
            } else {
                final Vector vel = dir.getDirection((Location) shooter).multiply(v.doubleValue());
                final Entity projectile = d.spawn((Location) shooter);
                if (projectile != null)
                    projectile.setVelocity(vel);
                lastSpawned = projectile;
            }
        }
    }
}

@SuppressWarnings("deprecation")
@EventHandler
public void onWandUse(PlayerInteractEvent e) {
    if (e.getAction() != Action.RIGHT_CLICK_BLOCK && e.getAction() != Action.RIGHT_CLICK_AIR) {
        return;
    }
    ArenaManager arenaManager = plugin.getArenaManager();
    if (!arenaManager.isInGame(e.getPlayer())) {
        return;
    }
    Player player = e.getPlayer();
    Arena arena = arenaManager.getArena(player.getUniqueId());
    if (player.getInventory().getItemInMainHand() == null) {
        return;
    }
    /*
         * WAND: MAGMA
         */
    if (getWandType(player.getInventory().getItemInMainHand()) == WandType.MAGMA) {
        if (player.getInventory().getItemInMainHand().getDurability() == (short) 0) {
            Fireball fb = player.launchProjectile(Fireball.class);
            fb.setVelocity(player.getLocation().getDirection().multiply(3));
            for (UUID id : arenaManager.getArena(player.getUniqueId()).getPlayers()) {
                Player pl = Bukkit.getPlayer(id);
                if (pl != player && arenaManager.getTeam(pl) != arenaManager.getTeam(player)) {
                    double pX = player.getLocation().getX();
                    double pZ = player.getLocation().getZ();
                    double plX = pl.getLocation().getX();
                    double plZ = pl.getLocation().getZ();
                    if (plX > pX - 6 && plX < pX + 6) {
                        if (plZ > pZ - 6 && plZ < pZ + 6) {
                            pl.setFireTicks(100);
                            pl.playEffect(pl.getLocation(), Effect.MOBSPAWNER_FLAMES, null);
                            pl.playSound(pl.getLocation(), Sound.ENTITY_BLAZE_DEATH, 1F, 1F);
                        }
                    }
                }
            }
            player.getInventory().getItemInMainHand().setDurability(WandType.MAGMA.getDurability());
        }
        return;
    }
    /*
         * WAND: TELEPORT
         */
    if (getWandType(player.getInventory().getItemInMainHand()) == WandType.TELEPORT) {
        if (player.getInventory().getItemInMainHand().getDurability() == (short) 0) {
            Set<Material> targetSet = null;
            Location loc = player.getTargetBlock(targetSet, 64).getLocation().add(0, 1, 0);
            if (loc.getBlock().getType() == Material.AIR) {
                if (plugin.prot.isInProtectedArena(loc)) {
                    boolean isInBounds = false;
                    double dX = player.getLocation().getX() - loc.getX();
                    double dY = player.getLocation().getY() - loc.getY();
                    double dZ = player.getLocation().getZ() - loc.getZ();
                    if (Math.sqrt(dX * dX + dY * dY + dZ * dZ) <= 40) {
                        isInBounds = true;
                    }
                    if (isInBounds) {
                        float yaw = player.getLocation().getYaw();
                        player.playEffect(player.getLocation(), Effect.ENDER_SIGNAL, null);
                        player.playSound(player.getLocation(), Sound.ENTITY_ENDERMEN_TELEPORT, 1F, 1F);
                        loc.setYaw(yaw);
                        player.teleport(loc);
                        player.playEffect(player.getLocation(), Effect.ENDER_SIGNAL, null);
                        player.playSound(player.getLocation(), Sound.ENTITY_ENDERMEN_TELEPORT, 1F, 1F);
                        player.getInventory().getItemInMainHand().setDurability(WandType.TELEPORT.getDurability());
                    }
                }
            }
        }
        return;
    }
    /*
         * WAND: HEAL
         */
    if (getWandType(player.getInventory().getItemInMainHand()) == WandType.HEAL) {
        if (player.getInventory().getItemInMainHand().getDurability() != (short) 0) {
            return;
        }
        CrystalQuestTeam team = arenaManager.getTeam(player);
        Team scoreboardTeam = arena.getTeamObject(team);
        for (OfflinePlayer pl : scoreboardTeam.getPlayers()) {
            Player target = Bukkit.getPlayer(pl.getName());
            target.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, 8, 5));
            for (int i = 0; i < 3; i++) {
                Wolf w = target.getWorld().spawn(target.getLocation(), Wolf.class);
                w.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 1000, 100));
                w.playEffect(EntityEffect.WOLF_HEARTS);
                w.playEffect(EntityEffect.WOLF_HEARTS);
                w.remove();
            }
        }
        player.getInventory().getItemInMainHand().setDurability(WandType.HEAL.getDurability());
        return;
    }
    /*
         * WAND: FREEZE
         */
    if (getWandType(player.getInventory().getItemInMainHand()) == WandType.FREEZE) {
        if (player.getInventory().getItemInMainHand().getDurability() != (short) 0) {
            return;
        }
        for (final UUID id : arenaManager.getArena(player.getUniqueId()).getPlayers()) {
            Player pl = Bukkit.getPlayer(id);
            if (pl == player || arenaManager.getTeam(pl) == arenaManager.getTeam(player)) {
                continue;
            }
            double pX = player.getLocation().getX();
            double pZ = player.getLocation().getZ();
            double plX = pl.getLocation().getX();
            double plZ = pl.getLocation().getZ();
            if (plX > pX - 12 && plX < pX + 12) {
                if (plZ > pZ - 12 && plZ < pZ + 12) {
                    pl.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 150, 10));
                    pl.playEffect(pl.getLocation(), Effect.EXTINGUISH, null);
                }
            }
        }
        player.getInventory().getItemInMainHand().setDurability(WandType.FREEZE.getDurability());
        return;
    }
    /*
         * WAND: WITHER
         */
    if (getWandType(player.getInventory().getItemInMainHand()) == WandType.WITHER) {
        if (player.getInventory().getItemInMainHand().getDurability() == (short) 0) {
            WitherSkull ws = player.launchProjectile(WitherSkull.class);
            ws.setVelocity(player.getLocation().getDirection().multiply(3));
            for (UUID id : arenaManager.getArena(player.getUniqueId()).getPlayers()) {
                Player pl = Bukkit.getPlayer(id);
                if (pl != player && arenaManager.getTeam(pl) != arenaManager.getTeam(player)) {
                    double pX = player.getLocation().getX();
                    double pZ = player.getLocation().getZ();
                    double plX = pl.getLocation().getX();
                    double plZ = pl.getLocation().getZ();
                    if (plX > pX - 5 && plX < pX + 5) {
                        if (plZ > pZ - 5 && plZ < pZ + 5) {
                            pl.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 150, 0));
                            pl.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 150, 0));
                            pl.getWorld().playEffect(pl.getLocation(), Effect.SMOKE, 16);
                            pl.playSound(pl.getLocation(), Sound.ENTITY_WITHER_HURT, 1F, 1F);
                        }
                    }
                }
            }
            player.getInventory().getItemInMainHand().setDurability(WandType.WITHER.getDurability());
        }
    }
}

@Override
public Fireball shootSmallFireball(Player player) {
    net.minecraft.server.v1_9_R1.World w = ((CraftWorld) player.getWorld()).getHandle();
    Location playerLoc = player.getLocation();
    Vector loc = player.getEyeLocation().toVector().add(player.getLocation().getDirection().multiply(10));
    double d0 = loc.getX() - playerLoc.getX();
    double d1 = loc.getY() - (playerLoc.getY() + 1.5);
    double d2 = loc.getZ() - playerLoc.getZ();
    EntitySmallFireball entitysmallfireball = new EntitySmallFireball(w, ((CraftPlayer) player).getHandle(), d0, d1, d2);
    entitysmallfireball.locY = playerLoc.getY() + 1.5;
    w.addEntity(entitysmallfireball);
    return (Fireball) entitysmallfireball.getBukkitEntity();
}

@Override
protected void magicSpellTriggered(RaCPlayer player, TraitResults result) {
    Vector viewDirection = player.getLocation().getDirection();
    if (viewDirection == null) {
        LanguageAPI.sendTranslatedMessage(player, Keys.no_taget_found);
        result.setTriggered(false);
        return;
    }
    Fireball fireball = player.getPlayer().launchProjectile(Fireball.class);
    fireball.setVelocity(viewDirection);
    fireball.setMetadata(META_KEY, new FixedMetadataValue((Plugin) plugin, player));
    startFireballRangeShortener(fireball);
    LanguageAPI.sendTranslatedMessage(player, Keys.launched_something, "name", "Fireball");
    result.setTriggered(true);
    return;
}

@Override
@SuppressWarnings("unchecked")
public <T extends Projectile> T launchProjectile(Class<? extends T> projectile, Vector velocity) {
    net.minecraft.server.World world = ((CraftWorld) getWorld()).getHandle();
    net.minecraft.server.Entity launch = null;
    if (Snowball.class.isAssignableFrom(projectile)) {
        launch = new EntitySnowball(world, getHandle());
        // ItemSnowball
        ((EntityProjectile) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, 0.0F, 1.5F, 1.0F);
    } else if (Egg.class.isAssignableFrom(projectile)) {
        launch = new EntityEgg(world, getHandle());
        // ItemEgg
        ((EntityProjectile) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, 0.0F, 1.5F, 1.0F);
    } else if (EnderPearl.class.isAssignableFrom(projectile)) {
        launch = new EntityEnderPearl(world, getHandle());
        // ItemEnderPearl
        ((EntityProjectile) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, 0.0F, 1.5F, 1.0F);
    } else if (Arrow.class.isAssignableFrom(projectile)) {
        if (TippedArrow.class.isAssignableFrom(projectile)) {
            launch = new EntityTippedArrow(world, getHandle());
            ((EntityTippedArrow) launch).setType(CraftPotionUtil.fromBukkit(new PotionData(PotionType.WATER, false, false)));
        } else if (SpectralArrow.class.isAssignableFrom(projectile)) {
            launch = new EntitySpectralArrow(world, getHandle());
        } else {
            launch = new EntityTippedArrow(world, getHandle());
        }
        // ItemBow
        ((EntityArrow) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, 0.0F, 3.0F, 1.0F);
    } else if (ThrownPotion.class.isAssignableFrom(projectile)) {
        if (LingeringPotion.class.isAssignableFrom(projectile)) {
            launch = new EntityPotion(world, getHandle(), CraftItemStack.asNMSCopy(new ItemStack(org.bukkit.Material.LINGERING_POTION, 1)));
        } else {
            launch = new EntityPotion(world, getHandle(), CraftItemStack.asNMSCopy(new ItemStack(org.bukkit.Material.SPLASH_POTION, 1)));
        }
        // ItemSplashPotion
        ((EntityProjectile) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, -20.0F, 0.5F, 1.0F);
    } else if (ThrownExpBottle.class.isAssignableFrom(projectile)) {
        launch = new EntityThrownExpBottle(world, getHandle());
        // ItemExpBottle
        ((EntityProjectile) launch).a(getHandle(), getHandle().pitch, getHandle().yaw, -20.0F, 0.7F, 1.0F);
    } else if (Fish.class.isAssignableFrom(projectile) && getHandle() instanceof EntityHuman) {
        launch = new EntityFishingHook(world, (EntityHuman) getHandle());
    } else if (Fireball.class.isAssignableFrom(projectile)) {
        Location location = getEyeLocation();
        Vector direction = location.getDirection().multiply(10);
        if (SmallFireball.class.isAssignableFrom(projectile)) {
            launch = new EntitySmallFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
        } else if (WitherSkull.class.isAssignableFrom(projectile)) {
            launch = new EntityWitherSkull(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
        } else if (DragonFireball.class.isAssignableFrom(projectile)) {
            launch = new EntityDragonFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
        } else {
            launch = new EntityLargeFireball(world, getHandle(), direction.getX(), direction.getY(), direction.getZ());
        }
        ((EntityFireball) launch).projectileSource = this;
        launch.setPositionRotation(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
    } else if (LlamaSpit.class.isAssignableFrom(projectile)) {
        Location location = getEyeLocation();
        Vector direction = location.getDirection();
        launch = new EntityLlamaSpit(world);
        ((EntityLlamaSpit) launch).shooter = getHandle();
        // EntityLlama
        ((EntityLlamaSpit) launch).shoot(direction.getX(), direction.getY(), direction.getZ(), 1.5F, 10.0F);
        launch.setPositionRotation(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
    }
    Validate.notNull(launch, "Projectile not supported");
    if (velocity != null) {
        ((T) launch.getBukkitEntity()).setVelocity(velocity);
    }
    world.addEntity(launch);
    return (T) launch.getBukkitEntity();
}

/**
     * Called on entity damage by an entity.
     *
     * @param event
     */
private void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
    if (event.getCause() == DamageCause.PROJECTILE) {
        onEntityDamageByProjectile(event);
        return;
    }
    Entity attacker = event.getDamager();
    Entity defender = event.getEntity();
    if (defender instanceof Player) {
        Player player = (Player) defender;
        ConfigurationManager cfg = plugin.getConfigurationManager();
        WorldConfiguration wcfg = cfg.get(player.getWorld());
        if (isInvincible(player)) {
            if (wcfg.regionInvinciblityRemovesMobs && attacker instanceof LivingEntity && !(attacker instanceof Player) && !(attacker instanceof Tameable && ((Tameable) attacker).isTamed())) {
                attacker.remove();
            }
            event.setCancelled(true);
            return;
        }
        RegionIndex index;
        try {
            index = plugin.getGlobalRegionManager().get(player.getWorld().getName());
        } catch (Exception e) {
            return;
        }
        if (attacker != null && attacker instanceof Player) {
            Vector pt = toVector(defender.getLocation());
            if (!index.query(pt).allows(DefaultFlag.PVP)) {
                ((Player) attacker).sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
                event.setCancelled(true);
                return;
            }
        }
        if (attacker != null && attacker instanceof TNTPrimed) {
            Vector pt = toVector(defender.getLocation());
            ApplicableRegionSet set = index.query(pt);
            if (!set.allows(DefaultFlag.TNT)) {
                event.setCancelled(true);
                return;
            }
        }
        if (attacker != null && attacker instanceof Fireball) {
            Vector pt = toVector(defender.getLocation());
            ApplicableRegionSet set = index.query(pt);
            if (!set.allows(DefaultFlag.GHAST_FIREBALL)) {
                event.setCancelled(true);
                return;
            }
        }
        if (attacker != null && attacker instanceof LivingEntity && !(attacker instanceof Player)) {
            Vector pt = toVector(defender.getLocation());
            ApplicableRegionSet set = index.query(pt);
            if (!set.allows(DefaultFlag.MOB_DAMAGE)) {
                event.setCancelled(true);
                return;
            }
            if (attacker instanceof Creeper) {
                if (!set.allows(DefaultFlag.CREEPER_EXPLOSION)) {
                    event.setCancelled(true);
                    return;
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.HIGH)
public void handleCustomDamage(EntityDamageEvent event) {
    if (event.getEntity().isDead())
        return;
    if (event.getEntity() instanceof Player) {
        if (((Player) event.getEntity()).getGameMode() == GameMode.CREATIVE) {
            return;
        }
    }
    event.setCancelled(true);
    if (event instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent nEvent = (EntityDamageByEntityEvent) event;
        if (event.getEntity() instanceof Player) {
            if (nEvent.getDamager() instanceof Player) {
                MPlayer attacker = MRPG.getPlayer(((Player) nEvent.getDamager()).getName());
                MPlayer defender = MRPG.getPlayer(((Player) event.getEntity()).getName());
                handlePlayerAttack(attacker, defender);
            } else if (nEvent.getDamager() instanceof LivingEntity) {
                MPlayer defender = MRPG.getPlayer((Player) event.getEntity());
                handleEntityAttackPlayer((LivingEntity) nEvent.getDamager(), defender);
            } else if (nEvent.getDamager() instanceof Projectile) {
                if (nEvent.getDamager() instanceof Fireball) {
                    Fireball ball = (Fireball) nEvent.getDamager();
                    handleEntityAttackPlayer(ball.getShooter(), MRPG.getPlayer((Player) nEvent.getEntity()));
                } else if (nEvent.getDamager() instanceof Arrow) {
                    Arrow arrow = (Arrow) nEvent.getDamager();
                    if (arrow.getShooter() instanceof Player) {
                        MPlayer attacker = MRPG.getPlayer((Player) arrow.getShooter());
                        handlePlayerShootPlayer(attacker, MRPG.getPlayer((Player) event.getEntity()), arrow);
                    } else {
                        handleEntityShootPlayer(arrow.getShooter(), MRPG.getPlayer((Player) event.getEntity()), arrow);
                    }
                }
            }
        } else if (event.getEntity() instanceof LivingEntity) {
            if (nEvent.getDamager() instanceof Player) {
                MPlayer attacker = MRPG.getPlayer(((Player) nEvent.getDamager()).getName());
                handlePlayerAttackEntity(attacker, (LivingEntity) event.getEntity());
            } else if (nEvent.getDamager() instanceof LivingEntity) {
                handleEntityAttackEntity((LivingEntity) nEvent.getDamager(), (LivingEntity) event.getEntity());
            } else if (nEvent.getDamager() instanceof Projectile) {
                if (nEvent.getDamager() instanceof Fireball) {
                    handleEntityAttackEntity(((Fireball) nEvent.getDamager()).getShooter(), (LivingEntity) nEvent.getEntity());
                } else if (nEvent.getDamager() instanceof Arrow) {
                    if (((Arrow) nEvent.getDamager()).getShooter() instanceof Player) {
                        MPlayer attacker = MRPG.getPlayer((Player) ((Arrow) nEvent.getDamager()).getShooter());
                        handlePlayerShootEntity(attacker, (LivingEntity) nEvent.getEntity(), (Arrow) nEvent.getDamager());
                    } else {
                        handleEntityShootEntity((LivingEntity) ((Arrow) nEvent.getDamager()).getShooter(), (LivingEntity) nEvent.getEntity(), (Arrow) nEvent.getDamager());
                    }
                }
            }
        }
    } else {
        if (event.getEntity() instanceof LivingEntity) {
            handleMiscDamage((LivingEntity) event.getEntity(), event, event.getCause());
        }
    }
}

private String getCause(EntityDamageEvent dmg) {
    switch(dmg.getCause()) {
        case ENTITY_ATTACK:
            {
                EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) dmg;
                Entity e = event.getDamager();
                if (e == null) {
                    return "a Dispenser";
                } else if (e instanceof Player) {
                    return ((Player) e).getDisplayName();
                } else if (e instanceof PigZombie) {
                    return "a Pig Zombie";
                } else if (e instanceof Giant) {
                    return "a Giant";
                } else if (e instanceof Zombie) {
                    return "a Zombie";
                } else if (e instanceof Skeleton) {
                    return "a Skeleton";
                } else if (e instanceof Spider) {
                    return "a Spider";
                } else if (e instanceof Creeper) {
                    return "a Creeper";
                } else if (e instanceof Ghast) {
                    return "a Ghast";
                } else if (e instanceof Slime) {
                    return "a Slime";
                } else if (e instanceof Wolf) {
                    return "a Wolf";
                } else {
                    return "a Monster";
                }
            }
        case CONTACT:
            return "a Cactus";
        case SUFFOCATION:
            return "Suffocation";
        case FALL:
            return "a Fall";
        case FIRE:
            return "a Fire";
        case FIRE_TICK:
            return "Burning";
        case LAVA:
            return "Lava";
        case DROWNING:
            return "Drowning";
        case BLOCK_EXPLOSION:
            return "an Explosion";
        case ENTITY_EXPLOSION:
            {
                try {
                    EntityDamageByEntityEvent event = (EntityDamageByEntityEvent) dmg;
                    Entity e = event.getDamager();
                    if (e instanceof TNTPrimed)
                        return "a TNT Explosion";
                    else if (e instanceof Fireball)
                        return "a Ghast";
                    else
                        return "a Creeper";
                } catch (Exception e) {
                    return "an Explosion";
                }
            }
        case VOID:
            return "the Void";
        case LIGHTNING:
            return "Lightning";
        default:
            return "Unknown";
    }
}

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockIgnite(BlockIgniteEvent event) {
    Player player = event.getPlayer();
    Entity ignitingEntity = event.getIgnitingEntity();
    Block block = event.getBlock();
    BlockIgniteEvent.IgniteCause igniteCause = event.getCause();
    Location loc;
    if (block != null) {
        loc = BukkitUtil.getLocation(block.getLocation());
    } else if (ignitingEntity != null) {
        loc = BukkitUtil.getLocation(ignitingEntity);
    } else if (player != null) {
        loc = BukkitUtil.getLocation(player);
    } else {
        return;
    }
    PlotArea area = loc.getPlotArea();
    if (area == null) {
        return;
    }
    if (igniteCause == BlockIgniteEvent.IgniteCause.LIGHTNING) {
        event.setCancelled(true);
        return;
    }
    Plot plot = area.getOwnedPlotAbs(loc);
    if (player != null) {
        PlotPlayer pp = BukkitUtil.getPlayer(player);
        if (plot == null) {
            if (!Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_ROAD)) {
                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, C.PERMISSION_ADMIN_BUILD_ROAD);
                event.setCancelled(true);
            }
        } else if (!plot.hasOwner()) {
            if (!Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_UNOWNED)) {
                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, C.PERMISSION_ADMIN_BUILD_UNOWNED);
                event.setCancelled(true);
            }
        } else if (!plot.isAdded(pp.getUUID())) {
            if (!Permissions.hasPermission(pp, C.PERMISSION_ADMIN_BUILD_OTHER)) {
                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, C.PERMISSION_ADMIN_BUILD_OTHER);
                event.setCancelled(true);
            }
        } else if (Flags.BLOCK_IGNITION.isFalse(plot)) {
            event.setCancelled(true);
        }
    } else {
        if (plot == null) {
            event.setCancelled(true);
            return;
        }
        if (ignitingEntity != null) {
            if (!plot.getFlag(Flags.BLOCK_IGNITION, false)) {
                event.setCancelled(true);
                return;
            }
            if (igniteCause == BlockIgniteEvent.IgniteCause.FIREBALL) {
                if (ignitingEntity instanceof Fireball) {
                    Projectile fireball = (Projectile) ignitingEntity;
                    Location location = null;
                    if (fireball.getShooter() instanceof Entity) {
                        Entity shooter = (Entity) fireball.getShooter();
                        location = BukkitUtil.getLocation(shooter.getLocation());
                    } else if (fireball.getShooter() instanceof BlockProjectileSource) {
                        Block shooter = ((BlockProjectileSource) fireball.getShooter()).getBlock();
                        location = BukkitUtil.getLocation(shooter.getLocation());
                    }
                    if (location != null && !plot.equals(location.getPlot())) {
                        event.setCancelled(true);
                    }
                }
            }
        } else if (event.getIgnitingBlock() != null) {
            Block ignitingBlock = event.getIgnitingBlock();
            Plot plotIgnited = BukkitUtil.getLocation(ignitingBlock.getLocation()).getPlot();
            if (igniteCause == BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL && (!plot.getFlag(Flags.BLOCK_IGNITION, false) || plotIgnited == null || !plotIgnited.equals(plot)) || (igniteCause == BlockIgniteEvent.IgniteCause.SPREAD || igniteCause == BlockIgniteEvent.IgniteCause.LAVA) && (!plot.getFlag(Flags.BLOCK_IGNITION).or(false) || plotIgnited == null || !plotIgnited.equals(plot))) {
                event.setCancelled(true);
            }
        }
    }
}

public static Object forFireballHit(Fireball fireballEntity, Entity hitEntity) {
    return DamageSource.fireball(CommonNMS.getNative(fireballEntity, EntityFireball.class), CommonNMS.getNative(hitEntity));
}