a.java

IceBladePenguin game source code

                t[3][l1] = JetMidlet.Z(copyInto[35], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[36] > 0)
                    t[1][l1] = o.I(copyInto[36], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[36], k1);
                t[3][l1] = JetMidlet.Z(copyInto[37], 12);
                l[3][l1] = 0xffff00;
            } else
            {
                if(copyInto[0] > 0)
                    t[3][l1] = o.I(copyInto[0], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[0], k1);
                l1++;
                t[1][l1] = o.I(copyInto[1], false);
                l[1][l1] = JetMidlet.Z(copyInto[1], 0);
                t[3][l1] = o.I(copyInto[2], 10000, true);
                l[3][l1] = JetMidlet.Z(copyInto[2], 0);
                l1++;
                t[1][l1] = JetMidlet.Z(copyInto[3], 9);
                l[1][l1] = 0xffff00;
                t[3][l1] = JetMidlet.Z(copyInto[8], 9);
                l[3][l1] = 65535;
                l1++;
                if(copyInto[4] > 0)
                    t[1][l1] = o.I(copyInto[4], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[4], k1);
                if(copyInto[5] > 0)
                    t[3][l1] = o.I(copyInto[5], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[5], k1);
                l1++;
                if(copyInto[6] > 0)
                    t[1][l1] = o.I(copyInto[6], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[6], k1);
                if(copyInto[7] > 0)
                    t[3][l1] = o.I(copyInto[7], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[7], k1);
                l1++;
                t[1][l1] = JetMidlet.Z(copyInto[9], 9);
                l[1][l1] = 0xff2020;
                t[3][l1] = JetMidlet.Z(copyInto[10], 9);
                l[3][l1] = 0x20ff20;
                l1++;
                t[1][l1] = o.I(copyInto[11], 10000, true);
                l[1][l1] = JetMidlet.Z(copyInto[12], 0);
                t[3][l1] = JetMidlet.Z(copyInto[12], 9);
                l[3][l1] = l[1][l1];
                l1++;
                t[1][l1] = copyInto[13] + "家";
                l[1][l1] = 0xff2020;
                t[3][l1] = copyInto[14] + "家";
                l[3][l1] = 0xffffff;
                l1++;
                t[1][l1] = copyInto[15] + "家";
                l[1][l1] = 0x20ff20;
            }
            o.H = l;
            o.K = t;
            l = null;
            t = null;
            copyInto = null;
        }
        return true;
    }

    private boolean arraycopy(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        min = datainputstream.readInt();
        u = datainputstream.readByte();
        boolean flag = false;
        if(u > 0)
        {
            y = new byte[u];
            for(int i1 = 0; i1 < u; i1++)
                y[i1] = datainputstream.readByte();

        }
        short word0 = datainputstream.readShort();
        byte abyte0[] = new byte[8];
        for(int j1 = 0; j1 < abyte0.length; j1++)
            abyte0[j1] = (byte)((word0 & 3 << 2 * j1) >> 2 * j1 & 0x3);

        D = datainputstream.readShort();
        boolean flag1 = false;
        boolean flag2 = false;
        boolean flag3 = false;
        int ai[] = new int[2];
        if(D > 0)
        {
            w = new int[D];
            v = new int[D][][];
            Q = new int[D][];
            for(int k1 = 0; k1 < D; k1++)
            {
                if(k1 != 0 && abyte0[0] == 1)
                    w[k1] = datainputstream.readByte() + w[k1 - 1];
                else
                if(k1 != 0 && abyte0[0] == 2)
                    w[k1] = datainputstream.readShort() + w[k1 - 1];
                else
                    w[k1] = datainputstream.readInt();
                if(V)
                {
                    Q[k1] = new int[6];
                    for(int l1 = 0; l1 < 6; l1++)
                    {
                        byte byte0;
                        if(l1 < 4)
                            byte0 = abyte0[1];
                        else
                        if(l1 < 5)
                            byte0 = abyte0[2];
                        else
                            byte0 = abyte0[3];
                        if(k1 != 0 && byte0 == 1)
                            Q[k1][l1] = datainputstream.readByte() + Q[k1 - 1][l1];
                        else
                        if(k1 != 0 && byte0 == 2)
                            Q[k1][l1] = datainputstream.readShort() + Q[k1 - 1][l1];
                        else
                            Q[k1][l1] = datainputstream.readInt();
                    }

                }
                short word1 = datainputstream.readShort();
                v[k1] = new int[u][];
                for(int i2 = 0; i2 < u; i2++)
                {
                    int j2 = JetMidlet.I(y[i2]);
                    if(j2 == 1)
                        ai[i2] = word1 & 0x1;
                    else
                    if(j2 == 2)
                        ai[i2] = word1 & 0x3;
                    else
                    if(j2 == 3)
                        ai[i2] = word1 & 0x7;
                    word1 >>= j2;
                }

                for(int k2 = 0; k2 < u; k2++)
                {
                    int l2 = JetMidlet.I(y[k2]);
                    v[k1][k2] = new int[4];
                    v[k1][k2][0] = ai[k2];
                    for(int i3 = 1; i3 <= l2; i3++)
                        if(k1 != 0 && abyte0[4 + k2] == 1)
                            v[k1][k2][i3] = datainputstream.readByte() + v[k1 - 1][k2][i3];
                        else
                        if(k1 != 0 && abyte0[4 + k2] == 2)
                            v[k1][k2][i3] = datainputstream.readShort() + v[k1 - 1][k2][i3];
                        else
                            v[k1][k2][i3] = datainputstream.readInt();

                }

            }

        }
        return true;
    }

    private boolean close(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        D = datainputstream.readShort();
        t = new String[3][];
        l = new int[3][];
        if(D > 0)
        {
            T = new int[D][];
            for(int i1 = 0; i1 < 3; i1++)
            {
                t[i1] = new String[D];
                if(i1 > 0)
                    l[i1] = new int[D];
            }

            for(int j1 = 0; j1 < D; j1++)
            {
                T[j1] = new int[3];
                T[j1][0] = datainputstream.readByte();
                T[j1][1] = datainputstream.readInt();
                T[j1][2] = datainputstream.readInt();
                t[0][j1] = S[j1].Q;
                if(T[j1][0] != 1)
                {
                    t[1][j1] = "--";
                    t[2][j1] = "--%";
                    l[2][j1] = 0xffffff;
                    l[1][j1] = l[2][j1];
                } else
                {
                    t[1][j1] = S[j1].I(T[j1][1], false);
                    t[2][j1] = S[j1].I(T[j1][1] - T[j1][2], T[j1][2], true);
                    l[2][j1] = JetMidlet.Z(T[j1][1], T[j1][2]);
                    l[1][j1] = l[2][j1];
                }
            }

        }
        return true;
    }

    private boolean copyInto(DataInputStream datainputstream)
    {
        d = datainputstream.readByte();
        int i1 = datainputstream.readShort();
        X = i1;
        boolean flag = false;
        if(d == 0)
        {
            if(i1 > 0)
            {
                i = new int[i1];
                flush = new boolean[i1];
                elementAt = new boolean[i1];
                getHeight = new String[i1];
                c = new String[i1];
                for(int j1 = 0; j1 < i1; j1++)
                {
                    i[j1] = datainputstream.readInt();
                    flush[j1] = datainputstream.readByte() == 1;
                    elementAt[j1] = datainputstream.readByte() == 1;
                    getHeight[j1] = JetMidlet.I(datainputstream, 1, 0, true);
                    c[j1] = JetMidlet.I(datainputstream, 1, 0, true);
                }

            }
        } else
        {
            W = JetMidlet.I(datainputstream, 2, 0, true);
        }
        return true;
    }

    private boolean elementAt(DataInputStream datainputstream)
    {
        I = new byte[14];
        datainputstream.read(I);
        if(Z == 4)
            length = datainputstream.readInt();
        F = datainputstream.readInt();
        if(Z == 5)
            P = datainputstream.readByte() == 0;
        return true;
    }

    private boolean flush(DataInputStream datainputstream)
    {
        boolean flag = false;
        if(datainputstream.readByte() == 1)
        {
            r = JetMidlet.I(datainputstream, 2, 0, true);
            Vector vector = JetMidlet.Z(r);
            o.G = new String[1][];
            o.G[0] = new String[vector.size()];
            vector.copyInto(o.G[0]);
        }
        return true;
    }

    private boolean getHeight(DataInputStream datainputstream)
    {
        J = datainputstream.readShort();
        t = new String[1][];
        if(J > 0)
        {
            S = new H[J];
            t[0] = new String[J];
            for(int i1 = 0; i1 < J; i1++)
            {
                readByte(datainputstream, i1, false);
                t[0][i1] = S[i1].Q + " " + S[i1].I;
            }

        }
        return true;
    }

    private boolean insertElementAt(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        J = D = datainputstream.readShort();
        if(D > 0)
        {
            H ah[] = new H[D];
            int ai[][] = new int[D][];
            for(int i1 = 0; i1 < D; i1++)
            {
                ah[i1] = new H();
                ah[i1].T = datainputstream.readShort();
                ah[i1].E = datainputstream.readByte();
                ah[i1].I = JetMidlet.I(datainputstream, 0, 6, false);
                ah[i1].Q = JetMidlet.I(datainputstream, 0, 16, true);
                ai[i1] = new int[3];
                ai[i1][0] = datainputstream.readInt();
                ai[i1][1] = datainputstream.readInt();
                ai[i1][2] = datainputstream.readByte();
            }

            if(S == null || S.length < 1)
            {
                S = ah;
                T = ai;
                A = 0;
            } else
            {
                int j1 = S.length;
                int l1 = j1 + D;
                if(l1 > 100)
                    l1 = 100;
                H ah1[] = new H[l1];
                int ai1[][] = new int[l1][];
                for(int k2 = 0; k2 < l1; k2++)
                    ai1[k2] = new int[3];

                if(n > A)
                {
                    int l2 = (j1 + D) - l1;
                    A = A + l2;
                    if(j1 > 0)
                    {
                        System.arraycopy(S, l2, ah1, 0, j1 - l2);
                        System.arraycopy(T, l2, ai1, 0, j1 - l2);
                    }
                    System.arraycopy(ah, 0, ah1, j1 - l2, D);
                    System.arraycopy(ai, 0, ai1, j1 - l2, D);
                } else
                {
                    A = A - D;
                    System.arraycopy(ah, 0, ah1, 0, D);
                    System.arraycopy(ai, 0, ai1, 0, D);
                    if(l1 - D > 0)
                    {
                        System.arraycopy(S, 0, ah1, D, l1 - D);
                        System.arraycopy(T, 0, ai1, D, l1 - D);
                    }
                }
                S = ah1;
                T = ai1;
            }
            D = S.length;
            t = new String[3][];
            l = new int[3][];
            for(int k1 = 0; k1 < 3; k1++)
            {
                t[k1] = new String[D];
                if(k1 > 0)
                    l[k1] = new int[D];
            }

            for(int i2 = 0; i2 < 3; i2++)
            {
                t[i2] = new String[D];
                if(i2 > 0)
                    l[i2] = new int[D];
            }

            for(int j2 = 0; j2 < D; j2++)
            {
                t[0][j2] = S[j2].Q;
                switch(E)
                {
                default:
                    break;

                case 0: // '\0'
                case 1: // '\001'
                case 4: // '\004'
                case 14: // '\016'
                case 15: // '\017'
                case 20: // '\024'
                    t[1][j2] = S[j2].I(T[j2][1], 10000, true);
                    l[1][j2] = JetMidlet.Z(T[j2][1], 0);
                    break;

                case 19: // '\023'
                    t[1][j2] = JetMidlet.I(T[j2][1], 2);
                    l[1][j2] = 0xffffff;
                    break;

                case 8: // '\b'
                case 12: // '\f'
                case 50: // '2'
                    t[1][j2] = Integer.toString(T[j2][1]);
                    if(E == 8)
                        l[1][j2] = 0xffff00;
                    else
                        l[1][j2] = 65535;
                    break;
                }
                t[2][j2] = S[j2].I(T[j2][0], false);
                l[2][j2] = JetMidlet.Z(T[j2][2], 0);
            }

        }
        return true;
    }

    private boolean length(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        o.R = datainputstream.readInt();
        D = datainputstream.readShort();
        int i1 = (II - D) + 1;
        int j1 = o.R;
        int k1 = 0;
        if(D > 0)
        {
            if(o.V == null)
                o.V = new int[241][];
            o.U = II + 1;
            byte byte0 = datainputstream.readByte();
            int ai[] = new int[3];
            ai[0] = byte0 & 0x3;
            ai[1] = (byte0 & 0xc) >> 2;
            ai[2] = (byte0 & 0x30) >> 4;
            byte byte1 = 3;
            if(o.C())
                byte1 = 2;
            int ai1[] = new int[3];
            if(i1 > 0)
            {
                j1 = o.V[i1 - 1][0];
                k1 = o.V[i1 - 1][1];
            }
            for(int l1 = 0; l1 < D; l1++)
            {
                for(int i2 = 0; i2 < byte1; i2++)
                {
                    if(ai[i2] == 0 || l1 == 0)
                        ai1[i2] = datainputstream.readInt();
                    else
                    if(ai[i2] == 2)
                        ai1[i2] = datainputstream.readShort() + ai1[i2];
                    else
                        ai1[i2] = datainputstream.readByte() + ai1[i2];
                    if(o.V[i1 + l1] == null)
                        o.V[i1 + l1] = new int[3];
                    o.V[i1 + l1][i2] = ai1[i2];
                }

                if(o.V[i1 + l1][0] <= 0)
                    o.V[i1 + l1][0] = j1;
                else
                    j1 = o.V[i1 + l1][0];
                if(o.V[i1 + l1][1] - k1 < 0)
                    o.V[i1 + l1][1] = k1;
                else
                    k1 = o.V[i1 + l1][1];
            }

        }
        return true;
    }
}