// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;

public class Field
{

    private static final int n_pos[] = {
        -8, 1, 8, -1
    };
    private static final int ojama_pos[] = {
        6, 1, 5, 2, 4, 3
    };
    private static final int main_d[] = {
        0, 0, 1, 0
    };
    private static final int sub_d[] = {
        1, 2, 0, -2
    };
    public int player;
    public int level;
    public Field enemy;
    private int field[][];
    private short sx;
    private short sy;
    private short next_x;
    private short next_y;
    private short next2_x;
    private short next2_y;
    private int stat;
    public boolean pause_flag;
    public int score;
    private int erase_score;
    private int pass_cnt;
    private int pass_time;
    private int fall_bonus;
    private int d_score;
    private int chain;
    private int erase_bonus;
    private int fall_speed;
    private int fall_cnt;
    private int land_cnt;
    private int erase_cnt;
    private int ojama_num;
    private int now_ojama;
    private int ojama_cnt;
    private int ojama_kill[];
    private int next_cnt;
    private int next_col[];
    private int next2_col[];
    private int falling[][];
    private int dir;
    private boolean draw_flag[];
    private int argo[];
    private int height[];
    private int target_x;
    private int target_turn;
    private int set_cnt;
    private int priority[][];
    private int now_priority;
    private int bonus1[];
    private boolean bonus2[];
    private int bonus3[];
    private Image ojamaImg;

    public Field(short word0, short word1, int i)
    {
        field = new int[120][5];
        ojama_kill = new int[2];
        next_col = new int[2];
        next2_col = new int[2];
        falling = new int[2][2];
        draw_flag = new boolean[3];
        height = new int[8];
        priority = new int[2][16];
        bonus1 = new int[7];
        bonus2 = new boolean[5];
        bonus3 = new int[2];
        ojamaImg = Image.createImage(60, 10);
        sx = word0;
        sy = word1;
        next_x = i != 0 ? (short)(sx - 20) : (short)(sx + 60 + 10);
        next_y = i != 0 ? (short)(sy + 61) : (short)(sy + 10);
        next2_x = i != 0 ? (short)(sx - 30) : (short)(sx + 60 + 20);
        next2_y = i != 0 ? (short)(sy + 71) : (short)(sy + 20);
    }

    public void init(int i, int j, int ai[])
    {
        int i1 = 0;
        player = (argo = ai) != null ? 1 : 0;
        level = i;
        for(int l = 0; l < 15; l++)
        {
            for(int k = 0; k < 8; k++)
            {
                int ai1[] = field[i1++];
                if(k > 0 && k < 7 && l > 0 && l < 14)
                    clear_puyo(ai1);
                else
                    ai1[0] = -2;
            }

        }

        score = j;
        erase_score = 0;
        next_cnt = PuyoPuyo2.get_next(0, next_col);
        next_cnt = PuyoPuyo2.get_next(next_cnt, next2_col);
        ojama_num = 0;
        now_ojama = 0;
        ojama_cnt = 0;
        pass_cnt = 1;
        pass_time = 0;
        stat = 0;
        pause_flag = false;
        bonus3[0] = 0;
        bonus3[1] = 0;
    }

    private void set_puyo(int i, int ai[])
    {
        ai[0] = i;
        ai[1] = 1;
        ai[2] = 0;
        ai[3] = 0;
        ai[4] = 0;
    }

    private void clear_puyo(int ai[])
    {
        ai[0] = -1;
        ai[1] = 1;
        ai[2] = 0;
        ai[3] = 0;
        ai[4] = 0;
    }

    private void add_score(int i)
    {
        score += i;
        if(score > 0x3b9ac9ff)
            score = 0x3b9ac9ff;
        draw_flag[0] = true;
    }

    public void start()
    {
        stat = 6;
    }

    public void add_ojama(int i)
    {
        if(i > 0)
        {
            ojama_num += i;
            draw_flag[1] = true;
        }
    }

