Java 类org.bukkit.projectiles.ProjectileSource 实例源码

/**
 * A basic shoot method, it _can_ be overridden but take care.
 * Handles passing the bullet to its BulletType for configuration, sets shooter, velocity, etc.
 * 
 * @param begin The location to shoot from
 * @param bulletType the Bullet type of this bullet
 * @param shooter the entity shooting
 * @param velocity the velocity to use as base for this shooting, if any
 * @param overrideVelocity if true, use the passed velocity and override anything set up by the bullet type.
 * @return the new Projectile that has been unleashed.
 */
public Projectile shoot(Location begin, Bullet bulletType, ProjectileSource shooter, Vector velocity, boolean overrideVelocity) {
    World world = begin.getWorld();
    begin = begin.clone();
    begin.setDirection(velocity);
    Projectile newBullet = world.spawn(begin, bulletType.getProjectileType() );

    newBullet.setCustomName(this.bulletTag);
    newBullet.setBounce(false);
    newBullet.setGravity(true);
    newBullet.setShooter(shooter);

    bulletType.configureBullet(newBullet, world, shooter, velocity);

    if (overrideVelocity) {
        newBullet.setVelocity(velocity);
    }

    return newBullet;
}

/**
 * Switch players on arrow hit
 *
 * @param event Event instance
 */
