a.java

IceBladePenguin game source code

        case 46: // '.'
            return insertElementAt(datainputstream);

        case 40: // '('
            return write(datainputstream);

        case 64: // '@'
            return writeByte(datainputstream);

        case 6: // '\006'
        case 7: // '\007'
        case 8: // '\b'
        case 9: // '\t'
        case 11: // '\013'
        case 12: // '\f'
        case 13: // '\r'
        case 14: // '\016'
        case 15: // '\017'
        case 17: // '\021'
        case 18: // '\022'
        case 19: // '\023'
        case 20: // '\024'
        case 21: // '\025'
        case 22: // '\026'
        case 23: // '\027'
        case 24: // '\030'
        case 25: // '\031'
        case 26: // '\032'
        case 27: // '\033'
        case 28: // '\034'
        case 29: // '\035'
        case 30: // '\036'
        case 31: // '\037'
        case 33: // '!'
        case 39: // '\''
        case 41: // ')'
        case 42: // '*'
        case 43: // '+'
        case 47: // '/'
        case 48: // '0'
        case 49: // '1'
        case 50: // '2'
        case 51: // '3'
        case 52: // '4'
        case 53: // '5'
        case 54: // '6'
        case 55: // '7'
        case 56: // '8'
        case 57: // '9'
        case 58: // ':'
        case 59: // ';'
        case 60: // '<'
        case 61: // '='
        case 62: // '>'
        case 63: // '?'
        default:
            return true;
        }
    }

    private boolean size(DataInputStream datainputstream)
    {
        F = datainputstream.readInt();
        P = datainputstream.readByte() == 0;
        return true;
    }

    private boolean toByteArray(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        max = datainputstream.readInt();
        m = datainputstream.readShort();
        D = datainputstream.readShort();
        if(D <= 0)
            return true;
        byte byte0 = datainputstream.readByte();
        byte abyte0[] = new byte[3];
        for(int i1 = 0; i1 < abyte0.length; i1++)
            abyte0[i1] = (byte)(byte0 >> 2 * i1 & 0x3);

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

            for(int k1 = 0; k1 < D; k1++)
            {
                T[k1] = new int[4];
                for(int l1 = 0; l1 < 3; l1++)
                    if(k1 == 0 || abyte0[l1] == 0)
                        T[k1][l1] = datainputstream.readInt();
                    else
                    if(abyte0[l1] == 1)
                        T[k1][l1] = datainputstream.readByte() + T[k1 - 1][l1];
                    else
                    if(abyte0[l1] == 2)
                        T[k1][l1] = datainputstream.readShort() + T[k1 - 1][l1];

                l[3][D - k1 - 1] = datainputstream.readByte();
                t[0][D - k1 - 1] = (m + k1 + 1) + "  " + JetMidlet.I(T[k1][0]);
                t[1][D - k1 - 1] = o.I(T[k1][1], false);
                l[1][D - k1 - 1] = JetMidlet.Z(T[k1][1], max);
                t[2][D - k1 - 1] = JetMidlet.Z(T[k1][2], 10);
                l[2][D - k1 - 1] = 0xffff00;
            }

            int i2 = o.C;
            int j2 = o.D;
            o.R = max;
            if(j2 < 0)
                o.D = m;
            else
                o.D = Math.min(m, j2);
            int k2 = (m + D) - 1;
            if(i2 != 0)
                k2 = Math.max(k2, (j2 + i2) - 1);
            o.C = (k2 - o.D) + 1;
            if(o.C > 220)
            {
                o.C = 220;
                if(g == 1)
                    o.D = (k2 - o.C) + 1;
            }
            String as[][] = new String[3][];
            int ai[][] = new int[4][];
            for(int l2 = 0; l2 < 4; l2++)
            {
                if(l2 < 3)
                    as[l2] = new String[o.C];
                if(l2 != 0)
                    ai[l2] = new int[o.C];
                if(i2 > 0)
                    if(g == 1)
                    {
                        if(l2 < 3)
                            System.arraycopy(o.B[l2], 0, as[l2], D, o.C - D);
                        if(l2 != 0)
                            System.arraycopy(o.Z[l2], 0, ai[l2], D, o.C - D);
                    } else
                    if(g == 0)
                    {
                        if(l2 < 3)
                            System.arraycopy(o.B[l2], i2 - (o.C - D), as[l2], 0, o.C - D);
                        if(l2 != 0)
                            System.arraycopy(o.Z[l2], i2 - (o.C - D), ai[l2], 0, o.C - D);
                    }
                if(g == 1)
                {
                    if(l2 < 3)
                        System.arraycopy(t[l2], 0, as[l2], 0, D);
                    if(l2 != 0)
                        System.arraycopy(l[l2], 0, ai[l2], 0, D);
                } else
                {
                    if(l2 < 3)
                        System.arraycopy(t[l2], 0, as[l2], o.C - D, D);
                    if(l2 != 0)
                        System.arraycopy(l[l2], 0, ai[l2], o.C - D, D);
                }
                if(l2 < 3)
                    t[l2] = null;
                l[l2] = null;
            }

            o.Z = ai;
            o.B = as;
        }
        return true;
    }

    private boolean toString(DataInputStream datainputstream)
    {
        II = datainputstream.readShort();
        o.F = datainputstream.readInt();
        min = o.F;
        o.R = datainputstream.readInt();
        max = o.R;
        close = datainputstream.readInt();
        append = datainputstream.readShort();
        o.J = datainputstream.readShort();
        D = o.J;
        byte byte0 = datainputstream.readByte();
        if(D > 0)
        {
            copyInto = new int[D];
            for(int i1 = 0; i1 < D; i1++)
                if((byte0 & 0x1) == 1)
                    copyInto[i1] = datainputstream.readShort();
                else
                    copyInto[i1] = datainputstream.readInt();

            Vector vector = new Vector();
            Vector vector1 = new Vector();
            int ai[] = new int[D];
            int ai1[] = new int[D];
            boolean flag = false;
            int k1 = 0;
            for(int l1 = 0; l1 < D; l1++)
            {
                int j1 = close + l1 * append;
                if(copyInto[l1] > 0)
                {
                    vector.insertElementAt(o.I(j1, false), 0);
                    vector1.insertElementAt(copyInto[l1] + "", 0);
                    ai[D - k1 - 1] = JetMidlet.Z(j1, max);
                    ai1[D - k1 - 1] = 0xffff00;
                    k1++;
                }
            }

            o.A = new String[4][];
            o.S = new int[4][];
            int i2 = JetMidlet.B / JetMidlet.HI.getHeight();
            int j2 = (k1 / (2 * i2)) * i2 + (k1 % (2 * i2) < i2 ? k1 % i2 : i2);
            for(int k2 = 0; k2 < 4; k2++)
            {
                o.A[k2] = new String[j2];
                o.S[k2] = new int[j2];
            }

            boolean flag1 = false;
            for(int i3 = 0; i3 < j2; i3++)
            {
                int l2 = (i3 / i2) * 2 * i2 + i3 % i2;
                if(l2 >= vector.size())
                    break;
                o.A[0][i3] = (String)vector.elementAt(l2);
                o.S[0][i3] = ai[(D - k1) + l2];
                o.A[1][i3] = (String)vector1.elementAt(l2);
                o.S[1][i3] = ai1[(D - k1) + l2];
                l2 = (i3 / i2) * 2 * i2 + i3 % i2 + i2;
                if(l2 < vector.size())
                {
                    o.A[2][i3] = (String)vector.elementAt(l2);
                    o.S[2][i3] = ai[(D - k1) + l2];
                    o.A[3][i3] = (String)vector1.elementAt(l2);
                    o.S[3][i3] = ai1[(D - k1) + l2];
                }
            }

        }
        return true;
    }

    private boolean write(DataInputStream datainputstream)
    {
        J = datainputstream.readShort();
        if(J > 0)
        {
            S = new H[J];
            for(int i1 = 0; i1 < J; i1++)
                readByte(datainputstream, i1, true);

        }
        return true;
    }

    private boolean writeByte(DataInputStream datainputstream)
    {
        r = JetMidlet.I(datainputstream, 2, 0, true);
        return true;
    }

    private boolean writeInt(DataInputStream datainputstream)
    {
        N = datainputstream.readByte();
        H = datainputstream.readShort();
        if(H > 0)
        {
            M = new int[H];
            O = new byte[H];
            G = new String[H];
            boolean flag = false;
            for(int i1 = 0; i1 < H; i1++)
            {
                O[i1] = datainputstream.readByte();
                M[i1] = datainputstream.readInt();
                G[i1] = JetMidlet.I(datainputstream, 2, 0, true);
            }

        }
        return true;
    }

    private boolean writeShort(DataInputStream datainputstream)
    {
        read = datainputstream.readByte() == 0;
        J = datainputstream.readShort();
        if(J > 0)
        {
            S = new H[J];
            for(int i1 = 0; i1 < J; i1++)
                readByte(datainputstream, i1, true);

        }
        b = datainputstream.readShort();
        f = datainputstream.readShort();
        z = datainputstream.readShort();
        return true;
    }

    private boolean append(DataInputStream datainputstream)
    {
        o.L = datainputstream.readShort();
        int i1 = datainputstream.readByte();
        boolean flag = o.C();
        t = o.K;
        l = o.H;
        if(i1 > 0)
        {
            copyInto = new int[i1];
            for(int j1 = 0; j1 < i1; j1++)
                copyInto[j1] = datainputstream.readInt();

            int k1 = 0;
            if(!flag)
                k1 = copyInto[5];
            else
                k1 = copyInto[4];
            i1 = t[0].length;
            t[1] = new String[i1];
            l[1] = new int[i1];
            t[3] = new String[i1];
            l[3] = new int[i1];
            int l1 = 0;
            if(!flag)
            {
                if(copyInto[0] > 0)
                    t[1][l1] = o.I(copyInto[0], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[0], k1);
                if(copyInto[1] > 0)
                    t[3][l1] = o.I(copyInto[1], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[1], k1);
                l1++;
                t[1][l1] = o.I(copyInto[2], true);
                l[1][l1] = JetMidlet.Z(copyInto[2], 0);
                t[3][l1] = o.I(copyInto[3], 10000, true);
                l[3][l1] = JetMidlet.Z(copyInto[3], 0);
                l1++;
                t[1][l1] = JetMidlet.Z(copyInto[4], 9);
                l[1][l1] = 0xffff00;
                t[3][l1] = JetMidlet.Z(copyInto[10], 9);
                l[3][l1] = 0xffff00;
                l1++;
                t[1][l1] = JetMidlet.Z(copyInto[9], 9);
                l[1][l1] = 65535;
                t[3][l1] = JetMidlet.I((copyInto[11] + 50) / 100, 2);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[5] > 0)
                    t[1][l1] = o.I(copyInto[5], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[5], k1);
                if(copyInto[6] > 0)
                    t[3][l1] = o.I(copyInto[6], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[6], k1);
                l1++;
                if(copyInto[7] > 0)
                    t[1][l1] = o.I(copyInto[7], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[7], k1);
                if(copyInto[8] > 0)
                    t[3][l1] = o.I(copyInto[8], false);
                else
                    t[3][l1] = "--";
                l[3][l1] = JetMidlet.Z(copyInto[8], copyInto[5]);
                l1++;
                t[1][l1] = JetMidlet.Z(copyInto[12], 9);
                l[1][l1] = 0xff2020;
                t[3][l1] = JetMidlet.Z(copyInto[13], 9);
                l[3][l1] = 0x20ff20;
                l1++;
                t[1][l1] = o.I(copyInto[14], 10000, false);
                l[1][l1] = JetMidlet.Z(copyInto[14], 0);
                t[3][l1] = JetMidlet.I(copyInto[15], 2);
                l[3][l1] = JetMidlet.Z(copyInto[15], 0);
                l1++;
                t[1][l1] = o.I(copyInto[16], 10000, true);
                l[1][l1] = JetMidlet.Z(copyInto[17], 0);
                t[3][l1] = JetMidlet.Z(copyInto[17], 9);
                l[3][l1] = l[1][l1];
                l1++;
                if(copyInto[18] > 0)
                    t[1][l1] = o.I(copyInto[18], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[18], k1);
                t[3][l1] = JetMidlet.Z(copyInto[19], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[20] > 0)
                    t[1][l1] = o.I(copyInto[20], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[20], k1);
                t[3][l1] = JetMidlet.Z(copyInto[21], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[22] > 0)
                    t[1][l1] = o.I(copyInto[22], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[22], k1);
                t[3][l1] = JetMidlet.Z(copyInto[23], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[24] > 0)
                    t[1][l1] = o.I(copyInto[24], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[24], k1);
                t[3][l1] = JetMidlet.Z(copyInto[25], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[26] > 0)
                    t[1][l1] = o.I(copyInto[26], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[26], k1);
                t[3][l1] = JetMidlet.Z(copyInto[27], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[28] > 0)
                    t[1][l1] = o.I(copyInto[28], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[28], k1);
                t[3][l1] = t[1][l1 - 1];
                l[3][l1] = l[1][l1 - 1];
                l1++;
                t[1][l1] = t[1][l1 - 1];
                l[1][l1] = l[1][l1 - 1];
                t[3][l1] = JetMidlet.Z(copyInto[29], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[30] > 0)
                    t[1][l1] = o.I(copyInto[30], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[30], k1);
                t[3][l1] = JetMidlet.Z(copyInto[31], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[32] > 0)
                    t[1][l1] = o.I(copyInto[32], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[32], k1);
                t[3][l1] = JetMidlet.Z(copyInto[33], 12);
                l[3][l1] = 0xffff00;
                l1++;
                if(copyInto[34] > 0)
                    t[1][l1] = o.I(copyInto[34], false);
                else
                    t[1][l1] = "--";
                l[1][l1] = JetMidlet.Z(copyInto[34], k1);