maincanvas.java

机器人大战MetalEN

        DrawString("Target", 0, 16);
        DrawString(as[0][Game_Stage], 0, 64);
        DrawString(as[1][Game_Stage], 0, 80);
        switch(Game_Stage)
        {
        case 0: // '\0'
            offGfx.drawImage(Img_Enemy[0][1], 48 + Draw_Zero_X, 16 + Draw_Zero_Y, 0);
            break;

        case 1: // '\001'
            DrawString("No Data", 16, 32);
            break;

        case 2: // '\002'
            offGfx.drawImage(Img_Enemy[0][3], 48 + Draw_Zero_X, 16 + Draw_Zero_Y, 0);
            DrawString("\3274", 80, 32);
            break;

        case 3: // '\003'
            offGfx.drawImage(Img_Enemy[0][0], 48 + Draw_Zero_X, 16 + Draw_Zero_Y, 0);
            break;

        case 4: // '\004'
            DrawString("Unknown", 16, 32);
            break;

        case 5: // '\005'
            DrawString("Unknown", 16, 32);
            break;
        }
        WipeOutDraw(Game_SubTimer);
    }

    public void ChapterGameInit()
    {
        int ai[] = {
            48, 96, 32, 32, 944, 48
        };
        int ai1[] = {
            832, 960, 320, 192, 448, 320
        };
        int ai2[] = {
            2800, 1300, 4200, 1500, 2300, 1800
        };
        byte abyte0[] = {
            32, 32, 32, 32, 32, 64
        };
        Game_MainFlag &= 0xfffffffe;
        Game_MainFlag &= 0xfffffffd;
        Game_MainTimer = ai2[Game_Stage];
        Game_SubTimer = 0;
        My_X = ai[Game_Stage] << 16;
        My_Y = ai1[Game_Stage] << 16;
        My_XSpeed = 0;
        My_YSpeed = 0;
        if(Game_Stage - 4 == 0)
            My_ActFlag = 1;
        else
            My_ActFlag = 0;
        My_AP = 128;
        My_GType = 0;
        My_AnimeCount = 0;
        My_AttackCount = 0;
        My_DCount = 0;
        My_WSpeed = 0x40000;
        MyBurst_Flag = 2048;
        for(int i = 7; i >= 0; i--)
            MyShot_Flag[i] = 2048;

        EnemyShot_Max = abyte0[Game_Stage];
        EnemyShot_X = null;
        EnemyShot_Y = null;
        EnemyShot_XSpeed = null;
        EnemyShot_YSpeed = null;
        EnemyShot_Width = null;
        EnemyShot_Height = null;
        EnemyShot_HitWidth = null;
        EnemyShot_HitHeight = null;
        EnemyShot_Attack = null;
        EnemyShot_Flag = null;
        EnemyShot_Count = null;
        EnemyShot_GType = null;
        EnemyShot_X = new int[EnemyShot_Max];
        EnemyShot_Y = new int[EnemyShot_Max];
        EnemyShot_XSpeed = new int[EnemyShot_Max];
        EnemyShot_YSpeed = new int[EnemyShot_Max];
        EnemyShot_Width = new byte[EnemyShot_Max];
        EnemyShot_Height = new byte[EnemyShot_Max];
        EnemyShot_HitWidth = new byte[EnemyShot_Max];
        EnemyShot_HitHeight = new byte[EnemyShot_Max];
        EnemyShot_Attack = new byte[EnemyShot_Max];
        EnemyShot_Flag = new int[EnemyShot_Max];
        EnemyShot_Count = new int[EnemyShot_Max];
        EnemyShot_GType = new int[EnemyShot_Max];
        for(int j = EnemyShot_Max - 1; j >= 0; j--)
            EnemyShot_Flag[j] = 2048;

        for(int k = 31; k >= 0; k--)
            Exp_Flag[k] = 2048;

        Camera_X = My_X + 0xfff00000;
        Camera_Y = My_Y + 0xffd80000;
        GameInitStageEnemy(Game_Stage);
        ik = 0;
        FillRect(0, 0, 0);
        SoftKeyName(2);
        Game_MainChapter = 8;
    }

    public void GameInitStage(int i)
    {
        int ai[] = {
            62, 16, 64, 24, 64, 14
        };
        int ai1[] = {
            56, 64, 64, 16, 32, 24
        };
        int ai2[] = {
            31, 8, 32, 12, 32, 7
        };
        int ai3[] = {
            28, 32, 32, 8, 16, 12
        };
        int ai4[] = {
            0, 21, 3, 0, 27, 0
        };
        String as[] = {
            "MD00.dat", "MD01.dat", "MD02.dat", "MD03.dat", "MD04.dat", "MD05.dat"
        };
        String as1[] = {
            "MDG00.dat", "MDG01.dat", "MDG02.dat", "MDG03.dat", "MDG04.dat", "MDG05.dat"
        };
        Map_Front = null;
        Map_Front_G = null;
        Run.gc();
        int l1 = ai[i] * ai1[i];
        Map_Front = new byte[ai1[i]][ai[i]];
        Map_Front_G = new byte[ai3[i]][ai2[i]];
        byte abyte0[] = new byte[l1];
        try
        {
            InputStream inputstream = getClass().getResourceAsStream(as[i]);
            inputstream.skip(0L);
            inputstream.read(abyte0);
            inputstream.close();
        }
        catch(Exception exception)
        {
            exception.printStackTrace();
        }
        for(int j = 0; j < ai1[i]; j++)
        {
            for(int i1 = 0; i1 < ai[i]; i1++)
                Map_Front[j][i1] = abyte0[j * ai[i] + i1];

        }

        abyte0 = null;
        Run.gc();
        l1 = ai2[i] * ai3[i];
        abyte0 = new byte[l1];
        try
        {
            InputStream inputstream1 = getClass().getResourceAsStream(as1[i]);
            inputstream1.skip(0L);
            inputstream1.read(abyte0);
            inputstream1.close();
        }
        catch(Exception exception1)
        {
            exception1.printStackTrace();
        }
        for(int k = 0; k < ai3[i]; k++)
        {
            for(int j1 = 0; j1 < ai2[i]; j1++)
                Map_Front_G[k][j1] = abyte0[k * ai2[i] + j1];

        }

        abyte0 = null;
        Run.gc();
        if(i - 1 == 0)
        {
            byte abyte1[] = new byte[32];
            try
            {
                InputStream inputstream2 = getClass().getResourceAsStream("MDG012.dat");
                inputstream2.skip(0L);
                inputstream2.read(abyte1);
                inputstream2.close();
            }
            catch(Exception exception2)
            {
                exception2.printStackTrace();
            }
            for(int l = 0; l < 4; l++)
            {
                for(int k1 = 0; k1 < 8; k1++)
                    Map_Back_G[l][k1] = abyte1[l * 8 + k1];

            }

            abyte1 = null;
            Run.gc();
        }
        Map_Width = ai[i];
        Map_Height = ai1[i];
        Map_GraWidth = ai2[i];
        Map_GraHeight = ai3[i];
        Game_ClearCond = ai4[i];
    }

    public void GameInitStageEnemy(int i)
    {
        int ai[] = {
            24, 22, 29, 1, 28, 1
        };
        int ai1[][] = {
            {
                960, 192, 384, 544, 576, 576, 576, 688, 832, 848, 
                848, 832, 784, 832, 784, 832, 784, 768, 640, 720, 
                768, 848, 800, 736
            }, {
                64, 160, 112, 64, 160, 112, 64, 160, 112, 64, 
                160, 112, 64, 112, 160, 64, 112, 64, 160, 64, 
                112, 160
            }, {
                32, 736, 448, 672, 256, 256, 400, 320, 384, 256, 
                384, 320, 384, 128, 384, 128, 272, 128, 256, 256, 
                496, 496, 112, 640, 896, 896, 768, 768, 640
            }, {
                176
            }, {
                768, 704, 704, 740, 832, 384, 256, 80, 128, 64, 
                448, 432, 448, 480, 496, 432, 448, 480, 496, 944, 
                944, 944, 784, 816, 816, 848, 880, 848, 880, 912, 
                944, 976
            }, {
                176
            }
        };
        int ai2[][] = {
            {
                128, 784, 768, 800, 800, 736, 688, 640, 848, 688, 
                624, 528, 528, 464, 464, 400, 400, 560, 320, 320, 
                320, 320, 144, 128
            }, {
                840, 780, 700, 650, 620, 550, 440, 380, 380, 300, 
                300, 250, 220, 200, 160, 160, 160, 100, 100, 64, 
                64, 32
            }, {
                96, 64, 896, 864, 960, 944, 944, 896, 896, 848, 
                848, 784, 720, 720, 656, 304, 304, 160, 64, 32, 
                272, 80, 48, 128, 256, 512, 496, 960, 800
            }, {
                176
            }, {
                384, 448, 384, 410, 304, 448, 336, 336, 448, 288, 
                192, 160, 144, 160, 144, 48, 32, 48, 32, 192, 
                144, 80, 176, 208, 128, 160, 192, 64, 96, 128, 
                160, 192
            }, {
                232
            }
        };
        int ai3[][] = {
            {
                0, 1, 1, 1, 4, 4, 1, 4, 2, 1, 
                1, 5, 6, 5, 6, 5, 6, 7, 5, 6, 
                5, 6, 7, 2
            }, {
                1, 1, 1, 1, 1, 2, 7, 1, 2, 1, 
                7, 1, 1, 1, 1, 1, 2, 7, 7, 1, 
                1, 1
            }, {
                8, 8, 8, 8, 7, 5, 6, 4, 4, 7, 
                1, 1, 7, 1, 1, 1, 6, 4, 7, 4, 
                6, 6, 6, 2, 2, 2, 1, 7, 1
            }, {
                9
            }, {
                10, 10, 10, 10, 10, 11, 11, 11, 10, 10, 
                11, 10, 10, 10, 10, 10, 10, 10, 10, 11, 
                11, 11, 10, 10, 10, 10, 10, 10
            }, {
                12
            }
        };
        Enemy_Max = ai[i];
        Enemy_X = null;
        Enemy_Y = null;
        Enemy_HitWidth = null;
        Enemy_HitHeight = null;
        Enemy_Speed = null;
        Enemy_XSpeed = null;
        Enemy_YSpeed = null;
        Enemy_Flag = null;
        Enemy_AP = null;
        Enemy_GType = null;
        Enemy_AnimeCount = null;
        Enemy_AttackCount = null;
        Enemy_AttackType = null;
        Enemy_MoveType = null;
        Run.gc();
        Enemy_X = new int[Enemy_Max];
        Enemy_Y = new int[Enemy_Max];
        Enemy_HitWidth = new int[Enemy_Max];
        Enemy_HitHeight = new int[Enemy_Max];
        Enemy_Speed = new int[Enemy_Max];
        Enemy_XSpeed = new int[Enemy_Max];
        Enemy_YSpeed = new int[Enemy_Max];
        Enemy_Flag = new int[Enemy_Max];
        Enemy_AP = new int[Enemy_Max];
        Enemy_GType = new byte[Enemy_Max];
        Enemy_AnimeCount = new int[Enemy_Max];
        Enemy_AttackCount = new int[Enemy_Max];
        Enemy_AttackType = new byte[Enemy_Max];
        Enemy_MoveType = new byte[Enemy_Max];
        for(int j = ai[i] - 1; j >= 0; j--)
        {
            Enemy_X[j] = ai1[i][j] << 16;
            Enemy_Y[j] = ai2[i][j] << 16;
            InitEnemyData(j, ai3[i][j]);
        }

    }

    public void InitEnemyData(int i, int j)
    {
        int ai[] = {
            32, 24, 24, 16, 16, 16, 16, 32, 32, 48, 
            16, 32, 32
        };
        int ai1[] = {
            32, 24, 24, 16, 16, 16, 16, 32, 32, 48, 
            16, 32, 128
        };
        int ai2[] = {
            0, 0x20000, 0x30000, 0, 0, 0, 0, 0x18000, 0, 0x20000, 
            0x40000, 0x30000, 0
        };
        int ai3[] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 0, 0
        };
        int ai4[] = {
            96, 32, 32, 16, 16, 16, 16, 64, 1, 800, 
            1, 96, 1400
        };
        byte abyte0[] = {
            2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 
            11, 12, 13
        };
        byte abyte1[] = {
            0, 2, 1, 3, 4, 5, 6, 7, 0, 8, 
            2, 9, 10
        };
        byte abyte2[] = {
            0, 1, 2, 0, 0, 0, 0, 3, 0, 4, 
            5, 6, 7
        };
        Enemy_HitWidth[i] = ai[j];
        Enemy_HitHeight[i] = ai1[j];
        Enemy_Speed[i] = ai2[j];
        Enemy_XSpeed[i] = ai2[j];
        Enemy_YSpeed[i] = 0;
        Enemy_Flag[i] = ai3[j];
        Enemy_AP[i] = ai4[j];
        Enemy_GType[i] = abyte0[j];
        Enemy_AnimeCount[i] = 0;
        Enemy_AttackCount[i] = 0;
        Enemy_AttackType[i] = abyte1[j];
        Enemy_MoveType[i] = abyte2[j];
    }

    public void ChapterGame()
    {
        if(!GameKeyIO())
        {
            return;
        } else
        {
            GameMain();
            GameDraw();
            return;
        }
    }

    public boolean GameKeyIO()
    {
        int i = ik | RK;
        int j = ik;
        ik = 0;
        if((Game_MainFlag & 0x1) == 0)
        {
            if((j & 0x80) != 0)
            {
                nOld_Chapter = Game_MainChapter;
                Game_MainChapter = 21;
                return false;
            }
            if((j & 0x8002) != 0 && (My_ActFlag & 0x80) == 0)
                if((My_ActFlag & 0x14) != 0)
                {
                    My_YSpeed = 0xfff30000;
                    My_ActFlag |= 0x80;
                    My_ActFlag &= 0xfffffb89;
                    MyBurstGenerator();
                    My_GType = 3;
                } else
                {
                    My_YSpeed = 0xfff30000;
                    My_ActFlag |= 0x4;
                    My_ActFlag &= 0xfffffbcd;
                    My_GType = 3;
                }
            if((i & 0x20008) != 0)