Java 类org.bukkit.entity.ExperienceOrb 实例源码

public void run(){
    switch (rain){
        case EXP:
            locs.forEach(l -> {
                experienceOrb = (ExperienceOrb)l.getWorld().spawnEntity(l, EntityType.EXPERIENCE_ORB);
                experienceOrb.setExperience(levels);
            });
            break;
        case MAT:
            locs.forEach(l -> l.getWorld().dropItemNaturally(l, new ItemStack(material)));
            break;
        default:
            cancel();
            break;
    }
}

@EventHandler(ignoreCancelled = true)
public void onTarget(EntityTargetEvent event) {
    if(!(event.getEntity() instanceof ExperienceOrb)) {
        ParticipantState victimState = null;
        if(event.getTarget() instanceof Player) {
            // Don't target allies
            MatchPlayer victim = getVictim(event.getTarget());
            if(victim == null) return;
            victimState = victim.getParticipantState();
        } else if(event.getTarget() != null) {
            // Don't target other mobs owned by allies
            victimState = entityResolver.getOwner(event.getTarget());
        }
        if(victimState == null) return;
        DamageInfo damageInfo = damageResolver.resolveDamage(EntityDamageEvent.DamageCause.ENTITY_ATTACK, event.getTarget(), event.getEntity());
        if(queryHostile(event, victimState, damageInfo).isDenied()) {
            event.setCancelled(true);
        }
    }
}

final void repellExpOrb(final Player player, final ExperienceOrb orb) {
    final Location pLoc = player.getLocation();
    final Location oLoc = orb.getLocation();
    final Vector dir = oLoc.toVector().subtract(pLoc.toVector());
    final double dx = Math.abs(dir.getX());
    final double dz = Math.abs(dir.getZ());
    if ( (dx == 0.0) && (dz == 0.0)){
        // Special case probably never happens
        dir.setX(0.001);
    }
    if ((dx < 3.0) && (dz < 3.0)){
        final Vector nDir = dir.normalize();
        final Vector newV = nDir.clone().multiply(0.3);
        newV.setY(0);
        orb.setVelocity(newV);
        if ((dx < 1.0) && (dz < 1.0)){
            // maybe oLoc
            orb.teleport(oLoc.clone().add(nDir.multiply(1.0)), TeleportCause.PLUGIN);
        } 
        if ((dx < 0.5) && (dz < 0.5)){
            orb.remove();
        } 
    } 
}

