diff options
Diffstat (limited to 'src/main/java/net/minecraft/server/Entity.java')
| -rw-r--r-- | src/main/java/net/minecraft/server/Entity.java | 870 |
1 files changed, 870 insertions, 0 deletions
diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java new file mode 100644 index 00000000..69d854f4 --- /dev/null +++ b/src/main/java/net/minecraft/server/Entity.java @@ -0,0 +1,870 @@ +package net.minecraft.server; + + +import org.bukkit.craftbukkit.CraftEntity; +import org.bukkit.craftbukkit.CraftLivingEntity; +import org.bukkit.craftbukkit.CraftPlayer; +import org.bukkit.craftbukkit.CraftServer; +import org.bukkit.event.entity.EntityDamagedEvent; + +import java.util.List; +import java.util.Random; + + +public abstract class Entity { + + private static int a = 0; + public int g; + public double h; + public boolean i; + public Entity j; + public Entity k; + public World l; + public double m; + public double n; + public double o; + public double p; + public double q; + public double r; + public double s; + public double t; + public double u; + public float v; + public float w; + public float x; + public float y; + public final AxisAlignedBB z = AxisAlignedBB.a(0.0D, 0.0D, 0.0D, 0.0D, 0.0D, 0.0D); + public boolean A; + public boolean B; + public boolean C; + public boolean D; + public boolean E; + public boolean F; + public boolean G; + public float H; + public float I; + public float J; + public float K; + public float L; + protected boolean M; + protected float N; + private int b; + public double O; + public double P; + public double Q; + public float R; + public float S; + public boolean T; + public float U; + public boolean V; + protected Random W; + public int X; + public int Y; + public int Z; + protected int aa; + protected boolean ab; + public int ac; + public int ad; + private boolean c; + protected boolean ae; + private double d; + private double e; + public boolean af; + public int ag; + public int ah; + public int ai; + + public Entity(World world) { + g = a++; + h = 1.0D; + i = false; + A = false; + D = false; + E = false; + F = true; + G = false; + H = 0.0F; + I = 0.6F; + J = 1.8F; + K = 0.0F; + L = 0.0F; + M = true; + N = 0.0F; + b = 1; + R = 0.0F; + S = 0.0F; + T = false; + U = 0.0F; + V = false; + W = new Random(); + X = 0; + Y = 1; + Z = 0; + aa = 300; + ab = false; + ac = 0; + ad = 300; + c = true; + ae = false; + af = false; + l = world; + a(0.0D, 0.0D, 0.0D); + } + + public boolean equals(Object obj) { + if (obj instanceof Entity) { + return ((Entity) obj).g == g; + } else { + return false; + } + } + + public int hashCode() { + return g; + } + + public void l() { + G = true; + } + + protected void a(float f1, float f2) { + I = f1; + J = f2; + } + + protected void b(float f1, float f2) { + v = f1; + w = f2; + } + + public void a(double d1, double d2, double d3) { + p = d1; + q = d2; + r = d3; + float f1 = I / 2.0F; + float f2 = J; + + z.c(d1 - (double) f1, (d2 - (double) H) + (double) R, d3 - (double) f1, d1 + (double) f1, (d2 - (double) H) + (double) R + (double) f2, d3 + (double) f1); + } + + public void b_() { + m(); + } + + public void m() { + if (k != null && k.G) { + k = null; + } + X++; + K = L; + m = p; + n = q; + o = r; + y = w; + x = v; + if (r()) { + if (!ab && !c) { + float f1 = MathHelper.a(s * s * 0.20000000298023224D + t * t + u * u * 0.20000000298023224D) * 0.2F; + + if (f1 > 1.0F) { + f1 = 1.0F; + } + l.a(this, "random.splash", f1, 1.0F + (W.nextFloat() - W.nextFloat()) * 0.4F); + float f2 = MathHelper.b(z.b); + + for (int i1 = 0; (float) i1 < 1.0F + I * 20F; i1++) { + float f3 = (W.nextFloat() * 2.0F - 1.0F) * I; + float f5 = (W.nextFloat() * 2.0F - 1.0F) * I; + + l.a("bubble", p + (double) f3, f2 + 1.0F, r + (double) f5, s, t - (double) (W.nextFloat() * 0.2F), u); + } + + for (int j1 = 0; (float) j1 < 1.0F + I * 20F; j1++) { + float f4 = (W.nextFloat() * 2.0F - 1.0F) * I; + float f6 = (W.nextFloat() * 2.0F - 1.0F) * I; + + l.a("splash", p + (double) f4, f2 + 1.0F, r + (double) f6, s, t, u); + } + + } + N = 0.0F; + ab = true; + Z = 0; + } else { + ab = false; + } + if (l.z) { + Z = 0; + } else if (Z > 0) { + if (ae) { + Z -= 4; + if (Z < 0) { + Z = 0; + } + } else { + if (Z % 20 == 0) { + a(((Entity) (null)), 1); + } + Z--; + } + } + if (t()) { + n(); + } + if (q < -64D) { + o(); + } + c = false; + } + + protected void n() { + if (!ae) { + a(((Entity) (null)), 4); + Z = 600; + } + } + + protected void o() { + l(); + } + + public boolean b(double d1, double d2, double d3) { + AxisAlignedBB axisalignedbb = z.c(d1, d2, d3); + List list = l.a(this, axisalignedbb); + + if (list.size() > 0) { + return false; + } + return !l.b(axisalignedbb); + } + + public void c(double d1, double d2, double d3) { + if (T) { + z.d(d1, d2, d3); + p = (z.a + z.d) / 2D; + q = (z.b + (double) H) - (double) R; + r = (z.c + z.f) / 2D; + return; + } + double d4 = p; + double d5 = r; + double d6 = d1; + double d7 = d2; + double d8 = d3; + AxisAlignedBB axisalignedbb = z.b(); + boolean flag = A && p(); + + if (flag) { + double d9 = 0.050000000000000003D; + + for (; d1 != 0.0D && l.a(this, z.c(d1, -1D, 0.0D)).size() == 0; d6 = d1) { + if (d1 < d9 && d1 >= -d9) { + d1 = 0.0D; + continue; + } + if (d1 > 0.0D) { + d1 -= d9; + } else { + d1 += d9; + } + } + + for (; d3 != 0.0D && l.a(this, z.c(0.0D, -1D, d3)).size() == 0; d8 = d3) { + if (d3 < d9 && d3 >= -d9) { + d3 = 0.0D; + continue; + } + if (d3 > 0.0D) { + d3 -= d9; + } else { + d3 += d9; + } + } + + } + List list = l.a(this, z.a(d1, d2, d3)); + + for (int i1 = 0; i1 < list.size(); i1++) { + d2 = ((AxisAlignedBB) list.get(i1)).b(z, d2); + } + + z.d(0.0D, d2, 0.0D); + if (!F && d7 != d2) { + d1 = d2 = d3 = 0.0D; + } + boolean flag1 = A || d7 != d2 && d7 < 0.0D; + + for (int j1 = 0; j1 < list.size(); j1++) { + d1 = ((AxisAlignedBB) list.get(j1)).a(z, d1); + } + + z.d(d1, 0.0D, 0.0D); + if (!F && d6 != d1) { + d1 = d2 = d3 = 0.0D; + } + for (int k1 = 0; k1 < list.size(); k1++) { + d3 = ((AxisAlignedBB) list.get(k1)).c(z, d3); + } + + z.d(0.0D, 0.0D, d3); + if (!F && d8 != d3) { + d1 = d2 = d3 = 0.0D; + } + if (S > 0.0F && flag1 && R < 0.05F && (d6 != d1 || d8 != d3)) { + double d10 = d1; + double d12 = d2; + double d14 = d3; + + d1 = d6; + d2 = S; + d3 = d8; + AxisAlignedBB axisalignedbb1 = z.b(); + + z.b(axisalignedbb); + List list1 = l.a(this, z.a(d1, d2, d3)); + + for (int j2 = 0; j2 < list1.size(); j2++) { + d2 = ((AxisAlignedBB) list1.get(j2)).b(z, d2); + } + + z.d(0.0D, d2, 0.0D); + if (!F && d7 != d2) { + d1 = d2 = d3 = 0.0D; + } + for (int k2 = 0; k2 < list1.size(); k2++) { + d1 = ((AxisAlignedBB) list1.get(k2)).a(z, d1); + } + + z.d(d1, 0.0D, 0.0D); + if (!F && d6 != d1) { + d1 = d2 = d3 = 0.0D; + } + for (int l2 = 0; l2 < list1.size(); l2++) { + d3 = ((AxisAlignedBB) list1.get(l2)).c(z, d3); + } + + z.d(0.0D, 0.0D, d3); + if (!F && d8 != d3) { + d1 = d2 = d3 = 0.0D; + } + if (d10 * d10 + d14 * d14 >= d1 * d1 + d3 * d3) { + d1 = d10; + d2 = d12; + d3 = d14; + z.b(axisalignedbb1); + } else { + R += 0.5D; + } + } + p = (z.a + z.d) / 2D; + q = (z.b + (double) H) - (double) R; + r = (z.c + z.f) / 2D; + B = d6 != d1 || d8 != d3; + C = d7 != d2; + A = d7 != d2 && d7 < 0.0D; + D = B || C; + a(d2, A); + if (d6 != d1) { + s = 0.0D; + } + if (d7 != d2) { + t = 0.0D; + } + if (d8 != d3) { + u = 0.0D; + } + double d11 = p - d4; + double d13 = r - d5; + + if (M && !flag) { + L += (double) MathHelper.a(d11 * d11 + d13 * d13) * 0.59999999999999998D; + int k3 = MathHelper.b(p); + int i4 = MathHelper.b(q - 0.20000000298023224D - (double) H); + int l1 = MathHelper.b(r); + int i3 = l.a(k3, i4, l1); + + if (L > (float) b && i3 > 0) { + b++; + StepSound stepsound = Block.m[i3].bq; + + if (l.a(k3, i4 + 1, l1) == Block.aS.bh) { + stepsound = Block.aS.bq; + l.a(this, stepsound.c(), stepsound.a() * 0.15F, stepsound.b()); + } else if (!Block.m[i3].bs.d()) { + l.a(this, stepsound.c(), stepsound.a() * 0.15F, stepsound.b()); + } + Block.m[i3].b(l, k3, i4, l1, this); + } + } + int l3 = MathHelper.b(z.a); + int j4 = MathHelper.b(z.b); + int i2 = MathHelper.b(z.c); + int j3 = MathHelper.b(z.d); + int k4 = MathHelper.b(z.e); + int l4 = MathHelper.b(z.f); + + for (int i5 = l3; i5 <= j3; i5++) { + for (int j5 = j4; j5 <= k4; j5++) { + for (int k5 = i2; k5 <= l4; k5++) { + int l5 = l.a(i5, j5, k5); + + if (l5 > 0) { + Block.m[l5].a(l, i5, j5, k5, this); + } + } + + } + + } + + R *= 0.4F; + boolean flag2 = r(); + + if (l.c(z)) { + b(1); + if (!flag2) { + Z++; + if (Z == 0) { + Z = 300; + } + } + } else if (Z <= 0) { + Z = -Y; + } + if (flag2 && Z > 0) { + l.a(this, "random.fizz", 0.7F, 1.6F + (W.nextFloat() - W.nextFloat()) * 0.4F); + Z = -Y; + } + } + + protected void a(double d1, boolean flag) { + if (flag) { + if (N > 0.0F) { + a(N); + N = 0.0F; + } + } else if (d1 < 0.0D) { + N -= d1; + } + } + + public boolean p() { + return false; + } + + public AxisAlignedBB q() { + return null; + } + + protected void b(int i1) { + if (!ae) { + if(this instanceof EntityLiving) + { + CraftEntity defender = null; + CraftServer server = ((WorldServer)l).getServer(); + if(this instanceof EntityPlayerMP) + { + defender = new CraftPlayer(server, (EntityPlayerMP)this); + } else { + defender = new CraftLivingEntity(server, (EntityLiving)this); + } + EntityDamagedEvent ede = new EntityDamagedEvent(defender, EntityDamagedEvent.DamageCause.FIRE, i1); + server.getPluginManager().callEvent(ede); + if(ede.isCancelled()) return; + } + a(((Entity) (null)), i1); + } + } + + protected void a(float f1) {} + + public boolean r() { + return l.a(z.b(0.0D, -0.40000000596046448D, 0.0D), Material.f, this); + } + + public boolean a(Material material) { + double d1 = q + (double) s(); + int i1 = MathHelper.b(p); + int j1 = MathHelper.d(MathHelper.b(d1)); + int k1 = MathHelper.b(r); + int l1 = l.a(i1, j1, k1); + + if (l1 != 0 && Block.m[l1].bs == material) { + float f1 = BlockFluids.b(l.b(i1, j1, k1)) - 0.1111111F; + float f2 = (float) (j1 + 1) - f1; + + return d1 < (double) f2; + } else { + return false; + } + } + + public float s() { + return 0.0F; + } + + public boolean t() { + return l.a(z.b(0.0D, -0.40000000596046448D, 0.0D), Material.g); + } + + public void a(float f1, float f2, float f3) { + float f4 = MathHelper.c(f1 * f1 + f2 * f2); + + if (f4 < 0.01F) { + return; + } + if (f4 < 1.0F) { + f4 = 1.0F; + } + f4 = f3 / f4; + f1 *= f4; + f2 *= f4; + float f5 = MathHelper.a((v * 3.141593F) / 180F); + float f6 = MathHelper.b((v * 3.141593F) / 180F); + + s += f1 * f6 - f2 * f5; + u += f2 * f6 + f1 * f5; + } + + public float b(float f1) { + int i1 = MathHelper.b(p); + double d1 = (z.e - z.b) * 0.66000000000000003D; + int j1 = MathHelper.b((q - (double) H) + d1); + int k1 = MathHelper.b(r); + + return l.k(i1, j1, k1); + } + + public void b(double d1, double d2, double d3, float f1, + float f2) { + m = p = d1; + n = q = d2; + o = r = d3; + x = v = f1; + y = w = f2; + R = 0.0F; + double d4 = x - f1; + + if (d4 < -180D) { + x += 360F; + } + if (d4 >= 180D) { + x -= 360F; + } + a(p, q, r); + b(f1, f2); + } + + public void c(double d1, double d2, double d3, float f1, + float f2) { + m = p = d1; + n = q = d2 + (double) H; + o = r = d3; + v = f1; + w = f2; + a(p, q, r); + } + + public float a(Entity entity) { + float f1 = (float) (p - entity.p); + float f2 = (float) (q - entity.q); + float f3 = (float) (r - entity.r); + + return MathHelper.c(f1 * f1 + f2 * f2 + f3 * f3); + } + + public double d(double d1, double d2, double d3) { + double d4 = p - d1; + double d5 = q - d2; + double d6 = r - d3; + + return d4 * d4 + d5 * d5 + d6 * d6; + } + + public double e(double d1, double d2, double d3) { + double d4 = p - d1; + double d5 = q - d2; + double d6 = r - d3; + + return (double) MathHelper.a(d4 * d4 + d5 * d5 + d6 * d6); + } + + public double b(Entity entity) { + double d1 = p - entity.p; + double d2 = q - entity.q; + double d3 = r - entity.r; + + return d1 * d1 + d2 * d2 + d3 * d3; + } + + public void b(EntityPlayer entityplayer) {} + + public void c(Entity entity) { + if (entity.j == this || entity.k == this) { + return; + } + double d1 = entity.p - p; + double d2 = entity.r - r; + double d3 = MathHelper.a(d1, d2); + + if (d3 >= 0.0099999997764825821D) { + d3 = MathHelper.a(d3); + d1 /= d3; + d2 /= d3; + double d4 = 1.0D / d3; + + if (d4 > 1.0D) { + d4 = 1.0D; + } + d1 *= d4; + d2 *= d4; + d1 *= 0.05000000074505806D; + d2 *= 0.05000000074505806D; + d1 *= 1.0F - U; + d2 *= 1.0F - U; + f(-d1, 0.0D, -d2); + entity.f(d1, 0.0D, d2); + } + } + + public void f(double d1, double d2, double d3) { + s += d1; + t += d2; + u += d3; + } + + protected void u() { + E = true; + } + + public boolean a(Entity entity, int i1) { + u(); + return false; + } + + public boolean c_() { + return false; + } + + public boolean v() { + return false; + } + + public void b(Entity entity, int i1) {} + + public boolean c(NBTTagCompound nbttagcompound) { + String s1 = w(); + + if (G || s1 == null) { + return false; + } else { + nbttagcompound.a("id", s1); + d(nbttagcompound); + return true; + } + } + + public void d(NBTTagCompound nbttagcompound) { + nbttagcompound.a("Pos", a(new double[] { + p, q, r + })); + nbttagcompound.a("Motion", a(new double[] { + s, t, u + })); + nbttagcompound.a("Rotation", a(new float[] { + v, w + })); + nbttagcompound.a("FallDistance", N); + nbttagcompound.a("Fire", (short) Z); + nbttagcompound.a("Air", (short) ad); + nbttagcompound.a("OnGround", A); + a(nbttagcompound); + } + + public void e(NBTTagCompound nbttagcompound) { + NBTTagList nbttaglist = nbttagcompound.k("Pos"); + NBTTagList nbttaglist1 = nbttagcompound.k("Motion"); + NBTTagList nbttaglist2 = nbttagcompound.k("Rotation"); + + a(0.0D, 0.0D, 0.0D); + s = ((NBTTagDouble) nbttaglist1.a(0)).a; + t = ((NBTTagDouble) nbttaglist1.a(1)).a; + u = ((NBTTagDouble) nbttaglist1.a(2)).a; + m = O = p = ((NBTTagDouble) nbttaglist.a(0)).a; + n = P = q = ((NBTTagDouble) nbttaglist.a(1)).a; + o = Q = r = ((NBTTagDouble) nbttaglist.a(2)).a; + x = v = ((NBTTagFloat) nbttaglist2.a(0)).a; + y = w = ((NBTTagFloat) nbttaglist2.a(1)).a; + N = nbttagcompound.f("FallDistance"); + Z = nbttagcompound.c("Fire"); + ad = nbttagcompound.c("Air"); + A = nbttagcompound.l("OnGround"); + a(p, q, r); + b(nbttagcompound); + } + + protected final String w() { + return EntityList.b(this); + } + + protected abstract void b(NBTTagCompound nbttagcompound); + + protected abstract void a(NBTTagCompound nbttagcompound); + + protected NBTTagList a(double ad1[]) { + NBTTagList nbttaglist = new NBTTagList(); + double ad2[] = ad1; + int i1 = ad2.length; + + for (int j1 = 0; j1 < i1; j1++) { + double d1 = ad2[j1]; + + nbttaglist.a(new NBTTagDouble(d1)); + } + + return nbttaglist; + } + + protected NBTTagList a(float af1[]) { + NBTTagList nbttaglist = new NBTTagList(); + float af2[] = af1; + int i1 = af2.length; + + for (int j1 = 0; j1 < i1; j1++) { + float f1 = af2[j1]; + + nbttaglist.a(new NBTTagFloat(f1)); + } + + return nbttaglist; + } + + public EntityItem b(int i1, int j1) { + return a(i1, j1, 0.0F); + } + + public EntityItem a(int i1, int j1, float f1) { + EntityItem entityitem = new EntityItem(l, p, q + (double) f1, r, new ItemStack(i1, j1)); + + entityitem.c = 10; + l.a(entityitem); + return entityitem; + } + + public boolean x() { + return !G; + } + + public boolean y() { + int i1 = MathHelper.b(p); + int j1 = MathHelper.b(q + (double) s()); + int k1 = MathHelper.b(r); + + return l.d(i1, j1, k1); + } + + public boolean a(EntityPlayer entityplayer) { + return false; + } + + public AxisAlignedBB d(Entity entity) { + return null; + } + + public void z() { + if (k.G) { + k = null; + return; + } + s = 0.0D; + t = 0.0D; + u = 0.0D; + b_(); + k.A(); + e += k.v - k.x; + d += k.w - k.y; + for (; e >= 180D; e -= 360D) { + ; + } + for (; e < -180D; e += 360D) { + ; + } + for (; d >= 180D; d -= 360D) { + ; + } + for (; d < -180D; d += 360D) { + ; + } + double d1 = e * 0.5D; + double d2 = d * 0.5D; + float f1 = 10F; + + if (d1 > (double) f1) { + d1 = f1; + } + if (d1 < (double) (-f1)) { + d1 = -f1; + } + if (d2 > (double) f1) { + d2 = f1; + } + if (d2 < (double) (-f1)) { + d2 = -f1; + } + e -= d1; + d -= d2; + v += d1; + w += d2; + } + + public void A() { + j.a(p, q + j() + j.B(), r); + } + + public double B() { + return (double) H; + } + + public double j() { + return (double) J * 0.75D; + } + + public void e(Entity entity) { + d = 0.0D; + e = 0.0D; + if (entity == null) { + if (k != null) { + c(k.p, k.z.b + (double) k.J, k.r, v, w); + k.j = null; + } + k = null; + return; + } + if (k == entity) { + k.j = null; + k = null; + c(entity.p, entity.z.b + (double) entity.J, entity.r, v, w); + return; + } + if (k != null) { + k.j = null; + } + if (entity.j != null) { + entity.j.k = null; + } + k = entity; + entity.j = this; + } + + public Vec3D C() { + return null; + } + + public void D() {} + + public int[] E() { + return null; + } + +} + |