c.java

泡泡龙游戏原代码

                _fldnew[l] = _fldnull;
                _mthfor();
                _fldvoid++;
                return 0;
            }
        }
        return byte0;
    }

    public static final void a(int i)
    {
        int ai[] = new int[60];
        for(int j = 0; j < 60; j++)
            ai[j] = _fldnew[j];

        i = i / 2 + 3;
        if(i > 7)
            i = 7;
        int k = 0;
        for(int l = 0; l < 6; l++)
        {
            int j1;
            while((j1 = (_flddo.nextInt() >>> 1) % i + 1) == k) ;
            if(j1 == 7 && (ai[l] & 0xf) == j1)
                j1 = (_flddo.nextInt() >>> 1) % 6 + 1;
            if(j1 == 7 && ai[5] == -1 && l > 0 && (ai[l - 1] & 0xf) == j1)
                j1 = (_flddo.nextInt() >>> 1) % 6 + 1;
            if(j1 == 7 && ai[5] != -1 && (ai[l + 1] & 0xf) == j1)
                j1 = (_flddo.nextInt() >>> 1) % 6 + 1;
            k = j1;
            _fldnew[l] = j1;
            _fldvoid++;
        }

        k = 1;
        for(int i1 = 0; k < 10; i1++)
        {
            for(int k1 = 0; k1 < 6; k1++)
                _fldnew[k1 + 6 * k] = ai[k1 + 6 * i1];

            k++;
        }

        if(_fldnew[11] != -1)
        {
            _fldvoid--;
            _fldnew[5] = -1;
        }
        _mthfor();
    }

    public static int _mthif()
    {
        int ai[] = new int[60];
        for(int i = 0; i < 60; i++)
            ai[i] = _fldnew[i];

        int j = _mthint(_fldchar + 6 * _fldcase);
        if(j >= 3)
        {
            _fldvoid -= j;
        } else
        {
            for(int k = 0; k < 60; k++)
                _fldnew[k] = ai[k];

            j = 0;
        }
        return j;
    }

    public static int _mthint()
    {
        int i = 0;
        for(int j = 0; j < 60; j++)
            if(_fldnew[j] > 0 && (_fldnew[j] & 0x40) != 64 && !_mthif(j))
            {
                _fldnew[j] |= 0x10;
                _fldnew[j] &= 0x18ffff;
                i++;
            }

        for(int k = 59; k >= 0; k--)
        {
            if(_fldnew[k] <= 0)
                continue;
            if((_fldnew[k] & 0x40) == 64)
                _fldnew[k] &= 0xffffffbf;
            if((_fldnew[k] & 0x10) != 16)
                continue;
            int l = 0;
            if(_fldnew[((k / 6) * 6 + 6) - 1] == -1)
                l = 1;
            if((_fldnew[k] & 0x80000) > 0 && _fldnew[k + 6 + l] > 0 && (_fldnew[k + 6 + l] & 0x10) == 0)
            {
                _fldnew[k] &= 0xffffffef;
                i--;
            }
            if((_fldnew[k] & 0x100000) > 0 && _fldnew[k + 5 + l] > 0 && (_fldnew[k + 5 + l] & 0x10) == 0)
            {
                _fldnew[k] &= 0xffffffef;
                i--;
            }
        }

        _fldvoid -= i;
        return i;
    }

    private static int _mthint(int i)
    {
        int j = 0;
        int k = 0;
        if(_fldnew[((i / 6) * 6 + 6) - 1] == -1)
            k = 1;
        if((_fldnew[i] & 0xff00) >= 256)
        {
            if((_fldnew[i] & 0x10) != 16)
            {
                _fldnew[i] |= 0x10;
                j++;
            }
            for(int l = 256; l < '\u4000'; l <<= 1)
            {
                int i1 = _fldnew[i] & 0xff00 & l;
                _fldnew[i] &= ~i1;
                if(i1 == 256)
                {
                    int j1 = (i - 7) + k;
                    j += _mthint(j1);
                    continue;
                }
                if(i1 == 512)
                {
                    int k1 = (i - 6) + k;
                    j += _mthint(k1);
                    continue;
                }
                if(i1 == 1024)
                {
                    int l1 = i + 1;
                    j += _mthint(l1);
                    continue;
                }
                if(i1 == 2048)
                {
                    int i2 = i + 6 + k;
                    j += _mthint(i2);
                    continue;
                }
                if(i1 == 4096)
                {
                    int j2 = i + 5 + k;
                    j += _mthint(j2);
                    continue;
                }
                if(i1 == 8192)
                {
                    int k2 = i - 1;
                    j += _mthint(k2);
                }
            }

        }
        return j;
    }

    private static boolean _mthif(int i)
    {
        if(_fldnew[i] == -1)
            return true;
        if(i >= 0 && i < 6)
            return true;
        if((_fldnew[i] & 0x40) == 64)
            return true;
        boolean flag = false;
        int j = 0;
        if(_fldnew[((i / 6) * 6 + 6) - 1] == -1)
            j = 1;
        int k = 0x10000;
        do
        {
            if(k >= 0x400000)
                break;
            int l = _fldnew[i] & 0xff0000 & k;
            if(l == 0x10000)
            {
                _fldnew[i] &= ~l;
                int i1 = (i - 7) + j;
                flag = _mthif(i1);
                _fldnew[i] |= l;
            } else
            if(l == 0x20000)
            {
                _fldnew[i] &= ~l;
                int j1 = (i - 6) + j;
                flag = _mthif(j1);
                _fldnew[i] |= l;
            } else
            if(l == 0x40000)
            {
                _fldnew[i] &= ~l;
                int k1 = i + 1;
                flag = _mthif(k1);
                _fldnew[i] |= l;
            } else
            if(l == 0x200000)
            {
                _fldnew[i] &= ~l;
                int l1 = i - 1;
                flag = _mthif(l1);
                _fldnew[i] |= l;
            }
            if(flag)
            {
                _fldnew[i] |= 0x40;
                break;
            }
            k <<= 1;
        } while(true);
        return flag;
    }

    public static void _mthdo(int i)
    {
        int j = 0;
        if(_fldnew[((i / 6) * 6 + 6) - 1] == -1)
            j = 1;
        if((_fldnew[i] & 0x10000) == 0x10000)
        {
            int k = (i - 7) + j;
            _fldnew[k] &= 0xfff7ffff;
        }
        if((_fldnew[i] & 0x20000) == 0x20000)
        {
            int l = (i - 6) + j;
            _fldnew[l] &= 0xffefffff;
        }
        if((_fldnew[i] & 0x40000) == 0x40000)
            _fldnew[i + 1] &= 0xffdfffff;
        if((_fldnew[i] & 0x80000) == 0x80000)
        {
            int i1 = i + 6 + j;
            _fldnew[i1] &= 0xfffeffff;
        }
        if((_fldnew[i] & 0x100000) == 0x100000)
        {
            int j1 = i + 5 + j;
            _fldnew[j1] &= 0xfffdffff;
        }
        if((_fldnew[i] & 0x200000) == 0x200000)
            _fldnew[i - 1] &= 0xfffbffff;
        _fldnew[i] = 0;
    }

    private static void _mthdo()
    {
        _fldbyte = 0;
label0:
        for(int i = 8; i >= 0; i--)
        {
            int k = i * 6;
            if((_fldnew[k] & 0xf) <= 0)
                continue;
            _fldint = 0;
            if(_fldnew[k + 5] == -1)
                _fldint = 1;
            int i1 = 0;
            do
            {
                if(i1 >= 60)
                    continue label0;
                if((k = _mthfor(k)) < 0)
                    return;
                i1++;
            } while(true);
        }

label1:
        for(int j = 0; j < 6 && _fldnew[j] != -1; j++)
        {
            if((_fldnew[j] & 0xf) <= 0)
                continue;
            _fldint = 2;
            int l = 0;
            do
            {
                if(l >= 60)
                    continue label1;
                if((j = _mthfor(j)) < 0)
                    return;
                l++;
            } while(true);
        }

        if((_fldbyte & 0x10) == 0)
            _fldbyte = 1;
    }

    private static int _mthfor(int i)
    {
        int j = i;
        _fldint -= 3;
        if(_fldint < 0)
            _fldint += 6;
        if(_fldnew[j] > 0)
            _fldbyte |= 1 << (_fldnew[j] & 0xf) - 1;
        int k = 5;
label0:
        do
        {
            if(k-- < 0)
                break;
            _fldint--;
            if(_fldint < 0)
                _fldint += 6;
            int l = 0;
            if(_fldnew[((i / 6) * 6 + 6) - 1] == -1)
                l = 1;
            if(_fldint == 0)
                j = (i - 7) + l;
            else
            if(_fldint == 1)
                j = (i - 6) + l;
            else
            if(_fldint == 2)
                j = i + 1;
            else
            if(_fldint == 3)
                j = i + 6 + l;
            else
            if(_fldint == 4)
                j = i + 5 + l;
            else
            if(_fldint == 5)
                j = i - 1;
            if(l == 1 ? i > ((i / 6) * 6 + 6) - 2 : i > ((i / 6) * 6 + 6) - 1)
                break;
            if(j < 0)
            {
                j = i;
                j++;
                do
                    if(++j > 5)
                        break label0;
                while((_fldnew[j] & 0xf) <= 0);
                _fldint = 2;
                return j;
            }
            if(j >= 60)
                return -1;
            if((_fldnew[j] & 0xf) > 0)
                return j;
        } while(true);
        return -1;
    }

    public static int _fldtry;
    public static int _fldfor;
    public static int _fldnull;
    public static int _fldlong;
    public static int _fldvoid;
    public static int a;
    public static int _fldnew[];
    private static int _fldgoto;
    private static int _fldelse;
    private static int _fldchar;
    private static int _fldcase;
    private static int _fldbyte;
    private static int _fldint;
    private static Random _flddo;
    public static final int _fldif[] = {
        -994, -984, -970, -951, -927, -898, -866, -829, -788, -743, 
        -694, -642, -587, -529, -469, -406, -342, -275, -207, -139, 
        -69, 0, 69, 139, 207, 275, 342, 406, 469, 529, 
        587, 642, 694, 743, 788, 829, 866, 898, 927, 951, 
        970, 984, 994
    };
    public static final int b[] = {
        -104, -173, -241, -309, -374, -438, -499, -559, -615, -669, 
        -719, -766, -809, -848, -882, -913, -939, -961, -978, -990, 
        -997, -1000, -997, -990, -978, -961, -939, -913, -882, -848, 
        -809, -766, -719, -669, -615, -559, -499, -438, -374, -309, 
        -241, -173, -104
    };

}