Paper/src/main/java/net/minecraft/server/World.java

2784 Zeilen
89 KiB
Java

2011-02-07 06:56:07 +01:00
package net.minecraft.server;
import java.util.ArrayList;
import java.util.Calendar;
2011-06-30 00:02:25 +02:00
import java.util.Collection;
import java.util.HashSet;
2011-02-07 06:56:07 +01:00
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
2012-07-29 09:33:13 +02:00
import java.util.concurrent.Callable;
2011-02-07 06:56:07 +01:00
2011-02-07 10:43:50 +01:00
// CraftBukkit start
import org.bukkit.Bukkit;
import org.bukkit.craftbukkit.util.LongHashSet;
import org.bukkit.craftbukkit.util.UnsafeList;
import org.bukkit.generator.ChunkGenerator;
import org.bukkit.craftbukkit.CraftServer;
2011-02-07 10:43:50 +01:00
import org.bukkit.craftbukkit.CraftWorld;
import org.bukkit.craftbukkit.event.CraftEventFactory;
2011-02-07 10:43:50 +01:00
import org.bukkit.event.block.BlockCanBuildEvent;
import org.bukkit.event.block.BlockPhysicsEvent;
import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
import org.bukkit.event.weather.WeatherChangeEvent;
import org.bukkit.event.weather.ThunderChangeEvent;
2011-02-07 10:43:50 +01:00
// CraftBukkit end
2012-07-29 09:33:13 +02:00
public abstract class World implements IBlockAccess {
2011-02-07 06:56:07 +01:00
public boolean d = false;
2012-03-01 11:49:23 +01:00
public List entityList = new ArrayList();
protected List f = new ArrayList();
2012-03-01 11:49:23 +01:00
public List tileEntityList = new ArrayList();
2012-07-29 09:33:13 +02:00
private List a = new ArrayList();
private List b = new ArrayList();
2012-03-01 11:49:23 +01:00
public List players = new ArrayList();
public List i = new ArrayList();
2012-07-29 09:33:13 +02:00
private long c = 16777215L;
public int j = 0;
protected int k = (new Random()).nextInt();
protected final int l = 1013904223;
protected float m;
2012-07-29 09:33:13 +02:00
protected float n;
protected float o;
protected float p;
2012-12-20 05:03:52 +01:00
public int q = 0;
2012-03-01 11:49:23 +01:00
public boolean suppressPhysics = false;
public int difficulty;
2012-03-01 11:49:23 +01:00
public Random random = new Random();
2011-06-12 00:02:58 +02:00
public WorldProvider worldProvider; // CraftBukkit - remove final
2012-12-20 05:03:52 +01:00
protected List v = new ArrayList();
2011-05-14 16:29:42 +02:00
public IChunkProvider chunkProvider; // CraftBukkit - protected -> public
protected final IDataManager dataManager;
2011-05-14 16:29:42 +02:00
public WorldData worldData; // CraftBukkit - protected -> public
public boolean isLoading;
public WorldMapCollection worldMaps;
public final VillageCollection villages;
2012-07-29 09:33:13 +02:00
protected final VillageSiege siegeManager = new VillageSiege(this);
public final MethodProfiler methodProfiler;
2012-12-20 05:03:52 +01:00
private final Vec3DPool J = new Vec3DPool(300, 2000);
private final Calendar K = Calendar.getInstance();
private UnsafeList L = new UnsafeList(); // CraftBukkit - ArrayList -> UnsafeList
private boolean M;
2012-07-29 09:33:13 +02:00
// CraftBukkit start - public, longhashset
public boolean allowMonsters = true;
public boolean allowAnimals = true;
protected LongHashSet chunkTickList = new LongHashSet();
2012-07-29 09:33:13 +02:00
public long ticksPerAnimalSpawns;
public long ticksPerMonsterSpawns;
// CraftBukkit end
2012-12-20 05:03:52 +01:00
private int N;
int[] H;
private List O;
2011-02-07 06:56:07 +01:00
public boolean isStatic;
2012-03-01 11:49:23 +01:00
public BiomeBase getBiome(int i, int j) {
if (this.isLoaded(i, 0, j)) {
Chunk chunk = this.getChunkAtWorldCoords(i, j);
if (chunk != null) {
return chunk.a(i & 15, j & 15, this.worldProvider.d);
2012-03-01 11:49:23 +01:00
}
}
return this.worldProvider.d.getBiome(i, j);
2012-03-01 11:49:23 +01:00
}
public WorldChunkManager getWorldChunkManager() {
return this.worldProvider.d;
2011-02-07 06:56:07 +01:00
}
2011-06-12 00:02:58 +02:00
// CraftBukkit start
private final CraftWorld world;
2011-06-12 00:02:58 +02:00
public boolean pvpMode;
public boolean keepSpawnInMemory = true;
2011-06-12 00:02:58 +02:00
public ChunkGenerator generator;
Chunk lastChunkAccessed;
int lastXAccessed = Integer.MIN_VALUE;
int lastZAccessed = Integer.MIN_VALUE;
final Object chunkLock = new Object();
public CraftWorld getWorld() {
return this.world;
}
public CraftServer getServer() {
return (CraftServer) Bukkit.getServer();
}
2012-07-29 09:33:13 +02:00
// Changed signature
public World(IDataManager idatamanager, String s, WorldSettings worldsettings, WorldProvider worldprovider, MethodProfiler methodprofiler, ChunkGenerator gen, org.bukkit.World.Environment env) {
this.generator = gen;
this.world = new CraftWorld((WorldServer) this, gen, env);
this.ticksPerAnimalSpawns = this.getServer().getTicksPerAnimalSpawns(); // CraftBukkit
this.ticksPerMonsterSpawns = this.getServer().getTicksPerMonsterSpawns(); // CraftBukkit
2012-07-29 09:33:13 +02:00
// CraftBukkit end
2012-12-20 05:03:52 +01:00
this.N = this.random.nextInt(12000);
this.H = new int['\u8000'];
this.O = new UnsafeList(); // CraftBukkit - ArrayList -> UnsafeList
2011-02-07 06:56:07 +01:00
this.isStatic = false;
this.dataManager = idatamanager;
2012-07-29 09:33:13 +02:00
this.methodProfiler = methodprofiler;
this.worldMaps = new WorldMapCollection(idatamanager);
this.worldData = idatamanager.getWorldData();
2011-02-07 06:56:07 +01:00
if (worldprovider != null) {
this.worldProvider = worldprovider;
} else if (this.worldData != null && this.worldData.j() != 0) {
this.worldProvider = WorldProvider.byDimension(this.worldData.j());
2011-02-23 03:37:56 +01:00
} else {
this.worldProvider = WorldProvider.byDimension(0);
2011-02-07 06:56:07 +01:00
}
if (this.worldData == null) {
2011-09-15 02:23:52 +02:00
this.worldData = new WorldData(worldsettings, s);
2011-02-23 03:37:56 +01:00
} else {
2012-07-29 09:33:13 +02:00
this.worldData.setName(s);
2011-02-07 06:56:07 +01:00
}
this.worldProvider.a(this);
this.chunkProvider = this.j();
2012-07-29 09:33:13 +02:00
if (!this.worldData.isInitialized()) {
2012-11-06 13:05:28 +01:00
try {
this.a(worldsettings);
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.a(throwable, "Exception initializing level");
try {
this.a(crashreport);
} catch (Throwable throwable1) {
;
}
throw new ReportedException(crashreport);
}
2012-07-29 09:33:13 +02:00
this.worldData.d(true);
2011-02-07 06:56:07 +01:00
}
VillageCollection villagecollection = (VillageCollection) this.worldMaps.get(VillageCollection.class, "villages");
if (villagecollection == null) {
this.villages = new VillageCollection(this);
this.worldMaps.a("villages", this.villages);
} else {
this.villages = villagecollection;
this.villages.a(this);
}
2012-11-06 13:05:28 +01:00
this.x();
2012-07-29 09:33:13 +02:00
this.a();
this.getServer().addWorld(this.world); // CraftBukkit
2011-02-07 06:56:07 +01:00
}
protected abstract IChunkProvider j();
2011-02-23 03:37:56 +01:00
2012-07-29 09:33:13 +02:00
protected void a(WorldSettings worldsettings) {
this.worldData.d(true);
2011-11-20 09:01:14 +01:00
}
2012-03-01 11:49:23 +01:00
public int b(int i, int j) {
2011-02-07 06:56:07 +01:00
int k;
2012-03-01 11:49:23 +01:00
for (k = 63; !this.isEmpty(i, k + 1, j); ++k) {
2011-02-07 06:56:07 +01:00
;
}
return this.getTypeId(i, k, j);
}
public int getTypeId(int i, int j, int k) {
2012-11-06 13:05:28 +01:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
if (j < 0) {
return 0;
} else if (j >= 256) {
return 0;
} else {
Chunk chunk = null;
try {
chunk = this.getChunkAt(i >> 4, k >> 4);
return chunk.getTypeId(i & 15, j, k & 15);
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.a(throwable, "Exception getting block type in world");
CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Requested block coordinates");
crashreportsystemdetails.a("Found chunk", Boolean.valueOf(chunk == null));
crashreportsystemdetails.a("Location", CrashReportSystemDetails.a(i, j, k));
throw new ReportedException(crashreport);
}
}
} else {
return 0;
}
2012-03-01 11:49:23 +01:00
}
2012-07-29 09:33:13 +02:00
public int b(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
return i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000 ? (j < 0 ? 0 : (j >= 256 ? 0 : this.getChunkAt(i >> 4, k >> 4).b(i & 15, j, k & 15))) : 0;
2011-02-07 06:56:07 +01:00
}
public boolean isEmpty(int i, int j, int k) {
return this.getTypeId(i, j, k) == 0;
}
2012-03-01 11:49:23 +01:00
public boolean isTileEntity(int i, int j, int k) {
int l = this.getTypeId(i, j, k);
return Block.byId[l] != null && Block.byId[l].u();
2012-03-01 11:49:23 +01:00
}
2012-11-06 13:05:28 +01:00
public int e(int i, int j, int k) {
int l = this.getTypeId(i, j, k);
return Block.byId[l] != null ? Block.byId[l].d() : -1;
}
public boolean isLoaded(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
return j >= 0 && j < 256 ? this.isChunkLoaded(i >> 4, k >> 4) : false;
2011-02-07 06:56:07 +01:00
}
public boolean areChunksLoaded(int i, int j, int k, int l) {
return this.d(i - l, j - l, k - l, i + l, j + l, k + l);
2011-02-07 06:56:07 +01:00
}
public boolean d(int i, int j, int k, int l, int i1, int j1) {
2012-03-01 11:49:23 +01:00
if (i1 >= 0 && j < 256) {
2011-02-07 06:56:07 +01:00
i >>= 4;
k >>= 4;
l >>= 4;
j1 >>= 4;
for (int k1 = i; k1 <= l; ++k1) {
for (int l1 = k; l1 <= j1; ++l1) {
// CraftBukkit - check unload queue too so we don't leak a chunk
if (!this.isChunkLoaded(k1, l1) || ((WorldServer) this).chunkProviderServer.unloadQueue.contains(k1, l1)) {
2011-02-07 06:56:07 +01:00
return false;
}
}
}
return true;
} else {
return false;
}
}
2012-07-29 09:33:13 +02:00
protected boolean isChunkLoaded(int i, int j) {
return this.chunkProvider.isChunkLoaded(i, j);
2011-02-07 06:56:07 +01:00
}
public Chunk getChunkAtWorldCoords(int i, int j) {
return this.getChunkAt(i >> 4, j >> 4);
2011-02-07 06:56:07 +01:00
}
2011-02-07 09:43:51 +01:00
// CraftBukkit start
public Chunk getChunkAt(int i, int j) {
2011-02-10 12:56:30 +01:00
Chunk result = null;
synchronized (this.chunkLock) {
if (this.lastChunkAccessed == null || this.lastXAccessed != i || this.lastZAccessed != j) {
this.lastChunkAccessed = this.chunkProvider.getOrCreateChunk(i, j);
this.lastXAccessed = i;
this.lastZAccessed = j;
2011-02-10 12:56:30 +01:00
}
result = this.lastChunkAccessed;
2011-02-07 06:56:07 +01:00
}
2011-02-10 12:56:30 +01:00
return result;
2011-02-07 06:56:07 +01:00
}
2011-02-07 09:43:51 +01:00
// CraftBukkit end
2011-02-07 06:56:07 +01:00
public boolean setRawTypeIdAndData(int i, int j, int k, int l, int i1) {
2012-07-29 09:33:13 +02:00
return this.setRawTypeIdAndData(i, j, k, l, i1, true);
}
public boolean setRawTypeIdAndData(int i, int j, int k, int l, int i1, boolean flag) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (j < 0) {
return false;
2012-03-01 11:49:23 +01:00
} else if (j >= 256) {
2011-02-07 06:56:07 +01:00
return false;
} else {
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2012-07-29 09:33:13 +02:00
boolean flag1 = chunk.a(i & 15, j, k & 15, l, i1);
2011-02-07 06:56:07 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("checkLight");
2012-11-06 13:05:28 +01:00
this.z(i, j, k);
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2012-07-29 09:33:13 +02:00
if (flag && flag1 && (this.isStatic || chunk.seenByPlayer)) {
this.notify(i, j, k);
}
return flag1;
2011-02-07 06:56:07 +01:00
}
} else {
return false;
}
}
public boolean setRawTypeId(int i, int j, int k, int l) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (j < 0) {
return false;
2012-03-01 11:49:23 +01:00
} else if (j >= 256) {
2011-02-07 06:56:07 +01:00
return false;
} else {
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2011-09-15 02:23:52 +02:00
boolean flag = chunk.a(i & 15, j, k & 15, l);
2011-02-07 06:56:07 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("checkLight");
2012-11-06 13:05:28 +01:00
this.z(i, j, k);
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2012-07-29 09:33:13 +02:00
if (flag && (this.isStatic || chunk.seenByPlayer)) {
this.notify(i, j, k);
}
2011-09-15 02:23:52 +02:00
return flag;
2011-02-07 06:56:07 +01:00
}
} else {
return false;
}
}
public Material getMaterial(int i, int j, int k) {
int l = this.getTypeId(i, j, k);
return l == 0 ? Material.AIR : Block.byId[l].material;
}
public int getData(int i, int j, int k) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (j < 0) {
return 0;
2012-03-01 11:49:23 +01:00
} else if (j >= 256) {
2011-02-07 06:56:07 +01:00
return 0;
} else {
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2011-02-07 06:56:07 +01:00
i &= 15;
k &= 15;
return chunk.getData(i, j, k);
2011-02-07 06:56:07 +01:00
}
} else {
return 0;
}
}
public void setData(int i, int j, int k, int l) {
if (this.setRawData(i, j, k, l)) {
2012-07-29 09:33:13 +02:00
this.update(i, j, k, this.getTypeId(i, j, k));
2011-02-07 06:56:07 +01:00
}
}
public boolean setRawData(int i, int j, int k, int l) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (j < 0) {
return false;
2012-03-01 11:49:23 +01:00
} else if (j >= 256) {
2011-02-07 06:56:07 +01:00
return false;
} else {
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2012-07-29 09:33:13 +02:00
int i1 = i & 15;
int j1 = k & 15;
boolean flag = chunk.b(i1, j, j1, l);
2011-02-07 06:56:07 +01:00
if (flag && (this.isStatic || chunk.seenByPlayer && Block.u[chunk.getTypeId(i1, j, j1) & 4095])) {
2012-07-29 09:33:13 +02:00
this.notify(i, j, k);
}
return flag;
2011-02-07 06:56:07 +01:00
}
} else {
return false;
}
}
public boolean setTypeId(int i, int j, int k, int l) {
2011-05-14 16:29:42 +02:00
// CraftBukkit start
2011-03-14 05:47:41 +01:00
int old = this.getTypeId(i, j, k);
if (this.setRawTypeId(i, j, k, l)) {
this.update(i, j, k, l == 0 ? old : l);
2012-07-29 09:33:13 +02:00
// CraftBukkit end
2011-02-07 06:56:07 +01:00
return true;
} else {
return false;
}
}
public boolean setTypeIdAndData(int i, int j, int k, int l, int i1) {
if (this.setRawTypeIdAndData(i, j, k, l, i1)) {
this.update(i, j, k, l);
2011-02-07 06:56:07 +01:00
return true;
} else {
return false;
}
}
public void notify(int i, int j, int k) {
2012-12-20 05:03:52 +01:00
for (int l = 0; l < this.v.size(); ++l) {
((IWorldAccess) this.v.get(l)).a(i, j, k);
2011-02-07 06:56:07 +01:00
}
}
2012-03-01 11:49:23 +01:00
public void update(int i, int j, int k, int l) {
this.applyPhysics(i, j, k, l);
2011-02-07 06:56:07 +01:00
}
public void g(int i, int j, int k, int l) {
2011-09-15 02:23:52 +02:00
int i1;
2011-02-07 06:56:07 +01:00
2011-09-15 02:23:52 +02:00
if (k > l) {
i1 = l;
2011-02-07 06:56:07 +01:00
l = k;
k = i1;
}
if (!this.worldProvider.f) {
2011-11-20 09:01:14 +01:00
for (i1 = k; i1 <= l; ++i1) {
2012-07-29 09:33:13 +02:00
this.c(EnumSkyBlock.SKY, i, i1, j);
2011-11-20 09:01:14 +01:00
}
2011-09-15 02:23:52 +02:00
}
this.e(i, k, j, i, l, j);
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
public void j(int i, int j, int k) {
2012-12-20 05:03:52 +01:00
for (int l = 0; l < this.v.size(); ++l) {
((IWorldAccess) this.v.get(l)).a(i, j, k, i, j, k);
2011-02-07 06:56:07 +01:00
}
}
public void e(int i, int j, int k, int l, int i1, int j1) {
2012-12-20 05:03:52 +01:00
for (int k1 = 0; k1 < this.v.size(); ++k1) {
((IWorldAccess) this.v.get(k1)).a(i, j, k, l, i1, j1);
2011-02-07 06:56:07 +01:00
}
}
public void applyPhysics(int i, int j, int k, int l) {
2012-07-29 09:33:13 +02:00
this.m(i - 1, j, k, l);
this.m(i + 1, j, k, l);
this.m(i, j - 1, k, l);
this.m(i, j + 1, k, l);
this.m(i, j, k - 1, l);
this.m(i, j, k + 1, l);
2011-02-07 06:56:07 +01:00
}
2012-07-29 09:33:13 +02:00
private void m(int i, int j, int k, int l) {
if (!this.suppressPhysics && !this.isStatic) {
2012-11-06 13:05:28 +01:00
int i1 = this.getTypeId(i, j, k);
Block block = Block.byId[i1];
2011-02-07 06:56:07 +01:00
if (block != null) {
2012-11-06 13:05:28 +01:00
try {
// CraftBukkit start
CraftWorld world = ((WorldServer) this).getWorld();
if (world != null) {
BlockPhysicsEvent event = new BlockPhysicsEvent(world.getBlockAt(i, j, k), l);
this.getServer().getPluginManager().callEvent(event);
if (event.isCancelled()) {
return;
}
}
2012-11-06 13:05:28 +01:00
// CraftBukkit end
block.doPhysics(this, i, j, k, l);
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.a(throwable, "Exception while updating neighbours");
CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Block being updated");
2012-11-06 13:05:28 +01:00
int j1;
try {
j1 = this.getData(i, j, k);
} catch (Throwable throwable1) {
j1 = -1;
}
crashreportsystemdetails.a("Source block type", (Callable) (new CrashReportSourceBlockType(this, l)));
CrashReportSystemDetails.a(crashreportsystemdetails, i, j, k, i1, j1);
throw new ReportedException(crashreport);
}
2011-02-07 06:56:07 +01:00
}
}
}
2012-11-06 13:05:28 +01:00
public boolean k(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
return this.getChunkAt(i >> 4, k >> 4).d(i & 15, j, k & 15);
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
public int l(int i, int j, int k) {
2011-05-26 14:48:22 +02:00
if (j < 0) {
return 0;
} else {
2012-03-01 11:49:23 +01:00
if (j >= 256) {
j = 255;
2011-05-26 14:48:22 +02:00
}
return this.getChunkAt(i >> 4, k >> 4).c(i & 15, j, k & 15, 0);
}
}
public int getLightLevel(int i, int j, int k) {
2011-02-07 06:56:07 +01:00
return this.a(i, j, k, true);
}
public int a(int i, int j, int k, boolean flag) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (flag) {
2011-05-26 14:48:22 +02:00
int l = this.getTypeId(i, j, k);
2012-07-29 09:33:13 +02:00
if (l == Block.STEP.id || l == Block.WOOD_STEP.id || l == Block.SOIL.id || l == Block.COBBLESTONE_STAIRS.id || l == Block.WOOD_STAIRS.id) {
2011-02-07 06:56:07 +01:00
int i1 = this.a(i, j + 1, k, false);
int j1 = this.a(i + 1, j, k, false);
int k1 = this.a(i - 1, j, k, false);
int l1 = this.a(i, j, k + 1, false);
int i2 = this.a(i, j, k - 1, false);
if (j1 > i1) {
i1 = j1;
}
if (k1 > i1) {
i1 = k1;
}
if (l1 > i1) {
i1 = l1;
}
if (i2 > i1) {
i1 = i2;
}
return i1;
}
}
if (j < 0) {
return 0;
2011-05-26 14:48:22 +02:00
} else {
2012-03-01 11:49:23 +01:00
if (j >= 256) {
j = 255;
2011-02-07 06:56:07 +01:00
}
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2011-02-07 06:56:07 +01:00
i &= 15;
k &= 15;
return chunk.c(i, j, k, this.j);
2011-02-07 06:56:07 +01:00
}
} else {
return 15;
}
}
public int getHighestBlockYAt(int i, int j) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && j >= -30000000 && i < 30000000 && j < 30000000) {
if (!this.isChunkLoaded(i >> 4, j >> 4)) {
2011-02-07 06:56:07 +01:00
return 0;
} else {
Chunk chunk = this.getChunkAt(i >> 4, j >> 4);
2011-02-07 06:56:07 +01:00
return chunk.b(i & 15, j & 15);
}
} else {
return 0;
}
}
public int g(int i, int j) {
if (i >= -30000000 && j >= -30000000 && i < 30000000 && j < 30000000) {
if (!this.isChunkLoaded(i >> 4, j >> 4)) {
return 0;
} else {
Chunk chunk = this.getChunkAt(i >> 4, j >> 4);
return chunk.p;
}
} else {
return 0;
}
}
2012-07-29 09:33:13 +02:00
public int b(EnumSkyBlock enumskyblock, int i, int j, int k) {
2011-05-26 14:48:22 +02:00
if (j < 0) {
j = 0;
}
2012-03-01 11:49:23 +01:00
if (j >= 256) {
j = 255;
2011-05-26 14:48:22 +02:00
}
2012-03-01 11:49:23 +01:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
int l = i >> 4;
int i1 = k >> 4;
if (!this.isChunkLoaded(l, i1)) {
2012-03-01 11:49:23 +01:00
return enumskyblock.c;
2011-02-07 06:56:07 +01:00
} else {
Chunk chunk = this.getChunkAt(l, i1);
2011-02-07 06:56:07 +01:00
2012-02-29 22:31:04 +01:00
return chunk.getBrightness(enumskyblock, i & 15, j, k & 15);
2011-02-07 06:56:07 +01:00
}
} else {
return enumskyblock.c;
}
}
2012-07-29 09:33:13 +02:00
public void b(EnumSkyBlock enumskyblock, int i, int j, int k, int l) {
2011-09-15 02:23:52 +02:00
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
2011-02-07 06:56:07 +01:00
if (j >= 0) {
2012-03-01 11:49:23 +01:00
if (j < 256) {
if (this.isChunkLoaded(i >> 4, k >> 4)) {
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2011-02-07 06:56:07 +01:00
chunk.a(enumskyblock, i & 15, j, k & 15, l);
2012-07-29 09:33:13 +02:00
2012-12-20 05:03:52 +01:00
for (int i1 = 0; i1 < this.v.size(); ++i1) {
((IWorldAccess) this.v.get(i1)).b(i, j, k);
2011-02-07 06:56:07 +01:00
}
}
}
}
}
}
2012-11-06 13:05:28 +01:00
public void o(int i, int j, int k) {
2012-12-20 05:03:52 +01:00
for (int l = 0; l < this.v.size(); ++l) {
((IWorldAccess) this.v.get(l)).b(i, j, k);
2012-03-01 11:49:23 +01:00
}
}
2012-11-06 13:05:28 +01:00
public float p(int i, int j, int k) {
return this.worldProvider.g[this.getLightLevel(i, j, k)];
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
public boolean u() {
return this.j < 4;
2011-02-07 06:56:07 +01:00
}
public MovingObjectPosition a(Vec3D vec3d, Vec3D vec3d1) {
2011-05-26 14:48:22 +02:00
return this.rayTrace(vec3d, vec3d1, false, false);
2011-02-07 06:56:07 +01:00
}
public MovingObjectPosition rayTrace(Vec3D vec3d, Vec3D vec3d1, boolean flag) {
2011-05-26 14:48:22 +02:00
return this.rayTrace(vec3d, vec3d1, flag, false);
}
public MovingObjectPosition rayTrace(Vec3D vec3d, Vec3D vec3d1, boolean flag, boolean flag1) {
if (!Double.isNaN(vec3d.c) && !Double.isNaN(vec3d.d) && !Double.isNaN(vec3d.e)) {
if (!Double.isNaN(vec3d1.c) && !Double.isNaN(vec3d1.d) && !Double.isNaN(vec3d1.e)) {
int i = MathHelper.floor(vec3d1.c);
int j = MathHelper.floor(vec3d1.d);
int k = MathHelper.floor(vec3d1.e);
int l = MathHelper.floor(vec3d.c);
int i1 = MathHelper.floor(vec3d.d);
int j1 = MathHelper.floor(vec3d.e);
2011-05-26 14:48:22 +02:00
int k1 = this.getTypeId(l, i1, j1);
int l1 = this.getData(l, i1, j1);
Block block = Block.byId[k1];
2011-06-30 00:02:25 +02:00
if ((!flag1 || block == null || block.e(this, l, i1, j1) != null) && k1 > 0 && block.a(l1, flag)) {
2011-05-26 14:48:22 +02:00
MovingObjectPosition movingobjectposition = block.a(this, l, i1, j1, vec3d, vec3d1);
if (movingobjectposition != null) {
return movingobjectposition;
}
}
k1 = 200;
2011-02-07 06:56:07 +01:00
while (k1-- >= 0) {
if (Double.isNaN(vec3d.c) || Double.isNaN(vec3d.d) || Double.isNaN(vec3d.e)) {
2011-02-07 06:56:07 +01:00
return null;
}
if (l == i && i1 == j && j1 == k) {
return null;
}
2011-05-26 14:48:22 +02:00
boolean flag2 = true;
boolean flag3 = true;
boolean flag4 = true;
2011-02-07 06:56:07 +01:00
double d0 = 999.0D;
double d1 = 999.0D;
double d2 = 999.0D;
if (i > l) {
d0 = (double) l + 1.0D;
2011-05-26 14:48:22 +02:00
} else if (i < l) {
2011-02-07 06:56:07 +01:00
d0 = (double) l + 0.0D;
2011-05-26 14:48:22 +02:00
} else {
flag2 = false;
2011-02-07 06:56:07 +01:00
}
if (j > i1) {
d1 = (double) i1 + 1.0D;
2011-05-26 14:48:22 +02:00
} else if (j < i1) {
2011-02-07 06:56:07 +01:00
d1 = (double) i1 + 0.0D;
2011-05-26 14:48:22 +02:00
} else {
flag3 = false;
2011-02-07 06:56:07 +01:00
}
if (k > j1) {
d2 = (double) j1 + 1.0D;
2011-05-26 14:48:22 +02:00
} else if (k < j1) {
2011-02-07 06:56:07 +01:00
d2 = (double) j1 + 0.0D;
2011-05-26 14:48:22 +02:00
} else {
flag4 = false;
2011-02-07 06:56:07 +01:00
}
double d3 = 999.0D;
double d4 = 999.0D;
double d5 = 999.0D;
double d6 = vec3d1.c - vec3d.c;
double d7 = vec3d1.d - vec3d.d;
double d8 = vec3d1.e - vec3d.e;
2011-02-07 06:56:07 +01:00
2011-05-26 14:48:22 +02:00
if (flag2) {
d3 = (d0 - vec3d.c) / d6;
2011-02-07 06:56:07 +01:00
}
2011-05-26 14:48:22 +02:00
if (flag3) {
d4 = (d1 - vec3d.d) / d7;
2011-02-07 06:56:07 +01:00
}
2011-05-26 14:48:22 +02:00
if (flag4) {
d5 = (d2 - vec3d.e) / d8;
2011-02-07 06:56:07 +01:00
}
2011-05-26 14:48:22 +02:00
boolean flag5 = false;
2011-02-07 06:56:07 +01:00
byte b0;
if (d3 < d4 && d3 < d5) {
if (i > l) {
b0 = 4;
} else {
b0 = 5;
}
vec3d.c = d0;
vec3d.d += d7 * d3;
vec3d.e += d8 * d3;
2011-02-07 06:56:07 +01:00
} else if (d4 < d5) {
if (j > i1) {
b0 = 0;
} else {
b0 = 1;
}
vec3d.c += d6 * d4;
vec3d.d = d1;
vec3d.e += d8 * d4;
2011-02-07 06:56:07 +01:00
} else {
if (k > j1) {
b0 = 2;
} else {
b0 = 3;
}
vec3d.c += d6 * d5;
vec3d.d += d7 * d5;
vec3d.e = d2;
2011-02-07 06:56:07 +01:00
}
Vec3D vec3d2 = this.getVec3DPool().create(vec3d.c, vec3d.d, vec3d.e);
2011-02-07 06:56:07 +01:00
l = (int) (vec3d2.c = (double) MathHelper.floor(vec3d.c));
2011-02-07 06:56:07 +01:00
if (b0 == 5) {
--l;
++vec3d2.c;
2011-02-07 06:56:07 +01:00
}
i1 = (int) (vec3d2.d = (double) MathHelper.floor(vec3d.d));
2011-02-07 06:56:07 +01:00
if (b0 == 1) {
--i1;
++vec3d2.d;
2011-02-07 06:56:07 +01:00
}
j1 = (int) (vec3d2.e = (double) MathHelper.floor(vec3d.e));
2011-02-07 06:56:07 +01:00
if (b0 == 3) {
--j1;
++vec3d2.e;
2011-02-07 06:56:07 +01:00
}
2011-05-26 14:48:22 +02:00
int i2 = this.getTypeId(l, i1, j1);
int j2 = this.getData(l, i1, j1);
Block block1 = Block.byId[i2];
2011-02-07 06:56:07 +01:00
2011-06-30 00:02:25 +02:00
if ((!flag1 || block1 == null || block1.e(this, l, i1, j1) != null) && i2 > 0 && block1.a(j2, flag)) {
2011-05-26 14:48:22 +02:00
MovingObjectPosition movingobjectposition1 = block1.a(this, l, i1, j1, vec3d, vec3d1);
2011-02-07 06:56:07 +01:00
2011-05-26 14:48:22 +02:00
if (movingobjectposition1 != null) {
vec3d2.b.release(vec3d2); // CraftBukkit
2011-05-26 14:48:22 +02:00
return movingobjectposition1;
2011-02-07 06:56:07 +01:00
}
}
vec3d2.b.release(vec3d2); // CraftBukkit
2011-02-07 06:56:07 +01:00
}
return null;
} else {
return null;
}
} else {
return null;
}
}
public void makeSound(Entity entity, String s, float f, float f1) {
2012-07-29 09:33:13 +02:00
if (entity != null && s != null) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).a(s, entity.locX, entity.locY - (double) entity.height, entity.locZ, f, f1);
2012-11-06 13:05:28 +01:00
}
}
}
2012-07-29 09:33:13 +02:00
2012-11-06 13:05:28 +01:00
public void a(EntityHuman entityhuman, String s, float f, float f1) {
if (entityhuman != null && s != null) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).a(entityhuman, s, entityhuman.locX, entityhuman.locY - (double) entityhuman.height, entityhuman.locZ, f, f1);
2012-07-29 09:33:13 +02:00
}
2011-02-07 06:56:07 +01:00
}
}
public void makeSound(double d0, double d1, double d2, String s, float f, float f1) {
2012-07-29 09:33:13 +02:00
if (s != null) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).a(s, d0, d1, d2, f, f1);
2012-07-29 09:33:13 +02:00
}
2011-02-07 06:56:07 +01:00
}
}
2012-12-20 05:03:52 +01:00
public void a(double d0, double d1, double d2, String s, float f, float f1, boolean flag) {}
2011-02-07 06:56:07 +01:00
public void a(String s, int i, int j, int k) {
2012-12-20 05:03:52 +01:00
for (int l = 0; l < this.v.size(); ++l) {
((IWorldAccess) this.v.get(l)).a(s, i, j, k);
2011-02-07 06:56:07 +01:00
}
}
public void addParticle(String s, double d0, double d1, double d2, double d3, double d4, double d5) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).a(s, d0, d1, d2, d3, d4, d5);
2011-02-07 06:56:07 +01:00
}
}
public boolean strikeLightning(Entity entity) {
this.i.add(entity);
2011-04-20 22:47:26 +02:00
return true;
}
// CraftBukkit start - used for entities other than creatures
public boolean addEntity(Entity entity) {
return this.addEntity(entity, SpawnReason.DEFAULT); // Set reason as DEFAULT
}
public boolean addEntity(Entity entity, SpawnReason spawnReason) { // Changed signature, added SpawnReason
if (entity == null) return false;
2012-01-28 09:04:16 +01:00
// CraftBukkit end
int i = MathHelper.floor(entity.locX / 16.0D);
int j = MathHelper.floor(entity.locZ / 16.0D);
2011-02-07 06:56:07 +01:00
boolean flag = false;
if (entity instanceof EntityHuman) {
flag = true;
}
2011-02-23 13:56:36 +01:00
// CraftBukkit start
org.bukkit.event.Cancellable event = null;
if (entity instanceof EntityLiving && !(entity instanceof EntityPlayer)) {
boolean isAnimal = entity instanceof EntityAnimal || entity instanceof EntityWaterAnimal || entity instanceof EntityGolem;
boolean isMonster = entity instanceof EntityMonster || entity instanceof EntityGhast || entity instanceof EntitySlime;
2012-04-14 13:56:23 +02:00
if (spawnReason != SpawnReason.CUSTOM) {
if (isAnimal && !allowAnimals || isMonster && !allowMonsters) {
entity.dead = true;
return false;
}
}
event = CraftEventFactory.callCreatureSpawnEvent((EntityLiving) entity, spawnReason);
2011-06-11 08:00:05 +02:00
} else if (entity instanceof EntityItem) {
event = CraftEventFactory.callItemSpawnEvent((EntityItem) entity);
} else if (entity.getBukkitEntity() instanceof org.bukkit.entity.Projectile) {
// Not all projectiles extend EntityProjectile, so check for Bukkit interface instead
event = CraftEventFactory.callProjectileLaunchEvent(entity);
}
if (event != null && (event.isCancelled() || entity.dead)) {
entity.dead = true;
return false;
}
2011-02-23 03:37:56 +01:00
// CraftBukkit end
if (!flag && !this.isChunkLoaded(i, j)) {
entity.dead = true; // CraftBukkit
2011-02-07 06:56:07 +01:00
return false;
} else {
if (entity instanceof EntityHuman) {
EntityHuman entityhuman = (EntityHuman) entity;
this.players.add(entityhuman);
this.everyoneSleeping();
2011-02-07 06:56:07 +01:00
}
this.getChunkAt(i, j).a(entity);
this.entityList.add(entity);
2012-07-29 09:33:13 +02:00
this.a(entity);
2011-02-07 06:56:07 +01:00
return true;
}
}
2012-07-29 09:33:13 +02:00
protected void a(Entity entity) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).a(entity);
2011-02-07 06:56:07 +01:00
}
entity.valid = true; // CraftBukkit
2011-02-07 06:56:07 +01:00
}
2012-07-29 09:33:13 +02:00
protected void b(Entity entity) {
2012-12-20 05:03:52 +01:00
for (int i = 0; i < this.v.size(); ++i) {
((IWorldAccess) this.v.get(i)).b(entity);
2011-02-07 06:56:07 +01:00
}
entity.valid = false; // CraftBukkit
2011-02-07 06:56:07 +01:00
}
public void kill(Entity entity) {
2011-02-07 06:56:07 +01:00
if (entity.passenger != null) {
entity.passenger.mount((Entity) null);
2011-02-07 06:56:07 +01:00
}
if (entity.vehicle != null) {
entity.mount((Entity) null);
2011-02-07 06:56:07 +01:00
}
entity.die();
2011-02-07 06:56:07 +01:00
if (entity instanceof EntityHuman) {
2012-07-29 09:33:13 +02:00
this.players.remove(entity);
this.everyoneSleeping();
2011-02-07 06:56:07 +01:00
}
}
public void removeEntity(Entity entity) {
entity.die();
2011-02-07 06:56:07 +01:00
if (entity instanceof EntityHuman) {
2012-07-29 09:33:13 +02:00
this.players.remove(entity);
this.everyoneSleeping();
2011-02-07 06:56:07 +01:00
}
int i = entity.ai;
int j = entity.ak;
2011-02-07 06:56:07 +01:00
if (entity.ah && this.isChunkLoaded(i, j)) {
this.getChunkAt(i, j).b(entity);
2011-02-07 06:56:07 +01:00
}
this.entityList.remove(entity);
2012-07-29 09:33:13 +02:00
this.b(entity);
2011-02-07 06:56:07 +01:00
}
public void addIWorldAccess(IWorldAccess iworldaccess) {
2012-12-20 05:03:52 +01:00
this.v.add(iworldaccess);
2011-02-07 06:56:07 +01:00
}
2012-02-29 22:31:04 +01:00
public List getCubes(Entity entity, AxisAlignedBB axisalignedbb) {
2012-12-20 05:03:52 +01:00
this.L.clear();
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = i1; l1 < j1; ++l1) {
2012-03-01 11:49:23 +01:00
if (this.isLoaded(k1, 64, l1)) {
2011-02-07 06:56:07 +01:00
for (int i2 = k - 1; i2 < l; ++i2) {
Block block = Block.byId[this.getTypeId(k1, i2, l1)];
if (block != null) {
2012-12-20 05:03:52 +01:00
block.a(this, k1, i2, l1, axisalignedbb, this.L, entity);
2011-02-07 06:56:07 +01:00
}
}
}
}
}
double d0 = 0.25D;
2012-01-12 16:27:39 +01:00
List list = this.getEntities(entity, axisalignedbb.grow(d0, d0, d0));
2011-02-07 06:56:07 +01:00
2012-11-06 13:05:28 +01:00
for (int j2 = 0; j2 < list.size(); ++j2) {
AxisAlignedBB axisalignedbb1 = ((Entity) list.get(j2)).E();
2011-02-07 06:56:07 +01:00
if (axisalignedbb1 != null && axisalignedbb1.a(axisalignedbb)) {
2012-12-20 05:03:52 +01:00
this.L.add(axisalignedbb1);
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
axisalignedbb1 = entity.g((Entity) list.get(j2));
2011-02-07 06:56:07 +01:00
if (axisalignedbb1 != null && axisalignedbb1.a(axisalignedbb)) {
2012-12-20 05:03:52 +01:00
this.L.add(axisalignedbb1);
2011-02-07 06:56:07 +01:00
}
}
2012-12-20 05:03:52 +01:00
return this.L;
2012-07-29 09:33:13 +02:00
}
public List a(AxisAlignedBB axisalignedbb) {
2012-12-20 05:03:52 +01:00
this.L.clear();
2012-07-29 09:33:13 +02:00
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = i1; l1 < j1; ++l1) {
if (this.isLoaded(k1, 64, l1)) {
for (int i2 = k - 1; i2 < l; ++i2) {
Block block = Block.byId[this.getTypeId(k1, i2, l1)];
if (block != null) {
2012-12-20 05:03:52 +01:00
block.a(this, k1, i2, l1, axisalignedbb, this.L, (Entity) null);
2012-07-29 09:33:13 +02:00
}
}
}
}
}
2012-12-20 05:03:52 +01:00
return this.L;
2011-02-07 06:56:07 +01:00
}
public int a(float f) {
2012-07-29 09:33:13 +02:00
float f1 = this.c(f);
float f2 = 1.0F - (MathHelper.cos(f1 * 3.1415927F * 2.0F) * 2.0F + 0.5F);
2011-02-07 06:56:07 +01:00
if (f2 < 0.0F) {
f2 = 0.0F;
}
if (f2 > 1.0F) {
f2 = 1.0F;
}
2011-04-20 22:47:26 +02:00
f2 = 1.0F - f2;
2012-07-29 09:33:13 +02:00
f2 = (float) ((double) f2 * (1.0D - (double) (this.j(f) * 5.0F) / 16.0D));
f2 = (float) ((double) f2 * (1.0D - (double) (this.i(f) * 5.0F) / 16.0D));
2011-04-20 22:47:26 +02:00
f2 = 1.0F - f2;
2011-02-07 06:56:07 +01:00
return (int) (f2 * 11.0F);
}
2012-07-29 09:33:13 +02:00
public float c(float f) {
2012-11-06 13:05:28 +01:00
return this.worldProvider.a(this.worldData.getDayTime(), f);
2011-02-07 06:56:07 +01:00
}
public int h(int i, int j) {
2012-03-01 11:49:23 +01:00
return this.getChunkAtWorldCoords(i, j).d(i & 15, j & 15);
2011-05-26 14:48:22 +02:00
}
public int i(int i, int j) {
Chunk chunk = this.getChunkAtWorldCoords(i, j);
2012-07-29 09:33:13 +02:00
int k = chunk.h() + 15;
2011-05-26 14:48:22 +02:00
i &= 15;
2011-02-07 06:56:07 +01:00
for (j &= 15; k > 0; --k) {
int l = chunk.getTypeId(i, k, j);
2011-02-07 06:56:07 +01:00
2011-09-15 02:23:52 +02:00
if (l != 0 && Block.byId[l].material.isSolid() && Block.byId[l].material != Material.LEAVES) {
2011-02-07 06:56:07 +01:00
return k + 1;
}
}
return -1;
}
2012-07-29 09:33:13 +02:00
public void a(int i, int j, int k, int l, int i1) {}
2011-02-07 06:56:07 +01:00
public void a(int i, int j, int k, int l, int i1, int j1) {}
2012-07-29 09:33:13 +02:00
public void b(int i, int j, int k, int l, int i1) {}
2011-11-20 09:01:14 +01:00
public void tickEntities() {
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("entities");
this.methodProfiler.a("global");
2011-11-20 09:01:14 +01:00
2011-02-07 06:56:07 +01:00
int i;
Entity entity;
2012-11-06 13:05:28 +01:00
CrashReport crashreport;
CrashReportSystemDetails crashreportsystemdetails;
2011-04-20 22:47:26 +02:00
for (i = 0; i < this.i.size(); ++i) {
entity = (Entity) this.i.get(i);
// CraftBukkit start - fixed an NPE, don't process entities in chunks queued for unload
if (entity == null) {
continue;
}
ChunkProviderServer chunkProviderServer = ((WorldServer) this).chunkProviderServer;
if (chunkProviderServer.unloadQueue.contains(MathHelper.floor(entity.locX) >> 4, MathHelper.floor(entity.locZ) >> 4)) {
continue;
}
// CraftBukkit end
2012-11-06 13:05:28 +01:00
try {
2012-12-20 05:03:52 +01:00
++entity.ticksLived;
2012-11-06 13:05:28 +01:00
entity.j_();
} catch (Throwable throwable) {
crashreport = CrashReport.a(throwable, "Ticking entity");
crashreportsystemdetails = crashreport.a("Entity being ticked");
if (entity == null) {
crashreportsystemdetails.a("Entity", "~~NULL~~");
} else {
entity.a(crashreportsystemdetails);
}
throw new ReportedException(crashreport);
}
2011-04-20 22:47:26 +02:00
if (entity.dead) {
this.i.remove(i--);
2011-04-20 22:47:26 +02:00
}
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("remove");
this.entityList.removeAll(this.f);
2011-04-20 22:47:26 +02:00
2011-02-07 06:56:07 +01:00
int j;
int k;
2012-11-06 13:05:28 +01:00
for (i = 0; i < this.f.size(); ++i) {
entity = (Entity) this.f.get(i);
j = entity.ai;
k = entity.ak;
if (entity.ah && this.isChunkLoaded(j, k)) {
this.getChunkAt(j, k).b(entity);
2011-02-07 06:56:07 +01:00
}
}
2012-11-06 13:05:28 +01:00
for (i = 0; i < this.f.size(); ++i) {
this.b((Entity) this.f.get(i));
2011-02-07 06:56:07 +01:00
}
this.f.clear();
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("regular");
2011-02-07 06:56:07 +01:00
for (i = 0; i < this.entityList.size(); ++i) {
entity = (Entity) this.entityList.get(i);
// CraftBukkit start - don't tick entities in chunks queued for unload
ChunkProviderServer chunkProviderServer = ((WorldServer) this).chunkProviderServer;
if (chunkProviderServer.unloadQueue.contains(MathHelper.floor(entity.locX) >> 4, MathHelper.floor(entity.locZ) >> 4)) {
continue;
}
// CraftBukkit end
2011-02-07 06:56:07 +01:00
if (entity.vehicle != null) {
if (!entity.vehicle.dead && entity.vehicle.passenger == entity) {
continue;
}
entity.vehicle.passenger = null;
entity.vehicle = null;
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("tick");
2011-02-07 06:56:07 +01:00
if (!entity.dead) {
2012-11-06 13:05:28 +01:00
try {
this.playerJoinedWorld(entity);
} catch (Throwable throwable1) {
crashreport = CrashReport.a(throwable1, "Ticking entity");
crashreportsystemdetails = crashreport.a("Entity being ticked");
if (entity == null) {
crashreportsystemdetails.a("Entity", "~~NULL~~");
} else {
entity.a(crashreportsystemdetails);
}
throw new ReportedException(crashreport);
}
2011-02-07 06:56:07 +01:00
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
this.methodProfiler.a("remove");
2011-02-07 06:56:07 +01:00
if (entity.dead) {
j = entity.ai;
k = entity.ak;
if (entity.ah && this.isChunkLoaded(j, k)) {
this.getChunkAt(j, k).b(entity);
2011-02-07 06:56:07 +01:00
}
this.entityList.remove(i--);
2012-07-29 09:33:13 +02:00
this.b(entity);
2011-02-07 06:56:07 +01:00
}
2011-11-20 09:01:14 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2011-02-07 06:56:07 +01:00
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("tileEntities");
2012-12-20 05:03:52 +01:00
this.M = true;
2012-11-06 13:05:28 +01:00
Iterator iterator = this.tileEntityList.iterator();
2011-02-07 06:56:07 +01:00
2011-06-30 00:02:25 +02:00
while (iterator.hasNext()) {
TileEntity tileentity = (TileEntity) iterator.next();
// CraftBukkit start - don't tick entities in chunks queued for unload
ChunkProviderServer chunkProviderServer = ((WorldServer) this).chunkProviderServer;
if (chunkProviderServer.unloadQueue.contains(tileentity.x >> 4, tileentity.z >> 4)) {
continue;
}
// CraftBukkit end
if (!tileentity.r() && tileentity.o() && this.isLoaded(tileentity.x, tileentity.y, tileentity.z)) {
2012-11-06 13:05:28 +01:00
try {
tileentity.g();
} catch (Throwable throwable2) {
crashreport = CrashReport.a(throwable2, "Ticking tile entity");
crashreportsystemdetails = crashreport.a("Tile entity being ticked");
if (tileentity == null) {
crashreportsystemdetails.a("Tile entity", "~~NULL~~");
} else {
tileentity.a(crashreportsystemdetails);
}
throw new ReportedException(crashreport);
}
2011-06-30 00:02:25 +02:00
}
if (tileentity.r()) {
2011-06-30 00:02:25 +02:00
iterator.remove();
2011-09-15 02:23:52 +02:00
if (this.isChunkLoaded(tileentity.x >> 4, tileentity.z >> 4)) {
Chunk chunk = this.getChunkAt(tileentity.x >> 4, tileentity.z >> 4);
2011-06-30 00:02:25 +02:00
2011-09-15 02:23:52 +02:00
if (chunk != null) {
2012-03-01 11:49:23 +01:00
chunk.f(tileentity.x & 15, tileentity.y, tileentity.z & 15);
2011-09-15 02:23:52 +02:00
}
2011-06-30 00:02:25 +02:00
}
}
}
2012-12-20 05:03:52 +01:00
this.M = false;
2012-07-29 09:33:13 +02:00
if (!this.b.isEmpty()) {
this.tileEntityList.removeAll(this.b);
this.b.clear();
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("pendingTileEntities");
2012-07-29 09:33:13 +02:00
if (!this.a.isEmpty()) {
2012-11-06 13:05:28 +01:00
for (int l = 0; l < this.a.size(); ++l) {
TileEntity tileentity1 = (TileEntity) this.a.get(l);
2011-06-30 00:02:25 +02:00
if (!tileentity1.r()) {
2012-07-29 09:33:13 +02:00
/* CraftBukkit start - order matters, moved down
if (!this.tileEntityList.contains(tileentity1)) {
this.tileEntityList.add(tileentity1);
}
// CraftBukkit end */
2011-06-30 00:02:25 +02:00
2011-09-15 02:23:52 +02:00
if (this.isChunkLoaded(tileentity1.x >> 4, tileentity1.z >> 4)) {
Chunk chunk1 = this.getChunkAt(tileentity1.x >> 4, tileentity1.z >> 4);
2011-06-30 00:02:25 +02:00
2011-09-15 02:23:52 +02:00
if (chunk1 != null) {
chunk1.a(tileentity1.x & 15, tileentity1.y, tileentity1.z & 15, tileentity1);
2012-07-29 09:33:13 +02:00
// CraftBukkit start - moved down from above
if (!this.tileEntityList.contains(tileentity1)) {
this.tileEntityList.add(tileentity1);
2011-09-15 02:23:52 +02:00
}
// CraftBukkit end
}
2011-06-30 00:02:25 +02:00
}
this.notify(tileentity1.x, tileentity1.y, tileentity1.z);
}
}
2012-07-29 09:33:13 +02:00
this.a.clear();
2011-06-30 00:02:25 +02:00
}
2011-11-20 09:01:14 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
this.methodProfiler.b();
2011-06-30 00:02:25 +02:00
}
public void a(Collection collection) {
2012-12-20 05:03:52 +01:00
if (this.M) {
2012-07-29 09:33:13 +02:00
this.a.addAll(collection);
2011-06-30 00:02:25 +02:00
} else {
this.tileEntityList.addAll(collection);
2011-02-07 06:56:07 +01:00
}
}
public void playerJoinedWorld(Entity entity) {
this.entityJoinedWorld(entity, true);
2011-02-07 06:56:07 +01:00
}
public void entityJoinedWorld(Entity entity, boolean flag) {
int i = MathHelper.floor(entity.locX);
int j = MathHelper.floor(entity.locZ);
2011-02-07 06:56:07 +01:00
byte b0 = 32;
if (!flag || this.d(i - b0, 0, j - b0, i + b0, 0, j + b0)) {
entity.T = entity.locX;
entity.U = entity.locY;
entity.V = entity.locZ;
2011-02-07 06:56:07 +01:00
entity.lastYaw = entity.yaw;
entity.lastPitch = entity.pitch;
if (flag && entity.ah) {
2011-02-07 06:56:07 +01:00
if (entity.vehicle != null) {
2012-07-29 09:33:13 +02:00
entity.U();
2011-02-07 06:56:07 +01:00
} else {
2012-12-20 05:03:52 +01:00
++entity.ticksLived;
entity.j_();
2011-02-07 06:56:07 +01:00
}
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("chunkCheck");
2011-02-07 06:56:07 +01:00
if (Double.isNaN(entity.locX) || Double.isInfinite(entity.locX)) {
entity.locX = entity.T;
2011-02-07 06:56:07 +01:00
}
if (Double.isNaN(entity.locY) || Double.isInfinite(entity.locY)) {
entity.locY = entity.U;
2011-02-07 06:56:07 +01:00
}
if (Double.isNaN(entity.locZ) || Double.isInfinite(entity.locZ)) {
entity.locZ = entity.V;
2011-02-07 06:56:07 +01:00
}
if (Double.isNaN((double) entity.pitch) || Double.isInfinite((double) entity.pitch)) {
entity.pitch = entity.lastPitch;
}
if (Double.isNaN((double) entity.yaw) || Double.isInfinite((double) entity.yaw)) {
entity.yaw = entity.lastYaw;
}
int k = MathHelper.floor(entity.locX / 16.0D);
int l = MathHelper.floor(entity.locY / 16.0D);
int i1 = MathHelper.floor(entity.locZ / 16.0D);
2011-02-07 06:56:07 +01:00
if (!entity.ah || entity.ai != k || entity.aj != l || entity.ak != i1) {
if (entity.ah && this.isChunkLoaded(entity.ai, entity.ak)) {
this.getChunkAt(entity.ai, entity.ak).a(entity, entity.aj);
2011-02-07 06:56:07 +01:00
}
if (this.isChunkLoaded(k, i1)) {
entity.ah = true;
this.getChunkAt(k, i1).a(entity);
2011-02-07 06:56:07 +01:00
} else {
entity.ah = false;
2011-02-07 06:56:07 +01:00
}
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
if (flag && entity.ah && entity.passenger != null) {
2011-02-07 06:56:07 +01:00
if (!entity.passenger.dead && entity.passenger.vehicle == entity) {
this.playerJoinedWorld(entity.passenger);
2011-02-07 06:56:07 +01:00
} else {
entity.passenger.vehicle = null;
entity.passenger = null;
}
}
}
}
2012-07-29 09:33:13 +02:00
public boolean b(AxisAlignedBB axisalignedbb) {
return this.a(axisalignedbb, (Entity) null);
}
public boolean a(AxisAlignedBB axisalignedbb, Entity entity) {
2012-01-12 23:10:13 +01:00
List list = this.getEntities((Entity) null, axisalignedbb);
2011-02-07 06:56:07 +01:00
2012-11-06 13:05:28 +01:00
for (int i = 0; i < list.size(); ++i) {
Entity entity1 = (Entity) list.get(i);
2011-02-07 06:56:07 +01:00
2012-11-06 13:05:28 +01:00
if (!entity1.dead && entity1.m && entity1 != entity) {
return false;
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
}
2011-02-07 06:56:07 +01:00
2012-11-06 13:05:28 +01:00
return true;
2011-02-07 06:56:07 +01:00
}
2012-07-29 09:33:13 +02:00
public boolean c(AxisAlignedBB axisalignedbb) {
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
if (axisalignedbb.a < 0.0D) {
--i;
}
if (axisalignedbb.b < 0.0D) {
--k;
}
if (axisalignedbb.c < 0.0D) {
--i1;
}
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
Block block = Block.byId[this.getTypeId(k1, l1, i2)];
2011-04-20 22:47:26 +02:00
if (block != null) {
2011-02-07 06:56:07 +01:00
return true;
}
}
}
}
return false;
}
2012-02-29 22:31:04 +01:00
public boolean containsLiquid(AxisAlignedBB axisalignedbb) {
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
2011-04-20 22:47:26 +02:00
if (axisalignedbb.a < 0.0D) {
--i;
}
if (axisalignedbb.b < 0.0D) {
--k;
}
if (axisalignedbb.c < 0.0D) {
--i1;
}
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
Block block = Block.byId[this.getTypeId(k1, l1, i2)];
if (block != null && block.material.isLiquid()) {
return true;
}
}
}
}
return false;
}
2012-07-29 09:33:13 +02:00
public boolean e(AxisAlignedBB axisalignedbb) {
2011-04-20 22:47:26 +02:00
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
if (this.d(i, k, i1, j, l, j1)) {
2011-02-07 06:56:07 +01:00
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
int j2 = this.getTypeId(k1, l1, i2);
if (j2 == Block.FIRE.id || j2 == Block.LAVA.id || j2 == Block.STATIONARY_LAVA.id) {
return true;
}
}
}
}
}
return false;
}
public boolean a(AxisAlignedBB axisalignedbb, Material material, Entity entity) {
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
if (!this.d(i, k, i1, j, l, j1)) {
2011-02-07 06:56:07 +01:00
return false;
} else {
boolean flag = false;
Vec3D vec3d = this.getVec3DPool().create(0.0D, 0.0D, 0.0D);
2011-02-07 06:56:07 +01:00
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
Block block = Block.byId[this.getTypeId(k1, l1, i2)];
if (block != null && block.material == material) {
2012-12-20 05:03:52 +01:00
double d0 = (double) ((float) (l1 + 1) - BlockFluids.e(this.getData(k1, l1, i2)));
2011-02-07 06:56:07 +01:00
if ((double) l >= d0) {
flag = true;
block.a(this, k1, l1, i2, entity, vec3d);
}
}
}
}
}
if (vec3d.b() > 0.0D) {
vec3d = vec3d.a();
2011-04-20 22:47:26 +02:00
double d1 = 0.014D;
2011-02-07 06:56:07 +01:00
entity.motX += vec3d.c * d1;
entity.motY += vec3d.d * d1;
entity.motZ += vec3d.e * d1;
2011-02-07 06:56:07 +01:00
}
vec3d.b.release(vec3d); // CraftBukkit - pop it - we're done
2011-02-07 06:56:07 +01:00
return flag;
}
}
public boolean a(AxisAlignedBB axisalignedbb, Material material) {
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
Block block = Block.byId[this.getTypeId(k1, l1, i2)];
if (block != null && block.material == material) {
return true;
}
}
}
}
return false;
}
public boolean b(AxisAlignedBB axisalignedbb, Material material) {
int i = MathHelper.floor(axisalignedbb.a);
int j = MathHelper.floor(axisalignedbb.d + 1.0D);
int k = MathHelper.floor(axisalignedbb.b);
int l = MathHelper.floor(axisalignedbb.e + 1.0D);
int i1 = MathHelper.floor(axisalignedbb.c);
int j1 = MathHelper.floor(axisalignedbb.f + 1.0D);
2011-02-07 06:56:07 +01:00
for (int k1 = i; k1 < j; ++k1) {
for (int l1 = k; l1 < l; ++l1) {
for (int i2 = i1; i2 < j1; ++i2) {
Block block = Block.byId[this.getTypeId(k1, l1, i2)];
if (block != null && block.material == material) {
int j2 = this.getData(k1, l1, i2);
double d0 = (double) (l1 + 1);
if (j2 < 8) {
d0 = (double) (l1 + 1) - (double) j2 / 8.0D;
}
if (d0 >= axisalignedbb.b) {
return true;
}
}
}
}
}
return false;
}
public Explosion explode(Entity entity, double d0, double d1, double d2, float f, boolean flag) {
return this.createExplosion(entity, d0, d1, d2, f, false, flag);
2011-02-07 06:56:07 +01:00
}
public Explosion createExplosion(Entity entity, double d0, double d1, double d2, float f, boolean flag, boolean flag1) {
2011-02-07 06:56:07 +01:00
Explosion explosion = new Explosion(this, entity, d0, d1, d2, f);
explosion.a = flag;
explosion.b = flag1;
2011-02-07 06:56:07 +01:00
explosion.a();
2011-04-20 22:47:26 +02:00
explosion.a(true);
2011-02-07 06:56:07 +01:00
return explosion;
}
public float a(Vec3D vec3d, AxisAlignedBB axisalignedbb) {
double d0 = 1.0D / ((axisalignedbb.d - axisalignedbb.a) * 2.0D + 1.0D);
double d1 = 1.0D / ((axisalignedbb.e - axisalignedbb.b) * 2.0D + 1.0D);
double d2 = 1.0D / ((axisalignedbb.f - axisalignedbb.c) * 2.0D + 1.0D);
int i = 0;
int j = 0;
Vec3D vec3d2 = vec3d.b.create(0, 0, 0); // CraftBukkit
2011-02-07 06:56:07 +01:00
for (float f = 0.0F; f <= 1.0F; f = (float) ((double) f + d0)) {
for (float f1 = 0.0F; f1 <= 1.0F; f1 = (float) ((double) f1 + d1)) {
for (float f2 = 0.0F; f2 <= 1.0F; f2 = (float) ((double) f2 + d2)) {
double d3 = axisalignedbb.a + (axisalignedbb.d - axisalignedbb.a) * (double) f;
double d4 = axisalignedbb.b + (axisalignedbb.e - axisalignedbb.b) * (double) f1;
double d5 = axisalignedbb.c + (axisalignedbb.f - axisalignedbb.c) * (double) f2;
if (this.a(vec3d2.b(d3, d4, d5), vec3d) == null) { // CraftBukkit
2011-02-07 06:56:07 +01:00
++i;
}
++j;
}
}
}
vec3d2.b.release(vec3d2); // CraftBukkit
2011-02-07 06:56:07 +01:00
return (float) i / (float) j;
}
2012-03-01 11:49:23 +01:00
public boolean douseFire(EntityHuman entityhuman, int i, int j, int k, int l) {
2011-05-26 14:48:22 +02:00
if (l == 0) {
--j;
}
if (l == 1) {
++j;
}
if (l == 2) {
--k;
}
if (l == 3) {
++k;
}
if (l == 4) {
--i;
}
if (l == 5) {
++i;
}
if (this.getTypeId(i, j, k) == Block.FIRE.id) {
this.a(entityhuman, 1004, i, j, k, 0);
this.setTypeId(i, j, k, 0);
2012-03-01 11:49:23 +01:00
return true;
} else {
return false;
2011-05-26 14:48:22 +02:00
}
}
2011-02-07 06:56:07 +01:00
public TileEntity getTileEntity(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
if (j >= 256) {
2011-11-20 09:01:14 +01:00
return null;
} else {
2012-03-01 11:49:23 +01:00
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
if (chunk == null) {
return null;
} else {
TileEntity tileentity = chunk.e(i & 15, j, k & 15);
2011-11-20 09:01:14 +01:00
2012-03-01 11:49:23 +01:00
if (tileentity == null) {
2012-11-06 13:05:28 +01:00
for (int l = 0; l < this.a.size(); ++l) {
TileEntity tileentity1 = (TileEntity) this.a.get(l);
2011-11-20 09:01:14 +01:00
if (!tileentity1.r() && tileentity1.x == i && tileentity1.y == j && tileentity1.z == k) {
2012-03-01 11:49:23 +01:00
tileentity = tileentity1;
break;
}
2011-11-20 09:01:14 +01:00
}
}
2012-03-01 11:49:23 +01:00
return tileentity;
}
2011-11-20 09:01:14 +01:00
}
2011-02-07 06:56:07 +01:00
}
public void setTileEntity(int i, int j, int k, TileEntity tileentity) {
if (tileentity != null && !tileentity.r()) {
2012-12-20 05:03:52 +01:00
if (this.M) {
2011-06-30 00:02:25 +02:00
tileentity.x = i;
tileentity.y = j;
tileentity.z = k;
2012-07-29 09:33:13 +02:00
this.a.add(tileentity);
2011-06-30 00:02:25 +02:00
} else {
2012-07-29 09:33:13 +02:00
this.tileEntityList.add(tileentity);
2011-06-30 00:02:25 +02:00
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
2011-02-07 06:56:07 +01:00
2011-06-30 00:02:25 +02:00
if (chunk != null) {
chunk.a(i & 15, j, k & 15, tileentity);
}
}
2011-02-07 06:56:07 +01:00
}
}
2012-11-06 13:05:28 +01:00
public void r(int i, int j, int k) {
2011-06-30 00:02:25 +02:00
TileEntity tileentity = this.getTileEntity(i, j, k);
2012-12-20 05:03:52 +01:00
if (tileentity != null && this.M) {
tileentity.w_();
2012-07-29 09:33:13 +02:00
this.a.remove(tileentity);
2011-06-30 00:02:25 +02:00
} else {
if (tileentity != null) {
2012-07-29 09:33:13 +02:00
this.a.remove(tileentity);
this.tileEntityList.remove(tileentity);
2011-06-30 00:02:25 +02:00
}
2011-02-07 06:56:07 +01:00
2011-06-30 00:02:25 +02:00
Chunk chunk = this.getChunkAt(i >> 4, k >> 4);
if (chunk != null) {
2012-03-01 11:49:23 +01:00
chunk.f(i & 15, j, k & 15);
2011-06-30 00:02:25 +02:00
}
2011-02-07 06:56:07 +01:00
}
}
2011-09-15 02:23:52 +02:00
public void a(TileEntity tileentity) {
2012-07-29 09:33:13 +02:00
this.b.add(tileentity);
2011-09-15 02:23:52 +02:00
}
2012-11-06 13:05:28 +01:00
public boolean s(int i, int j, int k) {
2011-02-07 06:56:07 +01:00
Block block = Block.byId[this.getTypeId(i, j, k)];
return block == null ? false : block.c();
2012-07-29 09:33:13 +02:00
}
2012-11-06 13:05:28 +01:00
public boolean t(int i, int j, int k) {
2012-07-29 09:33:13 +02:00
return Block.i(this.getTypeId(i, j, k));
2011-02-07 06:56:07 +01:00
}
2012-11-06 13:05:28 +01:00
public boolean u(int i, int j, int k) {
int l = this.getTypeId(i, j, k);
if (l != 0 && Block.byId[l] != null) {
AxisAlignedBB axisalignedbb = Block.byId[l].e(this, i, j, k);
return axisalignedbb != null && axisalignedbb.b() >= 1.0D;
} else {
return false;
}
}
public boolean v(int i, int j, int k) {
2012-07-29 09:33:13 +02:00
Block block = Block.byId[this.getTypeId(i, j, k)];
return block == null ? false : (block.material.k() && block.b() ? true : (block instanceof BlockStairs ? (this.getData(i, j, k) & 4) == 4 : (block instanceof BlockStepAbstract ? (this.getData(i, j, k) & 8) == 8 : false)));
2011-02-07 06:56:07 +01:00
}
2011-11-20 09:01:14 +01:00
public boolean b(int i, int j, int k, boolean flag) {
if (i >= -30000000 && k >= -30000000 && i < 30000000 && k < 30000000) {
Chunk chunk = this.chunkProvider.getOrCreateChunk(i >> 4, k >> 4);
if (chunk != null && !chunk.isEmpty()) {
Block block = Block.byId[this.getTypeId(i, j, k)];
return block == null ? false : block.material.k() && block.b();
2011-11-20 09:01:14 +01:00
} else {
return flag;
}
} else {
return flag;
}
}
2012-11-06 13:05:28 +01:00
public void x() {
2011-02-07 06:56:07 +01:00
int i = this.a(1.0F);
if (i != this.j) {
this.j = i;
2011-02-07 06:56:07 +01:00
}
}
public void setSpawnFlags(boolean flag, boolean flag1) {
this.allowMonsters = flag;
this.allowAnimals = flag1;
2011-02-07 06:56:07 +01:00
}
public void doTick() {
this.n();
2011-04-20 22:47:26 +02:00
}
2012-07-29 09:33:13 +02:00
private void a() {
if (this.worldData.hasStorm()) {
this.n = 1.0F;
if (this.worldData.isThundering()) {
this.p = 1.0F;
2011-04-20 22:47:26 +02:00
}
}
2011-02-07 06:56:07 +01:00
}
protected void n() {
if (!this.worldProvider.f) {
int i = this.worldData.getThunderDuration();
2011-04-20 22:47:26 +02:00
if (i <= 0) {
if (this.worldData.isThundering()) {
this.worldData.setThunderDuration(this.random.nextInt(12000) + 3600);
2011-04-20 22:47:26 +02:00
} else {
this.worldData.setThunderDuration(this.random.nextInt(168000) + 12000);
2011-04-20 22:47:26 +02:00
}
} else {
--i;
this.worldData.setThunderDuration(i);
2011-04-20 22:47:26 +02:00
if (i <= 0) {
// CraftBukkit start
ThunderChangeEvent thunder = new ThunderChangeEvent(this.getWorld(), !this.worldData.isThundering());
this.getServer().getPluginManager().callEvent(thunder);
if (!thunder.isCancelled()) {
this.worldData.setThundering(!this.worldData.isThundering());
}
// CraftBukkit end
2011-04-20 22:47:26 +02:00
}
}
int j = this.worldData.getWeatherDuration();
2011-04-20 22:47:26 +02:00
if (j <= 0) {
if (this.worldData.hasStorm()) {
this.worldData.setWeatherDuration(this.random.nextInt(12000) + 12000);
2011-04-20 22:47:26 +02:00
} else {
this.worldData.setWeatherDuration(this.random.nextInt(168000) + 12000);
2011-04-20 22:47:26 +02:00
}
} else {
--j;
this.worldData.setWeatherDuration(j);
2011-04-20 22:47:26 +02:00
if (j <= 0) {
// CraftBukkit start
WeatherChangeEvent weather = new WeatherChangeEvent(this.getWorld(), !this.worldData.hasStorm());
this.getServer().getPluginManager().callEvent(weather);
if (!weather.isCancelled()) {
this.worldData.setStorm(!this.worldData.hasStorm());
}
// CraftBukkit end
2011-04-20 22:47:26 +02:00
}
}
this.m = this.n;
if (this.worldData.hasStorm()) {
this.n = (float) ((double) this.n + 0.01D);
2011-04-20 22:47:26 +02:00
} else {
this.n = (float) ((double) this.n - 0.01D);
2011-04-20 22:47:26 +02:00
}
if (this.n < 0.0F) {
this.n = 0.0F;
2011-04-20 22:47:26 +02:00
}
if (this.n > 1.0F) {
this.n = 1.0F;
2011-04-20 22:47:26 +02:00
}
this.o = this.p;
if (this.worldData.isThundering()) {
this.p = (float) ((double) this.p + 0.01D);
2011-04-20 22:47:26 +02:00
} else {
this.p = (float) ((double) this.p - 0.01D);
2011-04-20 22:47:26 +02:00
}
if (this.p < 0.0F) {
this.p = 0.0F;
2011-04-20 22:47:26 +02:00
}
if (this.p > 1.0F) {
this.p = 1.0F;
2011-04-20 22:47:26 +02:00
}
}
}
2012-11-06 13:05:28 +01:00
public void y() {
2011-11-20 09:01:14 +01:00
this.worldData.setWeatherDuration(1);
}
2012-11-06 13:05:28 +01:00
protected void z() {
2012-03-01 11:49:23 +01:00
// this.chunkTickList.clear(); // CraftBukkit - removed
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("buildList");
2011-02-07 06:56:07 +01:00
int i;
2012-03-01 11:49:23 +01:00
EntityHuman entityhuman;
2011-02-07 06:56:07 +01:00
int j;
2012-03-01 11:49:23 +01:00
int k;
2011-02-07 06:56:07 +01:00
2011-11-20 09:01:14 +01:00
for (i = 0; i < this.players.size(); ++i) {
2012-03-01 11:49:23 +01:00
entityhuman = (EntityHuman) this.players.get(i);
j = MathHelper.floor(entityhuman.locX / 16.0D);
k = MathHelper.floor(entityhuman.locZ / 16.0D);
2011-11-20 09:01:14 +01:00
byte b0 = 7;
2011-02-07 06:56:07 +01:00
2012-03-01 11:49:23 +01:00
for (int l = -b0; l <= b0; ++l) {
2011-11-20 09:01:14 +01:00
for (int i1 = -b0; i1 <= b0; ++i1) {
// CraftBukkit start - don't tick chunks queued for unload
ChunkProviderServer chunkProviderServer = ((WorldServer) entityhuman.world).chunkProviderServer;
if (chunkProviderServer.unloadQueue.contains(l + j, i1 + k)) {
continue;
}
// CraftBukkit end
2012-07-29 09:33:13 +02:00
this.chunkTickList.add(org.bukkit.craftbukkit.util.LongHash.toLong(l + j, i1 + k)); // CraftBukkit
2011-02-07 06:56:07 +01:00
}
}
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2012-12-20 05:03:52 +01:00
if (this.N > 0) {
--this.N;
2011-02-07 06:56:07 +01:00
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("playerCheckLight");
2012-03-01 11:49:23 +01:00
if (!this.players.isEmpty()) {
i = this.random.nextInt(this.players.size());
entityhuman = (EntityHuman) this.players.get(i);
j = MathHelper.floor(entityhuman.locX) + this.random.nextInt(11) - 5;
k = MathHelper.floor(entityhuman.locY) + this.random.nextInt(11) - 5;
int j1 = MathHelper.floor(entityhuman.locZ) + this.random.nextInt(11) - 5;
2012-11-06 13:05:28 +01:00
this.z(j, k, j1);
2012-03-01 11:49:23 +01:00
}
2011-11-20 09:01:14 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2012-03-01 11:49:23 +01:00
}
protected void a(int i, int j, Chunk chunk) {
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("moodSound");
2012-12-20 05:03:52 +01:00
if (this.N == 0 && !this.isStatic) {
this.k = this.k * 3 + 1013904223;
int k = this.k >> 2;
2012-03-01 11:49:23 +01:00
int l = k & 15;
int i1 = k >> 8 & 15;
int j1 = k >> 16 & 255; // CraftBukkit - 127 -> 255
2012-03-01 11:49:23 +01:00
int k1 = chunk.getTypeId(l, j1, i1);
l += i;
i1 += j;
2012-11-06 13:05:28 +01:00
if (k1 == 0 && this.l(l, j1, i1) <= this.random.nextInt(8) && this.b(EnumSkyBlock.SKY, l, j1, i1) <= 0) {
2012-03-01 11:49:23 +01:00
EntityHuman entityhuman = this.findNearbyPlayer((double) l + 0.5D, (double) j1 + 0.5D, (double) i1 + 0.5D, 8.0D);
if (entityhuman != null && entityhuman.e((double) l + 0.5D, (double) j1 + 0.5D, (double) i1 + 0.5D) > 4.0D) {
this.makeSound((double) l + 0.5D, (double) j1 + 0.5D, (double) i1 + 0.5D, "ambient.cave.cave", 0.7F, 0.8F + this.random.nextFloat() * 0.2F);
2012-12-20 05:03:52 +01:00
this.N = this.random.nextInt(12000) + 6000;
2012-03-01 11:49:23 +01:00
}
}
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.c("checkLight");
2012-07-29 09:33:13 +02:00
chunk.o();
2012-03-01 11:49:23 +01:00
}
2012-07-29 09:33:13 +02:00
protected void g() {
2012-11-06 13:05:28 +01:00
this.z();
2011-11-20 09:01:14 +01:00
}
2011-04-20 22:47:26 +02:00
2012-11-06 13:05:28 +01:00
public boolean w(int i, int j, int k) {
2011-11-20 09:01:14 +01:00
return this.c(i, j, k, false);
}
2011-09-15 02:23:52 +02:00
2012-11-06 13:05:28 +01:00
public boolean x(int i, int j, int k) {
2011-11-20 09:01:14 +01:00
return this.c(i, j, k, true);
}
2011-09-15 02:23:52 +02:00
2011-11-20 09:01:14 +01:00
public boolean c(int i, int j, int k, boolean flag) {
2012-03-01 11:49:23 +01:00
BiomeBase biomebase = this.getBiome(i, k);
2012-07-29 09:33:13 +02:00
float f = biomebase.j();
2011-09-15 02:23:52 +02:00
2011-11-20 09:01:14 +01:00
if (f > 0.15F) {
return false;
} else {
2012-07-29 09:33:13 +02:00
if (j >= 0 && j < 256 && this.b(EnumSkyBlock.BLOCK, i, j, k) < 10) {
2011-11-20 09:01:14 +01:00
int l = this.getTypeId(i, j, k);
2011-09-15 02:23:52 +02:00
2011-11-20 09:01:14 +01:00
if ((l == Block.STATIONARY_WATER.id || l == Block.WATER.id) && this.getData(i, j, k) == 0) {
if (!flag) {
return true;
}
2011-09-15 02:23:52 +02:00
2011-11-20 09:01:14 +01:00
boolean flag1 = true;
2011-11-20 09:01:14 +01:00
if (flag1 && this.getMaterial(i - 1, j, k) != Material.WATER) {
flag1 = false;
}
if (flag1 && this.getMaterial(i + 1, j, k) != Material.WATER) {
flag1 = false;
}
if (flag1 && this.getMaterial(i, j, k - 1) != Material.WATER) {
flag1 = false;
}
if (flag1 && this.getMaterial(i, j, k + 1) != Material.WATER) {
flag1 = false;
}
if (!flag1) {
return true;
2011-02-07 06:56:07 +01:00
}
}
}
2011-11-20 09:01:14 +01:00
return false;
}
}
2012-11-06 13:05:28 +01:00
public boolean y(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
BiomeBase biomebase = this.getBiome(i, k);
2012-07-29 09:33:13 +02:00
float f = biomebase.j();
2011-09-15 02:23:52 +02:00
2011-11-20 09:01:14 +01:00
if (f > 0.15F) {
return false;
} else {
2012-07-29 09:33:13 +02:00
if (j >= 0 && j < 256 && this.b(EnumSkyBlock.BLOCK, i, j, k) < 10) {
2011-11-20 09:01:14 +01:00
int l = this.getTypeId(i, j - 1, k);
int i1 = this.getTypeId(i, j, k);
if (i1 == 0 && Block.SNOW.canPlace(this, i, j, k) && l != 0 && l != Block.ICE.id && Block.byId[l].material.isSolid()) {
return true;
2011-02-07 06:56:07 +01:00
}
}
2011-11-20 09:01:14 +01:00
return false;
2011-02-07 06:56:07 +01:00
}
}
2012-11-06 13:05:28 +01:00
public void z(int i, int j, int k) {
if (!this.worldProvider.f) {
2012-07-29 09:33:13 +02:00
this.c(EnumSkyBlock.SKY, i, j, k);
2011-11-20 09:01:14 +01:00
}
2012-07-29 09:33:13 +02:00
this.c(EnumSkyBlock.BLOCK, i, j, k);
2011-09-15 02:23:52 +02:00
}
private int b(int i, int j, int k, int l, int i1, int j1) {
2011-09-15 02:23:52 +02:00
int k1 = 0;
2012-11-06 13:05:28 +01:00
if (this.k(j, k, l)) {
2011-09-15 02:23:52 +02:00
k1 = 15;
} else {
if (j1 == 0) {
j1 = 1;
}
2012-07-29 09:33:13 +02:00
int l1 = this.b(EnumSkyBlock.SKY, j - 1, k, l) - j1;
int i2 = this.b(EnumSkyBlock.SKY, j + 1, k, l) - j1;
int j2 = this.b(EnumSkyBlock.SKY, j, k - 1, l) - j1;
int k2 = this.b(EnumSkyBlock.SKY, j, k + 1, l) - j1;
int l2 = this.b(EnumSkyBlock.SKY, j, k, l - 1) - j1;
int i3 = this.b(EnumSkyBlock.SKY, j, k, l + 1) - j1;
2011-09-15 02:23:52 +02:00
2012-03-01 11:49:23 +01:00
if (l1 > k1) {
k1 = l1;
}
if (i2 > k1) {
k1 = i2;
}
if (j2 > k1) {
k1 = j2;
}
if (k2 > k1) {
k1 = k2;
}
if (l2 > k1) {
k1 = l2;
}
if (i3 > k1) {
k1 = i3;
2011-09-15 02:23:52 +02:00
}
}
return k1;
}
private int g(int i, int j, int k, int l, int i1, int j1) {
int k1 = Block.lightEmission[i1];
2012-07-29 09:33:13 +02:00
int l1 = this.b(EnumSkyBlock.BLOCK, j - 1, k, l) - j1;
int i2 = this.b(EnumSkyBlock.BLOCK, j + 1, k, l) - j1;
int j2 = this.b(EnumSkyBlock.BLOCK, j, k - 1, l) - j1;
int k2 = this.b(EnumSkyBlock.BLOCK, j, k + 1, l) - j1;
int l2 = this.b(EnumSkyBlock.BLOCK, j, k, l - 1) - j1;
int i3 = this.b(EnumSkyBlock.BLOCK, j, k, l + 1) - j1;
2011-09-15 02:23:52 +02:00
if (l1 > k1) {
k1 = l1;
}
if (i2 > k1) {
k1 = i2;
}
if (j2 > k1) {
k1 = j2;
}
if (k2 > k1) {
k1 = k2;
}
if (l2 > k1) {
k1 = l2;
}
if (i3 > k1) {
k1 = i3;
}
return k1;
}
2012-07-29 09:33:13 +02:00
public void c(EnumSkyBlock enumskyblock, int i, int j, int k) {
2011-09-15 02:23:52 +02:00
if (this.areChunksLoaded(i, j, k, 17)) {
int l = 0;
int i1 = 0;
2012-03-01 11:49:23 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("getBrightness");
2012-07-29 09:33:13 +02:00
int j1 = this.b(enumskyblock, i, j, k);
2011-09-15 02:23:52 +02:00
boolean flag = false;
int k1 = this.getTypeId(i, j, k);
2012-07-29 09:33:13 +02:00
int l1 = this.b(i, j, k);
2011-09-15 02:23:52 +02:00
if (l1 == 0) {
l1 = 1;
}
boolean flag1 = false;
int i2;
if (enumskyblock == EnumSkyBlock.SKY) {
i2 = this.b(j1, i, j, k, k1, l1);
2011-09-15 02:23:52 +02:00
} else {
i2 = this.g(j1, i, j, k, k1, l1);
2011-09-15 02:23:52 +02:00
}
int j2;
int k2;
int l2;
int i3;
int j3;
int k3;
2012-07-29 09:33:13 +02:00
int l3;
int i4;
2011-09-15 02:23:52 +02:00
if (i2 > j1) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = 133152;
2011-09-15 02:23:52 +02:00
} else if (i2 < j1) {
if (enumskyblock != EnumSkyBlock.BLOCK) {
;
}
2012-12-20 05:03:52 +01:00
this.H[i1++] = 133152 + (j1 << 18);
2011-09-15 02:23:52 +02:00
while (l < i1) {
2012-12-20 05:03:52 +01:00
k1 = this.H[l++];
2012-07-29 09:33:13 +02:00
l1 = (k1 & 63) - 32 + i;
i2 = (k1 >> 6 & 63) - 32 + j;
j2 = (k1 >> 12 & 63) - 32 + k;
k2 = k1 >> 18 & 15;
l2 = this.b(enumskyblock, l1, i2, j2);
2011-09-15 02:23:52 +02:00
if (l2 == k2) {
2012-07-29 09:33:13 +02:00
this.b(enumskyblock, l1, i2, j2, 0);
2011-09-15 02:23:52 +02:00
if (k2 > 0) {
2012-07-29 09:33:13 +02:00
i3 = l1 - i;
k3 = i2 - j;
j3 = j2 - k;
2011-09-15 02:23:52 +02:00
if (i3 < 0) {
i3 = -i3;
}
if (k3 < 0) {
k3 = -k3;
}
if (j3 < 0) {
j3 = -j3;
}
if (i3 + k3 + j3 < 17) {
2012-07-29 09:33:13 +02:00
for (i4 = 0; i4 < 6; ++i4) {
l3 = i4 % 2 * 2 - 1;
int j4 = l1 + i4 / 2 % 3 / 2 * l3;
int k4 = i2 + (i4 / 2 + 1) % 3 / 2 * l3;
int l4 = j2 + (i4 / 2 + 2) % 3 / 2 * l3;
2011-09-15 02:23:52 +02:00
2012-07-29 09:33:13 +02:00
l2 = this.b(enumskyblock, j4, k4, l4);
int i5 = Block.lightBlock[this.getTypeId(j4, k4, l4)];
2011-11-20 09:01:14 +01:00
if (i5 == 0) {
i5 = 1;
}
2012-12-20 05:03:52 +01:00
if (l2 == k2 - i5 && i1 < this.H.length) {
this.H[i1++] = j4 - i + 32 + (k4 - j + 32 << 6) + (l4 - k + 32 << 12) + (k2 - i5 << 18);
2011-09-15 02:23:52 +02:00
}
}
}
}
}
}
l = 0;
}
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
this.methodProfiler.a("checkedPosition < toCheckCount");
2012-03-01 11:49:23 +01:00
2011-09-15 02:23:52 +02:00
while (l < i1) {
2012-12-20 05:03:52 +01:00
k1 = this.H[l++];
2012-07-29 09:33:13 +02:00
l1 = (k1 & 63) - 32 + i;
i2 = (k1 >> 6 & 63) - 32 + j;
j2 = (k1 >> 12 & 63) - 32 + k;
k2 = this.b(enumskyblock, l1, i2, j2);
l2 = this.getTypeId(l1, i2, j2);
i3 = Block.lightBlock[l2];
if (i3 == 0) {
i3 = 1;
2011-09-15 02:23:52 +02:00
}
boolean flag2 = false;
if (enumskyblock == EnumSkyBlock.SKY) {
k3 = this.b(k2, l1, i2, j2, l2, i3);
2011-09-15 02:23:52 +02:00
} else {
k3 = this.g(k2, l1, i2, j2, l2, i3);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (k3 != k2) {
this.b(enumskyblock, l1, i2, j2, k3);
if (k3 > k2) {
j3 = l1 - i;
i4 = i2 - j;
l3 = j2 - k;
if (j3 < 0) {
j3 = -j3;
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (i4 < 0) {
i4 = -i4;
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (l3 < 0) {
l3 = -l3;
2011-09-15 02:23:52 +02:00
}
2012-12-20 05:03:52 +01:00
if (j3 + i4 + l3 < 17 && i1 < this.H.length - 6) {
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1 - 1, i2, j2) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 - 1 - i + 32 + (i2 - j + 32 << 6) + (j2 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1 + 1, i2, j2) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 + 1 - i + 32 + (i2 - j + 32 << 6) + (j2 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1, i2 - 1, j2) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 - i + 32 + (i2 - 1 - j + 32 << 6) + (j2 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1, i2 + 1, j2) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 - i + 32 + (i2 + 1 - j + 32 << 6) + (j2 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1, i2, j2 - 1) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 - i + 32 + (i2 - j + 32 << 6) + (j2 - 1 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
2012-07-29 09:33:13 +02:00
if (this.b(enumskyblock, l1, i2, j2 + 1) < k3) {
2012-12-20 05:03:52 +01:00
this.H[i1++] = l1 - i + 32 + (i2 - j + 32 << 6) + (j2 + 1 - k + 32 << 12);
2011-09-15 02:23:52 +02:00
}
}
}
}
}
2012-03-01 11:49:23 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2011-09-15 02:23:52 +02:00
}
}
2011-02-07 06:56:07 +01:00
public boolean a(boolean flag) {
2012-07-29 09:33:13 +02:00
return false;
2011-02-07 06:56:07 +01:00
}
2011-11-20 09:01:14 +01:00
public List a(Chunk chunk, boolean flag) {
2012-07-29 09:33:13 +02:00
return null;
2011-11-20 09:01:14 +01:00
}
2012-01-12 16:27:39 +01:00
public List getEntities(Entity entity, AxisAlignedBB axisalignedbb) {
2012-12-20 05:03:52 +01:00
this.O.clear();
int i = MathHelper.floor((axisalignedbb.a - 2.0D) / 16.0D);
int j = MathHelper.floor((axisalignedbb.d + 2.0D) / 16.0D);
int k = MathHelper.floor((axisalignedbb.c - 2.0D) / 16.0D);
int l = MathHelper.floor((axisalignedbb.f + 2.0D) / 16.0D);
2011-02-07 06:56:07 +01:00
for (int i1 = i; i1 <= j; ++i1) {
for (int j1 = k; j1 <= l; ++j1) {
if (this.isChunkLoaded(i1, j1)) {
2012-12-20 05:03:52 +01:00
this.getChunkAt(i1, j1).a(entity, axisalignedbb, this.O);
2011-02-07 06:56:07 +01:00
}
}
}
2012-12-20 05:03:52 +01:00
return this.O;
2011-02-07 06:56:07 +01:00
}
public List a(Class oclass, AxisAlignedBB axisalignedbb) {
return this.a(oclass, axisalignedbb, (IEntitySelector) null);
}
public List a(Class oclass, AxisAlignedBB axisalignedbb, IEntitySelector ientityselector) {
int i = MathHelper.floor((axisalignedbb.a - 2.0D) / 16.0D);
int j = MathHelper.floor((axisalignedbb.d + 2.0D) / 16.0D);
int k = MathHelper.floor((axisalignedbb.c - 2.0D) / 16.0D);
int l = MathHelper.floor((axisalignedbb.f + 2.0D) / 16.0D);
2011-02-07 06:56:07 +01:00
ArrayList arraylist = new ArrayList();
for (int i1 = i; i1 <= j; ++i1) {
for (int j1 = k; j1 <= l; ++j1) {
if (this.isChunkLoaded(i1, j1)) {
this.getChunkAt(i1, j1).a(oclass, axisalignedbb, arraylist, ientityselector);
2011-02-07 06:56:07 +01:00
}
}
}
return arraylist;
}
2012-03-01 11:49:23 +01:00
public Entity a(Class oclass, AxisAlignedBB axisalignedbb, Entity entity) {
List list = this.a(oclass, axisalignedbb);
Entity entity1 = null;
double d0 = Double.MAX_VALUE;
2012-11-06 13:05:28 +01:00
for (int i = 0; i < list.size(); ++i) {
Entity entity2 = (Entity) list.get(i);
2012-03-01 11:49:23 +01:00
if (entity2 != entity) {
2012-07-29 09:33:13 +02:00
double d1 = entity.e(entity2);
2012-03-01 11:49:23 +01:00
if (d1 <= d0) {
entity1 = entity2;
d0 = d1;
}
}
}
return entity1;
}
public abstract Entity getEntity(int i);
2011-02-07 06:56:07 +01:00
public void b(int i, int j, int k, TileEntity tileentity) {
if (this.isLoaded(i, j, k)) {
2012-03-01 11:49:23 +01:00
this.getChunkAtWorldCoords(i, k).e();
2011-02-07 06:56:07 +01:00
}
}
public int a(Class oclass) {
int i = 0;
for (int j = 0; j < this.entityList.size(); ++j) {
Entity entity = (Entity) this.entityList.get(j);
2011-02-07 06:56:07 +01:00
if (oclass.isAssignableFrom(entity.getClass())) {
++i;
}
}
return i;
}
public void a(List list) {
// CraftBukkit start
Entity entity = null;
2011-02-07 06:56:07 +01:00
for (int i = 0; i < list.size(); ++i) {
entity = (Entity) list.get(i);
if (entity == null) {
continue;
}
this.entityList.add(entity);
// CraftBukkit end
2012-07-29 09:33:13 +02:00
this.a((Entity) list.get(i));
2011-02-07 06:56:07 +01:00
}
}
public void b(List list) {
this.f.addAll(list);
2011-02-07 06:56:07 +01:00
}
2012-07-29 09:33:13 +02:00
public boolean mayPlace(int i, int j, int k, int l, boolean flag, int i1, Entity entity) {
2011-05-26 14:48:22 +02:00
int j1 = this.getTypeId(j, k, l);
Block block = Block.byId[j1];
2011-02-07 06:56:07 +01:00
Block block1 = Block.byId[i];
2011-06-30 00:02:25 +02:00
AxisAlignedBB axisalignedbb = block1.e(this, j, k, l);
2011-02-07 06:56:07 +01:00
if (flag) {
axisalignedbb = null;
}
2011-06-12 00:02:58 +02:00
boolean defaultReturn; // CraftBukkit - store the default action
2012-07-29 09:33:13 +02:00
if (axisalignedbb != null && !this.a(axisalignedbb, entity)) {
2011-06-12 00:02:58 +02:00
defaultReturn = false; // CraftBukkit
2011-05-14 16:29:42 +02:00
} else {
2012-07-29 09:33:13 +02:00
if (block != null && (block == Block.WATER || block == Block.STATIONARY_WATER || block == Block.LAVA || block == Block.STATIONARY_LAVA || block == Block.FIRE || block.material.isReplaceable())) {
2011-05-14 16:29:42 +02:00
block = null;
}
// CraftBukkit
defaultReturn = block != null && block.material == Material.ORIENTABLE && block1 == Block.ANVIL ? true : i > 0 && block == null && block1.canPlace(this, j, k, l, i1);
}
2011-05-14 16:29:42 +02:00
// CraftBukkit start
BlockCanBuildEvent event = new BlockCanBuildEvent(this.getWorld().getBlockAt(j, k, l), i, defaultReturn);
this.getServer().getPluginManager().callEvent(event);
return event.isBuildable();
// CraftBukkit end
2011-02-07 06:56:07 +01:00
}
2012-03-01 11:49:23 +01:00
public PathEntity findPath(Entity entity, Entity entity1, float f, boolean flag, boolean flag1, boolean flag2, boolean flag3) {
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("pathfind");
int i = MathHelper.floor(entity.locX);
2012-03-01 11:49:23 +01:00
int j = MathHelper.floor(entity.locY + 1.0D);
int k = MathHelper.floor(entity.locZ);
2011-02-07 06:56:07 +01:00
int l = (int) (f + 16.0F);
int i1 = i - l;
int j1 = j - l;
int k1 = k - l;
int l1 = i + l;
int i2 = j + l;
int j2 = k + l;
ChunkCache chunkcache = new ChunkCache(this, i1, j1, k1, l1, i2, j2);
2012-03-01 11:49:23 +01:00
PathEntity pathentity = (new Pathfinder(chunkcache, flag, flag1, flag2, flag3)).a(entity, entity1, f);
2011-02-07 06:56:07 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2011-11-20 09:01:14 +01:00
return pathentity;
2011-02-07 06:56:07 +01:00
}
2012-03-01 11:49:23 +01:00
public PathEntity a(Entity entity, int i, int j, int k, float f, boolean flag, boolean flag1, boolean flag2, boolean flag3) {
2012-09-10 06:19:28 +02:00
this.methodProfiler.a("pathfind");
int l = MathHelper.floor(entity.locX);
int i1 = MathHelper.floor(entity.locY);
int j1 = MathHelper.floor(entity.locZ);
2011-02-07 06:56:07 +01:00
int k1 = (int) (f + 8.0F);
int l1 = l - k1;
int i2 = i1 - k1;
int j2 = j1 - k1;
int k2 = l + k1;
int l2 = i1 + k1;
int i3 = j1 + k1;
ChunkCache chunkcache = new ChunkCache(this, l1, i2, j2, k2, l2, i3);
2012-03-01 11:49:23 +01:00
PathEntity pathentity = (new Pathfinder(chunkcache, flag, flag1, flag2, flag3)).a(entity, i, j, k, f);
2011-02-07 06:56:07 +01:00
2012-09-10 06:19:28 +02:00
this.methodProfiler.b();
2011-11-20 09:01:14 +01:00
return pathentity;
2011-02-07 06:56:07 +01:00
}
public boolean isBlockFacePowered(int i, int j, int k, int l) {
2011-02-07 06:56:07 +01:00
int i1 = this.getTypeId(i, j, k);
2012-07-29 09:33:13 +02:00
return i1 == 0 ? false : Block.byId[i1].c(this, i, j, k, l);
2011-02-07 06:56:07 +01:00
}
public boolean isBlockPowered(int i, int j, int k) {
return this.isBlockFacePowered(i, j - 1, k, 0) ? true : (this.isBlockFacePowered(i, j + 1, k, 1) ? true : (this.isBlockFacePowered(i, j, k - 1, 2) ? true : (this.isBlockFacePowered(i, j, k + 1, 3) ? true : (this.isBlockFacePowered(i - 1, j, k, 4) ? true : this.isBlockFacePowered(i + 1, j, k, 5)))));
2011-02-07 06:56:07 +01:00
}
public boolean isBlockFaceIndirectlyPowered(int i, int j, int k, int l) {
2012-11-06 13:05:28 +01:00
if (this.t(i, j, k)) {
return this.isBlockPowered(i, j, k);
2011-02-07 06:56:07 +01:00
} else {
int i1 = this.getTypeId(i, j, k);
return i1 == 0 ? false : Block.byId[i1].b(this, i, j, k, l);
2011-02-07 06:56:07 +01:00
}
}
public boolean isBlockIndirectlyPowered(int i, int j, int k) {
return this.isBlockFaceIndirectlyPowered(i, j - 1, k, 0) ? true : (this.isBlockFaceIndirectlyPowered(i, j + 1, k, 1) ? true : (this.isBlockFaceIndirectlyPowered(i, j, k - 1, 2) ? true : (this.isBlockFaceIndirectlyPowered(i, j, k + 1, 3) ? true : (this.isBlockFaceIndirectlyPowered(i - 1, j, k, 4) ? true : this.isBlockFaceIndirectlyPowered(i + 1, j, k, 5)))));
2011-02-07 06:56:07 +01:00
}
public EntityHuman findNearbyPlayer(Entity entity, double d0) {
return this.findNearbyPlayer(entity.locX, entity.locY, entity.locZ, d0);
2011-02-07 06:56:07 +01:00
}
public EntityHuman findNearbyPlayer(double d0, double d1, double d2, double d3) {
2011-02-07 06:56:07 +01:00
double d4 = -1.0D;
EntityHuman entityhuman = null;
for (int i = 0; i < this.players.size(); ++i) {
EntityHuman entityhuman1 = (EntityHuman) this.players.get(i);
// CraftBukkit start - fixed an NPE
if (entityhuman1 == null || entityhuman1.dead) {
continue;
}
// CraftBukkit end
2011-07-08 14:25:53 +02:00
double d5 = entityhuman1.e(d0, d1, d2);
2011-02-07 06:56:07 +01:00
if ((d3 < 0.0D || d5 < d3 * d3) && (d4 == -1.0D || d5 < d4)) {
d4 = d5;
entityhuman = entityhuman1;
}
}
return entityhuman;
}
public EntityHuman findNearbyVulnerablePlayer(Entity entity, double d0) {
return this.findNearbyVulnerablePlayer(entity.locX, entity.locY, entity.locZ, d0);
2011-11-20 09:01:14 +01:00
}
public EntityHuman findNearbyVulnerablePlayer(double d0, double d1, double d2, double d3) {
2011-11-20 09:01:14 +01:00
double d4 = -1.0D;
EntityHuman entityhuman = null;
for (int i = 0; i < this.players.size(); ++i) {
EntityHuman entityhuman1 = (EntityHuman) this.players.get(i);
2012-07-29 09:33:13 +02:00
// CraftBukkit start - fixed an NPE
if (entityhuman1 == null || entityhuman1.dead) {
continue;
}
// CraftBukkit end
2012-12-20 05:03:52 +01:00
if (!entityhuman1.abilities.isInvulnerable && entityhuman1.isAlive()) {
2011-11-20 09:01:14 +01:00
double d5 = entityhuman1.e(d0, d1, d2);
double d6 = d3;
2011-11-20 09:01:14 +01:00
if (entityhuman1.isSneaking()) {
d6 = d3 * 0.800000011920929D;
}
if (entityhuman1.isInvisible()) {
2012-12-20 05:03:52 +01:00
float f = entityhuman1.bR();
if (f < 0.1F) {
f = 0.1F;
}
d6 *= (double) (0.7F * f);
}
if ((d3 < 0.0D || d5 < d6 * d6) && (d4 == -1.0D || d5 < d4)) {
2011-11-20 09:01:14 +01:00
d4 = d5;
entityhuman = entityhuman1;
}
}
}
return entityhuman;
}
2011-03-31 22:40:00 +02:00
public EntityHuman a(String s) {
for (int i = 0; i < this.players.size(); ++i) {
if (s.equals(((EntityHuman) this.players.get(i)).name)) {
return (EntityHuman) this.players.get(i);
2011-03-31 22:40:00 +02:00
}
}
return null;
}
2012-11-06 13:05:28 +01:00
public void D() throws ExceptionWorldConflict { // CraftBukkit - added throws
this.dataManager.checkSession();
2011-02-23 03:37:56 +01:00
}
2011-02-07 06:56:07 +01:00
public long getSeed() {
return this.worldData.getSeed();
2011-02-23 03:37:56 +01:00
}
public long getTime() {
return this.worldData.getTime();
2011-02-23 03:37:56 +01:00
}
2012-11-06 13:05:28 +01:00
public long getDayTime() {
return this.worldData.getDayTime();
}
2012-11-06 13:05:28 +01:00
public void setDayTime(long i) {
this.worldData.setDayTime(i);
}
public ChunkCoordinates getSpawn() {
return new ChunkCoordinates(this.worldData.c(), this.worldData.d(), this.worldData.e());
2011-02-07 06:56:07 +01:00
}
public boolean a(EntityHuman entityhuman, int i, int j, int k) {
return true;
}
2012-02-29 22:31:04 +01:00
public void broadcastEntityEffect(Entity entity, byte b0) {}
2011-02-07 06:56:07 +01:00
2012-11-06 13:05:28 +01:00
public IChunkProvider I() {
return this.chunkProvider;
2011-03-31 22:40:00 +02:00
}
2012-07-29 09:33:13 +02:00
public void playNote(int i, int j, int k, int l, int i1, int j1) {
if (l > 0) {
Block.byId[l].b(this, i, j, k, i1, j1);
2011-02-07 06:56:07 +01:00
}
}
2011-02-23 03:37:56 +01:00
public IDataManager getDataManager() {
return this.dataManager;
2011-02-23 03:37:56 +01:00
}
public WorldData getWorldData() {
return this.worldData;
2011-02-23 03:37:56 +01:00
}
public GameRules getGameRules() {
return this.worldData.getGameRules();
}
2012-07-29 09:33:13 +02:00
public void everyoneSleeping() {}
2011-02-23 03:37:56 +01:00
// CraftBukkit start
// Calls the method that checks to see if players are sleeping
// Called by CraftPlayer.setPermanentSleeping()
public void checkSleepStatus() {
if (!this.isStatic) {
this.everyoneSleeping();
}
}
// CraftBukkit end
2012-07-29 09:33:13 +02:00
public float i(float f) {
return (this.o + (this.p - this.o) * f) * this.j(f);
2011-04-20 22:47:26 +02:00
}
2012-07-29 09:33:13 +02:00
public float j(float f) {
return this.m + (this.n - this.m) * f;
2011-04-20 22:47:26 +02:00
}
2012-11-06 13:05:28 +01:00
public boolean M() {
2012-07-29 09:33:13 +02:00
return (double) this.i(1.0F) > 0.9D;
2011-04-20 22:47:26 +02:00
}
2012-11-06 13:05:28 +01:00
public boolean N() {
2012-07-29 09:33:13 +02:00
return (double) this.j(1.0F) > 0.2D;
2011-04-20 22:47:26 +02:00
}
2012-11-06 13:05:28 +01:00
public boolean D(int i, int j, int k) {
if (!this.N()) {
2011-04-20 22:47:26 +02:00
return false;
2012-11-06 13:05:28 +01:00
} else if (!this.k(i, j, k)) {
2011-04-20 22:47:26 +02:00
return false;
} else if (this.h(i, k) > j) {
2011-04-20 22:47:26 +02:00
return false;
} else {
2012-03-01 11:49:23 +01:00
BiomeBase biomebase = this.getBiome(i, k);
2011-04-20 22:47:26 +02:00
return biomebase.c() ? false : biomebase.d();
2011-04-20 22:47:26 +02:00
}
}
2011-05-26 14:48:22 +02:00
2012-11-06 13:05:28 +01:00
public boolean E(int i, int j, int k) {
2012-03-01 11:49:23 +01:00
BiomeBase biomebase = this.getBiome(i, k);
return biomebase.e();
2012-03-01 11:49:23 +01:00
}
2011-05-26 14:48:22 +02:00
public void a(String s, WorldMapBase worldmapbase) {
this.worldMaps.a(s, worldmapbase);
2011-05-26 14:48:22 +02:00
}
public WorldMapBase a(Class oclass, String s) {
2012-01-12 16:27:39 +01:00
return this.worldMaps.get(oclass, s);
2011-05-26 14:48:22 +02:00
}
public int b(String s) {
return this.worldMaps.a(s);
2011-05-26 14:48:22 +02:00
}
public void e(int i, int j, int k, int l, int i1) {
2012-12-20 05:03:52 +01:00
for (int j1 = 0; j1 < this.v.size(); ++j1) {
((IWorldAccess) this.v.get(j1)).a(i, j, k, l, i1);
}
}
2012-02-29 22:31:04 +01:00
public void triggerEffect(int i, int j, int k, int l, int i1) {
2011-05-26 14:48:22 +02:00
this.a((EntityHuman) null, i, j, k, l, i1);
}
public void a(EntityHuman entityhuman, int i, int j, int k, int l, int i1) {
2012-12-20 05:03:52 +01:00
try {
for (int j1 = 0; j1 < this.v.size(); ++j1) {
((IWorldAccess) this.v.get(j1)).a(entityhuman, i, j, k, l, i1);
}
} catch (Throwable throwable) {
CrashReport crashreport = CrashReport.a(throwable, "Playing level event");
CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Level event being played");
crashreportsystemdetails.a("Block coordinates", CrashReportSystemDetails.a(j, k, l));
crashreportsystemdetails.a("Event source", entityhuman);
crashreportsystemdetails.a("Event type", Integer.valueOf(i));
crashreportsystemdetails.a("Event data", Integer.valueOf(i1));
throw new ReportedException(crashreport);
2011-05-26 14:48:22 +02:00
}
}
2011-07-13 06:06:07 +02:00
2012-03-01 11:49:23 +01:00
public int getHeight() {
return 256;
}
2012-11-06 13:05:28 +01:00
public int P() {
return this.worldProvider.f ? 128 : 256;
}
public IUpdatePlayerListBox a(EntityMinecart entityminecart) {
return null;
2012-07-29 09:33:13 +02:00
}
2012-11-06 13:05:28 +01:00
public Random F(int i, int j, int k) {
long l = (long) i * 341873128712L + (long) j * 132897987541L + this.getWorldData().getSeed() + (long) k;
2011-09-15 02:23:52 +02:00
this.random.setSeed(l);
return this.random;
}
2012-07-29 09:33:13 +02:00
public ChunkPosition b(String s, int i, int j, int k) {
2012-11-06 13:05:28 +01:00
return this.I().findNearestMapFeature(this, s, i, j, k);
2011-11-20 09:01:14 +01:00
}
2012-11-06 13:05:28 +01:00
public CrashReportSystemDetails a(CrashReport crashreport) {
CrashReportSystemDetails crashreportsystemdetails = crashreport.a("Affected level", 1);
crashreportsystemdetails.a("Level name", (this.worldData == null ? "????" : this.worldData.getName()));
crashreportsystemdetails.a("All players", (Callable) (new CrashReportPlayers(this)));
crashreportsystemdetails.a("Chunk stats", (Callable) (new CrashReportChunkStats(this)));
try {
this.worldData.a(crashreportsystemdetails);
} catch (Throwable throwable) {
crashreportsystemdetails.a("Level Data Unobtainable", throwable);
}
return crashreportsystemdetails;
2011-11-20 09:01:14 +01:00
}
public void g(int i, int j, int k, int l, int i1) {
2012-12-20 05:03:52 +01:00
for (int j1 = 0; j1 < this.v.size(); ++j1) {
IWorldAccess iworldaccess = (IWorldAccess) this.v.get(j1);
2012-07-29 09:33:13 +02:00
iworldaccess.b(i, j, k, l, i1);
2012-07-29 09:33:13 +02:00
}
2011-07-13 06:06:07 +02:00
}
public Vec3DPool getVec3DPool() {
2012-12-20 05:03:52 +01:00
return this.J;
}
2012-11-06 13:05:28 +01:00
public Calendar T() {
if (this.getTime() % 600L == 0L) {
2012-12-20 05:03:52 +01:00
this.K.setTimeInMillis(System.currentTimeMillis());
2012-11-06 13:05:28 +01:00
}
2012-12-20 05:03:52 +01:00
return this.K;
}
2011-02-07 06:56:07 +01:00
}