From 24557bc2b37deb6a0edf497d547471832457b1dd Mon Sep 17 00:00:00 2001 From: Thinkofdeath Date: Wed, 26 Nov 2014 08:32:16 +1100 Subject: Update to Minecraft 1.8 For more information please see http://www.spigotmc.org/ --- nms-patches/WorldServer.patch | 550 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 550 insertions(+) create mode 100644 nms-patches/WorldServer.patch (limited to 'nms-patches/WorldServer.patch') diff --git a/nms-patches/WorldServer.patch b/nms-patches/WorldServer.patch new file mode 100644 index 00000000..b1ad5607 --- /dev/null +++ b/nms-patches/WorldServer.patch @@ -0,0 +1,550 @@ +--- ../work/decompile-bb26c12b/net/minecraft/server/WorldServer.java 2014-11-27 08:59:46.945420772 +1100 ++++ src/main/java/net/minecraft/server/WorldServer.java 2014-11-27 08:42:10.140850934 +1100 +@@ -16,6 +16,20 @@ + import org.apache.logging.log4j.LogManager; + import org.apache.logging.log4j.Logger; + ++// CraftBukkit start ++import java.util.*; ++import java.util.logging.Level; ++ ++import org.bukkit.WeatherType; ++import org.bukkit.block.BlockState; ++import org.bukkit.craftbukkit.util.LongHash; ++ ++import org.bukkit.event.block.BlockFormEvent; ++import org.bukkit.event.weather.LightningStrikeEvent; ++import org.bukkit.event.weather.ThunderChangeEvent; ++import org.bukkit.event.weather.WeatherChangeEvent; ++// CraftBukkit end ++ + public class WorldServer extends World implements IAsyncTaskHandler { + + private static final Logger a = LogManager.getLogger(); +@@ -37,14 +51,21 @@ + private static final List U = Lists.newArrayList(new StructurePieceTreasure[] { new StructurePieceTreasure(Items.STICK, 0, 1, 3, 10), new StructurePieceTreasure(Item.getItemOf(Blocks.PLANKS), 0, 1, 3, 10), new StructurePieceTreasure(Item.getItemOf(Blocks.LOG), 0, 1, 3, 10), new StructurePieceTreasure(Items.STONE_AXE, 0, 1, 1, 3), new StructurePieceTreasure(Items.WOODEN_AXE, 0, 1, 1, 5), new StructurePieceTreasure(Items.STONE_PICKAXE, 0, 1, 1, 3), new StructurePieceTreasure(Items.WOODEN_PICKAXE, 0, 1, 1, 5), new StructurePieceTreasure(Items.APPLE, 0, 2, 3, 5), new StructurePieceTreasure(Items.BREAD, 0, 2, 3, 3), new StructurePieceTreasure(Item.getItemOf(Blocks.LOG2), 0, 1, 3, 10)}); + private List V = Lists.newArrayList(); + +- public WorldServer(MinecraftServer minecraftserver, IDataManager idatamanager, WorldData worlddata, int i, MethodProfiler methodprofiler) { +- super(idatamanager, worlddata, WorldProvider.byDimension(i), methodprofiler, false); ++ // CraftBukkit start ++ public final int dimension; ++ ++ // Add env and gen to constructor ++ public WorldServer(MinecraftServer minecraftserver, IDataManager idatamanager, WorldData worlddata, int i, MethodProfiler methodprofiler, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) { ++ super(idatamanager, worlddata, WorldProvider.byDimension(env.getId()), methodprofiler, false, gen, env); ++ this.dimension = i; ++ this.pvpMode = minecraftserver.getPVP(); ++ // CraftBukkit end + this.server = minecraftserver; + this.tracker = new EntityTracker(this); + this.manager = new PlayerChunkMap(this); + this.worldProvider.a(this); + this.chunkProvider = this.k(); +- this.Q = new PortalTravelAgent(this); ++ this.Q = new org.bukkit.craftbukkit.CraftTravelAgent(this); // CraftBukkit + this.B(); + this.C(); + this.af().a(minecraftserver.aG()); +@@ -86,6 +107,89 @@ + + return this; + } ++ ++ // CraftBukkit start ++ @Override ++ public TileEntity getTileEntity(BlockPosition pos) { ++ TileEntity result = super.getTileEntity(pos); ++ Block type = getType(pos).getBlock(); ++ ++ if (type == Blocks.CHEST) { ++ if (!(result instanceof TileEntityChest)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.FURNACE) { ++ if (!(result instanceof TileEntityFurnace)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.DROPPER) { ++ if (!(result instanceof TileEntityDropper)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.DISPENSER) { ++ if (!(result instanceof TileEntityDispenser)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.JUKEBOX) { ++ if (!(result instanceof TileEntityRecordPlayer)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.NOTEBLOCK) { ++ if (!(result instanceof TileEntityNote)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.MOB_SPAWNER) { ++ if (!(result instanceof TileEntityMobSpawner)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if ((type == Blocks.STANDING_SIGN) || (type == Blocks.WALL_SIGN)) { ++ if (!(result instanceof TileEntitySign)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.ENDER_CHEST) { ++ if (!(result instanceof TileEntityEnderChest)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.BREWING_STAND) { ++ if (!(result instanceof TileEntityBrewingStand)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.BEACON) { ++ if (!(result instanceof TileEntityBeacon)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } else if (type == Blocks.HOPPER) { ++ if (!(result instanceof TileEntityHopper)) { ++ result = fixTileEntity(pos, type, result); ++ } ++ } ++ ++ return result; ++ } ++ ++ private TileEntity fixTileEntity(BlockPosition pos, Block type, TileEntity found) { ++ this.getServer().getLogger().log(Level.SEVERE, "Block at {0},{1},{2} is {3} but has {4}" + ". " ++ + "Bukkit will attempt to fix this, but there may be additional damage that we cannot recover.", new Object[]{pos.getX(), pos.getY(), pos.getZ(), org.bukkit.Material.getMaterial(Block.getId(type)).toString(), found}); ++ ++ if (type instanceof IContainer) { ++ TileEntity replacement = ((IContainer) type).a(this, type.toLegacyData(this.getType(pos))); ++ replacement.world = this; ++ this.setTileEntity(pos, replacement); ++ return replacement; ++ } else { ++ this.getServer().getLogger().severe("Don't know how to fix for this type... Can't do anything! :("); ++ return found; ++ } ++ } ++ ++ private boolean canSpawn(int x, int z) { ++ if (this.generator != null) { ++ return this.generator.canSpawn(this.getWorld(), x, z); ++ } else { ++ return this.worldProvider.canSpawn(x, z); ++ } ++ } ++ // CraftBukkit end + + public void doTick() { + super.doTick(); +@@ -105,8 +209,11 @@ + } + + this.methodProfiler.a("mobSpawner"); +- if (this.getGameRules().getBoolean("doMobSpawning") && this.worldData.getType() != WorldType.DEBUG_ALL_BLOCK_STATES) { +- this.R.a(this, this.allowMonsters, this.allowAnimals, this.worldData.getTime() % 400L == 0L); ++ // CraftBukkit start - Only call spawner if we have players online and the world allows for mobs or animals ++ long time = this.worldData.getTime(); ++ if (this.getGameRules().getBoolean("doMobSpawning") && this.worldData.getType() != WorldType.DEBUG_ALL_BLOCK_STATES && (this.allowMonsters || this.allowAnimals) && (this instanceof WorldServer && this.players.size() > 0)) { ++ this.R.a(this, this.allowMonsters && (this.ticksPerMonsterSpawns != 0 && time % this.ticksPerMonsterSpawns == 0L), this.allowAnimals && (this.ticksPerAnimalSpawns != 0 && time % this.ticksPerAnimalSpawns == 0L), this.worldData.getTime() % 400L == 0L); ++ // CraftBukkit end + } + + this.methodProfiler.c("chunkSource"); +@@ -135,6 +242,8 @@ + this.Q.a(this.getTime()); + this.methodProfiler.b(); + this.ak(); ++ ++ this.getWorld().processChunkGC(); // CraftBukkit + } + + public BiomeMeta a(EnumCreatureType enumcreaturetype, BlockPosition blockposition) { +@@ -161,7 +270,7 @@ + + if (entityhuman.v()) { + ++i; +- } else if (entityhuman.isSleeping()) { ++ } else if (entityhuman.isSleeping() || entityhuman.fauxSleeping) { // CraftBukkit + ++j; + } + } +@@ -187,26 +296,45 @@ + } + + private void ag() { +- this.worldData.setWeatherDuration(0); +- this.worldData.setStorm(false); +- this.worldData.setThunderDuration(0); +- this.worldData.setThundering(false); ++ // CraftBukkit start ++ WeatherChangeEvent weather = new WeatherChangeEvent(this.getWorld(), false); ++ this.getServer().getPluginManager().callEvent(weather); ++ ++ ThunderChangeEvent thunder = new ThunderChangeEvent(this.getWorld(), false); ++ this.getServer().getPluginManager().callEvent(thunder); ++ if (!weather.isCancelled()) { ++ this.worldData.setWeatherDuration(0); ++ this.worldData.setStorm(false); ++ } ++ if (!thunder.isCancelled()) { ++ this.worldData.setThunderDuration(0); ++ this.worldData.setThundering(false); ++ } ++ // CraftBukkit end + } + + public boolean everyoneDeeplySleeping() { + if (this.O && !this.isStatic) { + Iterator iterator = this.players.iterator(); + ++ // CraftBukkit - This allows us to assume that some people are in bed but not really, allowing time to pass in spite of AFKers ++ boolean foundActualSleepers = false; ++ + EntityHuman entityhuman; + + do { + if (!iterator.hasNext()) { +- return true; ++ return foundActualSleepers; + } + + entityhuman = (EntityHuman) iterator.next(); +- } while (!entityhuman.v() && entityhuman.isDeeplySleeping()); +- ++ // CraftBukkit start ++ if (entityhuman.isDeeplySleeping()) { ++ foundActualSleepers = true; ++ } ++ } while (!entityhuman.v() && (entityhuman.isDeeplySleeping() || entityhuman.fauxSleeping)); ++ // CraftBukkit end ++ + return false; + } else { + return false; +@@ -227,15 +355,22 @@ + } else { + int i = 0; + int j = 0; +- +- for (Iterator iterator1 = this.chunkTickList.iterator(); iterator1.hasNext(); this.methodProfiler.b()) { +- ChunkCoordIntPair chunkcoordintpair1 = (ChunkCoordIntPair) iterator1.next(); +- int k = chunkcoordintpair1.x * 16; +- int l = chunkcoordintpair1.z * 16; +- ++ ++ // CraftBukkit start ++ //for (Iterator iterator1 = this.chunkTickList.iterator(); iterator1.hasNext(); this.methodProfiler.b()) { ++ // ChunkCoordIntPair chunkcoordintpair1 = (ChunkCoordIntPair) iterator1.next(); ++ // int k = chunkcoordintpair1.x * 16; ++ // int l = chunkcoordintpair1.z * 16; ++ for (long chunkCoord : chunkTickList.popAll()) { ++ int chunkX = LongHash.msw(chunkCoord); ++ int chunkZ = LongHash.lsw(chunkCoord); ++ int k = chunkX * 16; ++ int l = chunkZ * 16; ++ + this.methodProfiler.a("getChunk"); +- Chunk chunk = this.getChunkAt(chunkcoordintpair1.x, chunkcoordintpair1.z); +- ++ Chunk chunk = this.getChunkAt(chunkX, chunkZ); ++ // CraftBukkit end ++ + this.a(k, l, chunk); + this.methodProfiler.c("tickChunk"); + chunk.b(false); +@@ -260,11 +395,29 @@ + BlockPosition blockposition1 = blockposition.down(); + + if (this.w(blockposition1)) { +- this.setTypeUpdate(blockposition1, Blocks.ICE.getBlockData()); ++ // CraftBukkit start ++ BlockState blockState = this.getWorld().getBlockAt(blockposition1.getX(), blockposition1.getY(), blockposition1.getZ()).getState(); ++ blockState.setTypeId(Block.getId(Blocks.ICE)); ++ ++ BlockFormEvent iceBlockForm = new BlockFormEvent(blockState.getBlock(), blockState); ++ this.getServer().getPluginManager().callEvent(iceBlockForm); ++ if (!iceBlockForm.isCancelled()) { ++ blockState.update(true); ++ } ++ // CraftBukkit end + } + + if (this.S() && this.f(blockposition, true)) { +- this.setTypeUpdate(blockposition, Blocks.SNOW_LAYER.getBlockData()); ++ // CraftBukkit start ++ BlockState blockState = this.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()).getState(); ++ blockState.setTypeId(Block.getId(Blocks.SNOW_LAYER)); ++ ++ BlockFormEvent snow = new BlockFormEvent(blockState.getBlock(), blockState); ++ this.getServer().getPluginManager().callEvent(snow); ++ if (!snow.isCancelled()) { ++ blockState.update(true); ++ } ++ // CraftBukkit end + } + + if (this.S() && this.getBiome(blockposition1).e()) { +@@ -376,7 +529,7 @@ + } + + public void tickEntities() { +- if (this.players.isEmpty()) { ++ if (false && this.players.isEmpty()) { // CraftBukkit - this prevents entity cleanup, other issues on servers with no players + if (this.emptyTime++ >= 1200) { + return; + } +@@ -401,7 +554,13 @@ + throw new IllegalStateException("TickNextTick list out of synch"); + } else { + if (i > 1000) { +- i = 1000; ++ // CraftBukkit start - If the server has too much to process over time, try to alleviate that ++ if (i > 20 * 1000) { ++ i = i / 20; ++ } else { ++ i = 1000; ++ } ++ // CraftBukkit end + } + + this.methodProfiler.a("cleaning"); +@@ -501,6 +660,7 @@ + return arraylist; + } + ++ /* CraftBukkit start - We prevent spawning in general, so this butchering is not needed + public void entityJoinedWorld(Entity entity, boolean flag) { + if (!this.getSpawnAnimals() && (entity instanceof EntityAnimal || entity instanceof EntityWaterAnimal)) { + entity.die(); +@@ -511,7 +671,9 @@ + } + + super.entityJoinedWorld(entity, flag); ++ + } ++ // CraftBukkit end */ + + private boolean getSpawnNPCs() { + return this.server.getSpawnNPCs(); +@@ -523,14 +685,44 @@ + + protected IChunkProvider k() { + IChunkLoader ichunkloader = this.dataManager.createChunkLoader(this.worldProvider); ++ ++ // CraftBukkit start ++ org.bukkit.craftbukkit.generator.InternalChunkGenerator gen; ++ ++ if (this.generator != null) { ++ gen = new org.bukkit.craftbukkit.generator.CustomChunkGenerator(this, this.getSeed(), this.generator); ++ } else if (this.worldProvider instanceof WorldProviderHell) { ++ gen = new org.bukkit.craftbukkit.generator.NetherChunkGenerator(this, this.getSeed()); ++ } else if (this.worldProvider instanceof WorldProviderTheEnd) { ++ gen = new org.bukkit.craftbukkit.generator.SkyLandsChunkGenerator(this, this.getSeed()); ++ } else { ++ gen = new org.bukkit.craftbukkit.generator.NormalChunkGenerator(this, this.getSeed()); ++ } + +- this.chunkProviderServer = new ChunkProviderServer(this, ichunkloader, this.worldProvider.getChunkProvider()); ++ this.chunkProviderServer = new ChunkProviderServer(this, ichunkloader, gen); ++ // CraftBukkit end + return this.chunkProviderServer; + } + + public List getTileEntities(int i, int j, int k, int l, int i1, int j1) { + ArrayList arraylist = Lists.newArrayList(); +- ++ ++ // CraftBukkit start - Get tile entities from chunks instead of world ++ for (int chunkX = (i >> 4); chunkX <= ((l - 1) >> 4); chunkX++) { ++ for (int chunkZ = (k >> 4); chunkZ <= ((j1 - 1) >> 4); chunkZ++) { ++ Chunk chunk = getChunkAt(chunkX, chunkZ); ++ if (chunk == null) { ++ continue; ++ } ++ for (Object te : chunk.tileEntities.values()) { ++ TileEntity tileentity = (TileEntity) te; ++ if ((tileentity.position.getX() >= i) && (tileentity.position.getY() >= j) && (tileentity.position.getZ() >= k) && (tileentity.position.getX() < l) && (tileentity.position.getY() < i1) && (tileentity.position.getZ() < j1)) { ++ arraylist.add(tileentity); ++ } ++ } ++ } ++ } ++ /* + for (int k1 = 0; k1 < this.h.size(); ++k1) { + TileEntity tileentity = (TileEntity) this.h.get(k1); + BlockPosition blockposition = tileentity.getPosition(); +@@ -539,6 +731,8 @@ + arraylist.add(tileentity); + } + } ++ */ ++ // CraftBukkit end + + return arraylist; + } +@@ -601,6 +795,23 @@ + int i = 0; + int j = this.worldProvider.getSeaLevel(); + int k = 0; ++ ++ // CraftBukkit start ++ if (this.generator != null) { ++ Random rand = new Random(this.getSeed()); ++ org.bukkit.Location spawn = this.generator.getFixedSpawnLocation(((WorldServer) this).getWorld(), rand); ++ ++ if (spawn != null) { ++ if (spawn.getWorld() != ((WorldServer) this).getWorld()) { ++ throw new IllegalStateException("Cannot set spawn point for " + this.worldData.getName() + " to be in another world (" + spawn.getWorld().getName() + ")"); ++ } else { ++ this.worldData.setSpawn(new BlockPosition(spawn.getBlockX(), spawn.getBlockY(), spawn.getBlockZ())); ++ this.isLoading = false; ++ return; ++ } ++ } ++ } ++ // CraftBukkit end + + if (blockposition != null) { + i = blockposition.getX(); +@@ -611,7 +822,7 @@ + + int l = 0; + +- while (!this.worldProvider.canSpawn(i, k)) { ++ while (!this.canSpawn(i, k)) { // CraftBukkit - use our own canSpawn + i += random.nextInt(64) - random.nextInt(64); + k += random.nextInt(64) - random.nextInt(64); + ++l; +@@ -648,7 +859,7 @@ + return this.worldProvider.h(); + } + +- public void save(boolean flag, IProgressUpdate iprogressupdate) { ++ public void save(boolean flag, IProgressUpdate iprogressupdate) throws ExceptionWorldConflict { // CraftBukkit - added throws + if (this.chunkProvider.canSave()) { + if (iprogressupdate != null) { + iprogressupdate.a("Saving level"); +@@ -660,7 +871,8 @@ + } + + this.chunkProvider.saveChunks(flag, iprogressupdate); +- List list = this.chunkProviderServer.a(); ++ // CraftBukkit - ArrayList -> Collection ++ Collection list = this.chunkProviderServer.a(); + Iterator iterator = list.iterator(); + + while (iterator.hasNext()) { +@@ -680,7 +892,7 @@ + } + } + +- protected void a() { ++ protected void a() throws ExceptionWorldConflict { // CraftBukkit - added throws + this.checkSession(); + this.worldData.a(this.af().h()); + this.worldData.d(this.af().f()); +@@ -692,7 +904,11 @@ + this.worldData.b(this.af().j()); + this.worldData.e(this.af().i()); + this.dataManager.saveWorldData(this.worldData, this.server.getPlayerList().u()); +- this.worldMaps.a(); ++ // CraftBukkit start - save worldMaps once, rather than once per shared world ++ if (!(this instanceof SecondaryWorldServer)) { ++ this.worldMaps.a(); ++ } ++ // CraftBukkit end + } + + protected void a(Entity entity) { +@@ -724,8 +940,16 @@ + } + + public boolean strikeLightning(Entity entity) { ++ // CraftBukkit start ++ LightningStrikeEvent lightning = new LightningStrikeEvent(this.getWorld(), (org.bukkit.entity.LightningStrike) entity.getBukkitEntity()); ++ this.getServer().getPluginManager().callEvent(lightning); ++ ++ if (lightning.isCancelled()) { ++ return false; ++ } + if (super.strikeLightning(entity)) { +- this.server.getPlayerList().sendPacketNearby(entity.locX, entity.locY, entity.locZ, 512.0D, this.worldProvider.getDimension(), new PacketPlayOutSpawnEntityWeather(entity)); ++ this.server.getPlayerList().sendPacketNearby(entity.locX, entity.locY, entity.locZ, 512.0D, this.dimension, new PacketPlayOutSpawnEntityWeather(entity)); ++ // CraftBukkit end + return true; + } else { + return false; +@@ -737,10 +961,20 @@ + } + + public Explosion createExplosion(Entity entity, double d0, double d1, double d2, float f, boolean flag, boolean flag1) { ++ // CraftBukkit start ++ Explosion explosion = super.createExplosion(entity, d0, d1, d2, f, flag, flag1); ++ ++ if (explosion.wasCanceled) { ++ return explosion; ++ } ++ ++ /* Remove + Explosion explosion = new Explosion(this, entity, d0, d1, d2, f, flag, flag1); + + explosion.a(); + explosion.a(false); ++ */ ++ // CraftBukkit end - TODO: Check if explosions are still properly implemented + if (!flag1) { + explosion.clearBlocks(); + } +@@ -786,7 +1020,8 @@ + BlockActionData blockactiondata = (BlockActionData) iterator.next(); + + if (this.a(blockactiondata)) { +- this.server.getPlayerList().sendPacketNearby((double) blockactiondata.a().getX(), (double) blockactiondata.a().getY(), (double) blockactiondata.a().getZ(), 64.0D, this.worldProvider.getDimension(), new PacketPlayOutBlockAction(blockactiondata.a(), blockactiondata.d(), blockactiondata.b(), blockactiondata.c())); ++ // CraftBukkit - this.worldProvider.dimension -> this.dimension ++ this.server.getPlayerList().sendPacketNearby((double) blockactiondata.a().getX(), (double) blockactiondata.a().getY(), (double) blockactiondata.a().getZ(), 64.0D, this.dimension, new PacketPlayOutBlockAction(blockactiondata.a(), blockactiondata.d(), blockactiondata.b(), blockactiondata.c())); + } + } + +@@ -809,6 +1044,7 @@ + boolean flag = this.S(); + + super.p(); ++ /* CraftBukkit start + if (this.o != this.p) { + this.server.getPlayerList().a(new PacketPlayOutGameStateChange(7, this.p), this.worldProvider.getDimension()); + } +@@ -827,6 +1063,16 @@ + this.server.getPlayerList().sendAll(new PacketPlayOutGameStateChange(7, this.p)); + this.server.getPlayerList().sendAll(new PacketPlayOutGameStateChange(8, this.r)); + } ++ // */ ++ if (flag != this.S()) { ++ // Only send weather packets to those affected ++ for (int i = 0; i < this.players.size(); ++i) { ++ if (((EntityPlayer) this.players.get(i)).world == this) { ++ ((EntityPlayer) this.players.get(i)).setPlayerWeather((!flag ? WeatherType.DOWNFALL : WeatherType.CLEAR), false); ++ } ++ } ++ // CraftBukkit end ++ } + + } + +@@ -855,10 +1101,17 @@ + } + + public void a(EnumParticle enumparticle, boolean flag, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, int... aint) { ++ // CraftBukkit - visibility api support ++ sendParticles(null, enumparticle, flag, d0, d1, d2, i, d3, d4, d5, d6, aint); ++ } ++ ++ public void sendParticles(EntityPlayer sender, EnumParticle enumparticle, boolean flag, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, int... aint) { ++ // CraftBukkit end + PacketPlayOutWorldParticles packetplayoutworldparticles = new PacketPlayOutWorldParticles(enumparticle, flag, (float) d0, (float) d1, (float) d2, (float) d3, (float) d4, (float) d5, (float) d6, i, aint); + + for (int j = 0; j < this.players.size(); ++j) { + EntityPlayer entityplayer = (EntityPlayer) this.players.get(j); ++ if (sender != null && !sender.getBukkitEntity().canSee(entityplayer.getBukkitEntity())) continue; // CraftBukkit + BlockPosition blockposition = entityplayer.getChunkCoordinates(); + double d7 = blockposition.c(d0, d1, d2); + -- cgit v1.2.3