Direct fire exposure event

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;
+    }
+
+}
+