Adding all Entities into CraftBukkit.

These are needed to properly allow for determining class type, in
accordance with current practice.

1 files changed, 723 insertions, 0 deletions

diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java
new file mode 100644
index 00000000..76cc6b5c
--- /dev/null
+++ b/src/main/java/net/minecraft/server/EntityLiving.java
@@ -0,0 +1,723 @@
+package net.minecraft.server;
+
+import java.util.List;
+import java.util.Random;
+
+public abstract class EntityLiving extends Entity {
+
+    public int aF;
+    public float aG;
+    public float aH;
+    public float aI;
+    public float aJ;
+    protected float aK;
+    protected float aL;
+    protected float aM;
+    protected float aN;
+    protected boolean aO;
+    protected String aP;
+    protected boolean aQ;
+    protected float aR;
+    protected String aS;
+    protected float aT;
+    protected int aU;
+    protected float aV;
+    public boolean aW;
+    public float aX;
+    public float aY;
+    public int aZ;
+    public int ba;
+    private int a;
+    public int bb;
+    public int bc;
+    public float bd;
+    public int be;
+    public int bf;
+    public float bg;
+    public float bh;
+    protected boolean bi;
+    public int bj;
+    public float bk;
+    public float bl;
+    public float bm;
+    public float bn;
+    protected int bo;
+    protected double bp;
+    protected double bq;
+    protected double br;
+    protected double bs;
+    protected double bt;
+    float bu;
+    protected int bv;
+    protected int bw;
+    protected float bx;
+    protected float by;
+    protected float bz;
+    protected boolean bA;
+    protected float bB;
+    protected float bC;
+    private Entity b;
+    private int c;
+
+    public EntityLiving(World world) {
+        super(world);
+        aF = 20;
+        aI = 0.0F;
+        aJ = 0.0F;
+        aO = true;
+        aP = "/mob/char.png";
+        aQ = true;
+        aR = 0.0F;
+        aS = null;
+        aT = 1.0F;
+        aU = 0;
+        aV = 0.0F;
+        aW = false;
+        bd = 0.0F;
+        be = 0;
+        bf = 0;
+        bi = false;
+        bj = -1;
+        bk = (float) (Math.random() * 0.89999997615814209D + 0.10000000149011612D);
+        bu = 0.0F;
+        bv = 0;
+        bw = 0;
+        bA = false;
+        bB = 0.0F;
+        bC = 0.7F;
+        c = 0;
+        aZ = 10;
+        i = true;
+        aH = (float) (Math.random() + 1.0D) * 0.01F;
+        a(p, q, r);
+        aG = (float) Math.random() * 12398F;
+        v = (float) (Math.random() * 3.1415927410125732D * 2D);
+        S = 0.5F;
+    }
+
+    protected void a() {}
+
+    public boolean i(Entity entity) {
+        return l.a(Vec3D.b(p, q + (double) w(), r), Vec3D.b(entity.p, entity.q + (double) entity.w(), entity.r)) == null;
+    }
+
+    public boolean c_() {
+        return !G;
+    }
+
+    public boolean z() {
+        return !G;
+    }
+
+    public float w() {
+        return J * 0.85F;
+    }
+
+    public int c() {
+        return 80;
+    }
+
+    public void r() {
+        aX = aY;
+        super.r();
+        if (W.nextInt(1000) < a++) {
+            a = -c();
+            String s = e();
+
+            if (s != null) {
+                this.l.a(((Entity) (this)), s, i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
+            }
+        }
+        if (B() && C()) {
+            a(((Entity) (null)), 1);
+        }
+        if (ae || this.l.z) {
+            Z = 0;
+        }
+        if (B() && a(Material.f) && !d_()) {
+            ad--;
+            if (ad == -20) {
+                ad = 0;
+                for (int k = 0; k < 8; k++) {
+                    float f1 = W.nextFloat() - W.nextFloat();
+                    float f2 = W.nextFloat() - W.nextFloat();
+                    float f3 = W.nextFloat() - W.nextFloat();
+
+                    this.l.a("bubble", p + (double) f1, q + (double) f2, r + (double) f3, this.s, t, u);
+                }
+
+                a(((Entity) (null)), 2);
+            }
+            Z = 0;
+        } else {
+            ad = aa;
+        }
+        bg = bh;
+        if (bf > 0) {
+            bf--;
+        }
+        if (bb > 0) {
+            bb--;
+        }
+        if (ac > 0) {
+            ac--;
+        }
+        if (aZ <= 0) {
+            be++;
+            if (be > 20) {
+                T();
+                q();
+                for (int l = 0; l < 20; l++) {
+                    double d1 = W.nextGaussian() * 0.02D;
+                    double d2 = W.nextGaussian() * 0.02D;
+                    double d3 = W.nextGaussian() * 0.02D;
+
+                    this.l.a("explode", (p + (double) (W.nextFloat() * I * 2.0F)) - (double) I, q + (double) (W.nextFloat() * J), (r + (double) (W.nextFloat() * I * 2.0F)) - (double) I, d1, d2, d3);
+                }
+            }
+        }
+        aN = aM;
+        aJ = aI;
+        x = v;
+        y = w;
+    }
+
+    public void R() {
+        for (int k = 0; k < 20; k++) {
+            double d1 = W.nextGaussian() * 0.02D;
+            double d2 = W.nextGaussian() * 0.02D;
+            double d3 = W.nextGaussian() * 0.02D;
+            double d4 = 10D;
+
+            l.a("explode", (p + (double) (W.nextFloat() * I * 2.0F)) - (double) I - d1 * d4, (q + (double) (W.nextFloat() * J)) - d2 * d4, (r + (double) (W.nextFloat() * I * 2.0F)) - (double) I - d3 * d4, d1, d2, d3);
+        }
+    }
+
+    public void D() {
+        super.D();
+        aK = aL;
+        aL = 0.0F;
+    }
+
+    public void b_() {
+        super.b_();
+        o();
+        double d1 = p - m;
+        double d2 = r - o;
+        float f1 = MathHelper.a(d1 * d1 + d2 * d2);
+        float f2 = aI;
+        float f3 = 0.0F;
+
+        aK = aL;
+        float f4 = 0.0F;
+
+        if (f1 > 0.05F) {
+            f4 = 1.0F;
+            f3 = f1 * 3F;
+            f2 = ((float) Math.atan2(d2, d1) * 180F) / 3.141593F - 90F;
+        }
+        if (aY > 0.0F) {
+            f2 = v;
+        }
+        if (!A) {
+            f4 = 0.0F;
+        }
+        aL = aL + (f4 - aL) * 0.3F;
+        float f5;
+
+        for (f5 = f2 - aI; f5 < -180F; f5 += 360F) {
+            ;
+        }
+        for (; f5 >= 180F; f5 -= 360F) {
+            ;
+        }
+        aI += f5 * 0.3F;
+        float f6;
+
+        for (f6 = v - aI; f6 < -180F; f6 += 360F) {
+            ;
+        }
+        for (; f6 >= 180F; f6 -= 360F) {
+            ;
+        }
+        boolean flag = f6 < -90F || f6 >= 90F;
+
+        if (f6 < -75F) {
+            f6 = -75F;
+        }
+        if (f6 >= 75F) {
+            f6 = 75F;
+        }
+        aI = v - f6;
+        if (f6 * f6 > 2500F) {
+            aI += f6 * 0.2F;
+        }
+        if (flag) {
+            f3 *= -1F;
+        }
+        for (; v - x < -180F; x -= 360F) {
+            ;
+        }
+        for (; v - x >= 180F; x += 360F) {
+            ;
+        }
+        for (; aI - aJ < -180F; aJ -= 360F) {
+            ;
+        }
+        for (; aI - aJ >= 180F; aJ += 360F) {
+            ;
+        }
+        for (; w - y < -180F; y -= 360F) {
+            ;
+        }
+        for (; w - y >= 180F; y += 360F) {
+            ;
+        }
+        aM += f3;
+    }
+
+    protected void a(float f1, float f2) {
+        super.a(f1, f2);
+    }
+
+    public void d(int k) {
+        if (aZ <= 0) {
+            return;
+        }
+        aZ += k;
+        if (aZ > 20) {
+            aZ = 20;
+        }
+        ac = aF / 2;
+    }
+
+    public boolean a(Entity entity, int k) {
+        if (l.z) {
+            return false;
+        }
+        bw = 0;
+        if (aZ <= 0) {
+            return false;
+        }
+        bm = 1.5F;
+        boolean flag = true;
+
+        if ((float) ac > (float) aF / 2.0F) {
+            if (k <= bv) {
+                return false;
+            }
+            e(k - bv);
+            bv = k;
+            flag = false;
+        } else {
+            bv = k;
+            ba = aZ;
+            ac = aF;
+            e(k);
+            bb = bc = 10;
+        }
+        bd = 0.0F;
+        if (flag) {
+            l.a(((Entity) (this)), (byte) 2);
+            y();
+            if (entity != null) {
+                double d1 = entity.p - p;
+                double d2;
+
+                for (d2 = entity.r - r; d1 * d1 + d2 * d2 < 0.0001D; d2 = (Math.random() - Math.random()) * 0.01D) {
+                    d1 = (Math.random() - Math.random()) * 0.01D;
+                }
+
+                bd = (float) ((Math.atan2(d2, d1) * 180D) / 3.1415927410125732D) - v;
+                a(entity, k, d1, d2);
+            } else {
+                bd = (int) (Math.random() * 2D) * 180;
+            }
+        }
+        if (aZ <= 0) {
+            if (flag) {
+                l.a(((Entity) (this)), g(), i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
+            }
+            f(entity);
+        } else if (flag) {
+            l.a(((Entity) (this)), f(), i(), (W.nextFloat() - W.nextFloat()) * 0.2F + 1.0F);
+        }
+        return true;
+    }
+
+    protected void e(int k) {
+        aZ -= k;
+    }
+
+    protected float i() {
+        return 1.0F;
+    }
+
+    protected String e() {
+        return null;
+    }
+
+    protected String f() {
+        return "random.hurt";
+    }
+
+    protected String g() {
+        return "random.hurt";
+    }
+
+    public void a(Entity entity, int k, double d1, double d2) {
+        float f1 = MathHelper.a(d1 * d1 + d2 * d2);
+        float f2 = 0.4F;
+
+        s /= 2D;
+        t /= 2D;
+        u /= 2D;
+        s -= (d1 / (double) f1) * (double) f2;
+        t += 0.40000000596046448D;
+        u -= (d2 / (double) f1) * (double) f2;
+        if (t > 0.40000000596046448D) {
+            t = 0.40000000596046448D;
+        }
+    }
+
+    public void f(Entity entity) {
+        if (aU > 0 && entity != null) {
+            entity.b(((Entity) (this)), aU);
+        }
+        bi = true;
+        if (!l.z) {
+            g_();
+        }
+        l.a(((Entity) (this)), (byte) 3);
+    }
+
+    protected void g_() {
+        int k = h();
+
+        if (k > 0) {
+            int l = W.nextInt(3);
+
+            for (int i1 = 0; i1 < l; i1++) {
+                a(k, 1);
+            }
+        }
+    }
+
+    protected int h() {
+        return 0;
+    }
+
+    protected void a(float f1) {
+        int k = (int) Math.ceil(f1 - 3F);
+
+        if (k > 0) {
+            a(((Entity) (null)), k);
+            int l = this.l.a(MathHelper.b(p), MathHelper.b(q - 0.20000000298023224D - (double) H), MathHelper.b(r));
+
+            if (l > 0) {
+                StepSound stepsound = Block.m[l].br;
+
+                this.l.a(((Entity) (this)), stepsound.c(), stepsound.a() * 0.5F, stepsound.b() * 0.75F);
+            }
+        }
+    }
+
+    public void c(float f1, float f2) {
+        if (v()) {
+            double d1 = q;
+
+            a(f1, f2, 0.02F);
+            c(s, t, u);
+            s *= 0.80000001192092896D;
+            t *= 0.80000001192092896D;
+            u *= 0.80000001192092896D;
+            t -= 0.02D;
+            if (B && b(s, ((t + 0.60000002384185791D) - q) + d1, u)) {
+                t = 0.30000001192092896D;
+            }
+        } else if (x()) {
+            double d2 = q;
+
+            a(f1, f2, 0.02F);
+            c(s, t, u);
+            s *= 0.5D;
+            t *= 0.5D;
+            u *= 0.5D;
+            t -= 0.02D;
+            if (B && b(s, ((t + 0.60000002384185791D) - q) + d2, u)) {
+                t = 0.30000001192092896D;
+            }
+        } else {
+            float f3 = 0.91F;
+
+            if (A) {
+                f3 = 0.5460001F;
+                int k = this.l.a(MathHelper.b(p), MathHelper.b(z.b) - 1, MathHelper.b(r));
+
+                if (k > 0) {
+                    f3 = Block.m[k].bu * 0.91F;
+                }
+            }
+            float f4 = 0.1627714F / (f3 * f3 * f3);
+
+            a(f1, f2, A ? 0.1F * f4 : 0.02F);
+            f3 = 0.91F;
+            if (A) {
+                f3 = 0.5460001F;
+                int l = this.l.a(MathHelper.b(p), MathHelper.b(z.b) - 1, MathHelper.b(r));
+
+                if (l > 0) {
+                    f3 = Block.m[l].bu * 0.91F;
+                }
+            }
+            if (m()) {
+                N = 0.0F;
+                if (t < -0.14999999999999999D) {
+                    t = -0.14999999999999999D;
+                }
+            }
+            c(s, t, u);
+            if (B && m()) {
+                t = 0.20000000000000001D;
+            }
+            t -= 0.080000000000000002D;
+            t *= 0.98000001907348633D;
+            s *= f3;
+            u *= f3;
+        }
+        bl = bm;
+        double d3 = p - m;
+        double d4 = r - o;
+        float f5 = MathHelper.a(d3 * d3 + d4 * d4) * 4F;
+
+        if (f5 > 1.0F) {
+            f5 = 1.0F;
+        }
+        bm += (f5 - bm) * 0.4F;
+        bn += bm;
+    }
+
+    public boolean m() {
+        int k = MathHelper.b(p);
+        int l = MathHelper.b(z.b);
+        int i1 = MathHelper.b(r);
+
+        return this.l.a(k, l, i1) == Block.aF.bi || this.l.a(k, l + 1, i1) == Block.aF.bi;
+    }
+
+    public void a(NBTTagCompound nbttagcompound) {
+        nbttagcompound.a("Health", (short) aZ);
+        nbttagcompound.a("HurtTime", (short) bb);
+        nbttagcompound.a("DeathTime", (short) be);
+        nbttagcompound.a("AttackTime", (short) bf);
+    }
+
+    public void b(NBTTagCompound nbttagcompound) {
+        aZ = ((int) (nbttagcompound.c("Health")));
+        if (!nbttagcompound.a("Health")) {
+            aZ = 10;
+        }
+        bb = ((int) (nbttagcompound.c("HurtTime")));
+        be = ((int) (nbttagcompound.c("DeathTime")));
+        bf = ((int) (nbttagcompound.c("AttackTime")));
+    }
+
+    public boolean B() {
+        return !G && aZ > 0;
+    }
+
+    public boolean d_() {
+        return false;
+    }
+
+    public void o() {
+        if (bo > 0) {
+            double d1 = p + (bp - p) / (double) bo;
+            double d2 = q + (bq - q) / (double) bo;
+            double d3 = r + (br - r) / (double) bo;
+            double d4;
+
+            for (d4 = bs - (double) v; d4 < -180D; d4 += 360D) {
+                ;
+            }
+            for (; d4 >= 180D; d4 -= 360D) {
+                ;
+            }
+            v += ((float) (d4 / (double) bo));
+            w += ((float) ((bt - (double) w) / (double) bo));
+            bo--;
+            a(d1, d2, d3);
+            b(v, w);
+        }
+        if (aZ <= 0) {
+            bA = false;
+            bx = 0.0F;
+            by = 0.0F;
+            bz = 0.0F;
+        } else if (!aW) {
+            d();
+        }
+        boolean flag = v();
+        boolean flag1 = x();
+
+        if (bA) {
+            if (flag) {
+                t += 0.039999999105930328D;
+            } else if (flag1) {
+                t += 0.039999999105930328D;
+            } else if (A) {
+                S();
+            }
+        }
+        bx *= 0.98F;
+        by *= 0.98F;
+        bz *= 0.9F;
+        c(bx, by);
+        List list = l.b(((Entity) (this)), z.b(0.20000000298023224D, 0.0D, 0.20000000298023224D));
+
+        if (list != null && list.size() > 0) {
+            for (int k = 0; k < list.size(); k++) {
+                Entity entity = (Entity) list.get(k);
+
+                if (entity.z()) {
+                    entity.c(((Entity) (this)));
+                }
+            }
+        }
+    }
+
+    protected void S() {
+        t = 0.41999998688697815D;
+    }
+
+    protected void d() {
+        bw++;
+        EntityPlayer entityplayer = l.a(((Entity) (this)), -1D);
+
+        if (entityplayer != null) {
+            double d1 = ((Entity) (entityplayer)).p - p;
+            double d2 = ((Entity) (entityplayer)).q - q;
+            double d3 = ((Entity) (entityplayer)).r - r;
+            double d4 = d1 * d1 + d2 * d2 + d3 * d3;
+
+            if (d4 > 16384D) {
+                q();
+            }
+            if (bw > 600 && W.nextInt(800) == 0) {
+                if (d4 < 1024D) {
+                    bw = 0;
+                } else {
+                    q();
+                }
+            }
+        }
+        bx = 0.0F;
+        by = 0.0F;
+        float f1 = 8F;
+
+        if (W.nextFloat() < 0.02F) {
+            EntityPlayer entityplayer1 = l.a(((Entity) (this)), f1);
+
+            if (entityplayer1 != null) {
+                b = ((Entity) (entityplayer1));
+                c = 10 + W.nextInt(20);
+            } else {
+                bz = (W.nextFloat() - 0.5F) * 20F;
+            }
+        }
+        if (b != null) {
+            b(b, 10F);
+            if (c-- <= 0 || b.G || b.b(((Entity) (this))) > (double) (f1 * f1)) {
+                b = null;
+            }
+        } else {
+            if (W.nextFloat() < 0.05F) {
+                bz = (W.nextFloat() - 0.5F) * 20F;
+            }
+            v += bz;
+            w = bB;
+        }
+        boolean flag = v();
+        boolean flag1 = x();
+
+        if (flag || flag1) {
+            bA = W.nextFloat() < 0.8F;
+        }
+    }
+
+    public void b(Entity entity, float f1) {
+        double d1 = entity.p - p;
+        double d2 = entity.r - r;
+        double d3;
+
+        if (entity instanceof EntityLiving) {
+            EntityLiving entityliving = (EntityLiving) entity;
+
+            d3 = (entityliving.q + (double) entityliving.w()) - (q + (double) w());
+        } else {
+            d3 = (entity.z.b + entity.z.e) / 2D - (q + (double) w());
+        }
+        double d4 = MathHelper.a(d1 * d1 + d2 * d2);
+        float f2 = (float) ((Math.atan2(d2, d1) * 180D) / 3.1415927410125732D) - 90F;
+        float f3 = (float) ((Math.atan2(d3, d4) * 180D) / 3.1415927410125732D);
+
+        w = -b(w, f3, f1);
+        v = b(v, f2, f1);
+    }
+
+    private float b(float f1, float f2, float f3) {
+        float f4;
+
+        for (f4 = f2 - f1; f4 < -180F; f4 += 360F) {
+            ;
+        }
+        for (; f4 >= 180F; f4 -= 360F) {
+            ;
+        }
+        if (f4 > f3) {
+            f4 = f3;
+        }
+        if (f4 < -f3) {
+            f4 = -f3;
+        }
+        return f1 + f4;
+    }
+
+    public void T() {}
+
+    public boolean b() {
+        return l.a(z) && l.a(((Entity) (this)), z).size() == 0 && !l.b(z);
+    }
+
+    protected void t() {
+        a(((Entity) (null)), 4);
+    }
+
+    public Vec3D G() {
+        return c(1.0F);
+    }
+
+    public Vec3D c(float f1) {
+        if (f1 == 1.0F) {
+            float f2 = MathHelper.b(-v * 0.01745329F - 3.141593F);
+            float f4 = MathHelper.a(-v * 0.01745329F - 3.141593F);
+            float f6 = -MathHelper.b(-w * 0.01745329F);
+            float f8 = MathHelper.a(-w * 0.01745329F);
+
+            return Vec3D.b(f4 * f6, f8, f2 * f6);
+        } else {
+            float f3 = y + (w - y) * f1;
+            float f5 = x + (v - x) * f1;
+            float f7 = MathHelper.b(-f5 * 0.01745329F - 3.141593F);
+            float f9 = MathHelper.a(-f5 * 0.01745329F - 3.141593F);
+            float f10 = -MathHelper.b(-f3 * 0.01745329F);
+            float f11 = MathHelper.a(-f3 * 0.01745329F);
+
+            return Vec3D.b(f9 * f10, f11, f7 * f10);
+        }
+    }
+
+    public int j() {
+        return 4;
+    }
+}