    public boolean run(int i)
    {
        if(stat < 8)
            pass_time++;
        if(player == 1)
            i = get_key();
        int j;
        do
        {
            j = stat;
            switch(stat)
            {
            default:
                break;

            case 1: // '\001'
                if(field[19][0] == -1)
                {
                    init_puyo();
                    stat = 2;
                } else
                {
                    stat = 8;
                    land_cnt = 0;
                    return false;
                }
                // fall through

            case 2: // '\002'
                control(i);
                if(land_cnt > 0)
                    continue;
                stat = 3;
                chain = 0;
                // fall through

            case 3: // '\003'
                if(fall())
                    return true;
                if(check_erase())
                {
                    stat = 5;
                    erase_cnt = 0;
                    chain++;
                    continue;
                }
                stat = 4;
                land_cnt = 5;
                // fall through

            case 4: // '\004'
                if(--land_cnt <= 0)
                {
                    add_score(d_score);
                    byte byte0;
                    switch((pass_time * 30) / 1000 / 32)
                    {
                    case 0: // '\0'
                        byte0 = 32;
                        break;

                    case 1: // '\001'
                        byte0 = 24;
                        break;

                    case 2: // '\002'
                        byte0 = 16;
                        break;

                    case 3: // '\003'
                        byte0 = 12;
                        break;

                    case 4: // '\004'
                        byte0 = 8;
                        break;

                    case 5: // '\005'
                        byte0 = 6;
                        break;

                    case 6: // '\006'
                        byte0 = 4;
                        break;

                    case 7: // '\007'
                        byte0 = 3;
                        break;

                    default:
                        byte0 = 2;
                        break;
                    }
                    int k2 = (40 * ((byte0 * 100) / 32)) / 100;
                    if(ojama_num == 0)
                    {
                        enemy.add_ojama((d_score + fall_bonus) / k2);
                    } else
                    {
                        if((d_score + fall_bonus) / k2 > 0)
                            ojama_kill[player] = 14;
                        if(ojama_num - (d_score + fall_bonus) / k2 < 0)
                        {
                            enemy.add_ojama((d_score + fall_bonus) / k2 - ojama_num);
                            ojama_num = 0;
                        } else
                        {
                            ojama_num -= (d_score + fall_bonus) / k2;
                        }
                    }
                    stat = 6;
                }
                break;

            case 5: // '\005'
                if(erase())
                    return true;
                stat = 3;
                break;

            case 6: // '\006'
                now_ojama = ojama_num >= 30 ? 30 : ojama_num;
                ojama_num -= now_ojama;
                draw_flag[1] = true;
                erase_score = 0;
                draw_flag[0] = true;
                stat = 7;
                if(now_ojama > 0 && PuyoPuyo2.config[1])
                    if(enemy.player != 1);
                // fall through

            case 7: // '\007'
                draw_ojama_field();
                if(fall_ojama())
                    return true;
                stat = 1;
                break;

            case 8: // '\b'
                if(++land_cnt > 40)
                    return false;
                if(land_cnt == 12)
                {
                    for(int k = 1; k < 7; k++)
                        clear_puyo(field[k + 112]);

                }
                for(int l = 1; l < 7; l++)
                    if(land_cnt > l + 12 && land_cnt > 18 - l)
                    {
                        int l1 = l + 112;
                        for(int j1 = 14; j1 > 1; j1--)
                        {
                            set_puyo(field[l1 - 8][0], field[l1]);
                            l1 -= 8;
                        }

                        field[l + 8][0] = -1;
                    }

                break;

            case 9: // '\t'
                land_cnt++;
                if(land_cnt == 40)
                {
                    erase_score = 0;
                    pass_time = (pass_time * 30) / 1000;
                    if(pass_time <= 40)
                        d_score = 29500 - 500 * pass_time;
                    else
                    if(pass_time <= 60)
                        d_score = 21500 - 300 * pass_time;
                    else
                    if(pass_time <= 90)
                        d_score = 9500 - 100 * pass_time;
                    else
                    if(pass_time <= 140)
                        d_score = 1400 - 10 * pass_time;
                    else
                        d_score = 0;
                    erase_cnt = score;
                    erase_bonus = d_score;
                    int i2 = 17;
                    for(int i1 = 2; i1 < 14; i1++)
                    {
                        for(int k1 = 1; k1 < 7; k1++)
                            clear_puyo(field[i2++]);

                        i2 += 2;
                    }

                } else
                if(land_cnt > 40)
                {
                    if(land_cnt > 206)
                        return false;
                    if((i & 0x10c21) != 0)
                        land_cnt = 206;
                    int j2 = land_cnt >= 104 ? 64 : land_cnt - 40;
                    if(player == 0 && j2 > 32)
                    {
                        score = erase_cnt + (erase_bonus * (j2 - 32)) / 32;
                        d_score = (erase_bonus * (64 - j2)) / 32;
                        add_score(0);
                    }
                }
                break;
            }
        } while(stat != j);
        return true;
    }

    private void init_puyo()
    {
        for(int i = 0; i < 2; i++)
        {
            falling[i][0] = next_col[i];