base.java

里面是个完整的项目 解压后放到wtk的apps文件夹下就可以运行了

// Decompiled by DJ v3.7.7.81 Copyright 2004 Atanas Neshkov  Date: 27/1/2005 16:13:52
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 


class Base
{

    Base()
    {
        P = false;
        b = false;
    }

    final void eE()
    {
        Q = true;
        byte byte0 = GameCanvas.readbyte();
        i = GameCanvas.readbyte();
        byte byte1 = GameCanvas.readbyte();
        constants = new Constants[byte1];
        for(int j = 0; j < byte1; j++)
        {
            constants[j] = new Constants();
            constants[j].G = GameCanvas.readbyte() == 1;
            byte byte2 = GameCanvas.readbyte();
            constants[j].I = new short[byte2];
            constants[j].C = new short[byte2];
            constants[j].B = new short[byte2];
            constants[j].Z = new int[byte2];
            constants[j].D = new short[byte2];
            constants[j].F = new short[byte2];
            constants[j].J = new short[byte2];
            constants[j].S = new short[byte2];
            constants[j].A = new short[byte2];
            constants[j].E = new short[byte2];
            for(int k = 0; k < byte2; k++)
            {
                constants[j].I[k] = GameCanvas.D();
                constants[j].C[k] = GameCanvas.D();
                constants[j].B[k] = GameCanvas.D();
                constants[j].D[k] = GameCanvas.readbyte();
                constants[j].F[k] = GameCanvas.readbyte();
                constants[j].J[k] = GameCanvas.readbyte();
                constants[j].S[k] = GameCanvas.readbyte();
                constants[j].A[k] = GameCanvas.readbyte();
                constants[j].E[k] = GameCanvas.readbyte();
                constants[j].Z[k] = constants[j].D[k] * constants[j].F[k];
                if(constants[j].Z[k] % 3 != 0)
                    constants[j].Z[k] += 3 - constants[j].Z[k] % 3;
                constants[j].Z[k] /= 3;
            }

        }

    }

    final void C(int j, int k)
    {
        if(O != 0)
            j = -j;
        int l = j;
        int i1 = T + (O != 0 ? L.E[M] : -L.E[M]);
        if(V)
        {
            int j1;
            if(O == 0)
            {
                if(j > 0)
                    j1 = i1 + L.D[M];
                else
                    j1 = i1;
            } else
            if(j < 0)
                j1 = i1 - L.D[M];
            else
                j1 = i1;
            if(GameCanvas.d.I(j1 + j, U, false) != -1)
            {
                if(j > 0)
                    for(; j > 0; j--)
                        if(GameCanvas.d.I(j1 + j, U, false) == -1)
                            break;

                else
                    for(; j < 0; j++)
                        if(GameCanvas.d.I(j1 + j, U, false) == -1)
                            break;

            } else
            {
                Children3 ad[] = GameCanvas.d.children3;
                for(int k1 = 0; k1 < ad.length; k1++)
                {
                    Children3 d = ad[k1];
                    if(U <= d.U - 8 || U >= d.U + 3 || d.C >= 4)
                        continue;
                    boolean flag = false;
                    byte byte0 = ((byte)(j <= 0 ? -1 : 1));
                    int l1;
                    for(l1 = j1; l1 != j1 + j; l1 += byte0)
                    {
                        if(l1 < d.T - 6 || l1 >= d.T + 10)
                            continue;
                        flag = true;
                        break;
                    }

                    if(!flag)
                        continue;
                    l1 -= byte0;
                    j = l1 - j1;
                    break;
                }

            }
        }
        T += j;
        U += k;
        c = l != j;
    }

    final void Z(int j)
    {
        M = j;
        C(L.S[j], L.A[j]);
    }

    void I(int j, int k)
    {
        Y = X;
        X = j;
        if(k != -1)
            C(k);
    }

    final boolean B(int j, int k)
    {
        if(O != 0)
            j = -j;
        int l = T + (O != 0 ? L.E[M] : -L.E[M]);
        if(V)
        {
            int i1;
            if(O == 0)
            {
                if(j > 0)
                    i1 = l + L.D[M];
                else
                    i1 = l;
            } else
            if(j < 0)
                i1 = l - L.D[M];
            else
                i1 = l;
            int j1 = GameCanvas.d.I(i1 + j, U, false);
            if(j1 == -1)
            {
                Children3 ad[] = GameCanvas.d.children3;
                for(int k1 = 0; k1 < ad.length; k1++)
                {
                    Children3 d = GameCanvas.d.children3[k1];
                    if(U > d.U - 8 && U < d.U + 3 && d.C < 4)
                    {
                        byte byte0 = ((byte)(j <= 0 ? -1 : 1));
                        for(int l1 = i1; l1 != i1 + j; l1 += byte0)
                            if(l1 >= d.T - 5 && l1 < d.T + 9)
                                return false;

                    }
                }

                return true;
            } else
            {
                return false;
            }
        } else
        {
            return true;
        }
    }

