field.java

手机游戏 SEGA《PuyoPuyo》 J2ME源代码+详细注释

            falling[i][1] = 19 - i * 8;
        }

        dir = 0;
        next_col[0] = next2_col[0];
        next_col[1] = next2_col[1];
        next_cnt = PuyoPuyo2.get_next(next_cnt, next2_col);
        draw_flag[2] = true;
        fall_speed = (pass_cnt * (level + 8) + (level * 2 + 16) * (16 + level)) / (pass_cnt * 4 + (16 + level) * 4);
        pass_cnt++;
        fall_cnt = fall_speed;
        land_cnt = 32;
        erase_cnt = 8;
        fall_bonus = 0;
        d_score = 0;
        if(player == 1)
            set_target();
    }

    private void control(int i)
    {
        int j = falling[0][1];
        int k = falling[1][1];
        clear_puyo(field[j]);
        clear_puyo(field[k]);
        if((i & 0x2010) != 0)
        {
            if(field[j - 1][0] == -1 && field[k - 1][0] == -1)
            {
                j--;
                k--;
            } else
            if((i & 0x1005) != 0 && field[j + 8][0] != -1 && field[j - 1][0] != -1 && field[k - 1][0] == -1 && field[j - 2][0] == -1 && field[k - 2][0] == -1)
            {
                j -= 2;
                k -= 2;
            } else
            {
                target_x = falling[0][1] % 8;
            }
        } else
        if((i & 0x4040) != 0)
            if(field[j + 1][0] == -1 && field[k + 1][0] == -1)
            {
                j++;
                k++;
            } else
            if((i & 0x10c20) != 0 && field[j + 8][0] != -1 && field[j + 1][0] != -1 && field[k + 1][0] == -1 && field[j + 2][0] == -1 && field[k + 2][0] == -1)
            {
                j += 2;
                k += 2;
            } else
            {
                target_x = falling[0][1] % 8;
            }
        byte byte0 = 0;
        if((i & 0x10c20) != 0)
            byte0 = !PuyoPuyo2.config[0] && player != 1 ? (byte)3 : (byte)1;
        else
        if((i & 0x1005) != 0)
            byte0 = !PuyoPuyo2.config[0] && player != 1 ? (byte)1 : (byte)3;
        if(byte0 != 0)
        {
            dir = dir + byte0 & 0x3;
            k = j + n_pos[dir];
            if(field[k][0] != -1)
            {
                if(field[j - n_pos[dir]][0] != -1)
                {
                    dir = dir + byte0 & 0x3;
                    target_turn = target_turn + byte0 & 0x3;
                }
                k = j;
                j -= n_pos[dir];
            }
        }
        if(field[j + 8][0] != -1 || field[k + 8][0] != -1)
        {
            if(erase_cnt > 0)
                if(erase_cnt-- != 8);
            if((i & 0x8100) != 0 && land_cnt > 16)
                land_cnt = 16;
            land_cnt--;
        } else
        {
            if((i & 0x8100) != 0)
            {
                if(fall_cnt > 1)
                    fall_cnt = 1;
                fall_bonus += 2;
                add_score(2);
            }
            erase_cnt = 8;
            if(--fall_cnt == 0)
            {
                j += 8;
                k += 8;
                fall_cnt = fall_speed;
            }
        }
        falling[0][1] = j;
        falling[1][1] = k;
        set_puyo(falling[0][0], field[j]);
        set_puyo(falling[1][0], field[k]);
        if((erase_cnt & 0x2) != 0)
        {
            byte byte1 = erase_cnt >> 1 != 3 ? ((byte) (17)) : 18;
            if(field[j + 8][0] != -1)
            {
                field[j][3] = byte1;
                if(k == j - 8)
                    field[k][3] = byte1;
            }
            if(field[k + 8][0] != -1)
            {
                field[k][3] = byte1;
                if(j == k - 8)
                    field[j][3] = byte1;
            }
        }
    }

    private boolean fall()
    {
        boolean flag = false;
        for(int i = 13; i > 0; i--)
        {
            int j = 1;
            for(int i1 = 1 + i * 8; j < 7; i1++)
            {
                int ai[] = field[i1];
                int k;
                int l;
                if((l = ai[0]) >= 0)
                    if(field[i1 + 8][0] == -1)
                    {
                        set_puyo(l, field[i1 + 8]);
                        clear_puyo(ai);
                        if(field[i1 + 16][0] != -1)
                            field[i1 + 8][4] = 8;
                        flag = true;
                    } else
                    if((k = ai[4]) > 0)
                    {
                        ai[4] = --k;
                        if(l < 5 && (k & 0x1) == 1)
                        {
                            ai[3] = (k & 0x2) != 0 ? k != 7 ? 17 : 18 : 0;
                            ai[1] = 1;
                        }
                        flag = true;
                    }
                j++;
            }

        }

        return flag;
    }

    private boolean check_erase()
    {
        boolean flag = false;
        int l3 = 9;
        for(int i = 1; i < 14; i++)
        {
            for(int k1 = 1; k1 < 7; k1++)
                field[l3++][2] = 0;

            l3 += 2;
        }

        l3 = 9;
        for(int j = 1; j < 14; j++)
        {
            for(int l1 = 1; l1 < 7; l1++)
            {
                int ai[] = field[l3];
                int i3 = ai[0];
                if(i3 >= 0 && i3 < 5)
                {
                    int i4 = 0;
                    for(int j2 = 0; j2 < 4; j2++)
                        if(field[l3 - n_pos[j2]][0] == i3)
                            i4 |= 1 << j2;

                    if(i4 != ai[3])
                    {
                        ai[3] = i4;
                        ai[1] = 1;
                    }
                    check_neighbor(l3, ai[2]);
                }
                l3++;
            }

            l3 += 2;
        }

        for(int k = 0; k < 7; k++)
            bonus1[k] = 0;

        for(int l = 0; l < 5; l++)
            bonus2[l] = false;

        bonus3[player] = 0;
        erase_score = 0;
        erase_bonus = 0;
        l3 = 17;
        for(int i1 = 2; i1 < 14; i1++)
        {
            for(int i2 = 1; i2 < 7; i2++)
            {
                int ai1[] = field[l3];
                int k2 = ai1[2];
                if(k2 >= 4 && k2 < 256)
                {
                    flag = true;
                    erase_score += 10;
                    if(k2 >= 5)
                    {
                        int j3 = k2 >= 11 ? 6 : k2 - 5;
                        if(bonus1[j3] > 0)
                        {
                            bonus1[j3]--;
                        } else
                        {
                            erase_bonus += j3 >= 6 ? 10 : j3 + 2;
                            bonus1[j3] += k2;
                        }
                    }
                    bonus2[ai1[0]] = true;
                    for(int k3 = 0; k3 < 4; k3++)
                    {
                        ai1 = field[l3 + n_pos[k3]];
                        if(ai1[0] == 5)
                            ai1[2] = 256;
                    }

                }
                if(bonus3[player] == 0 && ai1[0] != -1)
                    bonus3[player] = 2;
                l3++;
            }

            l3 += 2;
        }

        if(bonus3[player] == 0)
        {
            bonus3[player] = 1;
            d_score += 600;
        } else
        if(bonus3[player] == 2)
            bonus3[player] = 0;
        if(!flag)
            return false;
        if(chain > 0)
            erase_bonus += chain < 9 ? 1 << chain + 2 : 999;
        int l2 = 1;
        for(int j1 = 0; j1 < 5; j1++)
            if(bonus2[j1])
                l2 <<= 1;

        if(l2 > 2)
            erase_bonus += (l2 >> 2) * 3;
        else
        if(erase_bonus == 0)
            erase_bonus = 1;
        draw_flag[0] = true;
        d_score += erase_score * erase_bonus;
        return true;
    }

    private void check_neighbor(int i, int j)
    {
        field[i][2]++;
        int l = field[i][0];
        for(int i1 = 0; i1 < 4; i1++)
        {
            int k = i + n_pos[i1];
            if(field[k][0] == l && field[k][2] <= j)
                check_neighbor(k, j);
        }

    }

    private boolean erase()
    {
        erase_cnt++;
        int k = 17;
        for(int i = 2; i < 14; i++)
        {
            for(int j = 1; j < 7; j++)
            {
                int ai[] = field[k++];
                if(ai[2] < 4)
                    continue;
                if(erase_cnt == 18)
                {
                    clear_puyo(ai);
                    continue;
                }
                if(erase_cnt <= 11)
                    ai[1] = 1;
            }

            k += 2;
        }

        return erase_cnt < 18;
    }

    private boolean fall_ojama()
    {
        if(now_ojama >= 6)
        {
            for(int i = 9; i < 15; i++)
                field[i][0] = 5;

            now_ojama -= 6;
        } else
        {
            for(int j = 0; j < now_ojama; j++)
            {
                field[ojama_pos[ojama_cnt] + 8][0] = 5;
                ojama_cnt = (ojama_cnt + 1) % 6;
            }

            now_ojama = 0;
        }
        return fall();
    }

    public void set_win()
    {
        stat = 9;
        land_cnt = 0;
    }

    private void set_height()
    {
        for(int i = 1; i < 7; i++)
        {
            int j = 1;
            for(int k = i + 8; j < 14 && field[k][0] == -1; k += 8)
                j++;

            height[i] = j - 1;
        }

        height[0] = height[7] = 0;
    }

    private void set_target()
    {
        set_height();
        set_priority(falling[0][0], priority[0]);
        set_priority(falling[1][0], priority[1]);
        now_priority = 0;
        for(int i = 1; i < 7; i++)
        {
            for(int j = 0; j < argo[4]; j++)
            {
                int k = (i << 1) + sub_d[j];
                if(k < 2 || k >= 14)
                    continue;
                k = priority[0][(i << 1) + main_d[j]] + priority[1][k];
                if(k >= now_priority)
                {
                    target_x = i;
                    target_turn = j;
                    now_priority = k;
                }
            }

        }

        set_cnt = 0;
    }