Minecraft Passive AI

// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3)
// Source File Name:   SourceFile

import org.lwjgl.opengl.GL11;

public abstract class boc extends bnz
{

    public boc(bhl bhl, float f)
    {
        super(bhl, f);
    }

    protected boolean b(ri ri1)
    {
        return super.b(ri1) && (ri1.bi() || ri1.bF() && ri1 == b.i);
    }

    public void a(ri ri1, double d, double d1, double d2,
            float f, float f1)
    {
        super.a(ri1, d, d1, d2, f, f1);
        b(ri1, d, d1, d2, f, f1);
    }

    private double a(double d, double d1, double d2)
    {
        return d + (d1 - d) * d2;
    }

    protected void b(ri ri1, double d, double d1, double d2,
            float f, float f1)
    {
        qn qn1 = ri1.bM();
        if(qn1 != null)
        {
            d1 -= (1.6000000000000001D - (double)ri1.O) * 0.5D;
            blz blz1 = blz.a;
            double d3 = a(qn1.B, qn1.z, f1 * 0.5F) * 0.01745329238474369D;
            double d4 = a(qn1.C, qn1.A, f1 * 0.5F) * 0.01745329238474369D;
            double d5 = Math.cos(d3);
            double d6 = Math.sin(d3);
            double d7 = Math.sin(d4);
            if(qn1 instanceof re)
            {
                d5 = 0.0D;
                d6 = 0.0D;
                d7 = -1D;
            }
            double d8 = Math.cos(d4);
            double d9 = a(qn1.q, qn1.t, f1) - d5 * 0.69999999999999996D - d6 * 0.5D * d8;
            double d10 = a(qn1.r + (double)qn1.g() * 0.69999999999999996D, qn1.u + (double)qn1.g() * 0.69999999999999996D, f1) - d7 * 0.5D - 0.25D;
            double d11 = (a(qn1.s, qn1.v, f1) - d6 * 0.69999999999999996D) + d5 * 0.5D * d8;
            double d12 = a(ri1.aO, ri1.aN, f1) * 0.01745329238474369D + 1.5707963267948966D;
            d5 = Math.cos(d12) * (double)ri1.N * 0.40000000000000002D;
            d6 = Math.sin(d12) * (double)ri1.N * 0.40000000000000002D;
            double d13 = a(ri1.q, ri1.t, f1) + d5;
            double d14 = a(ri1.r, ri1.u, f1);
            double d15 = a(ri1.s, ri1.v, f1) + d6;
            d += d5;
            d2 += d6;
            double d16 = (float)(d9 - d13);
            double d17 = (float)(d10 - d14);
            double d18 = (float)(d11 - d15);
            GL11.glDisable(3553);
            GL11.glDisable(2896);
            GL11.glDisable(2884);
            byte byte0 = 24;
            double d19 = 0.025000000000000001D;
            blz1.a(5);
            for(int i = 0; i <= 24; i++)
            {
                if(i % 2 == 0)
                    blz1.a(0.5F, 0.4F, 0.3F, 1.0F);
                else
                    blz1.a(0.35F, 0.28F, 0.21F, 1.0F);
                float f2 = (float)i / 24F;
                blz1.a(d + d16 * (double)f2 + 0.0D, d1 + d17 * (double)(f2 * f2 + f2) * 0.5D + (double)((24F - (float)i) / 18F + 0.125F), d2 + d18 * (double)f2);
                blz1.a(d + d16 * (double)f2 + 0.025000000000000001D, d1 + d17 * (double)(f2 * f2 + f2) * 0.5D + (double)((24F - (float)i) / 18F + 0.125F) + 0.025000000000000001D, d2 + d18 * (double)f2);
            }

            blz1.a();
            blz1.a(5);
            for(int j = 0; j <= 24; j++)
            {
                if(j % 2 == 0)
                    blz1.a(0.5F, 0.4F, 0.3F, 1.0F);
                else
                    blz1.a(0.35F, 0.28F, 0.21F, 1.0F);
                float f3 = (float)j / 24F;
                blz1.a(d + d16 * (double)f3 + 0.0D, d1 + d17 * (double)(f3 * f3 + f3) * 0.5D + (double)((24F - (float)j) / 18F + 0.125F) + 0.025000000000000001D, d2 + d18 * (double)f3);
                blz1.a(d + d16 * (double)f3 + 0.025000000000000001D, d1 + d17 * (double)(f3 * f3 + f3) * 0.5D + (double)((24F - (float)j) / 18F + 0.125F), d2 + d18 * (double)f3 + 0.025000000000000001D);
            }

            blz1.a();
            GL11.glEnable(2896);
            GL11.glEnable(3553);
            GL11.glEnable(2884);
        }
    }

    protected volatile boolean b(rh rh)
    {
        return b((ri)rh);
    }

    public volatile void a(rh rh, double d, double d1, double d2,
            float f, float f1)
    {
        a((ri)rh, d, d1, d2, f, f1);
    }

    public volatile void a(qn qn1, double d, double d1, double d2,
            float f, float f1)
    {
        a((ri)qn1, d, d1, d2, f, f1);
    }
}