summaryrefslogtreecommitdiffstats
path: root/src/main/java/net/minecraft/server/Entity.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/net/minecraft/server/Entity.java')
-rw-r--r--src/main/java/net/minecraft/server/Entity.java870
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;
+ }
+
+}
+