@EventHandler(priority = EventPriority.LOWEST)
public void onDamage(EntityDamageByEntityEvent event)
{
    if (!event.isCancelled() && event.getDamager() instanceof Arrow && event.getEntity() instanceof Player)
    {
        ProjectileSource source = ((Arrow)event.getDamager()).getShooter();

        if (source == null || !(source instanceof Player))
            return;

        Player player = (Player)source;
        Location tmp = player.getLocation();

        player.teleport(event.getEntity());
        event.getEntity().teleport(tmp);
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onPlayerFish(PlayerFishEvent event) {
    double amount = event.getExpToDrop();
    if (amount > 0) {
        amount = Math.ceil(amount * SettingsYML.EXP_MULTIPLIER_FISHING);
        ProjectileSource projectileSource = event.getHook().getShooter();
        if (projectileSource instanceof Player) {
            ItemStack stack = ((Player) projectileSource).getItemInHand();
            int enchantmentLevel = stack.getEnchantmentLevel(Enchantment.LUCK);
            if (enchantmentLevel > 0L) {
                amount = Math.ceil(amount * (enchantmentLevel * SettingsYML.EXP_MULTIPLIER_LUCK_PER_LEVEL));
            }
        }

        event.setExpToDrop((int) amount);
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onProjectileLaunch(ProjectileLaunchEvent event) {
    Projectile projectile = event.getEntity();
    if (projectile instanceof EnderPearl) {
        EnderPearl enderPearl = (EnderPearl) projectile;
        ProjectileSource source = enderPearl.getShooter();
        if (source instanceof Player) {
            Player shooter = (Player) source;
            long remaining = getRemaining(shooter);
            if (remaining > 0L) {
                shooter.sendMessage(ChatColor.RED + "You are still on " + ChatColor.LIGHT_PURPLE + getName() + ChatColor.RED + " cooldown for another " + ChatColor.BOLD
                        + DurationFormatter.getRemaining(remaining, true, false) + ChatColor.RED + '.');

                event.setCancelled(true);
                return;
            }

            if (setCooldown(shooter, shooter.getUniqueId(), defaultCooldown, true)) {
                startDisplaying(shooter);
            }
        }
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onPlayerFish(PlayerFishEvent event) {
    double amount = event.getExpToDrop();
    if (amount > 0) {
        amount = Math.ceil(amount * SettingsYML.EXP_MULTIPLIER_FISHING);
        ProjectileSource projectileSource = event.getHook().getShooter();
        if (projectileSource instanceof Player) {
            ItemStack stack = ((Player) projectileSource).getItemInHand();
            int enchantmentLevel = stack.getEnchantmentLevel(Enchantment.LUCK);
            if (enchantmentLevel > 0L) {
                amount = Math.ceil(amount * (enchantmentLevel * SettingsYML.EXP_MULTIPLIER_LUCK_PER_LEVEL));
            }
        }

        event.setExpToDrop((int) amount);
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onProjectileLaunch(ProjectileLaunchEvent event) {
    Projectile projectile = event.getEntity();
    if (projectile instanceof EnderPearl) {
        EnderPearl enderPearl = (EnderPearl) projectile;
        ProjectileSource source = enderPearl.getShooter();
        if (source instanceof Player) {
            Player shooter = (Player) source;
            long remaining = getRemaining(shooter);
            if (remaining > 0L) {
                shooter.sendMessage(ChatColor.RED + "You are still on " + ChatColor.LIGHT_PURPLE + getName() + ChatColor.RED + " cooldown for another " + ChatColor.BOLD
                        + DurationFormatter.getRemaining(remaining, true, false) + ChatColor.RED + '.');

                event.setCancelled(true);
                return;
            }

            if (setCooldown(shooter, shooter.getUniqueId(), defaultCooldown, true)) {
                startDisplaying(shooter);
            }
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onProjectileHit(EntityDamageByEntityEvent e){
    Entity entity = e.getEntity();
    Entity damager = e.getDamager();
    if(entity != null && entity instanceof Player && damager.getType().equals(EntityType.ARROW)){
        Player player = (Player) entity;
        if(isEnabled(player.getWorld())){
            ProjectileSource shooter = ((Arrow) damager).getShooter();
            if(shooter instanceof Player){
                Player shootingPlayer = (Player) shooter;
                if(player.getUniqueId().equals(shootingPlayer.getUniqueId())){
                    e.setCancelled(true);
                    debug("We cancelled your bow boost", player);
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.LOW)
public void onProjectileHit(ProjectileHitEvent event)
{
    if(event.getEntityType() != EntityType.ARROW && event.getEntityType() != EntityType.SNOWBALL) return;

    Projectile arrow = event.getEntity();

    ProjectileSource source = arrow.getShooter();
    if(source == null || !(source instanceof Player)) return;

    Player player = (Player)source;
    if(player.getGameMode() == GameMode.CREATIVE) return;

    Flag flag = this.GetFlagInstanceAtLocation(arrow.getLocation(), player);
    if(flag == null) return;

    PlayerInventory inventory = player.getInventory();
    ItemMeta meta = inventory.getItemInMainHand().getItemMeta();
    if(meta != null && meta.hasEnchant(Enchantment.ARROW_INFINITE)) return;

    arrow.remove();
    inventory.addItem(new ItemStack(Material.ARROW));
}

/**
 * Gets the {@link LivingEntity} from a {@link EntityDamageByEntityEvent}. If the {@link
 * EntityDamageByEntityEvent#getDamager()} is a LivingEntity, then that instance is returned.
 * Otherwise, if the damager is a projectile and it's shooter is a LivingEntity, that
 * LivingEntity
 * shooter instance is returned.
 *
 * @param event event to get LivingEntity from
 *
 * @return instance of {@link LivingEntity}, nullable
 */
public static LivingEntity getLivingEntityDamager(@Nonnull EntityDamageByEntityEvent event) {
  checkNotNull(event, "event cannot be null.");
  // This is the living entity
  if (event.getDamager() instanceof LivingEntity) {
    return ((LivingEntity) event.getDamager());
  }
  // Check for projectile's shooter
  if (event.getDamager() instanceof Projectile) {
    ProjectileSource shooter = ((Projectile) event.getDamager()).getShooter();
    if (shooter != null && shooter instanceof LivingEntity) {
      return ((LivingEntity) shooter);
    }
  }
  return null;
}

@EventHandler
public void onEntityDamage(EntityDamageByEntityEvent event) {
    if ((!killAnimalsEnabled && !killMonstersEnabled) || !plugin.isSkyAssociatedWorld(event.getDamager().getWorld())) {
        return;
    }
    if (!(event.getEntity() instanceof Creature)) {
        return;
    }
    if (event.getDamager() instanceof Player
            && !plugin.playerIsOnIsland((Player)event.getDamager())) {
        if (hasPermission(event.getDamager(), "usb.mod.bypassprotection")) {
            return;
        }
        cancelMobDamage(event);
    } else if (event.getDamager() instanceof Projectile) {
        ProjectileSource shooter = ((Projectile) event.getDamager()).getShooter();
        if (!(shooter instanceof Player)) {
            return;
        }
        Player player = (Player) shooter;
        if (hasPermission(player, "usb.mod.bypassprotection") || plugin.playerIsOnIsland(player)) {
            return;
        }
        cancelMobDamage(event);
    }
}

/**
 * INTERNAL METHOD. Determines if the sources of two damage events are equal.
 */
static boolean sourcesEqual(DamageData a, DamageData b){
    if(a == null){
        return b == null;
    }
    if(b == null){
        return a == null;
    }

    if(a.getRawSource() == null){
        return b.getRawSource() == null;
    }
    if(b.getRawSource() == null){
        return a.getRawSource() == null;
    }

    if(a.getRawSource() instanceof Projectile){
        ProjectileSource aSrc = a.getSourceAsProjectile().getShooter();
        ProjectileSource bSrc = b.getSourceAsProjectile().getShooter();

        return Utilities.equals(aSrc, bSrc);
    }

    return Utilities.equals(a.getRawSource(), b.getRawSource());
}

@Nullable
public Player findAttacker(EntityDamageByEntityEvent event) {
    Player attackerPlayer = null;
    Entity attackerEntity = event.getDamager();

    if (attackerEntity instanceof Player) {
        attackerPlayer = (Player) attackerEntity;
    } else if (attackerEntity instanceof Projectile) {
        ProjectileSource shooter = ((Projectile) attackerEntity).getShooter();

        if (shooter instanceof Player) {
            attackerPlayer = (Player) shooter;
        }
    }

    return attackerPlayer;
}

private void projectileDamageAnimal(EntityDamageByEntityEvent event) {
    final Tameable animal = (Tameable) event.getEntity();
    final ProjectileSource source = ((Projectile) event.getDamager()).getShooter();
    if (source instanceof Player) {
        // If a player harmed the animal
        final Player player = (Player) source;
        if (!canPlayerHurt(animal, player, false)) {
            event.setCancelled(true);
            new LangString("error.protected", getAnimal(event.getEntityType())).send(player);
        }
    }
    else if (source instanceof Monster) {
        // If a monster harmed the animal
        if (getProtectionConfig().getBoolean("monster-ranged"))
            event.setCancelled(true);
    }
    else {
        // If something else harmed the animal (eg, dispenser)
        if (getProtectionConfig().getBoolean("other-ranged"))
            event.setCancelled(true);
    }
}

@EventHandler
public void onProjectileLaunch(ProjectileLaunchEvent event) {
    Projectile entity = event.getEntity();
    if (!(entity instanceof ThrownPotion)) {
        return;
    }
    ProjectileSource shooter = entity.getShooter();
    if (!(shooter instanceof Player)) {
        return;
    }
    Location l = BukkitUtil.getLocation(entity);
    if (!PS.get().hasPlotArea(l.getWorld())) {
        return;
    }
    PlotPlayer pp = BukkitUtil.getPlayer((Player) shooter);
    Plot plot = l.getOwnedPlot();
    if (plot != null && !plot.isAdded(pp.getUUID())) {
        entity.remove();
        event.setCancelled(true);
    }
}

private Player getDamager(Entity entity) {
    if (entity == null){
        return null;
    } else
    if (entity instanceof Player) {
        return (Player) entity;
    } else if (entity instanceof Projectile) {
        final ProjectileSource source = ((Projectile) entity).getShooter();
        if (source instanceof Entity) {
            return getDamager((Entity) source);
        } else {
            return null;
        }
    } else {
        return null;
    }
}

@EventHandler
public void onProjectileLaunchEvent(ProjectileLaunchEvent event) {
    Projectile projectile = event.getEntity();
    ProjectileSource source = projectile.getShooter();

    if (!(source instanceof Player)) {
        return;
    }

    SpleefPlayer shooter = getHeavySpleef().getSpleefPlayer(((Player) source));
    if (!game.isIngame(shooter)) {
        return;
    }

    ItemStack stack = shooter.getBukkitPlayer().getItemInHand();
    stack.setDurability((short)0);
    shooter.getBukkitPlayer().setItemInHand(stack);
}

@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onEntityDamageByEntity(final ExtendedEntityDamageEvent ext) {
    if (ext.getBaseEvent() instanceof EntityDamageByEntityEvent) {
        final EntityDamageByEntityEvent event = (EntityDamageByEntityEvent)ext.getBaseEvent();
        final Player p;
        if (event.getDamager().getType() == EntityType.PLAYER) {
            p = (Player)event.getDamager();
        } else if (event.getDamager() instanceof Projectile) {
            final ProjectileSource shooter = ((Projectile)event.getDamager()).getShooter();
            if (shooter != null && shooter instanceof Player) {
                p = (Player)shooter;
            } else {
                return;
            }
        } else {
            return;
        }
        if (getAnimals().contains(event.getEntityType()) &&
            ext.getEntityRegion() != null &&
            ext.getEntityRegion().getFlag(Flag.FARM) &&
            !ext.getEntityRegion().isUser(p)) {
            event.setCancelled(true);
        }
    }
}

@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
public void onPotionSplash(final ExtendedPotionSplashEvent ext) {
    final PotionSplashEvent event = (PotionSplashEvent)ext.getBaseEvent();
    final ProjectileSource shooter = event.getPotion().getShooter();
    if (shooter instanceof LivingEntity && getMobs().contains(((Entity)shooter).getType())) {
        if (ext.hasNegativeEffect()) {
            GeneralRegion region;
            for (final LivingEntity e : event.getAffectedEntities()) {
                if (e.getType() == EntityType.PLAYER) {
                    region = this.getPlugin().getDb().getPriorByLocation(e.getLocation());
                    if (region != null && region.getFlag(Flag.MOB)) {
                        event.setCancelled(true);
                    }
                }
            }
        }
    }
}

/**
 * Handle PotionSplashEvent events that involve modifying the event.
 *
 * @param event The event to modify
 */
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onPotionSplash(PotionSplashEvent event) {
    ProjectileSource shooter = event.getPotion().getShooter();

    if (!(shooter instanceof Player)) {
        return;
    }

    Player player = (Player) shooter;

    for (LivingEntity entity : event.getAffectedEntities()) {
        if (!(entity instanceof Player) || player == entity) {
            continue;
        }

        if (Ghosts.p.getGhostManager().isGhost(player)) {
            event.setIntensity(entity, 0);
        }
    }
}

/**
 * Called when the powerup is used
 * 
 * @param jockey The player who used it
 */
@Override
public void onUse(Jockey jockey) {

    this.amount--;

    final Player player = jockey.getPlayer();
    final World world = player.getWorld();
    final Location location = player.getEyeLocation();      

    Projectile projectile = (Projectile)world.spawnEntity(location, type);
    projectile.setVelocity(player.getLocation().getDirection().multiply(this.speed));
    projectile.setShooter((ProjectileSource) player);

    projectile.setMetadata("powerup", new FixedMetadataValue(MineKart.getInstance(), this));

}

@Test
public void shouldAllowProjectileLaunchFromNonHuman() {
    // given
    Projectile projectile = mock(Projectile.class);
    ProjectileSource source = mock(ProjectileSource.class);
    given(projectile.getShooter()).willReturn(source);
    ProjectileLaunchEvent event = mock(ProjectileLaunchEvent.class);
    given(event.getEntity()).willReturn(projectile);

    // when
    listener.onProjectileLaunch(event);

    // then
    verifyZeroInteractions(listenerService);
    verify(event, never()).setCancelled(anyBoolean());
}

@EventHandler
public void onProjectileHit(ProjectileHitEvent event) {
    if (event.getEntityType() != EntityType.FISHING_HOOK &&
        event.getEntityType() != EntityType.SNOWBALL &&
        event.getEntityType() != EntityType.EGG) return;
    ProjectileSource shooter = ((Projectile) event.getEntity()).getShooter();
    if (shooter != null && shooter instanceof Player && event.getHitEntity() instanceof Damageable) {
        ((Damageable) event.getHitEntity()).damage(0.01, (Player) shooter);
    }

}

public void setShooter(ProjectileSource shooter) {
    if (shooter instanceof CraftLivingEntity) {
        getHandle().thrower = (net.minecraft.entity.EntityLivingBase) ((CraftLivingEntity) shooter).entity;
        if (shooter instanceof CraftHumanEntity) {
            getHandle().throwerName = ((CraftHumanEntity) shooter).getName();
        }
    } else {
        getHandle().thrower = null;
        getHandle().throwerName = null;
    }
    getHandle().projectileSource = shooter;
}

public void setShooter(ProjectileSource shooter) {
    if (shooter instanceof LivingEntity) {
        getHandle().shootingEntity = ((CraftLivingEntity) shooter).getHandle();
    } else {
        getHandle().shootingEntity = null;
    }
    getHandle().projectileSource = shooter;
}

public ProjectileSource getShooter() {
    if (getHandle().field_146042_b != null) {
        return getHandle().field_146042_b.getBukkitEntity();
    }

    return null;
}

public void setShooter(ProjectileSource shooter) {
    if (shooter instanceof CraftLivingEntity) {
        getHandle().shootingEntity = ((CraftLivingEntity) shooter).getHandle();
    } else {
        getHandle().shootingEntity = null;
    }
    getHandle().projectileSource = shooter;
}

/**
 * Based on the parameters in this bullet, configure some stuff.
 * 
 * @param bullet the newly minted projectile 
 * @param world the world it inhabits
 * @param shooter who shot it
 * @param velocity The gun's intrinsic velocity. Might be ignored. 
 */
public void configureBullet(Projectile bullet, World world, ProjectileSource shooter, Vector velocity) {

    bullet.setVelocity(velocity);
    bullet.setFireTicks(this.fireTicks);

    if (bullet instanceof Fireball) {
        ((Fireball) bullet).setIsIncendiary(Math.random() < this.fireChance);
    }
}

@Override
public @Nullable PhysicalInfo resolveShooter(ProjectileSource source) {
    if(source instanceof Entity) {
        return entityTracker.resolveEntity((Entity) source);
    } else if(source instanceof BlockProjectileSource) {
        return blockTracker.resolveBlock(((BlockProjectileSource) source).getBlock());
    }
    return null;
}

void handleLaunch(Entity projectile, ProjectileSource source) {
    PhysicalInfo projectileInfo = entities.resolveEntity(projectile);
    if(!(projectileInfo instanceof ProjectileInfo)) {
        ProjectileDefinition definition = Projectiles.launchingProjectileDefinition(projectile);
        String customName = definition == null ? null : definition.getName();
        entities.trackEntity(projectile, new ProjectileInfo(projectileInfo,
                                                              projectiles.resolveShooter(source),
                                                              projectile.getLocation(),
                                                              customName));
    }
}

public KingdomFactionsPlayer getPlayer(ProjectileSource projSource) throws PlayerException {
    if(projSource instanceof Player) {
    Player p = (Player) projSource;
    return getPlayer(p.getName());
    } else {
        throw new PlayerException("ProjectileSource is not a valid Player!");
    }
}

private Player getDamageSource(Entity damager) {
    if (damager instanceof Player) {
        return (Player) damager;
    } else if (damager instanceof Arrow) {
        ProjectileSource shooter = ((Arrow) damager).getShooter();
        if (shooter instanceof Player) {
            return (Player) shooter;
        }
    }
    return null;
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPotionSplash(PotionSplashEvent event) {
    ThrownPotion potion = event.getEntity();
    if (!BukkitUtils.isDebuff(potion)) {
        return;
    }

    // Prevents potion effecting players that are in safe-zones.
    Faction factionAt = plugin.getFactionManager().getFactionAt(potion.getLocation());
    if (factionAt.isSafezone()) {
        event.setCancelled(true);
        return;
    }

    ProjectileSource source = potion.getShooter();
    if (source instanceof Player) {
        Player player = (Player) source;
        // Allow faction members to splash damage their own, PlayerFaction playerFaction = plugin.getFactionManager().getPlayerFaction(player);
        for (LivingEntity affected : event.getAffectedEntities()) {
            if (affected instanceof Player && !player.equals(affected)) {
                Player target = (Player) affected;
                if (target.equals(source))
                    continue; // allow the source to be affected regardless
                if (plugin.getFactionManager().getFactionAt(target.getLocation()).isSafezone()/* Nope || playerFaction.getMembers().containsKey(other.getUniqueId()) */) {
                    event.setIntensity(affected, 0);
                }
            }
        }
    }
}

@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
public void onPotionSplash(PotionSplashEvent event) {
    ThrownPotion potion = event.getEntity();
    if (!BukkitUtils.isDebuff(potion)) {
        return;
    }

    // Prevents potion effecting players that are in safe-zones.
    Faction factionAt = plugin.getFactionManager().getFactionAt(potion.getLocation());
    if (factionAt.isSafezone()) {
        event.setCancelled(true);
        return;
    }

    ProjectileSource source = potion.getShooter();
    if (source instanceof Player) {
        Player player = (Player) source;
        // Allow faction members to splash damage their own, PlayerFaction playerFaction = plugin.getFactionManager().getPlayerFaction(player);
        for (LivingEntity affected : event.getAffectedEntities()) {
            if (affected instanceof Player && !player.equals(affected)) {
                Player target = (Player) affected;
                if (target.equals(source))
                    continue; // allow the source to be affected regardless
                if (plugin.getFactionManager().getFactionAt(target.getLocation()).isSafezone()/* Nope || playerFaction.getMembers().containsKey(other.getUniqueId()) */) {
                    event.setIntensity(affected, 0);
                }
            }
        }
    }
}

@EventHandler
public void onProjectileLaunch(ProjectileLaunchEvent e){
    Projectile projectile = e.getEntity(); //Getting the projectile
    ProjectileSource shooter = projectile.getShooter(); //Getting the shooter
    if(shooter instanceof Player){ //If the shooter was a player
        Player player = (Player) shooter;
        if(!isEnabled(player.getWorld())) return; //If this module is enabled in this world
        debug("Making projectile go straight", player);
        //Here we get a unit vector of the direction the player is looking in and multiply it by the projectile's vector's magnitude
        //We then assign this to the projectile as its new velocity
        projectile.setVelocity(player.getLocation().getDirection().normalize().multiply(projectile.getVelocity().length()));
    }
}

@EventHandler
public void OnGhastProjectileLaunch(ProjectileLaunchEvent event)
{
    if(maze != null) {
        ProjectileSource e = event.getEntity().getShooter();
        if (e instanceof Ghast && maze.checkIfInMaze(((Ghast) e).getLocation())) {
            Fireball ball = (Fireball) event.getEntity();
            float roll = 1 + 3 * random.nextFloat();
            ball.setYield(roll);
        }
    }
}

/**
 * Retrieve the shooter of this projectile.
 * <p/>
 * <b>Entities: </b> {@link Projectile}, {@link ShulkerBullet}
 *
 * @return the {@link ProjectileSource} that shot this projectile ({@code null} when not Projectile)
 */
public ProjectileSource getShooter() {
    if (entity instanceof Projectile) {
        return ((Projectile)entity).getShooter();
    } else if (entity instanceof ShulkerBullet) {
        return ((ShulkerBullet)entity).getShooter();
    }
    return null;
}

/**
 * Set the shooter of this projectile.
 * <p/>
 * <b>Entities: </b> {@link Projectile}, {@link ShulkerBullet}
 *
 * @param shooter the {@link ProjectileSource} that shot this projectile
 * @return this instance
 */
public EEntity setShooter(ProjectileSource shooter) {
    if (entity instanceof Projectile) {
        ((Projectile)entity).setShooter(shooter);
    } else if (entity instanceof ShulkerBullet) {
        ((ShulkerBullet)entity).setShooter(shooter);
    }
    return this;
}

public EEntity setShooter(EEntity shooter) {
    if (shooter.bukkit() instanceof ProjectileSource) {
        if (entity instanceof Projectile) {
            ((Projectile)entity).setShooter((ProjectileSource)shooter.bukkit());
        } else if (entity instanceof ShulkerBullet) {
            ((ShulkerBullet)entity).setShooter((ProjectileSource)shooter.bukkit());
        }
    }
    return this;
}

@EventHandler(priority = EventPriority.LOWEST)
public void onEntityDamage(EntityDamageEvent event)
{
    Entity entity = event.getEntity();

    DamageCause cause = event.getCause();
    if(cause == DamageCause.ENTITY_ATTACK || cause == DamageCause.PROJECTILE)
    {
        EntityDamageByEntityEvent event2 = (EntityDamageByEntityEvent)event;
        Entity attacker = event2.getDamager();

        if(attacker != null && attacker.getType() == EntityType.PLAYER) return;

        if(attacker instanceof Projectile)
        {
            ProjectileSource source = ((Projectile)attacker).getShooter();
            if(source != null && source instanceof Player) return;
        }
    }

    if(entity instanceof Animals || entity instanceof WaterMob || entity.getType() == EntityType.VILLAGER || entity.getCustomName() != null)
    {
        Flag flag = this.GetFlagInstanceAtLocation(entity.getLocation(), null);
        if(flag == null) return;
        event.setCancelled(true);
    }
}

public void setShooter(ProjectileSource shooter) {
    if (shooter instanceof CraftLivingEntity) {
        getHandle().thrower = (net.minecraft.entity.EntityLivingBase) ((CraftLivingEntity) shooter).entity;
        if (shooter instanceof CraftHumanEntity) {
            getHandle().throwerName = ((CraftHumanEntity) shooter).getName();
        }
    } else {
        getHandle().thrower = null;
        getHandle().throwerName = null;
    }
    getHandle().projectileSource = shooter;
}