@EventHandler(priority = EventPriority.MONITOR)
public void onEntityExplode(EntityExplodeEvent event) {
    if (!event.isCancelled()) {
        Player player = TntTracker.getWhoPlaced(event.getEntity()) != null && Bukkit.getOfflinePlayer(TntTracker.getWhoPlaced(event.getEntity())).isOnline() ? Bukkit.getPlayer(TntTracker.getWhoPlaced(event.getEntity())) : null;
        if (player != null) {
            for (Block block : event.blockList()) {
                if (filter == null || filter.evaluate(player, block).equals(FilterState.ALLOW)) {
                    if (region == null || region.contains(new BlockRegion(null, block.getLocation().toVector().add(new Vector(0.5, 0.5, 0.5))))) {
                        for (ItemStack drop : this.drops) {
                            GameHandler.getGameHandler().getMatchWorld().dropItemNaturally(block.getLocation(), drop);
                        }
                        if (this.experience != 0) {
                            ExperienceOrb xp = GameHandler.getGameHandler().getMatchWorld().spawn(block.getLocation(), ExperienceOrb.class);
                            xp.setExperience(this.experience);
                        }
                        block.setType(replace);
                    }
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.MONITOR)
public void onEntityExplode(EntityExplodeEvent event) {
    if (!event.isCancelled()) {
        Player player = TntTracker.getWhoPlaced(event.getEntity()) != null && Bukkit.getOfflinePlayer(TntTracker.getWhoPlaced(event.getEntity())).isOnline() ? Bukkit.getPlayer(TntTracker.getWhoPlaced(event.getEntity())) : null;
        if (player != null) {
            List<Block> toRemove = new ArrayList<>();
            for (Block block : event.blockList()) {
                if (filter == null || filter.evaluate(player, block, event).equals(FilterState.ALLOW)) {
                    if (region == null || region.contains(block.getLocation().toVector().add(new Vector(0.5, 0.5, 0.5)))) {
                        for (ItemStack drop : this.drops) {
                            GameHandler.getGameHandler().getMatchWorld().dropItemNaturally(block.getLocation(), drop);
                        }
                        if (this.experience != 0) {
                            ExperienceOrb xp = GameHandler.getGameHandler().getMatchWorld().spawn(block.getLocation(), ExperienceOrb.class);
                            xp.setExperience(this.experience);
                        }
                        toRemove.add(block);
                        block.setType(replaceType);
                        block.setData((byte) replaceDamage);
                    }
                }
            }
            event.blockList().removeAll(toRemove);
        }
    }
}

protected void tick(Block b)
        throws Exception
    {
        for(Iterator iterator = me.mrCookieSlime.Slimefun.holograms.XPCollector.getArmorStand(b).getNearbyEntities(4D, 4D, 4D).iterator(); iterator.hasNext();)
        {
            Entity n = (Entity)iterator.next();
            if(n instanceof ExperienceOrb)
            {
                if(ChargableBlock.getCharge(b) < getEnergyConsumption())
                    return;
                if(n.isValid())
                {
                    int xp = getEXP(b) + ((ExperienceOrb)n).getExperience();
                    ChargableBlock.addCharge(b, -getEnergyConsumption());
                    n.remove();
                    int withdrawn = 0;
                    for(int level = 0; level < getEXP(b); level += 10)
                        if(fits(b, new ItemStack[] {
    new CustomItem(Material.EXP_BOTTLE, "&a\u5B66\u8BC6\u4E4B\u74F6", 0)
}))
                        {
                            withdrawn += 10;
                            pushItems(b, new ItemStack[] {
                                new CustomItem(Material.EXP_BOTTLE, "&a\u5B66\u8BC6\u4E4B\u74F6", 0)
                            });
                        }

                    BlockStorage.addBlockInfo(b, "stored-exp", String.valueOf(xp - withdrawn));
                    return;
                }
            }
        }

    }

private void dropExperience(BlockDrops drops, Location location) {
    if(drops.experience != 0) {
        ExperienceOrb expOrb = (ExperienceOrb) location.getWorld().spawnEntity(BlockUtils.center(location), EntityType.EXPERIENCE_ORB);
        if(expOrb != null) {
            expOrb.setExperience(drops.experience);
        }
    }
}

@EventHandler
protected void onEntityTarget(EntityTargetEvent e) {
    // On entity target - Stop mobs targeting spectators
    // Check to make sure it isn't an NPC (Citizens NPC's will be detectable using 'entity.hasMetadata("NPC")')
    if (e.getTarget() != null && e.getTarget() instanceof Player && !e.getTarget().hasMetadata("NPC") && SkyWarsReloaded.getPC().getPlayer(((Player) e.getTarget()).getUniqueId()).isSpectating()) {
        e.setCancelled(true);
    }
    if (e.getTarget() instanceof Player && e.getTarget() != null && SkyWarsReloaded.getPC().getPlayer(((Player) e.getTarget()).getUniqueId()).isSpectating()) {
        if (e.getEntity() instanceof ExperienceOrb) {
            repellExpOrb((Player) e.getTarget(), (ExperienceOrb) e.getEntity());
            e.setCancelled(true);
            e.setTarget(null);
        }
    }
}

public XpManager() {
    new BukkitRunnable() {
        public void run() {
            if (TaskID == -1) {
                TaskID = this.getTaskId();
            }
            for (Arena arena : ArenaManager.getArenas()) {
                if (arena.getPlayers().size() != 0) {
                    for (XpGen gen : arena.getXpGenerators()) {
                        if (!data.containsKey(gen)) {
                            data.put(gen, 1);
                        } else {
                            int value = data.get(gen);
                            data.remove(gen);
                            data.put(gen, value + 1);
                        }
                        if (data.get(gen) == gen.getInterval()) {
                            ExperienceOrb exp = (ExperienceOrb) gen.getLocation().getWorld().spawnEntity(gen.getLocation(), EntityType.EXPERIENCE_ORB);
                            exp.setExperience(1);
                            data.remove(gen);
                        }
                    }
                }
            }
        }
    }.runTaskTimer(Main.getInstance(), 20L, 20L);
}

@EventHandler
public void onDeath(PlayerDeathEvent e) {
    Player p = e.getEntity();
    if (!Utils.isInArena(p)) {
        return;
    }
    int level = p.getLevel();
    ExperienceOrb exp = (ExperienceOrb) p.getWorld().spawnEntity(p.getLocation(), EntityType.EXPERIENCE_ORB);
    exp.setExperience(level * 2);
}

@EventHandler
public void onCExpDrop(KMCExpDropEvent e) {
    if (e.isCancelled()) {
        return;
    }

    e.getLocation().getWorld().spawn(e.getLocation(), ExperienceOrb.class).setExperience(e.getValue());
}

@Override
@Nullable
public ExperienceOrb spawn(final Location loc) {
    final ExperienceOrb orb = super.spawn(loc);
    if (orb == null)
        return null;
    if (xp == -1)
        orb.setExperience(1);
    return orb;
}

private void doXP(DropConfig dc, String biomeName, ToolConfig dropModifier, Location loc, Player p) {
    double xpChance = dc.getXPChance(biomeName) 
            * (dropModifier == null ? 1.0 : dropModifier.getDropChanceModifier())
            * dc.getStateChance(biomeName, p);
    if (xpChance > Math.random()) {
        int toXP = dc.renderXP(biomeName, dropModifier);
        if (toXP > 0) {
            Entity xp = loc.getWorld().spawnEntity(loc, EntityType.EXPERIENCE_ORB);
            if (xp instanceof ExperienceOrb) {
                ExperienceOrb eo = (ExperienceOrb) xp;
                eo.setExperience(toXP);
            }
        }
    }
}

public void dropItems() {
    try {
        if (entity == null) {
            return;
        }

        LinkedList<MobDrop> dropped = getRandomDrops();
        World world = entity.getBukkitEntity().getWorld();
        Location loc = getLocation(entity);

        for (MobDrop d : dropped) {
            ItemStack stack;
            if (d.isVanillaDrop) {
                stack = ItemManager.createItemStack(d.vanillaType, 1, d.vanillaData);
            } else {
                LoreCraftableMaterial craftMat = LoreCraftableMaterial.getCraftMaterialFromId(d.craftMatId);
                stack = LoreCraftableMaterial.spawn(craftMat);
            }

            world.dropItem(loc, stack);
        }

        if (this.coinMax != 0 && this.coinMin != 0) {
            ExperienceOrb orb = (ExperienceOrb)world.spawn(loc, ExperienceOrb.class);
            Random random = new Random();
            int coins = random.nextInt(this.coinMax - this.coinMin) + this.coinMin;
            orb.setExperience(coins);

        }
    } catch(Exception e) {
        e.printStackTrace();
    }
}

protected void tick(Block b) throws Exception {
    Iterator<Entity> iterator = me.mrCookieSlime.Slimefun.holograms.XPCollector.getArmorStand(b).getNearbyEntities(4D, 4D, 4D).iterator();
    while (iterator.hasNext()) {
        Entity n = iterator.next();
        if (n instanceof ExperienceOrb) {
            if (ChargableBlock.getCharge(b) < getEnergyConsumption()) return;

            if (n.isValid()) {
                int xp = getEXP(b) + ((ExperienceOrb) n).getExperience();

                ChargableBlock.addCharge(b, -getEnergyConsumption());
                n.remove();

                int withdrawn = 0;
                for (int level = 0; level < getEXP(b); level = level + 10) {
                    if (fits(b, new CustomItem(Material.EXP_BOTTLE, "&aFlask of Knowledge", 0))) {
                        withdrawn = withdrawn + 10;
                        pushItems(b, new CustomItem(Material.EXP_BOTTLE, "&aFlask of Knowledge", 0));
                    }
                }
                BlockStorage.addBlockInfo(b, "stored-exp", String.valueOf(xp - withdrawn));

                return;
            }
        }
    }
}

@EventHandler
public void onCleanup(ChunkUnloadEvent e) {
    for(Entity entity : e.getChunk().getEntities()) {
        if(entity instanceof Item) {
            Item item = (Item) entity;
            item.remove();
        } else if(entity instanceof Monster) {
            Monster monster = (Monster) entity;
            monster.remove();
        } else if(entity instanceof ExperienceOrb) {
            ExperienceOrb orb = (ExperienceOrb) entity;
            orb.remove();
        }
    }
}

/**
    * Called when a Zombie is killed by a player
    * 
    * @param attacker
    *        the {@link ZvPPlayer} who killed the zombie
    * @param zombie
    *        the zombie {@link Entity} who is killed
    */
   public void onZombieKill(final ZvPPlayer attacker, Entity zombie, EntityDeathEvent event) {

if (this.arena.getConfig().isKeepXP()) {
    // entity.remove() does cancel xp spawn.
    // --> spawn xp

    int droppedExp = (int) Math.ceil((event.getDroppedExp() / 2.0) * this.arena.getDifficultyTool().getExpFactor());

    for (int xp = 0; xp < droppedExp; xp++) {
    zombie.getWorld().spawn(zombie.getLocation().clone(), ExperienceOrb.class).setExperience(1);
    }
}

// Remove entity is faster than waiting for Server to do it
zombie.remove();

// Task is needed because entity.remove() is asyncron and takes longer
// therefor the scoreboard gets updated to early and needs to wait!
Bukkit.getScheduler().runTaskLater(ZvP.getInstance(), new Runnable() {

    @Override
    public void run() {
    attacker.addKill();
    }
}, 5L);

   }

public void clearArena() {
for (Entity e : getArea().getEntities()) {
    if (e instanceof Monster || e instanceof Item || e instanceof ExperienceOrb) {
    e.remove();
    }
}
   }

@EventHandler(priority=EventPriority.HIGHEST)
public void onDeath(final EntityDeathEvent e) {
    if (e.getEntity().hasMetadata("android_killer")) {
        for (MetadataValue value: e.getEntity().getMetadata("android_killer")) {
            final AndroidObject obj = (AndroidObject) value.value();
            Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunStartup.instance, new Runnable() {

                @SuppressWarnings("deprecation")
                @Override
                public void run() {
                    List<ItemStack> items = new ArrayList<ItemStack>();
                    for (Entity n: e.getEntity().getNearbyEntities(0.5D, 0.5D, 0.5D)) {
                        if (n instanceof Item && !n.hasMetadata("no_pickup")) {
                            items.add(((Item) n).getItemStack());
                            n.remove();
                        }
                    }

                    switch (e.getEntityType()) {
                    case BLAZE: {
                        items.add(new ItemStack(Material.BLAZE_ROD, 1 + CSCoreLib.randomizer().nextInt(2)));
                        break;
                    }
                    case PIG_ZOMBIE: {
                        items.add(new ItemStack(Material.GOLD_NUGGET, 1 + CSCoreLib.randomizer().nextInt(3)));
                        break;
                    }
                    case SKELETON: {
                        if (((Skeleton) e.getEntity()).getSkeletonType().equals(SkeletonType.WITHER)) {
                            if (CSCoreLib.randomizer().nextInt(250) < 2) items.add(new MaterialData(Material.SKULL_ITEM, (byte) 1).toItemStack(1));
                        }
                        break;
                    }
                    default:
                        break;
                    }

                    obj.getAndroid().addItems(obj.getBlock(), items.toArray(new ItemStack[items.size()]));
                    ExperienceOrb exp = (ExperienceOrb) e.getEntity().getWorld().spawnEntity(e.getEntity().getLocation(), EntityType.EXPERIENCE_ORB);
                    exp.setExperience(1 + CSCoreLib.randomizer().nextInt(6));
                }
            }, 1L);
            return;
        }
    }
}

private static void drop(Material material, int amount, Location location) {
    location.getWorld().dropItem(location, new ItemStack(material, amount));

    ExperienceOrb exp = location.getWorld().spawn(location, ExperienceOrb.class);
    exp.setExperience(1);
}

@Override
protected boolean init(final @Nullable Class<? extends ExperienceOrb> c, final @Nullable ExperienceOrb e) {
    xp = e == null ? -1 : e.getExperience();
    return true;
}

@Override
public Class<? extends ExperienceOrb> getType() {
    return ExperienceOrb.class;
}

@Override
protected boolean match(final ExperienceOrb entity) {
    return xp == -1 || entity.getExperience() == xp;
}

@Override
public void set(final ExperienceOrb entity) {
    if (xp != -1)
        entity.setExperience(xp);
}

@EventHandler(priority=EventPriority.HIGHEST)
public void onDeath(final EntityDeathEvent e) {
    if (e.getEntity().hasMetadata("android_killer")) {
        for (MetadataValue value: e.getEntity().getMetadata("android_killer")) {
            final AndroidObject obj = (AndroidObject) value.value();
            Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunStartup.instance, new Runnable() {

                @SuppressWarnings("deprecation")
                @Override
                public void run() {
                    List<ItemStack> items = new ArrayList<ItemStack>();
                    for (Entity n: e.getEntity().getNearbyEntities(0.5D, 0.5D, 0.5D)) {
                        if (n instanceof Item && !n.hasMetadata("no_pickup")) {
                            items.add(((Item) n).getItemStack());
                            n.remove();
                        }
                    }

                    switch (e.getEntityType()) {
                    case BLAZE: {
                        items.add(new ItemStack(Material.BLAZE_ROD, 1 + CSCoreLib.randomizer().nextInt(2)));
                        break;
                    }
                    case PIG_ZOMBIE: {
                        items.add(new ItemStack(Material.GOLD_NUGGET, 1 + CSCoreLib.randomizer().nextInt(3)));
                        break;
                    }
                    case SKELETON: {
                        if (((Skeleton) e.getEntity()).getSkeletonType().equals(SkeletonType.WITHER)) {
                            if (CSCoreLib.randomizer().nextInt(250) < 2) items.add(new MaterialData(Material.SKULL_ITEM, (byte) 1).toItemStack(1));
                        }
                        break;
                    }
                    default:
                        break;
                    }

                    obj.getAndroid().addItems(obj.getBlock(), items.toArray(new ItemStack[items.size()]));
                    ExperienceOrb exp = (ExperienceOrb) e.getEntity().getWorld().spawnEntity(e.getEntity().getLocation(), EntityType.EXPERIENCE_ORB);
                    exp.setExperience(1 + CSCoreLib.randomizer().nextInt(6));
                }
            }, 1L);
            return;
        }
    }
}

private static boolean spawnEntities(Location location, EntityType obj, CommandSender sender, Material mat, 
        PotionType potionType, int amount, int radius, boolean isOnFire){

    Location newLoc;
    Random rdm = new Random();

    try{
        //Spawn entity
        for (int i = 0; i < amount; i++){
            newLoc = location.clone();
            newLoc.setX(location.getX()+(double)rdm.nextInt(radius*2)-(double)radius);
            newLoc.setY(location.getY()+(double)rdm.nextInt(250)+100.0);
            newLoc.setZ(location.getZ()+(double)rdm.nextInt(radius*2)-(double)radius);

            if (obj != null){
                Entity creature = location.getWorld().spawn(newLoc, obj.getEntityClass());
                thrownedItems.put(creature, isOnFire);

                if (creature instanceof Fireball)
                    ((Fireball)creature).setDirection(new Vector(0, -1, 0));
                if (creature instanceof ExperienceOrb)
                    ((ExperienceOrb) creature).setExperience(1000 + (int)rdm.nextFloat()*300);
                if (creature instanceof TNTPrimed)
                    ((TNTPrimed) creature).setFuseTicks(150);
                if (isOnFire)
                    creature.setFireTicks(1000 + (int)rdm.nextFloat()*300);
            }else{
                ItemStack is;
                if(potionType != null)
                    is = new Potion(potionType).toItemStack(1);
                else
                    is = new ItemStack(mat);
                location.getWorld().dropItem(newLoc, is);

            }
        }
    }catch(Exception e){
        Resources.privateMsg(sender, "This entity or world is invalid");
        return false;
    }
    return true;
}

public void dropExp(Location loc){
    ((ExperienceOrb)loc.getWorld().spawn(loc, ExperienceOrb.class)).setExperience(100);
}

private static boolean spawnEntities(Location location, EntityType obj, CommandSender sender, Material mat, 
        PotionType potionType, int amount, int radius, boolean isOnFire){

    Location newLoc;
    Random rdm = new Random();

    try{
        //Spawn entity
        for (int i = 0; i < amount; i++){
            newLoc = location.clone();
            newLoc.setX(location.getX()+(double)rdm.nextInt(radius*2)-(double)radius);
            newLoc.setY(location.getY()+(double)rdm.nextInt(250)+100.0);
            newLoc.setZ(location.getZ()+(double)rdm.nextInt(radius*2)-(double)radius);

            if (obj != null){
                Entity creature = location.getWorld().spawn(newLoc, obj.getEntityClass());
                thrownedItems.put(creature, isOnFire);

                if (creature instanceof Fireball)
                    ((Fireball)creature).setDirection(new Vector(0, -1, 0));
                if (creature instanceof ExperienceOrb)
                    ((ExperienceOrb) creature).setExperience(1000 + (int)rdm.nextFloat()*300);
                if (creature instanceof TNTPrimed)
                    ((TNTPrimed) creature).setFuseTicks(150);
                if (isOnFire)
                    creature.setFireTicks(1000 + (int)rdm.nextFloat()*300);
            }else{
                ItemStack is;
                if(potionType != null)
                    is = new Potion(potionType).toItemStack(1);
                else
                    is = new ItemStack(mat);
                location.getWorld().dropItem(newLoc, is);

            }
        }
    }catch(Exception e){
        Resources.privateMsg(sender, "This entity or world is invalid");
        return false;
    }
    return true;
}

/**
 * Drop an experience orb
 *
 * @param location
 *            the location
 * @param xp
 *            the amount of xp
 */
public static void dropXp(Location location, int xp)
{
    ((ExperienceOrb) location.getWorld().spawn(location, ExperienceOrb.class)).setExperience(xp);
}