    final boolean G()
    {
        int j = T - GameCanvas.d.JJ;
        int k = U - GameCanvas.d.A;
        int l;
        if(O == 0)
            l = j - L.E[M];
        else
            l = j - (L.D[M] - 1 - L.E[M]);
        int i1 = k - L.F[M];
        return l >= 128 || i1 >= 127 || l + L.D[M] < 0 || i1 + L.F[M] < 0;
    }

    void I()
    {
        if(R)
            return;
        if(W && GameCanvas.d.I(T, U + 1, true) == -1)
            F();
        if(L == null)
            return;
        if(L.J[M] == 0)
            return;
        N++;
        if(N < L.J[M])
        {
            C(L.S[M], L.A[M]);
            return;
        }
        if(M < L.A.length - 1)
        {
            N = 0;
            Z(++M);
        } else
        if(L.G)
        {
            N = 0;
            Z(0);
        }
    }

    final void Z(Base e)
    {
        i = e.i;
        constants = e.constants;
        Q = false;
        C(0);
    }

    void paint(int j, int k)
    {
        if(R)
            return;
        if(i != j)
            return;
        int l = U + 10;
        boolean flag = false;
        boolean flag1 = false;
        int i1 = T - GameCanvas.d.JJ - (O != 0 ? L.D[M] - 1 - L.E[M] : L.E[M]);
        int j1 = l - GameCanvas.d.A - L.F[M];
        if(i1 + L.D[M] < 0 || i1 >= 128 || j1 + L.F[M] < 0 || j1 >= 127)
            return;
        switch(k)
        {
        case 3: // '\003'
        default:
            break;

        case 4: // '\004'
            short word0 = L.D[M];
            if(b)
                word0 = 20;
            GameCanvas.g.setClip(i1, Math.max(10, j1), word0, L.F[M] - (Math.max(10, j1) - j1));
//            Graphics _tmp = GameCanvas.g;
//            Graphics _tmp1 = GameCanvas.g;
            GameCanvas.g.drawImage(GameCanvas.getImage(7), i1 - L.C[M], j1 - L.B[M], 0x10 | 4);
            break;

        case 5: // '\005'
            GameCanvas.g.setClip(i1, Math.max(10, j1), L.D[0], L.F[0] - (Math.max(10, j1) - j1));
//            Graphics _tmp2 = GameCanvas.g;
//            Graphics _tmp3 = GameCanvas.g;
            GameCanvas.g.drawImage(GameCanvas.buffer_224x96, i1 - L.C[0], j1 - L.B[0], 0x10 | 4);
            break;

        case 6: // '\006'
            int k1 = l - GameCanvas.d.A - L.F[0];
            GameCanvas.g.setClip(i1, Math.max(10, k1), L.D[M], L.F[M] - (Math.max(10, k1) - k1));
//            Graphics _tmp4 = GameCanvas.g;
//            Graphics _tmp5 = GameCanvas.g;
            GameCanvas.g.drawImage(GameCanvas.getImage(7), i1 - L.C[M], k1 - L.B[M], 0x10 | 4);
            break;

        case 2: // '\002'
            GameCanvas.g.setClip(i1, Math.max(10, j1), L.D[M], L.F[M] - (Math.max(10, j1) - j1));
//            Graphics _tmp6 = GameCanvas.g;
//            Graphics _tmp7 = GameCanvas.g;
            GameCanvas.g.drawImage(GameCanvas.getImage(10), i1 - L.C[M], j1 - L.B[M], 0x10 | 4);
            break;
        }
    }

    final void C(int j)
    {
        Constants k = constants[j];
        if(L == k)
        {
            return;
        } else
        {
            L = k;
            Z(0);
            N = 0;
            return;
        }
    }

    final boolean H()
    {
        if(L == null)
            return false;
        if(N <= L.J[M] - 1)
            return false;
        return M >= L.J.length - 1;
    }

    final boolean K()
    {
        Children1 aa[] = GameCanvas.d.children1;
        for(int j = 0; j < aa.length; j++)
            if(aa[j].I(this))
                return true;

        return false;
    }

    void F()
    {
    }

    void D()
    {
    }

    final void L()
    {
        V = false;
    }

    final void M()
    {
        W = false;
    }

    final void N()
    {
        V = true;
    }

    final void O()
    {
        W = true;
    }

    Constants constants[];
    Constants L;
    int M;
    int N;
    int O;
    boolean P;
    boolean Q;
    boolean R;
    int T;
    int U;
    boolean V;
    boolean W;
    int X;
    int Y;
    int i;
    int z;
    boolean c;
    boolean b;
}