diff --git a/include/applications/frontier/battle_arcade/main.h b/include/applications/frontier/battle_arcade/main.h new file mode 100644 index 0000000000..289bd5a6ac --- /dev/null +++ b/include/applications/frontier/battle_arcade/main.h @@ -0,0 +1,13 @@ +#ifndef POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_MAIN_H +#define POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_MAIN_H + +#include "overlay_manager.h" + +BOOL BattleArcadeApp_Init(ApplicationManager *appMan, int *state); +BOOL BattleArcadeApp_Main(ApplicationManager *appMan, int *state); +BOOL BattleArcadeApp_Exit(ApplicationManager *appMan, int *state); +void BattleArcadeApp_HandleInitialLayoutCmd(int netID, int unused, void *data, void *context); +void BattleArcadeApp_HandleResultCmd(int netID, int unused, void *data, void *context); +void BattleArcadeApp_HandleUnusedCmd(int netID, int unused, void *data, void *context); + +#endif // POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_MAIN_H diff --git a/include/applications/frontier/battle_arcade/sprite_manager.h b/include/applications/frontier/battle_arcade/sprite_manager.h new file mode 100644 index 0000000000..a8749ca31b --- /dev/null +++ b/include/applications/frontier/battle_arcade/sprite_manager.h @@ -0,0 +1,30 @@ +#ifndef POKEPLATINUM_APPICATIONS_BATTLE_ARCADE_SPRITE_MANAGER_H +#define POKEPLATINUM_APPICATIONS_BATTLE_ARCADE_SPRITE_MANAGER_H + +#include "constants/battle_frontier.h" + +#include "party.h" +#include "sprite.h" +#include "sprite_resource.h" +#include "sprite_util.h" + +#define RESOURCE_ID_SUB_SPRITES 0 +#define RESOURCE_ID_MAIN_SPRITES 1 +#define RESOURCE_ID_ITEM_SPRITES 2 +#define RESOURCE_ID_MON_SPRITES 3 +#define RESOURCE_ID_OPP_MON_ANIMS 7 + +#define NUM_MON_SPRITES MATH_MAX(ARCADE_PARTY_SIZE_SOLO, ARCADE_PARTY_SIZE_MULTI * 2) + +typedef struct { + SpriteList *spriteList; + G2dRenderer renderer; + SpriteResourceCollection *resourceCollection[MAX_SPRITE_RESOURCE_GEN4]; + SpriteResource *resources[11][MAX_SPRITE_RESOURCE_GEN4]; +} BattleArcadeAppSpriteManager; + +void BattleArcadeApp_InitSpriteManager(BattleArcadeAppSpriteManager *spriteMan, Party *party, Party *opponentParty, u8 isMultiPlayerChallenge); +Sprite *BattleArcadeApp_InitSprite(BattleArcadeAppSpriteManager *spriteMan, u32 charResourceID, u32 plttResourceID, u32 cellResourceID, u32 animID, u32 priority, int resourcePriority, u8 onSubScreen); +void BattleArcadeApp_FreeSprites(BattleArcadeAppSpriteManager *spriteMan); + +#endif // POKEPLATINUM_APPICATIONS_BATTLE_ARCADE_SPRITE_MANAGER_H diff --git a/include/applications/frontier/battle_arcade/sprites.h b/include/applications/frontier/battle_arcade/sprites.h new file mode 100644 index 0000000000..f03ed162cb --- /dev/null +++ b/include/applications/frontier/battle_arcade/sprites.h @@ -0,0 +1,25 @@ +#ifndef POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_SPRITES_H +#define POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_SPRITES_H + +#include "applications/frontier/battle_arcade/sprite_manager.h" + +typedef struct BattleArcadeAppSprite { + u32 unk_00; + u32 unk_04; + u16 unk_08; + u8 unk_0A; + u8 onSubScreen; + u16 x; + u16 y; + Sprite *sprite; +} BattleArcadeAppSprite; + +BattleArcadeAppSprite *BattleArcadeAppSprite_New(BattleArcadeAppSpriteManager *spriteMan, u32 charResourceID, u32 plttResourceID, u32 cellResourceID, u32 animID, u16 x, u16 y, u32 priority, int resourcePriority, u8 onSubScreen); +void *BattleArcadeAppSprite_Free(BattleArcadeAppSprite *sprite); +void BattleArcadeAppSprite_SetDrawFlag(BattleArcadeAppSprite *app, BOOL draw); +void BattleArcadeAppSprite_SetPosition(BattleArcadeAppSprite *sprite, u16 x, u16 y); +void BattleArcadeAppSprite_SetAnim(BattleArcadeAppSprite *sprite, u32 animID); +void BattleArcadeAppSprite_UpdatePalette(BattleArcadeAppSprite *sprite, Pokemon *mon); +void BattleArcadeAppSprite_SetAnimateFlag(BattleArcadeAppSprite *sprite, u8 animate); + +#endif // POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_SPRITES_H diff --git a/include/applications/frontier/battle_arcade/windows.h b/include/applications/frontier/battle_arcade/windows.h new file mode 100644 index 0000000000..bef5f8944c --- /dev/null +++ b/include/applications/frontier/battle_arcade/windows.h @@ -0,0 +1,9 @@ +#ifndef POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_WINDOWS_H +#define POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_WINDOWS_H + +#include "bg_window.h" + +void BattleArcadeApp_InitWindows(BgConfig *bgConfig, Window *window); +void BattleArcadeApp_FreeWindows(Window *windows); + +#endif // POKEPLATINUM_APPLICATIONS_BATTLE_ARCADE_WINDOWS_H diff --git a/include/constants/battle_frontier.h b/include/constants/battle_frontier.h index fa5408c471..4046988e3e 100644 --- a/include/constants/battle_frontier.h +++ b/include/constants/battle_frontier.h @@ -6,4 +6,49 @@ #define FRONTIER_CHALLENGE_MULTI 2 #define FRONTIER_CHALLENGE_MULTI_WFC 3 +#define BATTLES_PER_ROUND_ARCADE 7 + +#define ARCADE_PARTY_SIZE_SOLO 3 +#define ARCADE_PARTY_SIZE_MULTI 2 + +#define ARCADE_EFFECT_LOWER_FOE_HP 0 +#define ARCADE_EFFECT_POISON_FOE 1 +#define ARCADE_EFFECT_PARALYZE_FOE 2 +#define ARCADE_EFFECT_BURN_FOE 3 +#define ARCADE_EFFECT_SLEEP_FOE 4 +#define ARCADE_EFFECT_FREEZE_FOE 5 +#define ARCADE_EFFECT_FOE_GET_BERRY 6 +#define ARCADE_EFFECT_FOE_GET_ITEM 7 +#define ARCADE_EFFECT_FOE_GET_LEVELS 8 +#define ARCADE_EFFECT_LOWER_ALLY_HP 9 +#define ARCADE_EFFECT_POISON_ALLY 10 +#define ARCADE_EFFECT_PARALYZE_ALLY 11 +#define ARCADE_EFFECT_BURN_ALLY 12 +#define ARCADE_EFFECT_SLEEP_ALLY 13 +#define ARCADE_EFFECT_FREEZE_ALLY 14 +#define ARCADE_EFFECT_ALLY_GET_BERRY 15 +#define ARCADE_EFFECT_ALLY_GET_ITEM 16 +#define ARCADE_EFFECT_ALLY_GET_LEVELS 17 +#define ARCADE_EFFECT_SUNNY_BATTLE 18 +#define ARCADE_EFFECT_RAINY_BATTLE 19 +#define ARCADE_EFFECT_SANDY_BATTLE 20 +#define ARCADE_EFFECT_HAIL_BATTLE 21 +#define ARCADE_EFFECT_FOGGY_BATTLE 22 +#define ARCADE_EFFECT_TRICK_ROOM 23 +#define ARCADE_EFFECT_SWAP_MONS 24 +#define ARCADE_EFFECT_SPEED_UP 25 +#define ARCADE_EFFECT_SLOW_DOWN 26 +#define ARCADE_EFFECT_RANDOMIZE_CURSOR 27 +#define ARCADE_EFFECT_GET_1_BP 28 +#define ARCADE_EFFECT_NO_BATTLE 29 +#define ARCADE_EFFECT_NO_EVENT 30 +#define ARCADE_EFFECT_GET_3_BP 31 +#define NUM_ARCADE_EFFECTS 32 + +#define ARCADE_EFFECT_CATEGORY_FOE 0 +#define ARCADE_EFFECT_CATEGORY_ALLY 1 +#define ARCADE_EFFECT_CATEGORY_ENV 2 +#define ARCADE_EFFECT_CATEGORY_BONUS 3 +#define NUM_ARCADE_EFFECT_CATEGORIES 4 + #endif // POKEPLATINUM_CONSTANTS_BATTLE_FRONTIER_H diff --git a/include/constants/heap.h b/include/constants/heap.h index 3d7b57c30f..435f91f443 100644 --- a/include/constants/heap.h +++ b/include/constants/heap.h @@ -105,7 +105,7 @@ enum HeapID { HEAP_ID_BATTLE_CASTLE_APP, HEAP_ID_101, HEAP_ID_102, - HEAP_ID_103, + HEAP_ID_BATTLE_ARCADE_APP, HEAP_ID_104, HEAP_ID_105, HEAP_ID_106, @@ -136,6 +136,7 @@ enum HeapSize { HEAP_SIZE_BATTLE_HALL_APP = 0x20000, HEAP_SIZE_BATTLE_FACTORY_APP = 0x20000, + HEAP_SIZE_BATTLE_ARCADE_APP = 0x20000, HEAP_SIZE_BAG = 0x30000, HEAP_SIZE_PRE_POKETCH_SUBSCREEN = 0x18000, diff --git a/include/narc_frontier_bg.h b/include/narc_frontier_bg.h index 12203cf85d..cafa1e5860 100644 --- a/include/narc_frontier_bg.h +++ b/include/narc_frontier_bg.h @@ -53,6 +53,13 @@ #define BATTLE_ARCADE_CORRIDOR_TILES 56 #define BATTLE_ARCADE_BATTLE_ROOM_HP_SCREEN_TILEMAP 57 #define BATTLE_ARCADE_BATTLE_ROOM_HP_SCREEN_TILES 89 +#define BATTLE_ARCADE_APP_MAIN_INITIAL_TILEMAP 116 +#define BATTLE_ARCADE_APP_MAIN_ROULETTE_TILEMAP 117 +#define BATTLE_ARCADE_APP_MAIN_MULTI_INITIAL_TILEMAP 118 +#define BATTLE_ARCADE_APP_MAIN_MULTI_ROULETTE_TILEMAP 119 +#define BATTLE_ARCADE_APP_MAIN_TILES 120 +#define BATTLE_ARCADE_APP_SUB_TILEMAP 121 +#define BATTLE_ARCADE_APP_SUB_TILES 122 #define BATTLE_FRONTIER_APP_SUB_SCREEN_TILES 125 #define BATTLE_FRONTIER_APP_SUB_SCREEN_TILEMAP 126 #define BATTLE_FACTORY_PLTT 129 @@ -68,6 +75,7 @@ #define BATTLE_TOWER_PLTT 141 #define BATTLE_ARCADE_BATTLE_ROOM_PLTT 142 #define BATTLE_ARCADE_CORRIDOR_PLTT 143 +#define Battle_ARCADE_APP_SUB_PLTT 168 #define BATTLE_ARCADE_BATTLE_ROOM_HP_SCREEN_PLTT 169 #define BATTLE_FRONTIER_APP_SUB_SCREEN_PLTT 171 diff --git a/include/narc_frontier_obj.h b/include/narc_frontier_obj.h index 4984bb35c9..bd72a2f342 100644 --- a/include/narc_frontier_obj.h +++ b/include/narc_frontier_obj.h @@ -4,17 +4,25 @@ // frontier_obj.narc. This file should eventually be deleted and the constants // replaced with those from a naix file once the NARC is unpacked. -#define BATTLE_FACTORY_APP_SPRITES_NCGR 0 -#define BATTLE_FACTORY_APP_SPRITES_NANR 1 -#define BATTLE_FACTORY_APP_SPRITES_NCER 2 -#define BATTLE_HALL_APP_CURSOR_BOX_NCGR 12 -#define BATTLE_HALL_APP_CURSOR_BOX_NANR 13 -#define BATTLE_HALL_APP_CURSOR_BOX_NCER 14 -#define BATTLE_CASTLE_APP_SPRITES_NCGR 15 -#define BATTLE_CASTLE_APP_SPRITES_NANR 16 -#define BATTLE_CASTLE_APP_SPRITES_NCER 17 -#define BATTLE_FACTORY_APP_SPRITES_PLTT 36 -#define BATTLE_HALL_APP_CURSOR_BOX_PLTT 38 -#define BATTLE_CASTLE_APP_SPRITES_PLTT 39 +#define BATTLE_FACTORY_APP_SPRITES_NCGR 0 +#define BATTLE_FACTORY_APP_SPRITES_NANR 1 +#define BATTLE_FACTORY_APP_SPRITES_NCER 2 +#define BATTLE_HALL_APP_CURSOR_BOX_NCGR 12 +#define BATTLE_HALL_APP_CURSOR_BOX_NANR 13 +#define BATTLE_HALL_APP_CURSOR_BOX_NCER 14 +#define BATTLE_CASTLE_APP_SPRITES_NCGR 15 +#define BATTLE_CASTLE_APP_SPRITES_NANR 16 +#define BATTLE_CASTLE_APP_SPRITES_NCER 17 +#define BATTLE_ARCADE_APP_SPRITES_NCGR 18 +#define BATTLE_ARCADE_APP_SPRITES_NANR 19 +#define BATTLE_ARCADE_APP_SPRITES_NCER 20 +#define BATTLE_ARCADE_APP_SUB_SPRITES_NCGR 21 +#define BATTLE_ARCADE_APP_SUB_SPRITES_NANR 22 +#define BATTLE_ARCADE_APP_SUB_SPRITES_NCER 23 +#define BATTLE_FACTORY_APP_SPRITES_PLTT 36 +#define BATTLE_HALL_APP_CURSOR_BOX_PLTT 38 +#define BATTLE_CASTLE_APP_SPRITES_PLTT 39 +#define BATTLE_ARCADE_APP_SPRITES_PLTT 40 +#define BATTLE_ARCADE_APP_SUB_SPRITES_PLTT 41 #endif diff --git a/include/overlay104/ov104_0223BCBC.h b/include/overlay104/ov104_0223BCBC.h index 85fcdbc009..3aa711dd33 100644 --- a/include/overlay104/ov104_0223BCBC.h +++ b/include/overlay104/ov104_0223BCBC.h @@ -9,16 +9,16 @@ #include "pokemon.h" void ov104_0223BD28(u8 param0, int param1, u16 param2[], u8 param3); -u8 ov104_0223BD70(u8 param0, BOOL param1); -u8 ov104_0223BDA4(u8 param0, BOOL param1); +u8 BattleArcade_GetPartySize(u8 challengeType, BOOL includePartnerMons); +u8 BattleArcade_GetOpponentPartySize(u8 challengeType, BOOL includeBothOpponents); FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_02230BE4 *param1); u8 ov104_0223BFFC(UnkStruct_ov104_0223BFFC *param0); -BOOL BattleArcade_IsMultiPlayerChallenge(u8 param0); +BOOL BattleArcade_IsMultiPlayerChallenge(u8 challengeType); void ov104_0223C010(UnkStruct_ov104_0223BFFC *param0, Pokemon *param1); void ov104_0223C034(UnkStruct_ov104_0223BFFC *param0, Party *param1, Pokemon *param2); void ov104_0223C04C(UnkStruct_ov104_0223BFFC *param0); u16 ov104_0223C0BC(UnkStruct_ov104_0223BFFC *param0, u8 param1); u16 ov104_0223C124(UnkStruct_ov104_0223BFFC *param0); -u8 ov104_0223C148(u8 param0); +u8 BattleArcade_GetCategoryFromEffect(u8 effect); #endif // POKEPLATINUM_OV104_0223BCBC_H diff --git a/include/overlay108/ov108_02241AE0.h b/include/overlay108/ov108_02241AE0.h deleted file mode 100644 index 1dd0e36d7d..0000000000 --- a/include/overlay108/ov108_02241AE0.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef POKEPLATINUM_OV108_02241AE0_H -#define POKEPLATINUM_OV108_02241AE0_H - -#include "overlay_manager.h" - -int ov108_02241AE0(ApplicationManager *appMan, int *param1); -int ov108_02241C38(ApplicationManager *appMan, int *param1); -int ov108_02241D70(ApplicationManager *appMan, int *param1); -void ov108_02242AB0(int param0, int param1, void *param2, void *param3); -void ov108_02242B24(int param0, int param1, void *param2, void *param3); -void ov108_02242B84(int param0, int param1, void *param2, void *param3); - -#endif // POKEPLATINUM_OV108_02241AE0_H diff --git a/include/overlay108/ov108_02243030.h b/include/overlay108/ov108_02243030.h deleted file mode 100644 index e5d0a52643..0000000000 --- a/include/overlay108/ov108_02243030.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef POKEPLATINUM_OV108_02243030_H -#define POKEPLATINUM_OV108_02243030_H - -#include "overlay108/struct_ov108_02243030.h" - -#include "party.h" -#include "sprite.h" - -void ov108_02243030(UnkStruct_ov108_02243030 *param0, Party *param1, Party *param2, u8 param3); -Sprite *ov108_022430F0(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u32 param5, int param6, u8 param7); -void ov108_02243194(UnkStruct_ov108_02243030 *param0); - -#endif // POKEPLATINUM_OV108_02243030_H diff --git a/include/overlay108/ov108_0224351C.h b/include/overlay108/ov108_0224351C.h deleted file mode 100644 index 7b73ddd85e..0000000000 --- a/include/overlay108/ov108_0224351C.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef POKEPLATINUM_OV108_0224351C_H -#define POKEPLATINUM_OV108_0224351C_H - -#include "overlay108/struct_ov108_02243030.h" -#include "overlay108/struct_ov108_02243594_decl.h" - -#include "pokemon.h" - -UnkStruct_ov108_02243594 *ov108_0224351C(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u16 param5, u16 param6, u32 param7, int param8, u8 param9); -void *ov108_02243594(UnkStruct_ov108_02243594 *param0); -void ov108_022435A8(UnkStruct_ov108_02243594 *param0, int param1); -void ov108_022435B4(UnkStruct_ov108_02243594 *param0, u16 param1, u16 param2); -void ov108_022435F4(UnkStruct_ov108_02243594 *param0, u32 param1); -void ov108_02243610(UnkStruct_ov108_02243594 *param0, Pokemon *param1); -void ov108_02243624(UnkStruct_ov108_02243594 *param0, u8 param1); - -#endif // POKEPLATINUM_OV108_0224351C_H diff --git a/include/overlay108/ov108_02243630.h b/include/overlay108/ov108_02243630.h deleted file mode 100644 index 06bac501dc..0000000000 --- a/include/overlay108/ov108_02243630.h +++ /dev/null @@ -1,9 +0,0 @@ -#ifndef POKEPLATINUM_OV108_02243630_H -#define POKEPLATINUM_OV108_02243630_H - -#include "bg_window.h" - -void ov108_02243630(BgConfig *param0, Window *param1); -void ov108_02243660(Window *param0); - -#endif // POKEPLATINUM_OV108_02243630_H diff --git a/include/overlay108/struct_ov108_02241DB0_decl.h b/include/overlay108/struct_ov108_02241DB0_decl.h deleted file mode 100644 index e1c7e01b9c..0000000000 --- a/include/overlay108/struct_ov108_02241DB0_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_OV108_02241DB0_DECL_H -#define POKEPLATINUM_STRUCT_OV108_02241DB0_DECL_H - -typedef struct UnkStruct_ov108_02241DB0_t UnkStruct_ov108_02241DB0; - -#endif // POKEPLATINUM_STRUCT_OV108_02241DB0_DECL_H diff --git a/include/overlay108/struct_ov108_02243030.h b/include/overlay108/struct_ov108_02243030.h deleted file mode 100644 index 45851120da..0000000000 --- a/include/overlay108/struct_ov108_02243030.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_OV108_02243030_H -#define POKEPLATINUM_STRUCT_OV108_02243030_H - -#include "sprite.h" -#include "sprite_resource.h" -#include "sprite_util.h" - -typedef struct { - SpriteList *unk_00; - G2dRenderer unk_04; - SpriteResourceCollection *unk_190[4]; - SpriteResource *unk_1A0[11][4]; -} UnkStruct_ov108_02243030; - -#endif // POKEPLATINUM_STRUCT_OV108_02243030_H diff --git a/include/overlay108/struct_ov108_02243594_decl.h b/include/overlay108/struct_ov108_02243594_decl.h deleted file mode 100644 index 32f36332b1..0000000000 --- a/include/overlay108/struct_ov108_02243594_decl.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef POKEPLATINUM_STRUCT_OV108_02243594_DECL_H -#define POKEPLATINUM_STRUCT_OV108_02243594_DECL_H - -typedef struct UnkStruct_ov108_02243594_t UnkStruct_ov108_02243594; - -#endif // POKEPLATINUM_STRUCT_OV108_02243594_DECL_H diff --git a/platinum.us/main.lsf b/platinum.us/main.lsf index 258f66296e..d18ff2fa89 100644 --- a/platinum.us/main.lsf +++ b/platinum.us/main.lsf @@ -1601,13 +1601,13 @@ Overlay battle_castle_app Object main.nef.p/src_applications_frontier_battle_castle_windows.c.o } -Overlay overlay108 +Overlay battle_arcade_app { After overlay104 - Object main.nef.p/src_overlay108_ov108_02241AE0.c.o - Object main.nef.p/src_overlay108_ov108_02243030.c.o - Object main.nef.p/src_overlay108_ov108_0224351C.c.o - Object main.nef.p/src_overlay108_ov108_02243630.c.o + Object main.nef.p/src_applications_frontier_battle_arcade_main.c.o + Object main.nef.p/src_applications_frontier_battle_arcade_sprite_manager.c.o + Object main.nef.p/src_applications_frontier_battle_arcade_sprites.c.o + Object main.nef.p/src_applications_frontier_battle_arcade_windows.c.o } Overlay overlay109 diff --git a/platinum.us/sbins_shared.sha1 b/platinum.us/sbins_shared.sha1 index dfa2ab4eaa..1ddfbad0ad 100644 --- a/platinum.us/sbins_shared.sha1 +++ b/platinum.us/sbins_shared.sha1 @@ -105,7 +105,7 @@ a3f4dcf6634992ff3367fe5a377825fb913a39f6 *overlay104.sbin 0e6e923a1a359b9482646b3dd0a7a2562e140672 *battle_factory_app.sbin c3a66997e55fb3e761d521136a42f07f4761f5da *battle_hall_app.sbin f8d3fd65261098ff45b3a31319c904b520814fa2 *battle_castle_app.sbin -901f6afe6c1b0b54dc42af812f13560758814d2b *overlay108.sbin +901f6afe6c1b0b54dc42af812f13560758814d2b *battle_arcade_app.sbin 5acaa19b61120f72d546a83e36c361b2e383c0bd *overlay109.sbin 1626b234bbd0915fc1bd57d0b67c59c86f1138bd *overlay110.sbin eb9d61aa9d3ad877f55af30ff212ecc7094049c5 *overlay111.sbin diff --git a/src/applications/frontier/battle_arcade/main.c b/src/applications/frontier/battle_arcade/main.c new file mode 100644 index 0000000000..39906a0f71 --- /dev/null +++ b/src/applications/frontier/battle_arcade/main.c @@ -0,0 +1,1472 @@ +#include "applications/frontier/battle_arcade/main.h" + +#include +#include + +#include "constants/battle_frontier.h" +#include "constants/graphics.h" + +#include "struct_decls/struct_020304A0_decl.h" +#include "struct_decls/struct_020305B8_decl.h" +#include "struct_defs/battle_frontier.h" + +#include "applications/frontier/battle_arcade/sprite_manager.h" +#include "applications/frontier/battle_arcade/sprites.h" +#include "applications/frontier/battle_arcade/windows.h" +#include "overlay104/ov104_0223BCBC.h" +#include "overlay104/struct_ov104_02238240.h" + +#include "bg_window.h" +#include "communication_system.h" +#include "font.h" +#include "game_options.h" +#include "game_overlay.h" +#include "graphics.h" +#include "gx_layers.h" +#include "heap.h" +#include "math_util.h" +#include "message.h" +#include "narc.h" +#include "narc_frontier_bg.h" +#include "overlay_manager.h" +#include "palette.h" +#include "party.h" +#include "pokemon.h" +#include "render_oam.h" +#include "save_player.h" +#include "savedata.h" +#include "screen_fade.h" +#include "sound_playback.h" +#include "sprite.h" +#include "sprite_util.h" +#include "string_gf.h" +#include "string_template.h" +#include "system.h" +#include "touch_screen.h" +#include "trainer_info.h" +#include "unk_02030494.h" +#include "unk_0203061C.h" +#include "unk_020363E8.h" +#include "unk_020393C8.h" +#include "unk_0209BA80.h" +#include "vram_transfer.h" + +FS_EXTERN_OVERLAY(overlay104); + +#define GRID_WIDTH 4 +#define GRID_HEIGHT 4 +#define GRID_SIZE (GRID_HEIGHT * GRID_WIDTH) + +// Sub screen sprite animation IDs +#define ANIM_ID_BUTTON_UNPRESSED 0 +#define ANIM_ID_BUTTON_PRESSED 1 +#define ANIM_ID_BUTTON_INACTIVE 2 + +// Main screen sprite animation IDs +#define ANIM_ID_TILE_3 32 +#define ANIM_ID_TILE_2 33 +#define ANIM_ID_TILE_1 34 +#define ANIM_ID_CURSOR 35 + +#define COMM_CMD_INITIAL_LAYOUT 30 +#define COMM_CMD_RESULT 31 + +enum BattleArcadeAppState { + STATE_FADE_IN_APP = 0, + STATE_OPERATE_ROULETTE, + STATE_SYNC_RESULT, + STATE_SYNC_BEFORE_EXIT, + STATE_FADE_OUT_APP, +}; + +static const u8 sCursorMoveFrames[8][2] = { + { 20, 0 }, + { 16, 0 }, + { 8, 0 }, + { 4, 0 }, + { 3, 0 }, + { 2, 0 }, + { 1, 0 }, + { 0, 0 } +}; + +// clang-format off +static const struct { + u8 round1 : 1; + u8 round2 : 1; + u8 round3 : 1; + u8 round4 : 1; + u8 round5 : 1; + u8 round6 : 1; + u8 round7 : 1; +} sEffectAvailabilityByRound[NUM_ARCADE_EFFECTS] = { + [ARCADE_EFFECT_LOWER_FOE_HP] = { 0, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_POISON_FOE] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_PARALYZE_FOE] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_BURN_FOE] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_SLEEP_FOE] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_FREEZE_FOE] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_FOE_GET_BERRY] = { 1, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_FOE_GET_ITEM] = { 0, 0, 0, 1, 1, 1, 1 }, + [ARCADE_EFFECT_FOE_GET_LEVELS] = { 0, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_LOWER_ALLY_HP] = { 0, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_POISON_ALLY] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_PARALYZE_ALLY] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_BURN_ALLY] = { 1, 0, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_SLEEP_ALLY] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_FREEZE_ALLY] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_ALLY_GET_BERRY] = { 1, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_ALLY_GET_ITEM] = { 0, 0, 0, 1, 1, 1, 1 }, + [ARCADE_EFFECT_ALLY_GET_LEVELS] = { 0, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_SUNNY_BATTLE] = { 0, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_RAINY_BATTLE] = { 0, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_SANDY_BATTLE] = { 0, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_HAIL_BATTLE] = { 0, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_FOGGY_BATTLE] = { 0, 0, 0, 1, 0, 1, 1 }, + [ARCADE_EFFECT_TRICK_ROOM] = { 0, 0, 0, 1, 0, 1, 1 }, + [ARCADE_EFFECT_SWAP_MONS] = { 1, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_SPEED_UP] = { 1, 1, 1, 0, 0, 0, 1 }, + [ARCADE_EFFECT_SLOW_DOWN] = { 1, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_RANDOMIZE_CURSOR] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_GET_1_BP] = { 0, 0, 0, 1, 1, 1, 1 }, + [ARCADE_EFFECT_NO_BATTLE] = { 0, 0, 0, 0, 1, 1, 1 }, + [ARCADE_EFFECT_NO_EVENT] = { 1, 1, 1, 1, 1, 1, 1 }, + [ARCADE_EFFECT_GET_3_BP] = { 0, 0, 0, 0, 0, 0, 1 }, +}; +// clang-format on + +static const struct { + u8 battle1 : 1; + u8 battle2 : 1; + u8 battle3 : 1; + u8 battle4 : 1; + u8 battle5 : 1; + u8 battle6 : 1; + u8 battle7 : 1; +} sEffectAvailabilityByBattle[BATTLES_PER_ROUND_ARCADE] = { + { 1, 1, 1, 1, 1, 1, 0 }, // ARCADE_EFFECT_RANDOMIZE_CURSOR + { 1, 1, 1, 1, 1, 1, 0 }, // ARCADE_EFFECT_SWAP_MONS + { 1, 1, 1, 1, 1, 1, 0 }, // ARCADE_EFFECT_SPEED_UP + { 1, 1, 1, 1, 1, 1, 0 }, // ARCADE_EFFECT_SLOW_DOWN + { 1, 0, 1, 0, 1, 0, 0 }, // ARCADE_EFFECT_GET_1_BP + { 0, 1, 0, 1, 0, 1, 0 }, // ARCADE_EFFECT_NO_BATTLE + { 0, 1, 0, 1, 0, 1, 0 }, // ARCADE_EFFECT_GET_3_BP +}; + +static const u8 sCategoryWeights[][NUM_ARCADE_EFFECT_CATEGORIES] = { + { 15, 15, 40, 30 }, + { 35, 20, 30, 15 }, + { 30, 30, 35, 5 }, + { 25, 40, 30, 5 }, + { 10, 75, 10, 5 } +}; + +static const u8 Unk_ov108_0224367C[] = { + 21, + 16, + 10, + 5 +}; + +typedef struct BattleArcadeApp { + ApplicationManager *appMan; + BattleFrontier *frontier; + u8 subState; + u8 challengeType; + u8 unused; + u8 subStateTimer; + u8 randomizeCursorMovement; + u8 cursorPos; + u8 cursorPosID; + u8 numReceivedMsgs; + u8 cursorUpdateTimer; + u8 categoryWeightTier; + u8 unk_12; + u8 unusedFlag : 1; + u8 pointlessTimer : 7; + u8 resultCursorPos; + u8 unused2; + u16 startingCursorPos; + int rouletteTimer; + u8 *rouletteSpeed; + u8 *selectedEffect; + u16 *unk_24; + u16 battleStreak; + u16 round; + u8 gridWidth; + u8 gridHeight; + u8 gridSize; + u8 unused3 : 1; + u8 buttonPressed : 7; + u8 availableEffectsPerCategory[NUM_ARCADE_EFFECT_CATEGORIES]; + u8 rouletteEffects[GRID_SIZE]; + u8 availableEffects[NUM_ARCADE_EFFECTS]; + u8 numAvailableEffects; + MessageLoader *msgLoader; + StringTemplate *strTemplate; + String *displayStr; + String *fmtStr; + String *unusedStrs[2]; + u16 unused4[8]; + BgConfig *bgConfig; + Window windows[2]; + u32 unused5[8]; + PaletteData *plttData; + Options *options; + SaveData *saveData; + UnkStruct_020304A0 *unk_E0; + UnkStruct_020305B8 *unk_E4; + BattleArcadeAppSpriteManager spriteMan; + BattleArcadeAppSprite *cursorSprite; + BattleArcadeAppSprite *tileSprites[GRID_SIZE]; + BattleArcadeAppSprite *monSprites[NUM_MON_SPRITES]; + BattleArcadeAppSprite *opponentMonSprites[NUM_MON_SPRITES]; + BattleArcadeAppSprite *itemSprites[NUM_MON_SPRITES]; + BattleArcadeAppSprite *opponentItemSprites[NUM_MON_SPRITES]; + BattleArcadeAppSprite *buttonSprite; + int *unused6; + u16 *cursorPosPtr; + Party *party; + Party *opponentsParty; + NARC *narc; + u16 commPayload[40]; + u8 partnerCursorPos; + u8 cursorPosTemp; + u16 partnerBattleStreak; + u16 unused8[3]; +} BattleArcadeApp; + +static BOOL State_FadeInApp(BattleArcadeApp *app); +static BOOL State_OperateRoulette(BattleArcadeApp *app); +static BOOL State_SyncResult(BattleArcadeApp *app); +static BOOL State_SyncBeforeExit(BattleArcadeApp *app); +static BOOL State_FadeOutApp(BattleArcadeApp *app); +static void FreeAssets(BattleArcadeApp *app); +static void InitGraphicsPlane(void); +static void LoadAssets(BattleArcadeApp *app); +static void InitSpriteManager(BattleArcadeApp *app); +static void LoadBackgrounds(BattleArcadeApp *app); +static void FreeBackgrounds(BgConfig *app); +static void VBlankCallback(void *data); +static void InitGXBanks(void); +static void InitBackgrounds(BgConfig *bgConfig); +static void LoadInitialBackround(BattleArcadeApp *app, enum BgLayer bgLayer); +static void LoadRouletteBackground(BattleArcadeApp *app, enum BgLayer bgLayer); +static void LoadPalette(void); +static void LoadSubScreenBackground(BattleArcadeApp *app, enum BgLayer bgLayer); +static void ChangeState(BattleArcadeApp *app, int *state, enum BattleArcadeAppState newState); +static void UpdateCursorPosition(BattleArcadeApp *app, int unused); +static void UpdateCursorSpritePosition(BattleArcadeApp *app, u8 cursorPos); +static void SetResultCursorPos(BattleArcadeApp *app); +static u8 NormalizeCursorPosition(u8 gridSize, u8 cursorPos); +static u16 GetBattleNumber(BattleArcadeApp *app); +static BOOL SendCommMessage(BattleArcadeApp *app, u16 cmd, u16 arg); +static void CreateInitialLayoutPayload(BattleArcadeApp *app, u16 cmd); +static void CreateResultPayload(BattleArcadeApp *app, u16 cmd, u16 resultCursorPos); +static void UnusedCommCommandPayload(BattleArcadeApp *app, u16 cmd); +static void SetSelectedEffect(BattleArcadeApp *app, u8 cursorPos); +static u8 GetRandomCategory(BattleArcadeApp *app, u8 weightsIndex); +static void GetAvailableEffects(BattleArcadeApp *app); +static void GetEffectCategoryCounts(BattleArcadeApp *app); +static void AssignEffectsToGrid(BattleArcadeApp *app); +static void UpdateItemSprites(BattleArcadeApp *app); +static BOOL CheckStopButtonPressed(BattleArcadeApp *app); +static void PressStopButton(BattleArcadeApp *app); +static u16 GetRandomNumber(BattleArcadeApp *app); + +static u8 unusedStatic; +static u8 unusedStatic2; + +static const TouchScreenHitTable sStopButtonHitBox[] = { + { .circle = { .code = TOUCHSCREEN_USE_CIRCLE, .x = 128, .y = 96, .r = 32 } }, + { TOUCHSCREEN_TABLE_TERMINATOR } +}; + +BOOL BattleArcadeApp_Init(ApplicationManager *appMan, int *state) +{ + Overlay_LoadByID(FS_OVERLAY_ID(overlay104), OVERLAY_LOAD_ASYNC); + InitGraphicsPlane(); + Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_BATTLE_ARCADE_APP, HEAP_SIZE_BATTLE_ARCADE_APP); + + BattleArcadeApp *app = ApplicationManager_NewData(appMan, sizeof(BattleArcadeApp), HEAP_ID_BATTLE_ARCADE_APP); + memset(app, 0, sizeof(BattleArcadeApp)); + + app->bgConfig = BgConfig_New(HEAP_ID_BATTLE_ARCADE_APP); + app->appMan = appMan; + + UnkStruct_ov104_02238240 *v2 = ApplicationManager_Args(appMan); + + app->saveData = v2->saveData; + app->unk_E0 = sub_020304A0(app->saveData); + app->unk_E4 = sub_020305B8(app->saveData); + app->challengeType = v2->unk_04; + app->round = v2->unk_1E; + app->battleStreak = v2->unk_1C; + app->partnerBattleStreak = v2->unk_18; + app->unk_12 = v2->unk_07; + app->cursorPosPtr = &v2->unk_38; + app->options = SaveData_GetOptions(app->saveData); + app->party = v2->unk_30; + app->opponentsParty = v2->unk_34; + app->cursorPosID = 0xff; + app->frontier = SaveData_GetBattleFrontier(app->saveData); + app->unused6 = v2->unk_08; + app->rouletteSpeed = v2->unk_0C; + app->selectedEffect = v2->unk_10; + app->unk_24 = v2->unk_14; + app->rouletteTimer = 30 * 30; // 30 Seconds at 30FPS + app->randomizeCursorMovement = v2->unk_40; + + for (int i = 0; i < NUM_ARCADE_EFFECTS; i++) { + app->availableEffects[i] = NUM_ARCADE_EFFECTS; + } + + app->gridWidth = GRID_WIDTH; + app->gridHeight = GRID_HEIGHT; + app->gridSize = GRID_SIZE; + app->partnerCursorPos = 0; + + *app->unk_24 = GetRandomNumber(app); + + app->startingCursorPos = LCRNG_Next() % GRID_SIZE; + + LoadAssets(app); + + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + sub_0209BA80(app); + } + + *state = 0; + + unusedStatic = 0; + unusedStatic2 = 0; + + return TRUE; +} + +BOOL BattleArcadeApp_Main(ApplicationManager *appMan, int *state) +{ + BattleArcadeApp *app = ApplicationManager_Data(appMan); + + if (app->cursorPosID != 0xff) { + switch (*state) { + case STATE_OPERATE_ROULETTE: + PressStopButton(app); + app->resultCursorPos = NormalizeCursorPosition(app->gridSize, app->cursorPosID); + ChangeState(app, state, STATE_SYNC_RESULT); + break; + } + } + + switch (*state) { + case STATE_FADE_IN_APP: + if (State_FadeInApp(app) == TRUE) { + ChangeState(app, state, STATE_OPERATE_ROULETTE); + } + break; + case STATE_OPERATE_ROULETTE: + if (State_OperateRoulette(app) == TRUE) { + if (app->buttonPressed == TRUE) { + ChangeState(app, state, STATE_SYNC_RESULT); + } else { + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + ChangeState(app, state, STATE_SYNC_BEFORE_EXIT); + } else { + ChangeState(app, state, STATE_FADE_OUT_APP); + } + } + } + break; + case STATE_SYNC_RESULT: + if (State_SyncResult(app) == TRUE) { + ChangeState(app, state, STATE_SYNC_BEFORE_EXIT); + } + break; + case STATE_SYNC_BEFORE_EXIT: + if (State_SyncBeforeExit(app) == TRUE) { + ChangeState(app, state, STATE_FADE_OUT_APP); + } + break; + case STATE_FADE_OUT_APP: + if (State_FadeOutApp(app) == TRUE) { + return TRUE; + } + break; + } + + app->pointlessTimer++; + if (app->pointlessTimer >= 4) { + app->pointlessTimer = 0; + app->unusedFlag ^= 1; + } + + SpriteList_Update(app->spriteMan.spriteList); + + return FALSE; +} + +BOOL BattleArcadeApp_Exit(ApplicationManager *appMan, int *state) +{ + BattleArcadeApp *app = ApplicationManager_Data(appMan); + *app->cursorPosPtr = app->cursorPos; + + VramTransfer_Free(); + FreeAssets(app); + ApplicationManager_FreeData(appMan); + SetVBlankCallback(NULL, NULL); + Heap_Destroy(HEAP_ID_BATTLE_ARCADE_APP); + Overlay_UnloadByID(FS_OVERLAY_ID(overlay104)); + + return TRUE; +} + +static BOOL State_FadeInApp(BattleArcadeApp *app) +{ + switch (app->subState) { + case 0: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + CommTiming_StartSync(199); + app->subState++; + } else { + app->subState++; + } + break; + case 1: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + if (CommTiming_IsSyncState(199) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + app->subState++; + } + } else { + app->subState++; + } + break; + case 2: + GetAvailableEffects(app); + app->subState++; + break; + case 3: + GetEffectCategoryCounts(app); + app->subState++; + break; + case 4: + AssignEffectsToGrid(app); + app->subState++; + break; + case 5: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + CommTiming_StartSync(201); + app->subState++; + } else { + app->subState++; + } + break; + case 6: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + if (CommTiming_IsSyncState(201) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + app->subState++; + } + } else { + app->subState++; + } + break; + case 7: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + if (SendCommMessage(app, COMM_CMD_INITIAL_LAYOUT, 0) == TRUE) { + app->subState++; + } + } else { + StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 6, 3, HEAP_ID_BATTLE_ARCADE_APP); + app->subState++; + } + break; + case 8: + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + if (app->numReceivedMsgs >= 2) { + app->numReceivedMsgs = 0; + StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 6, 3, HEAP_ID_BATTLE_ARCADE_APP); + app->subState++; + } + } else { + app->subState++; + } + break; + case 9: + if (IsScreenFadeDone() == TRUE) { + return TRUE; + } + break; + } + + return FALSE; +} + +static BOOL State_OperateRoulette(BattleArcadeApp *app) +{ + switch (app->subState) { + case 0: + app->subStateTimer = 0; + app->cursorPos = app->startingCursorPos; + UpdateCursorSpritePosition(app, app->cursorPos); + app->subState = 1; + break; + case 1: + app->subStateTimer++; + + if (app->subStateTimer >= 10) { + app->subStateTimer = 0; + app->subState = 2; + } + break; + case 2: + for (int i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_SetAnim(app->tileSprites[i], ANIM_ID_TILE_3); + BattleArcadeAppSprite_SetDrawFlag(app->tileSprites[i], TRUE); + } + } + + LoadRouletteBackground(app, BG_LAYER_MAIN_3); + Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); + + app->subStateTimer = 24; + app->subState = 3; + break; + case 3: + app->subStateTimer--; + + if (app->subStateTimer > 0) { + break; + } + + for (int i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_SetAnim(app->tileSprites[i], ANIM_ID_TILE_2); + } + } + + Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); + app->subStateTimer = 24; + app->subState = 4; + break; + case 4: + app->subStateTimer--; + + if (app->subStateTimer > 0) { + break; + } + + for (int i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_SetAnim(app->tileSprites[i], ANIM_ID_TILE_1); + } + } + + Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); + app->subStateTimer = 24; + app->subState = 5; + break; + case 5: + app->subStateTimer--; + + if (app->subStateTimer > 0) { + break; + } + + for (int i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_SetAnim(app->tileSprites[i], app->rouletteEffects[i]); + } + } + + BattleArcadeAppSprite_SetDrawFlag(app->cursorSprite, TRUE); + Sound_PlayEffect(SEQ_SE_DP_UG_020); + BattleArcadeAppSprite_SetAnim(app->buttonSprite, ANIM_ID_BUTTON_UNPRESSED); + app->subState = 6; + break; + case 6: + UpdateCursorPosition(app, gSystem.pressedKeys); + + if (CommSys_CurNetId() == 0) { + if (app->rouletteTimer > 0) { + app->rouletteTimer--; + } + } + + if (CheckStopButtonPressed(app) == TRUE || app->rouletteTimer == 0) { + SetResultCursorPos(app); + + if (!BattleArcade_IsMultiPlayerChallenge(app->challengeType)) { + app->subState = 7; + break; + } else { + app->buttonPressed = TRUE; + return TRUE; + } + } + break; + case 7: + SetSelectedEffect(app, app->cursorPos); + app->subStateTimer = 30; + app->subState = 8; + break; + case 8: + app->subStateTimer--; + + if (app->subStateTimer == 0) { + return TRUE; + } + break; + } + + return FALSE; +} + +static BOOL State_SyncResult(BattleArcadeApp *app) +{ + switch (app->subState) { + case 0: + if (SendCommMessage(app, COMM_CMD_RESULT, app->resultCursorPos) == TRUE) { + app->buttonPressed = FALSE; + app->subState++; + } + break; + case 1: + app->subState++; + break; + case 2: + if (app->cursorPosID == 0xff) { + break; + } + + app->numReceivedMsgs = 0; + SetSelectedEffect(app, app->cursorPosID); + app->subState++; + break; + case 3: + CommTool_ClearReceivedTempDataAllPlayers(); + CommTiming_StartSync(151); + app->subState++; + break; + case 4: + if (CommTiming_IsSyncState(151) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + CommTool_Init(103); + app->cursorPosID = 0xff; + return TRUE; + } + break; + } + + return FALSE; +} + +static BOOL State_SyncBeforeExit(BattleArcadeApp *app) +{ + switch (app->subState) { + case 0: + app->subStateTimer = 15; + app->subState++; + break; + case 1: + if (app->subStateTimer > 0) { + app->subStateTimer--; + } + + if (app->subStateTimer == 0) { + CommTool_ClearReceivedTempDataAllPlayers(); + CommTiming_StartSync(152); + app->subState++; + } + break; + case 2: + if (CommTiming_IsSyncState(152) == TRUE) { + CommTool_ClearReceivedTempDataAllPlayers(); + return TRUE; + } + break; + } + + return FALSE; +} + +static BOOL State_FadeOutApp(BattleArcadeApp *app) +{ + switch (app->subState) { + case 0: + StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_OUT, FADE_TYPE_BRIGHTNESS_OUT, COLOR_BLACK, 6, 1, HEAP_ID_BATTLE_ARCADE_APP); + app->subState++; + break; + case 1: + if (IsScreenFadeDone() == TRUE) { + return TRUE; + } + break; + } + + return FALSE; +} + +static void FreeAssets(BattleArcadeApp *app) +{ + int i; + + if (app->cursorSprite != NULL) { + BattleArcadeAppSprite_Free(app->cursorSprite); + } + + if (app->buttonSprite != NULL) { + BattleArcadeAppSprite_Free(app->buttonSprite); + } + + for (i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_Free(app->tileSprites[i]); + } + } + + u8 numMons = BattleArcade_GetPartySize(app->challengeType, TRUE); + + for (i = 0; i < numMons; i++) { + if (app->monSprites[i] != NULL) { + BattleArcadeAppSprite_Free(app->monSprites[i]); + } + + if (app->opponentMonSprites[i] != NULL) { + BattleArcadeAppSprite_Free(app->opponentMonSprites[i]); + } + + if (app->itemSprites[i] != NULL) { + BattleArcadeAppSprite_Free(app->itemSprites[i]); + } + + if (app->opponentItemSprites[i] != NULL) { + BattleArcadeAppSprite_Free(app->opponentItemSprites[i]); + } + } + + NetworkIcon_Destroy(); + PaletteData_FreeBuffer(app->plttData, PLTTBUF_MAIN_OBJ); + PaletteData_FreeBuffer(app->plttData, PLTTBUF_MAIN_BG); + PaletteData_Free(app->plttData); + + app->plttData = NULL; + BattleArcadeApp_FreeSprites(&app->spriteMan); + + MessageLoader_Free(app->msgLoader); + StringTemplate_Free(app->strTemplate); + String_Free(app->displayStr); + String_Free(app->fmtStr); + + for (i = 0; i < 2; i++) { + String_Free(app->unusedStrs[i]); + } + + BattleArcadeApp_FreeWindows(app->windows); + FreeBackgrounds(app->bgConfig); + + NARC_dtor(app->narc); +} + +static void InitGraphicsPlane(void) +{ + SetVBlankCallback(NULL, NULL); + SetHBlankCallback(NULL, NULL); + + GXLayers_DisableEngineALayers(); + GXLayers_DisableEngineBLayers(); + + GX_SetVisiblePlane(0); + GXS_SetVisiblePlane(0); +} + +static void LoadAssets(BattleArcadeApp *app) +{ + int i; + + app->narc = NARC_ctor(NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_BG, HEAP_ID_BATTLE_ARCADE_APP); + + LoadBackgrounds(app); + InitSpriteManager(app); + + app->msgLoader = MessageLoader_Init(MSG_LOADER_LOAD_ON_DEMAND, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_DUMMY_0536, HEAP_ID_BATTLE_ARCADE_APP); + app->strTemplate = StringTemplate_Default(HEAP_ID_BATTLE_ARCADE_APP); + app->displayStr = String_Init(600, HEAP_ID_BATTLE_ARCADE_APP); + app->fmtStr = String_Init(600, HEAP_ID_BATTLE_ARCADE_APP); + + for (i = 0; i < 2; i++) { + app->unusedStrs[i] = String_Init(32, HEAP_ID_BATTLE_ARCADE_APP); + } + + Font_LoadTextPalette(PAL_LOAD_MAIN_BG, 13 * PALETTE_SIZE_BYTES, HEAP_ID_BATTLE_ARCADE_APP); + Font_LoadScreenIndicatorsPalette(PAL_LOAD_MAIN_BG, 12 * PALETTE_SIZE_BYTES, HEAP_ID_BATTLE_ARCADE_APP); + + BattleArcadeApp_InitWindows(app->bgConfig, app->windows); + app->cursorSprite = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_MAIN_SPRITES, RESOURCE_ID_MAIN_SPRITES, RESOURCE_ID_MAIN_SPRITES, ANIM_ID_CURSOR, 68, 36, 0, 2, FALSE); + BattleArcadeAppSprite_SetDrawFlag(app->cursorSprite, FALSE); + + for (i = 0; i < GRID_SIZE; i++) { + app->tileSprites[i] = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_MAIN_SPRITES, RESOURCE_ID_MAIN_SPRITES, RESOURCE_ID_MAIN_SPRITES, ANIM_ID_TILE_3, 68 + (40 * (i % 4)), 36 + (40 * (i / 4)), 1, 2, 0); + BattleArcadeAppSprite_SetDrawFlag(app->tileSprites[i], FALSE); + } + + u8 numMons = BattleArcade_GetPartySize(app->challengeType, TRUE); + + u16 monYOffset, itemsYOffset; + if (!BattleArcade_IsMultiPlayerChallenge(app->challengeType)) { + monYOffset = 46; + itemsYOffset = 50; + } else { + monYOffset = 22; + itemsYOffset = 26; + } + + for (i = 0; i < numMons; i++) { + app->itemSprites[i] = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_ITEM_SPRITES, RESOURCE_ID_ITEM_SPRITES, RESOURCE_ID_ITEM_SPRITES, 0, 24, itemsYOffset + (40 * i), 0, 2, FALSE); + app->opponentItemSprites[i] = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_ITEM_SPRITES, RESOURCE_ID_ITEM_SPRITES, RESOURCE_ID_ITEM_SPRITES, 0, 246, itemsYOffset + (40 * i), 0, 2, FALSE); + app->monSprites[i] = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_MON_SPRITES + i, RESOURCE_ID_MON_SPRITES, RESOURCE_ID_MON_SPRITES, 1, 16, monYOffset + (40 * i), 1, 2, FALSE); + app->opponentMonSprites[i] = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_OPP_MON_ANIMS + i, RESOURCE_ID_MON_SPRITES, RESOURCE_ID_MON_SPRITES, 1, 238, monYOffset + (40 * i), 1, 2, FALSE); + + BattleArcadeAppSprite_UpdatePalette(app->monSprites[i], Party_GetPokemonBySlotIndex(app->party, i)); + BattleArcadeAppSprite_UpdatePalette(app->opponentMonSprites[i], Party_GetPokemonBySlotIndex(app->opponentsParty, i)); + + BattleArcadeAppSprite_SetAnimateFlag(app->monSprites[i], FALSE); + BattleArcadeAppSprite_SetAnimateFlag(app->opponentMonSprites[i], FALSE); + } + + UpdateItemSprites(app); + app->buttonSprite = BattleArcadeAppSprite_New(&app->spriteMan, RESOURCE_ID_SUB_SPRITES, RESOURCE_ID_SUB_SPRITES, RESOURCE_ID_SUB_SPRITES, ANIM_ID_BUTTON_INACTIVE, 128, 96, 0, 0, TRUE); + + if (CommSys_IsInitialized()) { + ReserveVramForWirelessIconChars(NNS_G2D_VRAM_TYPE_2DMAIN, GX_OBJVRAMMODE_CHAR_1D_32K); + ReserveSlotsForWirelessIconPalette(NNS_G2D_VRAM_TYPE_2DMAIN); + sub_02039734(); + } + + SetVBlankCallback(VBlankCallback, app); +} + +static void LoadBackgrounds(BattleArcadeApp *app) +{ + InitGXBanks(); + InitBackgrounds(app->bgConfig); + + app->plttData = PaletteData_New(HEAP_ID_BATTLE_ARCADE_APP); + PaletteData_AllocBuffer(app->plttData, PLTTBUF_MAIN_OBJ, PALETTE_SIZE_BYTES * SLOTS_PER_PALETTE, HEAP_ID_BATTLE_ARCADE_APP); + PaletteData_AllocBuffer(app->plttData, PLTTBUF_MAIN_BG, PALETTE_SIZE_BYTES * SLOTS_PER_PALETTE, HEAP_ID_BATTLE_ARCADE_APP); + + LoadInitialBackround(app, BG_LAYER_MAIN_3); + LoadPalette(); + LoadSubScreenBackground(app, BG_LAYER_SUB_0); +} + +static void InitSpriteManager(BattleArcadeApp *app) +{ + BattleArcadeApp_InitSpriteManager(&app->spriteMan, app->party, app->opponentsParty, BattleArcade_IsMultiPlayerChallenge(app->challengeType)); +} + +static void FreeBackgrounds(BgConfig *app) +{ + GXLayers_EngineAToggleLayers(GX_PLANEMASK_BG0 | GX_PLANEMASK_BG1 | GX_PLANEMASK_BG2 | GX_PLANEMASK_BG3 | GX_PLANEMASK_OBJ, FALSE); + GXLayers_EngineBToggleLayers(GX_PLANEMASK_BG0 | GX_PLANEMASK_BG1 | GX_PLANEMASK_BG2 | GX_PLANEMASK_BG3 | GX_PLANEMASK_OBJ, FALSE); + + Bg_FreeTilemapBuffer(app, BG_LAYER_MAIN_3); + Bg_FreeTilemapBuffer(app, BG_LAYER_MAIN_1); + Bg_FreeTilemapBuffer(app, BG_LAYER_SUB_0); + Heap_Free(app); +} + +static void VBlankCallback(void *data) +{ + BattleArcadeApp *app = data; + + if (app->plttData != NULL) { + PaletteData_CommitFadedBuffers(app->plttData); + } + + Bg_RunScheduledUpdates(app->bgConfig); + VramTransfer_Process(); + RenderOam_Transfer(); + + OS_SetIrqCheckFlag(OS_IE_V_BLANK); +} + +static void InitGXBanks(void) +{ + GXBanks banks = { + GX_VRAM_BG_128_C, + GX_VRAM_BGEXTPLTT_NONE, + GX_VRAM_SUB_BG_32_H, + GX_VRAM_SUB_BGEXTPLTT_NONE, + GX_VRAM_OBJ_64_E, + GX_VRAM_OBJEXTPLTT_NONE, + GX_VRAM_SUB_OBJ_16_I, + GX_VRAM_SUB_OBJEXTPLTT_NONE, + GX_VRAM_TEX_01_AB, + GX_VRAM_TEXPLTT_01_FG + }; + + GXLayers_SetBanks(&banks); +} + +static void InitBackgrounds(BgConfig *bgConfig) +{ + GraphicsModes graphicsModes = { + GX_DISPMODE_GRAPHICS, + GX_BGMODE_0, + GX_BGMODE_0, + GX_BG0_AS_2D + }; + + SetAllGraphicsModes(&graphicsModes); + + BgTemplate bgTemplate1 = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0x0000, + .charBase = GX_BG_CHARBASE_0x04000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 0, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_MAIN_1, &bgTemplate1, BG_TYPE_STATIC); + Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32, 0, HEAP_ID_BATTLE_ARCADE_APP); + Bg_ClearTilemap(bgConfig, BG_LAYER_MAIN_1); + + BgTemplate bgTemplate2 = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0x2000, + .charBase = GX_BG_CHARBASE_0x0c000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 2, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_MAIN_3, &bgTemplate2, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_MAIN_3); + + BgTemplate bgTemplate3 = { + .x = 0, + .y = 0, + .bufferSize = 0x800, + .baseTile = 0, + .screenSize = BG_SCREEN_SIZE_256x256, + .colorMode = GX_BG_COLORMODE_16, + .screenBase = GX_BG_SCRBASE_0x3000, + .charBase = GX_BG_CHARBASE_0x10000, + .bgExtPltt = GX_BG_EXTPLTT_01, + .priority = 0, + .areaOver = 0, + .mosaic = FALSE, + }; + + Bg_InitFromTemplate(bgConfig, BG_LAYER_SUB_0, &bgTemplate3, BG_TYPE_STATIC); + Bg_ClearTilemap(bgConfig, BG_LAYER_SUB_0); + + G2_SetBG0Priority(0); + GXLayers_EngineAToggleLayers(GX_PLANEMASK_BG0, FALSE); +} + +static void LoadInitialBackround(BattleArcadeApp *app, enum BgLayer bgLayer) +{ + Graphics_LoadTilesToBgLayerFromOpenNARC(app->narc, BATTLE_ARCADE_APP_MAIN_TILES, app->bgConfig, bgLayer, 0, 0, TRUE, HEAP_ID_BATTLE_ARCADE_APP); + + u32 idx = !BattleArcade_IsMultiPlayerChallenge(app->challengeType) ? BATTLE_ARCADE_APP_MAIN_INITIAL_TILEMAP : BATTLE_ARCADE_APP_MAIN_MULTI_INITIAL_TILEMAP; + Graphics_LoadTilemapToBgLayerFromOpenNARC(app->narc, idx, app->bgConfig, bgLayer, 0, 0, TRUE, HEAP_ID_BATTLE_ARCADE_APP); +} + +static void LoadRouletteBackground(BattleArcadeApp *app, enum BgLayer bgLayer) +{ + u32 idx = !BattleArcade_IsMultiPlayerChallenge(app->challengeType) ? BATTLE_ARCADE_APP_MAIN_ROULETTE_TILEMAP : BATTLE_ARCADE_APP_MAIN_MULTI_ROULETTE_TILEMAP; + Graphics_LoadTilemapToBgLayerFromOpenNARC(app->narc, idx, app->bgConfig, bgLayer, 0, 0, TRUE, HEAP_ID_BATTLE_ARCADE_APP); +} + +static void LoadPalette(void) +{ + NNSG2dPaletteData *plttData; + void *pltt = Graphics_GetPlttData(NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_BG, 167, &plttData, HEAP_ID_BATTLE_ARCADE_APP); + + DC_FlushRange(plttData->pRawData, PALETTE_SIZE_BYTES * 7); + GX_LoadBGPltt(plttData->pRawData, 0, PALETTE_SIZE_BYTES * 7); + Heap_Free(pltt); +} + +static void LoadSubScreenBackground(BattleArcadeApp *app, enum BgLayer bgLayer) +{ + Graphics_LoadTilesToBgLayerFromOpenNARC(app->narc, BATTLE_ARCADE_APP_SUB_TILES, app->bgConfig, bgLayer, 0, 0, TRUE, HEAP_ID_BATTLE_ARCADE_APP); + Graphics_LoadPaletteFromOpenNARC(app->narc, Battle_ARCADE_APP_SUB_PLTT, PAL_LOAD_SUB_BG, 0, PLTT_OFFSET(2), HEAP_ID_BATTLE_ARCADE_APP); + Graphics_LoadTilemapToBgLayerFromOpenNARC(app->narc, BATTLE_ARCADE_APP_SUB_TILEMAP, app->bgConfig, bgLayer, 0, 0, TRUE, HEAP_ID_BATTLE_ARCADE_APP); +} + +static void ChangeState(BattleArcadeApp *app, int *state, enum BattleArcadeAppState newState) +{ + app->subState = 0; + *state = newState; +} + +static void UpdateCursorPosition(BattleArcadeApp *app, int unused) +{ + u8 rouletteSpeed = *app->rouletteSpeed; + app->cursorUpdateTimer++; + + if (app->cursorUpdateTimer >= sCursorMoveFrames[rouletteSpeed][0]) { + app->cursorUpdateTimer = 0; + + if (app->randomizeCursorMovement == TRUE) { + app->cursorPos = LCRNG_Next() % GRID_SIZE; + } else { + app->cursorPos++; + } + + Sound_PlayEffect(SEQ_SE_DP_BUTTON3); + + if (app->cursorPos >= app->gridSize) { + app->cursorPos = 0; + } + + UpdateCursorSpritePosition(app, app->cursorPos); + } +} + +static void UpdateCursorSpritePosition(BattleArcadeApp *app, u8 cursorPos) +{ + BattleArcadeAppSprite_SetPosition(app->cursorSprite, 68 + (40 * (cursorPos % 4)), 36 + (40 * (cursorPos / 4))); +} + +static void SetResultCursorPos(BattleArcadeApp *app) +{ + app->resultCursorPos = app->cursorPos; +} + +static u8 NormalizeCursorPosition(u8 gridSize, u8 cursorPos) +{ + if (cursorPos < gridSize) { + return cursorPos; + } + + return cursorPos - gridSize; +} + +static u16 GetBattleNumber(BattleArcadeApp *app) +{ + u16 battleNum = app->battleStreak; + + if (BattleArcade_IsMultiPlayerChallenge(app->challengeType) == TRUE) { + if (app->partnerBattleStreak > app->battleStreak) { + battleNum = app->partnerBattleStreak; + } + } + + return battleNum; +} + +static BOOL SendCommMessage(BattleArcadeApp *app, u16 cmd, u16 arg) +{ + int commCmd; + switch (cmd) { + case COMM_CMD_INITIAL_LAYOUT: + commCmd = 71; + CreateInitialLayoutPayload(app, cmd); + break; + case COMM_CMD_RESULT: + commCmd = 72; + CreateResultPayload(app, cmd, arg); + break; + case 32: + commCmd = 73; + UnusedCommCommandPayload(app, cmd); + break; + } + + return CommSys_SendData(commCmd, app->commPayload, 40) == TRUE; +} + +static void CreateInitialLayoutPayload(BattleArcadeApp *app, u16 cmd) +{ + int i = 0; + TrainerInfo *trainerInfo = SaveData_GetTrainerInfo(app->saveData); + + app->commPayload[i] = cmd; + + i += 1; + i += 1; + + for (int j = 0; j < GRID_SIZE; j++) { + app->commPayload[i + j] = app->rouletteEffects[j]; + } + + i += GRID_SIZE; + app->commPayload[i] = app->startingCursorPos; + i += 1; +} + +void BattleArcadeApp_HandleInitialLayoutCmd(int netID, int unused, void *data, void *context) +{ + BattleArcadeApp *app = context; + const u16 *payload = data; + + int i = 0; + app->numReceivedMsgs++; + + if (CommSys_CurNetId() == netID) { + return; + } + + i += 2; + + if (CommSys_CurNetId() != 0) { + for (int j = 0; j < GRID_SIZE; j++) { + app->rouletteEffects[j] = payload[i + j]; + } + + i += GRID_SIZE; + app->startingCursorPos = payload[i]; + } +} + +static void CreateResultPayload(BattleArcadeApp *app, u16 cmd, u16 resultCursorPos) +{ + app->commPayload[0] = cmd; + app->commPayload[1] = resultCursorPos; + + if (CommSys_CurNetId() == 0) { + if (app->cursorPosID == 0xff) { + app->cursorPosID = resultCursorPos; + } + } + + app->commPayload[2] = app->cursorPosID; + app->commPayload[3] = *app->unk_24; +} + +static u16 GetRandomNumber(BattleArcadeApp *app) +{ + return LCRNG_Next(); +} + +void BattleArcadeApp_HandleResultCmd(int netID, int unused, void *data, void *context) +{ + BattleArcadeApp *app = context; + const u16 *payload = data; + + app->numReceivedMsgs++; + + if (CommSys_CurNetId() == netID) { + return; + } + + app->cursorPosTemp = payload[1]; + + if (CommSys_CurNetId() == 0) { + if (app->cursorPosID != 0xff) { + app->cursorPosTemp = 0; + } else { + app->cursorPosID = app->cursorPosTemp + app->gridSize; + } + } else { + app->cursorPosID = payload[2]; + *app->unk_24 = payload[3]; + } +} + +static void UnusedCommCommandPayload(BattleArcadeApp *app, u16 cmd) +{ + app->commPayload[0] = cmd; + app->commPayload[1] = app->cursorPos; +} + +void BattleArcadeApp_HandleUnusedCmd(int netID, int unused, void *data, void *context) +{ + BattleArcadeApp *app = context; + const u16 *payload = data; + + if (CommSys_CurNetId() == netID) { + return; + } + + app->partnerCursorPos = payload[1]; +} + +static void SetSelectedEffect(BattleArcadeApp *app, u8 cursorPos) +{ + u8 finalCursorPos = NormalizeCursorPosition(app->gridSize, cursorPos); + u8 selectedEffect = app->rouletteEffects[finalCursorPos]; + + *app->selectedEffect = selectedEffect; + + for (int i = 0; i < GRID_SIZE; i++) { + if (app->tileSprites[i] != NULL) { + BattleArcadeAppSprite_SetAnim(app->tileSprites[i], selectedEffect); + } + } + + UpdateCursorSpritePosition(app, finalCursorPos); + Sound_PlayEffect(SEQ_SE_DP_PIRORIRO2); +} + +static void GetAvailableEffects(BattleArcadeApp *app) +{ + for (int effect = 0; effect < NELEMS(sEffectAvailabilityByRound); effect++) { + u8 isAvailable; + + switch (app->round) { + case 0: + isAvailable = sEffectAvailabilityByRound[effect].round1; + break; + case 1: + isAvailable = sEffectAvailabilityByRound[effect].round2; + break; + case 2: + isAvailable = sEffectAvailabilityByRound[effect].round3; + break; + case 3: + isAvailable = sEffectAvailabilityByRound[effect].round4; + break; + case 4: + isAvailable = sEffectAvailabilityByRound[effect].round5; + break; + case 5: + isAvailable = sEffectAvailabilityByRound[effect].round6; + break; + default: + isAvailable = sEffectAvailabilityByRound[effect].round7; + break; + } + + if (isAvailable == TRUE) { + u8 effectIndex = 0xff; + + switch (effect) { + case ARCADE_EFFECT_RANDOMIZE_CURSOR: + effectIndex = 0; + break; + case ARCADE_EFFECT_SWAP_MONS: + effectIndex = 1; + break; + case ARCADE_EFFECT_SPEED_UP: + effectIndex = 2; + break; + case ARCADE_EFFECT_SLOW_DOWN: + effectIndex = 3; + break; + case ARCADE_EFFECT_GET_1_BP: + effectIndex = 4; + break; + case ARCADE_EFFECT_NO_BATTLE: + effectIndex = 5; + break; + case ARCADE_EFFECT_GET_3_BP: + effectIndex = 6; + break; + } + + u16 battleNum = GetBattleNumber(app); + u16 normalizedBattleNum = battleNum % BATTLES_PER_ROUND_ARCADE; + + if (battleNum >= 9999) { + normalizedBattleNum = 6; + } + + if (effectIndex != 0xff) { + switch (normalizedBattleNum) { + case 0: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle1; + break; + case 1: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle2; + break; + case 2: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle3; + break; + case 3: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle4; + break; + case 4: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle5; + break; + case 5: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle6; + break; + case 6: + case 7: + isAvailable = sEffectAvailabilityByBattle[effectIndex].battle7; + break; + default: + GF_ASSERT(0); + isAvailable = TRUE; + break; + } + } else { + isAvailable = TRUE; + } + + if (isAvailable == TRUE) { + app->availableEffects[app->numAvailableEffects] = effect; + app->numAvailableEffects++; + } + } + } +} + +static void GetEffectCategoryCounts(BattleArcadeApp *app) +{ + int i; + for (i = 0; i < NELEMS(Unk_ov108_0224367C); i++) { + if (app->unk_12 >= Unk_ov108_0224367C[i]) { + break; + } + } + + app->categoryWeightTier = i; + + for (i = 0; i < app->numAvailableEffects; i++) { + if (BattleArcade_GetCategoryFromEffect(app->availableEffects[i]) == ARCADE_EFFECT_CATEGORY_FOE) { + app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_FOE]++; + } else if (BattleArcade_GetCategoryFromEffect(app->availableEffects[i]) == ARCADE_EFFECT_CATEGORY_ALLY) { + app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_ALLY]++; + } else if (BattleArcade_GetCategoryFromEffect(app->availableEffects[i]) == ARCADE_EFFECT_CATEGORY_ENV) { + app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_ENV]++; + } else if (BattleArcade_GetCategoryFromEffect(app->availableEffects[i]) == ARCADE_EFFECT_CATEGORY_BONUS) { + app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_BONUS]++; + } + } +} + +static void AssignEffectsToGrid(BattleArcadeApp *app) +{ + u8 effectsIndex = 0; + + for (int i = 0; i < GRID_SIZE; i++) { + u8 category = GetRandomCategory(app, app->categoryWeightTier); + int numEffectsInCategory = app->availableEffectsPerCategory[category]; + + int startOffset = 0; + if (category == ARCADE_EFFECT_CATEGORY_FOE) { + startOffset = 0; + } else if (category == ARCADE_EFFECT_CATEGORY_ALLY) { + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_FOE]; + } else if (category == ARCADE_EFFECT_CATEGORY_ENV) { + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_FOE]; + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_ALLY]; + } else if (category == ARCADE_EFFECT_CATEGORY_BONUS) { + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_FOE]; + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_ALLY]; + startOffset += app->availableEffectsPerCategory[ARCADE_EFFECT_CATEGORY_ENV]; + } + + u16 start = LCRNG_Next() % numEffectsInCategory; + start += startOffset; + effectsIndex = start; + + int loopCounter = 0; + while (TRUE) { + if (loopCounter >= 50) { + GF_ASSERT(0); + app->rouletteEffects[i] = ARCADE_EFFECT_LOWER_FOE_HP; + loopCounter = 0; + break; + } + + if (BattleArcade_GetCategoryFromEffect(app->availableEffects[effectsIndex]) == category) { + app->rouletteEffects[i] = app->availableEffects[effectsIndex]; + loopCounter = 0; + break; + } + + effectsIndex++; + loopCounter++; + + if (effectsIndex >= app->numAvailableEffects) { + effectsIndex = 0; + } + + if (effectsIndex == start) { + category++; + + if (category >= NUM_ARCADE_EFFECT_CATEGORIES) { + category = ARCADE_EFFECT_CATEGORY_FOE; + } + } + } + } +} + +static u8 GetRandomCategory(BattleArcadeApp *app, u8 weightsIndex) +{ + u8 category; + u8 sum = 0; + u16 rand = LCRNG_Next() % 100; + + for (category = ARCADE_EFFECT_CATEGORY_FOE; category < NUM_ARCADE_EFFECT_CATEGORIES; category++) { + sum += sCategoryWeights[weightsIndex][category]; + + if (rand < sum) { + break; + } + } + + if (category >= NUM_ARCADE_EFFECT_CATEGORIES) { + GF_ASSERT(0); + category = ARCADE_EFFECT_CATEGORY_FOE; + } + + return category; +} + +static void UpdateItemSprites(BattleArcadeApp *app) +{ + u8 partySize = BattleArcade_GetPartySize(app->challengeType, TRUE); + u8 opponentPartySize = BattleArcade_GetOpponentPartySize(app->challengeType, TRUE); + + for (u8 i = 0; i < partySize; i++) { + Pokemon *mon = Party_GetPokemonBySlotIndex(app->party, i); + + if (Pokemon_GetValue(mon, MON_DATA_HELD_ITEM, NULL) == ITEM_NONE) { + BattleArcadeAppSprite_SetDrawFlag(app->itemSprites[i], FALSE); + } else { + BattleArcadeAppSprite_SetDrawFlag(app->itemSprites[i], TRUE); + } + } + + for (u8 i = 0; i < opponentPartySize; i++) { + Pokemon *mon = Party_GetPokemonBySlotIndex(app->opponentsParty, i); + + if (Pokemon_GetValue(mon, MON_DATA_HELD_ITEM, NULL) == ITEM_NONE) { + BattleArcadeAppSprite_SetDrawFlag(app->opponentItemSprites[i], FALSE); + } else { + BattleArcadeAppSprite_SetDrawFlag(app->opponentItemSprites[i], TRUE); + } + } +} + +static BOOL CheckStopButtonPressed(BattleArcadeApp *app) +{ + if (TouchScreen_CheckPressedHitTableID(sStopButtonHitBox) == TOUCH_BUTTON_PRESSED) { + PressStopButton(app); + return TRUE; + } + + return FALSE; +} + +static void PressStopButton(BattleArcadeApp *app) +{ + Sound_StopEffect(SEQ_SE_CONFIRM, 0); + Sound_PlayEffect(SEQ_SE_DP_BUTTON9); + BattleArcadeAppSprite_SetAnim(app->buttonSprite, ANIM_ID_BUTTON_PRESSED); +} diff --git a/src/applications/frontier/battle_arcade/sprite_manager.c b/src/applications/frontier/battle_arcade/sprite_manager.c new file mode 100644 index 0000000000..47537b1fb2 --- /dev/null +++ b/src/applications/frontier/battle_arcade/sprite_manager.c @@ -0,0 +1,186 @@ +#include "applications/frontier/battle_arcade/sprite_manager.h" + +#include + +#include "applications/party_menu/main.h" + +#include "char_transfer.h" +#include "gx_layers.h" +#include "narc.h" +#include "narc_frontier_obj.h" +#include "party.h" +#include "pltt_transfer.h" +#include "pokemon_icon.h" +#include "render_oam.h" +#include "sprite.h" +#include "sprite_resource.h" +#include "sprite_transfer.h" +#include "sprite_util.h" +#include "vram_transfer.h" + +static const u8 sCapacities[4] = { 11, 11, 11, 11 }; + +static void InitCharPlttTransferBuffers(void); +static void InitMainScreenSpriteResources(BattleArcadeAppSpriteManager *spriteMan); +static void InitItemSpriteResources(BattleArcadeAppSpriteManager *spriteMan); +static void InitMonSpriteResources(BattleArcadeAppSpriteManager *spriteMan, Party *party, Party *opponentParty, u8 isMultiPlayerChallenge); +static void InitSubScreenSpriteResources(BattleArcadeAppSpriteManager *spriteMan); + +void BattleArcadeApp_InitSpriteManager(BattleArcadeAppSpriteManager *spriteMan, Party *party, Party *opponentParty, u8 isMultiPlayerChallenge) +{ + VramTransfer_New(32, HEAP_ID_BATTLE_ARCADE_APP); + InitCharPlttTransferBuffers(); + + NNS_G2dInitOamManagerModule(); + RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, HEAP_ID_BATTLE_ARCADE_APP); + + spriteMan->spriteList = SpriteList_InitRendering(34, &spriteMan->renderer, HEAP_ID_BATTLE_ARCADE_APP); + + for (int i = 0; i < MAX_SPRITE_RESOURCE_GEN4; i++) { + spriteMan->resourceCollection[i] = SpriteResourceCollection_New(sCapacities[i], i, HEAP_ID_BATTLE_ARCADE_APP); + } + + InitSubScreenSpriteResources(spriteMan); + InitMainScreenSpriteResources(spriteMan); + InitItemSpriteResources(spriteMan); + InitMonSpriteResources(spriteMan, party, opponentParty, isMultiPlayerChallenge); + + for (int i = 0; i < 11; i++) { + SpriteTransfer_RequestChar(spriteMan->resources[i][SPRITE_RESOURCE_CHAR]); + } + + for (int i = 0; i < 4; i++) { + SpriteTransfer_RequestPlttWholeRange(spriteMan->resources[i][SPRITE_RESOURCE_PLTT]); + } + + GXLayers_EngineBToggleLayers(GX_PLANEMASK_OBJ, TRUE); + GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, TRUE); +} + +Sprite *BattleArcadeApp_InitSprite(BattleArcadeAppSpriteManager *spriteMan, u32 charResourceID, u32 plttResourceID, u32 cellResourceID, u32 animID, u32 priority, int resourcePriority, u8 onSubScreen) +{ + SpriteResourcesHeader resourceHeader; + SpriteResourcesHeader_Init(&resourceHeader, charResourceID, plttResourceID, cellResourceID, cellResourceID, -1, -1, FALSE, resourcePriority, spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], spriteMan->resourceCollection[SPRITE_RESOURCE_PLTT], spriteMan->resourceCollection[SPRITE_RESOURCE_CELL], spriteMan->resourceCollection[SPRITE_RESOURCE_ANIM], NULL, NULL); + + AffineSpriteListTemplate spriteTemplate; + spriteTemplate.list = spriteMan->spriteList; + spriteTemplate.resourceData = &resourceHeader; + spriteTemplate.position.x = 0; + spriteTemplate.position.y = 0; + spriteTemplate.position.z = 0; + spriteTemplate.affineScale.x = FX32_ONE; + spriteTemplate.affineScale.y = FX32_ONE; + spriteTemplate.affineScale.z = FX32_ONE; + spriteTemplate.affineZRotation = 0; + spriteTemplate.priority = priority; + spriteTemplate.heapID = HEAP_ID_BATTLE_ARCADE_APP; + + if (!onSubScreen) { + spriteTemplate.vramType = NNS_G2D_VRAM_TYPE_2DMAIN; + } else { + spriteTemplate.vramType = NNS_G2D_VRAM_TYPE_2DSUB; + spriteTemplate.position.y += FX32_CONST(HW_LCD_HEIGHT); + } + + Sprite *sprite = SpriteList_AddAffine(&spriteTemplate); + + Sprite_SetAnimateFlag(sprite, TRUE); + Sprite_SetAnimSpeed(sprite, FX32_ONE); + Sprite_SetAnim(sprite, animID); + + return sprite; +} + +void BattleArcadeApp_FreeSprites(BattleArcadeAppSpriteManager *spriteMan) +{ + for (u8 i = 0; i < 11; i++) { + SpriteTransfer_ResetCharTransfer(spriteMan->resources[i][SPRITE_RESOURCE_CHAR]); + } + + for (u8 i = 0; i < 4; i++) { + SpriteTransfer_ResetPlttTransfer(spriteMan->resources[i][SPRITE_RESOURCE_PLTT]); + } + + for (u8 i = 0; i < 4; i++) { + SpriteResourceCollection_Delete(spriteMan->resourceCollection[i]); + } + + SpriteList_Delete(spriteMan->spriteList); + RenderOam_Free(); + CharTransfer_Free(); + PlttTransfer_Free(); +} + +static void InitCharPlttTransferBuffers(void) +{ + CharTransferTemplate transferTemplate = { + .maxTasks = 32, + .sizeMain = 1024, + .sizeSub = 1024, + HEAP_ID_BATTLE_ARCADE_APP + }; + + CharTransfer_InitWithVramModes(&transferTemplate, GX_OBJVRAMMODE_CHAR_1D_32K, GX_OBJVRAMMODE_CHAR_1D_32K); + + PlttTransfer_Init(14, HEAP_ID_BATTLE_ARCADE_APP); + CharTransfer_ClearBuffers(); + PlttTransfer_Clear(); +} + +static void InitMainScreenSpriteResources(BattleArcadeAppSpriteManager *spriteMan) +{ + spriteMan->resources[RESOURCE_ID_MAIN_SPRITES][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTiles(spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SPRITES_NCGR, TRUE, RESOURCE_ID_MAIN_SPRITES, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_MAIN_SPRITES][SPRITE_RESOURCE_PLTT] = SpriteResourceCollection_AddPalette(spriteMan->resourceCollection[SPRITE_RESOURCE_PLTT], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SPRITES_PLTT, FALSE, RESOURCE_ID_MAIN_SPRITES, NNS_G2D_VRAM_TYPE_2DMAIN, 8, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_MAIN_SPRITES][SPRITE_RESOURCE_CELL] = SpriteResourceCollection_Add(spriteMan->resourceCollection[SPRITE_RESOURCE_CELL], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SPRITES_NCER, TRUE, RESOURCE_ID_MAIN_SPRITES, SPRITE_RESOURCE_CELL, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_MAIN_SPRITES][SPRITE_RESOURCE_ANIM] = SpriteResourceCollection_Add(spriteMan->resourceCollection[SPRITE_RESOURCE_ANIM], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SPRITES_NANR, TRUE, RESOURCE_ID_MAIN_SPRITES, SPRITE_RESOURCE_ANIM, HEAP_ID_BATTLE_ARCADE_APP); +} + +static void InitItemSpriteResources(BattleArcadeAppSpriteManager *spriteMan) +{ + NARC *narc = NARC_ctor(NARC_INDEX_GRAPHIC__PL_PLIST_GRA, HEAP_ID_BATTLE_ARCADE_APP); + + spriteMan->resources[RESOURCE_ID_ITEM_SPRITES][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTilesFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], narc, sub_02081930(), FALSE, RESOURCE_ID_ITEM_SPRITES, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_ITEM_SPRITES][SPRITE_RESOURCE_PLTT] = SpriteResourceCollection_AddPalette(spriteMan->resourceCollection[SPRITE_RESOURCE_PLTT], NARC_INDEX_GRAPHIC__PL_PLIST_GRA, sub_02081934(), FALSE, RESOURCE_ID_ITEM_SPRITES, NNS_G2D_VRAM_TYPE_2DMAIN, 3, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_ITEM_SPRITES][SPRITE_RESOURCE_CELL] = SpriteResourceCollection_AddFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_CELL], narc, sub_02081938(), FALSE, RESOURCE_ID_ITEM_SPRITES, SPRITE_RESOURCE_CELL, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_ITEM_SPRITES][SPRITE_RESOURCE_ANIM] = SpriteResourceCollection_AddFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_ANIM], narc, sub_0208193C(), FALSE, RESOURCE_ID_ITEM_SPRITES, SPRITE_RESOURCE_ANIM, HEAP_ID_BATTLE_ARCADE_APP); + + NARC_dtor(narc); +} + +static void InitMonSpriteResources(BattleArcadeAppSpriteManager *spriteMan, Party *party, Party *opponentParty, u8 isMultiPlayerChallenge) +{ + Pokemon *mon, *oppMon; + NARC *narc = NARC_ctor(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, HEAP_ID_BATTLE_ARCADE_APP); + + spriteMan->resources[RESOURCE_ID_MON_SPRITES][SPRITE_RESOURCE_PLTT] = SpriteResourceCollection_AddPalette(spriteMan->resourceCollection[SPRITE_RESOURCE_PLTT], NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, PokeIconPalettesFileIndex(), FALSE, RESOURCE_ID_MON_SPRITES, NNS_G2D_VRAM_TYPE_2DMAIN, RESOURCE_ID_MON_SPRITES, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_MON_SPRITES][SPRITE_RESOURCE_CELL] = SpriteResourceCollection_AddFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_CELL], narc, PokeIcon32KCellsFileIndex(), FALSE, RESOURCE_ID_MON_SPRITES, SPRITE_RESOURCE_CELL, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_MON_SPRITES][SPRITE_RESOURCE_ANIM] = SpriteResourceCollection_AddFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_ANIM], narc, PokeIcon32KAnimationFileIndex(), FALSE, RESOURCE_ID_MON_SPRITES, SPRITE_RESOURCE_ANIM, HEAP_ID_BATTLE_ARCADE_APP); + + for (u32 i = 0; i < NUM_MON_SPRITES; i++) { + if (i == ARCADE_PARTY_SIZE_SOLO) { + if (!isMultiPlayerChallenge) { + mon = Party_GetPokemonBySlotIndex(party, 0); + oppMon = Party_GetPokemonBySlotIndex(opponentParty, 0); + } else { + mon = Party_GetPokemonBySlotIndex(party, i); + oppMon = Party_GetPokemonBySlotIndex(opponentParty, i); + } + } else { + mon = Party_GetPokemonBySlotIndex(party, i); + oppMon = Party_GetPokemonBySlotIndex(opponentParty, i); + } + + spriteMan->resources[RESOURCE_ID_MON_SPRITES + i][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTilesFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], narc, Pokemon_IconSpriteIndex(mon), SPRITE_RESOURCE_CHAR, RESOURCE_ID_MON_SPRITES + i, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_OPP_MON_ANIMS + i][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTilesFrom(spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], narc, Pokemon_IconSpriteIndex(oppMon), SPRITE_RESOURCE_CHAR, RESOURCE_ID_OPP_MON_ANIMS + i, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_BATTLE_ARCADE_APP); + } + + NARC_dtor(narc); +} + +static void InitSubScreenSpriteResources(BattleArcadeAppSpriteManager *spriteMan) +{ + spriteMan->resources[RESOURCE_ID_SUB_SPRITES][SPRITE_RESOURCE_CHAR] = SpriteResourceCollection_AddTiles(spriteMan->resourceCollection[SPRITE_RESOURCE_CHAR], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SUB_SPRITES_NCGR, TRUE, RESOURCE_ID_SUB_SPRITES, NNS_G2D_VRAM_TYPE_2DSUB, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_SUB_SPRITES][SPRITE_RESOURCE_PLTT] = SpriteResourceCollection_AddPalette(spriteMan->resourceCollection[SPRITE_RESOURCE_PLTT], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SUB_SPRITES_PLTT, FALSE, RESOURCE_ID_SUB_SPRITES, NNS_G2D_VRAM_TYPE_2DSUB, 2, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_SUB_SPRITES][SPRITE_RESOURCE_CELL] = SpriteResourceCollection_Add(spriteMan->resourceCollection[SPRITE_RESOURCE_CELL], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SUB_SPRITES_NCER, TRUE, RESOURCE_ID_SUB_SPRITES, SPRITE_RESOURCE_CELL, HEAP_ID_BATTLE_ARCADE_APP); + spriteMan->resources[RESOURCE_ID_SUB_SPRITES][SPRITE_RESOURCE_ANIM] = SpriteResourceCollection_Add(spriteMan->resourceCollection[SPRITE_RESOURCE_ANIM], NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_OBJ, BATTLE_ARCADE_APP_SUB_SPRITES_NANR, TRUE, RESOURCE_ID_SUB_SPRITES, SPRITE_RESOURCE_ANIM, HEAP_ID_BATTLE_ARCADE_APP); +} diff --git a/src/applications/frontier/battle_arcade/sprites.c b/src/applications/frontier/battle_arcade/sprites.c new file mode 100644 index 0000000000..be2e7daae0 --- /dev/null +++ b/src/applications/frontier/battle_arcade/sprites.c @@ -0,0 +1,76 @@ +#include "applications/frontier/battle_arcade/sprites.h" + +#include +#include + +#include "applications/frontier/battle_arcade/sprite_manager.h" + +#include "heap.h" +#include "pokemon_icon.h" +#include "sprite.h" + +BattleArcadeAppSprite *BattleArcadeAppSprite_New(BattleArcadeAppSpriteManager *spriteMan, u32 charResourceID, u32 plttResourceID, u32 cellResourceID, u32 animID, u16 x, u16 y, u32 priority, int resourcePriority, u8 onSubScreen) +{ + BattleArcadeAppSprite *appSprite = Heap_Alloc(HEAP_ID_BATTLE_ARCADE_APP, sizeof(BattleArcadeAppSprite)); + memset(appSprite, 0, sizeof(BattleArcadeAppSprite)); + + appSprite->sprite = BattleArcadeApp_InitSprite(spriteMan, charResourceID, plttResourceID, cellResourceID, animID, priority, resourcePriority, onSubScreen); + appSprite->x = x; + appSprite->y = y; + appSprite->onSubScreen = onSubScreen; + + VecFx32 pos; + pos.x = x * FX32_ONE; + pos.y = y * FX32_ONE; + + if (onSubScreen == TRUE) { + pos.y += FX32_CONST(HW_LCD_HEIGHT); + } + + Sprite_SetPosition(appSprite->sprite, &pos); + + return appSprite; +} + +void *BattleArcadeAppSprite_Free(BattleArcadeAppSprite *appSprite) +{ + Sprite_Delete(appSprite->sprite); + Heap_Free(appSprite); + + return NULL; +} + +void BattleArcadeAppSprite_SetDrawFlag(BattleArcadeAppSprite *appSprite, BOOL draw) +{ + Sprite_SetDrawFlag(appSprite->sprite, draw); +} + +void BattleArcadeAppSprite_SetPosition(BattleArcadeAppSprite *appSprite, u16 x, u16 y) +{ + VecFx32 pos = *Sprite_GetPosition(appSprite->sprite); + + pos.x = x * FX32_ONE; + pos.y = y * FX32_ONE; + + if (appSprite->onSubScreen == TRUE) { + pos.y += FX32_CONST(HW_LCD_HEIGHT); + } + + Sprite_SetPosition(appSprite->sprite, &pos); +} + +void BattleArcadeAppSprite_SetAnim(BattleArcadeAppSprite *appSprite, u32 animID) +{ + Sprite_SetAnimSpeed(appSprite->sprite, FX32_ONE); + Sprite_SetAnimNoRestart(appSprite->sprite, animID); +} + +void BattleArcadeAppSprite_UpdatePalette(BattleArcadeAppSprite *appSprite, Pokemon *mon) +{ + Sprite_SetExplicitPaletteOffsetAutoAdjust(appSprite->sprite, Pokemon_IconPaletteIndex(mon)); +} + +void BattleArcadeAppSprite_SetAnimateFlag(BattleArcadeAppSprite *appSprite, u8 animate) +{ + Sprite_SetAnimateFlag(appSprite->sprite, animate); +} diff --git a/src/applications/frontier/battle_arcade/windows.c b/src/applications/frontier/battle_arcade/windows.c new file mode 100644 index 0000000000..843e6f6b53 --- /dev/null +++ b/src/applications/frontier/battle_arcade/windows.c @@ -0,0 +1,41 @@ +#include "applications/frontier/battle_arcade/windows.h" + +#include + +#include "bg_window.h" + +static const WindowTemplate sWinTemplates[] = { + { + .bgLayer = BG_LAYER_MAIN_1, + .tilemapLeft = 2, + .tilemapTop = 19, + .width = 27, + .height = 4, + .palette = 12, + .baseTile = 1, + }, + { + .bgLayer = BG_LAYER_MAIN_1, + .tilemapLeft = 24, + .tilemapTop = 13, + .width = 7, + .height = 4, + .palette = 13, + .baseTile = 109, + } +}; + +void BattleArcadeApp_InitWindows(BgConfig *bgConfig, Window *window) +{ + for (u8 i = 0; i < NELEMS(sWinTemplates); i++) { + Window_AddFromTemplate(bgConfig, &window[i], &sWinTemplates[i]); + Window_FillTilemap(&window[i], 0); + } +} + +void BattleArcadeApp_FreeWindows(Window *windows) +{ + for (u16 i = 0; i < NELEMS(sWinTemplates); i++) { + Window_Remove(&windows[i]); + } +} diff --git a/src/meson.build b/src/meson.build index 6803c7ae61..ca8ee62fa2 100644 --- a/src/meson.build +++ b/src/meson.build @@ -968,10 +968,10 @@ pokeplatinum_c = files( 'applications/frontier/battle_castle/sprites.c', 'applications/frontier/battle_castle/helpers.c', 'applications/frontier/battle_castle/windows.c', - 'overlay108/ov108_02241AE0.c', - 'overlay108/ov108_02243030.c', - 'overlay108/ov108_0224351C.c', - 'overlay108/ov108_02243630.c', + 'applications/frontier/battle_arcade/main.c', + 'applications/frontier/battle_arcade/sprite_manager.c', + 'applications/frontier/battle_arcade/sprites.c', + 'applications/frontier/battle_arcade/windows.c', 'overlay109/ov109_021D0D80.c', 'overlay109/ov109_021D3D50.c', 'overlay110/ov110_021D0D80.c', diff --git a/src/overlay104/ov104_0222ECE8.c b/src/overlay104/ov104_0222ECE8.c index 16a98b023d..8ccf9cef92 100644 --- a/src/overlay104/ov104_0222ECE8.c +++ b/src/overlay104/ov104_0222ECE8.c @@ -1346,7 +1346,7 @@ BOOL ov104_0222FAD0(UnkStruct_ov104_0223BFFC *param0) v1 = 0; v3 = 512; - v5 = ov104_0223BD70(param0->unk_10, 0); + v5 = BattleArcade_GetPartySize(param0->unk_10, 0); v4 = Pokemon_StructSize(); for (v0 = 0; v0 < v5; v0++) { @@ -1378,7 +1378,7 @@ void ov104_0222FB34(int param0, int param1, void *param2, void *param3) return; } - v0 = ov104_0223BD70(v5->unk_10, 0); + v0 = BattleArcade_GetPartySize(v5->unk_10, 0); v3 = Pokemon_StructSize(); v4 = Pokemon_New(HEAP_ID_FIELD2); diff --git a/src/overlay104/ov104_02237378.c b/src/overlay104/ov104_02237378.c index 31e95ebfab..9e2515cced 100644 --- a/src/overlay104/ov104_02237378.c +++ b/src/overlay104/ov104_02237378.c @@ -1,6 +1,7 @@ #include #include +#include "applications/frontier/battle_arcade/main.h" #include "overlay063/ov63_0222CCE4.h" #include "overlay104/frontier_script_context.h" #include "overlay104/frscrcmd.h" @@ -19,7 +20,6 @@ #include "overlay104/struct_ov104_0223BFFC.h" #include "overlay104/struct_ov104_0223C4CC.h" #include "overlay104/struct_ov104_0223C634.h" -#include "overlay108/ov108_02241AE0.h" #include "communication_information.h" #include "field_battle_data_transfer.h" @@ -42,7 +42,7 @@ #include "constdata/const_020EA358.h" -FS_EXTERN_OVERLAY(overlay108); +FS_EXTERN_OVERLAY(battle_arcade_app); #include @@ -96,13 +96,13 @@ BOOL FrontierScrCmd_C3(FrontierScriptContext *param0) UnkStruct_ov104_02238240 *v2; UnkStruct_ov104_02230BE4 *v3 = sub_0209B970(param0->unk_00->unk_00); - FS_EXTERN_OVERLAY(overlay108); + FS_EXTERN_OVERLAY(battle_arcade_app); static const ApplicationManagerTemplate v4 = { - ov108_02241AE0, - ov108_02241C38, - ov108_02241D70, - FS_OVERLAY_ID(overlay108) + BattleArcadeApp_Init, + BattleArcadeApp_Main, + BattleArcadeApp_Exit, + FS_OVERLAY_ID(battle_arcade_app) }; v1 = sub_0209B978(param0->unk_00->unk_00); @@ -152,7 +152,7 @@ BOOL FrontierScrCmd_BB(FrontierScriptContext *param0) } if (v9->unk_13 == 17) { - v0 = ov104_0223BD70(v9->unk_10, 1); + v0 = BattleArcade_GetPartySize(v9->unk_10, 1); for (v1 = 0; v1 < v0; v1++) { v11 = Party_GetPokemonBySlotIndex(v9->unk_70, v1); @@ -367,8 +367,8 @@ BOOL FrontierScrCmd_BF(FrontierScriptContext *param0) break; case 25: if (v3->unk_13 == 27) { - v4 = ov104_0223BD70(v3->unk_10, 1); - v5 = ov104_0223BDA4(v3->unk_10, 1); + v4 = BattleArcade_GetPartySize(v3->unk_10, 1); + v5 = BattleArcade_GetOpponentPartySize(v3->unk_10, 1); { VecFx32 v21; @@ -416,8 +416,8 @@ BOOL FrontierScrCmd_BF(FrontierScriptContext *param0) case 31: ov104_02238764(v3, v15, v18); - v4 = ov104_0223BD70(v3->unk_10, 1); - v5 = ov104_0223BDA4(v3->unk_10, 1); + v4 = BattleArcade_GetPartySize(v3->unk_10, 1); + v5 = BattleArcade_GetOpponentPartySize(v3->unk_10, 1); if (v18 == 0) { for (v11 = 0; v11 < v4; v11++) { @@ -453,7 +453,7 @@ BOOL FrontierScrCmd_BF(FrontierScriptContext *param0) } break; case 38: - v6 = ov104_0223C148(v3->unk_13); + v6 = BattleArcade_GetCategoryFromEffect(v3->unk_13); if (v6 == 0) { StringTemplate_SetFrontierTrainerName(param0->unk_00->strTemplate, v18, v3->unk_78[ov104_02238498(v3, v19)]); diff --git a/src/overlay104/ov104_02237DD8.c b/src/overlay104/ov104_02237DD8.c index 0b44e80025..be91dd1495 100644 --- a/src/overlay104/ov104_02237DD8.c +++ b/src/overlay104/ov104_02237DD8.c @@ -207,7 +207,7 @@ UnkStruct_ov104_0223BFFC *ov104_02237DD8(SaveData *saveData, u16 param1, u8 para } v2 = SaveData_GetParty(v9->saveData); - v6 = ov104_0223BD70(v9->unk_10, 0); + v6 = BattleArcade_GetPartySize(v9->unk_10, 0); for (v7 = 0; v7 < v6; v7++) { Party_AddPokemon(v9->unk_70, Party_GetPokemonBySlotIndex(v2, v9->unk_2C[v7])); @@ -246,7 +246,7 @@ static void ov104_02238080(UnkStruct_ov104_0223BFFC *param0) { ov104_0223BD28(param0->unk_10, ov104_0223C124(param0), param0->unk_78, (7 * 2)); - ov104_0222E4BC(ov104_0223BDA4(param0->unk_10, 1), param0->unk_78[param0->unk_11], param0->unk_78[param0->unk_11 + 7], param0->unk_314, param0->unk_330, param0->unk_31C, param0->unk_320, BattleArcade_IsMultiPlayerChallenge(param0->unk_10)); + ov104_0222E4BC(BattleArcade_GetOpponentPartySize(param0->unk_10, 1), param0->unk_78[param0->unk_11], param0->unk_78[param0->unk_11 + 7], param0->unk_314, param0->unk_330, param0->unk_31C, param0->unk_320, BattleArcade_IsMultiPlayerChallenge(param0->unk_10)); u16 v0 = ov104_0223C124(param0); @@ -372,7 +372,7 @@ void ov104_02238278(UnkStruct_ov104_0223BFFC *param0, u8 param1) UnkStruct_020304A0 *v8 = param0->unk_08; UnkStruct_020305B8 *v9 = sub_020305B8(param0->saveData); - v1 = ov104_0223BDA4(param0->unk_10, 1); + v1 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); v2[0] = param0->unk_10; sub_020304CC(param0->unk_08, 0, 0, 0, v2); @@ -488,7 +488,7 @@ void ov104_022384DC(UnkStruct_ov104_0223BFFC *param0) int v0, v1, v2; u8 v3; - ov104_0222E4BC(ov104_0223BDA4(param0->unk_10, 1), param0->unk_78[param0->unk_11], param0->unk_78[param0->unk_11 + 7], param0->unk_314, param0->unk_330, param0->unk_31C, param0->unk_320, BattleArcade_IsMultiPlayerChallenge(param0->unk_10)); + ov104_0222E4BC(BattleArcade_GetOpponentPartySize(param0->unk_10, 1), param0->unk_78[param0->unk_11], param0->unk_78[param0->unk_11 + 7], param0->unk_314, param0->unk_330, param0->unk_31C, param0->unk_320, BattleArcade_IsMultiPlayerChallenge(param0->unk_10)); for (v0 = 0; v0 < 4; v0++) { (void)0; @@ -529,7 +529,7 @@ int ov104_02238538(UnkStruct_ov104_0223BFFC *param0, Party *param1, Party *param int v1; Pokemon *v2; int v3 = 0; - v0 = ov104_0223BD70(param0->unk_10, 0); + v0 = BattleArcade_GetPartySize(param0->unk_10, 0); v3 += ov104_02238584(param0, param1, param2, v0); @@ -666,8 +666,8 @@ void ov104_02238764(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * int v2; Pokemon *v3; - v0 = ov104_0223BD70(param0->unk_10, 1); - v1 = ov104_0223BDA4(param0->unk_10, 1); + v0 = BattleArcade_GetPartySize(param0->unk_10, 1); + v1 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param2 == 0) { for (v2 = 0; v2 < v0; v2++) { @@ -691,8 +691,8 @@ void ov104_02238814(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * u8 v0, v1; int v2; - v0 = ov104_0223BD70(param0->unk_10, 1); - v1 = ov104_0223BDA4(param0->unk_10, 1); + v0 = BattleArcade_GetPartySize(param0->unk_10, 1); + v1 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param2 == 0) { for (v2 = 0; v2 < v0; v2++) { @@ -709,7 +709,7 @@ void ov104_02238814(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * void ov104_0223886C(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC *param1, u16 param2, u16 param3) { - u8 v0 = ov104_0223BD70(param0->unk_10, 1); + u8 v0 = BattleArcade_GetPartySize(param0->unk_10, 1); if (param3 >= v0) { return; @@ -726,7 +726,7 @@ void ov104_0223886C(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * void ov104_022388A4(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC *param1, u16 param2, u16 param3) { - u8 v0 = ov104_0223BDA4(param0->unk_10, 1); + u8 v0 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param3 >= v0) { return; @@ -747,8 +747,8 @@ void ov104_022388DC(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * int v2; Pokemon *v3; - v0 = ov104_0223BD70(param0->unk_10, 1); - v1 = ov104_0223BDA4(param0->unk_10, 1); + v0 = BattleArcade_GetPartySize(param0->unk_10, 1); + v1 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param2 == 0) { for (v2 = 0; v2 < v0; v2++) { @@ -780,8 +780,8 @@ void ov104_022389A0(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * u8 v0, v1; int v2; - v0 = ov104_0223BD70(param0->unk_10, 1); - v1 = ov104_0223BDA4(param0->unk_10, 1); + v0 = BattleArcade_GetPartySize(param0->unk_10, 1); + v1 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param2 == 0) { for (v2 = 0; v2 < v0; v2++) { @@ -802,8 +802,8 @@ void ov104_022389F4(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_0223C4CC * u8 v1, v2; Pokemon *mon; - v1 = ov104_0223BD70(param0->unk_10, 1); - v2 = ov104_0223BDA4(param0->unk_10, 1); + v1 = BattleArcade_GetPartySize(param0->unk_10, 1); + v2 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); if (param2 == 0) { if (slot >= v1) { @@ -1054,10 +1054,10 @@ void ov104_02238B88(UnkStruct_ov104_0223BFFC *param0, u8 param1) if (param1 < 9) { v1 = param0->unk_74; - v0 = ov104_0223BDA4(param0->unk_10, 1); + v0 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); } else { v1 = param0->unk_70; - v0 = ov104_0223BD70(param0->unk_10, 1); + v0 = BattleArcade_GetPartySize(param0->unk_10, 1); } v2 = Unk_ov104_02241A38[param1]; diff --git a/src/overlay104/ov104_0223BCBC.c b/src/overlay104/ov104_0223BCBC.c index bcf746d007..a880f2d0ca 100644 --- a/src/overlay104/ov104_0223BCBC.c +++ b/src/overlay104/ov104_0223BCBC.c @@ -24,8 +24,6 @@ #include "string_gf.h" #include "trainer_info.h" -u8 ov104_0223BD70(u8 param0, BOOL param1); -u8 ov104_0223BDA4(u8 param0, BOOL param1); FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_02230BE4 *param1); static u32 ov104_0223BFD0(u8 param0); u8 ov104_0223BFFC(UnkStruct_ov104_0223BFFC *param0); @@ -35,7 +33,6 @@ void ov104_0223C034(UnkStruct_ov104_0223BFFC *param0, Party *param1, Pokemon *pa u16 ov104_0223C0BC(UnkStruct_ov104_0223BFFC *param0, u8 param1); static u16 ov104_0223C0D0(UnkStruct_ov104_0223BFFC *param0); u16 ov104_0223C124(UnkStruct_ov104_0223BFFC *param0); -u8 ov104_0223C148(u8 param0); void FieldBattleDTO_CopyPlayerInfoToTrainerData(FieldBattleDTO *param0); static int ov104_0223BCBC(u8 param0, int param1, int param2); void ov104_0223BD28(u8 param0, int param1, u16 param2[], u8 param3); @@ -120,42 +117,42 @@ void ov104_0223BD28(u8 param0, int param1, u16 param2[], u8 param3) } while (v0 < param3); } -u8 ov104_0223BD70(u8 param0, BOOL param1) +u8 BattleArcade_GetPartySize(u8 challengeType, BOOL includePartnerMons) { - switch (param0) { - case 0: - case 1: - return 3; - case 2: - case 3: - if (param1 == 0) { - return 2; + switch (challengeType) { + case FRONTIER_CHALLENGE_SINGLE: + case FRONTIER_CHALLENGE_DOUBLE: + return ARCADE_PARTY_SIZE_SOLO; + case FRONTIER_CHALLENGE_MULTI: + case FRONTIER_CHALLENGE_MULTI_WFC: + if (includePartnerMons == FALSE) { + return ARCADE_PARTY_SIZE_MULTI; } else { - return 2 * 2; + return ARCADE_PARTY_SIZE_MULTI * 2; } } GF_ASSERT(0); - return 3; + return ARCADE_PARTY_SIZE_SOLO; } -u8 ov104_0223BDA4(u8 param0, BOOL param1) +u8 BattleArcade_GetOpponentPartySize(u8 challengeType, BOOL includeBothOpponents) { - switch (param0) { - case 0: - case 1: - return 3; - case 2: - case 3: - if (param1 == 0) { - return 2; + switch (challengeType) { + case FRONTIER_CHALLENGE_SINGLE: + case FRONTIER_CHALLENGE_DOUBLE: + return ARCADE_PARTY_SIZE_SOLO; + case FRONTIER_CHALLENGE_MULTI: + case FRONTIER_CHALLENGE_MULTI_WFC: + if (includeBothOpponents == FALSE) { + return ARCADE_PARTY_SIZE_MULTI; } else { - return 2 * 2; + return ARCADE_PARTY_SIZE_MULTI * 2; } } GF_ASSERT(0); - return 3; + return ARCADE_PARTY_SIZE_SOLO; } FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104_02230BE4 *param1) @@ -167,8 +164,8 @@ FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104 Party *v12; Party *v13; - v2 = ov104_0223BD70(param0->unk_10, 0); - v3 = ov104_0223BDA4(param0->unk_10, 0); + v2 = BattleArcade_GetPartySize(param0->unk_10, 0); + v3 = BattleArcade_GetOpponentPartySize(param0->unk_10, 0); FieldBattleDTO *v5 = FieldBattleDTO_New(HEAP_ID_FIELD2, ov104_0223BFD0(param0->unk_10)); FieldBattleDTO_InitFromGameState(v5, NULL, param1->saveData, param1->unk_1C, param1->journalEntry, param1->bagCursor, param1->unk_20); @@ -207,7 +204,7 @@ FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104 Heap_Free(v8); ov104_0222E284(v5, &v7, v3, 1, 11); - Party_InitWithCapacity(v5->parties[1], ov104_0223BDA4(param0->unk_10, 0)); + Party_InitWithCapacity(v5->parties[1], BattleArcade_GetOpponentPartySize(param0->unk_10, 0)); for (v0 = 0; v0 < 4; v0++) { v5->trainer[v0].header.aiMask = ov104_0223C0D0(param0); @@ -233,7 +230,7 @@ FieldBattleDTO *ov104_0223BDD8(UnkStruct_ov104_0223BFFC *param0, UnkStruct_ov104 Heap_Free(v8); ov104_0222E284(v5, &v7, v3, 3, 11); - Party_InitWithCapacity(v5->parties[3], ov104_0223BDA4(param0->unk_10, 0)); + Party_InitWithCapacity(v5->parties[3], BattleArcade_GetOpponentPartySize(param0->unk_10, 0)); v6 = Pokemon_New(HEAP_ID_FIELD2); @@ -302,7 +299,7 @@ void ov104_0223C04C(UnkStruct_ov104_0223BFFC *param0) Party_Init(param0->unk_74); - v3 = ov104_0223BDA4(param0->unk_10, 1); + v3 = BattleArcade_GetOpponentPartySize(param0->unk_10, 1); v5 = Pokemon_New(HEAP_ID_FIELD2); for (v1 = 0; v1 < v3; v1++) { @@ -386,15 +383,15 @@ u16 ov104_0223C124(UnkStruct_ov104_0223BFFC *param0) return v0; } -u8 ov104_0223C148(u8 param0) +u8 BattleArcade_GetCategoryFromEffect(u8 effect) { - if (param0 < 9) { - return 0; - } else if (param0 < 18) { - return 1; - } else if (param0 < 27) { - return 2; + if (effect < ARCADE_EFFECT_LOWER_ALLY_HP) { + return ARCADE_EFFECT_CATEGORY_FOE; + } else if (effect < ARCADE_EFFECT_SUNNY_BATTLE) { + return ARCADE_EFFECT_CATEGORY_ALLY; + } else if (effect < ARCADE_EFFECT_RANDOMIZE_CURSOR) { + return ARCADE_EFFECT_CATEGORY_ENV; } - return 3; + return ARCADE_EFFECT_CATEGORY_BONUS; } diff --git a/src/overlay108/ov108_02241AE0.c b/src/overlay108/ov108_02241AE0.c deleted file mode 100644 index 7800c3e8c9..0000000000 --- a/src/overlay108/ov108_02241AE0.c +++ /dev/null @@ -1,1604 +0,0 @@ -#include "overlay108/ov108_02241AE0.h" - -#include -#include - -#include "struct_decls/struct_020304A0_decl.h" -#include "struct_decls/struct_020305B8_decl.h" -#include "struct_defs/battle_frontier.h" - -#include "overlay104/ov104_0223BCBC.h" -#include "overlay104/struct_ov104_02238240.h" -#include "overlay108/ov108_02243030.h" -#include "overlay108/ov108_0224351C.h" -#include "overlay108/ov108_02243630.h" -#include "overlay108/struct_ov108_02241DB0_decl.h" -#include "overlay108/struct_ov108_02243030.h" -#include "overlay108/struct_ov108_02243594_decl.h" - -#include "bg_window.h" -#include "communication_system.h" -#include "font.h" -#include "game_options.h" -#include "game_overlay.h" -#include "graphics.h" -#include "gx_layers.h" -#include "heap.h" -#include "math_util.h" -#include "menu.h" -#include "message.h" -#include "narc.h" -#include "overlay_manager.h" -#include "palette.h" -#include "party.h" -#include "pokemon.h" -#include "render_oam.h" -#include "save_player.h" -#include "savedata.h" -#include "screen_fade.h" -#include "sound_playback.h" -#include "sprite.h" -#include "sprite_util.h" -#include "string_gf.h" -#include "string_list.h" -#include "string_template.h" -#include "system.h" -#include "touch_screen.h" -#include "trainer_info.h" -#include "unk_02030494.h" -#include "unk_0203061C.h" -#include "unk_020363E8.h" -#include "unk_020393C8.h" -#include "unk_0209BA80.h" -#include "vram_transfer.h" - -FS_EXTERN_OVERLAY(overlay104); - -static const u8 Unk_ov108_0224368F[8][2] = { - { 0x14, 0x0 }, - { 0x10, 0x0 }, - { 0x8, 0x0 }, - { 0x4, 0x0 }, - { 0x3, 0x0 }, - { 0x2, 0x0 }, - { 0x1, 0x0 }, - { 0x0, 0x0 } -}; - -typedef struct { - u8 unk_00_0 : 1; - u8 unk_00_1 : 1; - u8 unk_00_2 : 1; - u8 unk_00_3 : 1; - u8 unk_00_4 : 1; - u8 unk_00_5 : 1; - u8 unk_00_6 : 1; - u8 unk_00_7 : 1; -} UnkStruct_ov108_02243718; - -static const UnkStruct_ov108_02243718 Unk_ov108_02243718[] = { - { 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x1, 0x0, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x1, 0x0, 0x1, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x1, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0 }, - { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0 } -}; - -typedef struct { - u8 unk_00_0 : 1; - u8 unk_00_1 : 1; - u8 unk_00_2 : 1; - u8 unk_00_3 : 1; - u8 unk_00_4 : 1; - u8 unk_00_5 : 1; - u8 unk_00_6 : 1; - u8 unk_00_7 : 1; -} UnkStruct_ov108_02243680; - -static const UnkStruct_ov108_02243680 Unk_ov108_02243680[7] = { - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0 }, - { 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x0 }, - { 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x0 }, - { 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0 }, - { 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0 } -}; - -static const u8 Unk_ov108_022436B0[][4] = { - { 0xF, 0xF, 0x28, 0x1E }, - { 0x23, 0x14, 0x1E, 0xF }, - { 0x1E, 0x1E, 0x23, 0x5 }, - { 0x19, 0x28, 0x1E, 0x5 }, - { 0xA, 0x4B, 0xA, 0x5 } -}; - -static const u8 Unk_ov108_0224367C[] = { - 0x15, - 0x10, - 0xA, - 0x5 -}; - -struct UnkStruct_ov108_02241DB0_t { - ApplicationManager *appMan; - BattleFrontier *frontier; - u8 unk_08; - u8 unk_09; - u8 unk_0A; - u8 unk_0B; - u8 unk_0C; - u8 unk_0D; - u8 unk_0E; - u8 unk_0F; - u8 unk_10; - u8 unk_11; - u8 unk_12; - u8 unk_13_0 : 1; - u8 unk_13_1 : 7; - u8 unk_14; - u8 unk_15; - u16 unk_16; - int unk_18; - u8 *unk_1C; - u8 *unk_20; - u16 *unk_24; - u16 unk_28; - u16 unk_2A; - u8 unk_2C; - u8 unk_2D; - u8 unk_2E; - u8 unk_2F_0 : 1; - u8 unk_2F_1 : 7; - u8 unk_30[4]; - u8 unk_34[16]; - u8 unk_44[32]; - u8 unk_64; - MessageLoader *unk_68; - StringTemplate *unk_6C; - String *unk_70; - String *unk_74; - String *unk_78[2]; - u16 unk_80[8]; - BgConfig *unk_90; - Window unk_94[2]; - MenuTemplate unk_B4; - Menu *unk_C0; - StringList unk_C4[2]; - PaletteData *unk_D4; - Options *options; - SaveData *saveData; - UnkStruct_020304A0 *unk_E0; - UnkStruct_020305B8 *unk_E4; - UnkStruct_ov108_02243030 unk_E8; - UnkStruct_ov108_02243594 *unk_338; - UnkStruct_ov108_02243594 *unk_33C[16]; - UnkStruct_ov108_02243594 *unk_37C[4]; - UnkStruct_ov108_02243594 *unk_38C[4]; - UnkStruct_ov108_02243594 *unk_39C[4]; - UnkStruct_ov108_02243594 *unk_3AC[4]; - UnkStruct_ov108_02243594 *unk_3BC; - int *unk_3C0; - u16 *unk_3C4; - Party *unk_3C8; - Party *unk_3CC; - NARC *unk_3D0; - u16 unk_3D4[40]; - u8 unk_424; - u8 unk_425; - u16 unk_426; - u16 unk_428; - u32 unk_42C; -}; - -int ov108_02241AE0(ApplicationManager *appMan, int *param1); -int ov108_02241C38(ApplicationManager *appMan, int *param1); -int ov108_02241D70(ApplicationManager *appMan, int *param1); -static BOOL ov108_02241DB0(UnkStruct_ov108_02241DB0 *param0); -static BOOL ov108_02241F28(UnkStruct_ov108_02241DB0 *param0); -static BOOL ov108_02242104(UnkStruct_ov108_02241DB0 *param0); -static BOOL ov108_02242198(UnkStruct_ov108_02241DB0 *param0); -static BOOL ov108_022421F0(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242238(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242344(void); -static void ov108_0224237C(UnkStruct_ov108_02241DB0 *param0); -static void ov108_022426B0(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242658(UnkStruct_ov108_02241DB0 *param0); -static void ov108_022426D4(BgConfig *param0); -static void ov108_02242708(void *param0); -static void ov108_02242740(void); -static void ov108_02242760(BgConfig *param0); -static void ov108_02242828(UnkStruct_ov108_02241DB0 *param0, u32 param1); -static void ov108_02242884(UnkStruct_ov108_02241DB0 *param0, u32 param1); -static void ov108_022428C0(void); -static void ov108_022428F4(UnkStruct_ov108_02241DB0 *param0, u32 param1); -static void ov108_0224295C(UnkStruct_ov108_02241DB0 *param0, int *param1, int param2); -static void ov108_02242964(UnkStruct_ov108_02241DB0 *param0, int param1); -static void ov108_022429C8(UnkStruct_ov108_02241DB0 *param0, u8 param1); -static void ov108_022429FC(UnkStruct_ov108_02241DB0 *param0); -static u8 ov108_02242A04(u8 param0, u8 param1); -static u16 ov108_02242A14(UnkStruct_ov108_02241DB0 *param0); -BOOL ov108_02242A38(UnkStruct_ov108_02241DB0 *param0, u16 param1, u16 param2); -void ov108_02242A7C(UnkStruct_ov108_02241DB0 *param0, u16 param1); -void ov108_02242AB0(int param0, int param1, void *param2, void *param3); -void ov108_02242AE8(UnkStruct_ov108_02241DB0 *param0, u16 param1, u16 param2); -void ov108_02242B24(int param0, int param1, void *param2, void *param3); -void ov108_02242B74(UnkStruct_ov108_02241DB0 *param0, u16 param1); -void ov108_02242B84(int param0, int param1, void *param2, void *param3); -static void ov108_02242BA0(UnkStruct_ov108_02241DB0 *param0, u8 param1); -static u8 ov108_02242EF4(UnkStruct_ov108_02241DB0 *param0, u8 param1); -static void ov108_02242BF0(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242D5C(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242E10(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02242F38(UnkStruct_ov108_02241DB0 *param0); -static BOOL ov108_02242FE8(UnkStruct_ov108_02241DB0 *param0); -static void ov108_02243008(UnkStruct_ov108_02241DB0 *param0); -static u16 ov108_02242B1C(UnkStruct_ov108_02241DB0 *param0); - -static u8 Unk_ov108_022437A0; -static u8 Unk_ov108_022437A1; - -static const TouchScreenHitTable Unk_ov108_02243687[] = { - { TOUCHSCREEN_USE_CIRCLE, 0x80, 0x60, 0x20 }, - { TOUCHSCREEN_TABLE_TERMINATOR, 0x0, 0x0, 0x0 } -}; - -int ov108_02241AE0(ApplicationManager *appMan, int *param1) -{ - int v0; - UnkStruct_ov108_02241DB0 *v1; - UnkStruct_ov104_02238240 *v2; - - Overlay_LoadByID(FS_OVERLAY_ID(overlay104), 2); - ov108_02242344(); - Heap_Create(HEAP_ID_APPLICATION, HEAP_ID_103, 0x20000); - - v1 = ApplicationManager_NewData(appMan, sizeof(UnkStruct_ov108_02241DB0), HEAP_ID_103); - memset(v1, 0, sizeof(UnkStruct_ov108_02241DB0)); - - v1->unk_90 = BgConfig_New(HEAP_ID_103); - v1->appMan = appMan; - - v2 = (UnkStruct_ov104_02238240 *)ApplicationManager_Args(appMan); - - v1->saveData = v2->saveData; - v1->unk_E0 = sub_020304A0(v1->saveData); - v1->unk_E4 = sub_020305B8(v1->saveData); - v1->unk_09 = v2->unk_04; - v1->unk_2A = v2->unk_1E; - v1->unk_28 = v2->unk_1C; - v1->unk_426 = v2->unk_18; - v1->unk_12 = v2->unk_07; - v1->unk_3C4 = &v2->unk_38; - v1->options = SaveData_GetOptions(v1->saveData); - v1->unk_3C8 = v2->unk_30; - v1->unk_3CC = v2->unk_34; - v1->unk_0E = 0xff; - v1->frontier = SaveData_GetBattleFrontier(v1->saveData); - v1->unk_3C0 = v2->unk_08; - v1->unk_1C = v2->unk_0C; - v1->unk_20 = v2->unk_10; - v1->unk_24 = v2->unk_14; - v1->unk_18 = (30 * 30); - v1->unk_0C = v2->unk_40; - - for (v0 = 0; v0 < 32; v0++) { - v1->unk_44[v0] = 32; - } - - v1->unk_2C = 4; - v1->unk_2D = 4; - v1->unk_2E = (4 * 4); - v1->unk_424 = 0; - - (*v1->unk_24) = ov108_02242B1C(v1); - - v1->unk_16 = (LCRNG_Next() % (4 * 4)); - - ov108_0224237C(v1); - - if (BattleArcade_IsMultiPlayerChallenge(v1->unk_09) == 1) { - sub_0209BA80(v1); - } - - (*param1) = 0; - - Unk_ov108_022437A0 = 0; - Unk_ov108_022437A1 = 0; - - return 1; -} - -int ov108_02241C38(ApplicationManager *appMan, int *param1) -{ - UnkStruct_ov108_02241DB0 *v0 = ApplicationManager_Data(appMan); - - if (v0->unk_0E != 0xff) { - switch (*param1) { - case 1: - ov108_02243008(v0); - v0->unk_14 = ov108_02242A04(v0->unk_2E, v0->unk_0E); - ov108_0224295C(v0, param1, 2); - break; - } - } - - switch (*param1) { - case 0: - if (ov108_02241DB0(v0) == 1) { - ov108_0224295C(v0, param1, 1); - } - break; - case 1: - if (ov108_02241F28(v0) == 1) { - if (v0->unk_2F_1 == 1) { - ov108_0224295C(v0, param1, 2); - } else { - if (BattleArcade_IsMultiPlayerChallenge(v0->unk_09) == 1) { - ov108_0224295C(v0, param1, 3); - } else { - ov108_0224295C(v0, param1, 4); - } - } - } - break; - case 2: - if (ov108_02242104(v0) == 1) { - ov108_0224295C(v0, param1, 3); - } - break; - case 3: - if (ov108_02242198(v0) == 1) { - ov108_0224295C(v0, param1, 4); - } - break; - case 4: - if (ov108_022421F0(v0) == 1) { - return 1; - } - break; - } - - v0->unk_13_1++; - - if (v0->unk_13_1 >= 4) { - v0->unk_13_1 = 0; - v0->unk_13_0 ^= 1; - } - - SpriteList_Update(v0->unk_E8.unk_00); - - return 0; -} - -int ov108_02241D70(ApplicationManager *appMan, int *param1) -{ - int v0; - UnkStruct_ov108_02241DB0 *v1 = ApplicationManager_Data(appMan); - - *(v1->unk_3C4) = v1->unk_0D; - - VramTransfer_Free(); - ov108_02242238(v1); - ApplicationManager_FreeData(appMan); - SetVBlankCallback(NULL, NULL); - Heap_Destroy(HEAP_ID_103); - Overlay_UnloadByID(FS_OVERLAY_ID(overlay104)); - - return 1; -} - -static BOOL ov108_02241DB0(UnkStruct_ov108_02241DB0 *param0) -{ - switch (param0->unk_08) { - case 0: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - CommTiming_StartSync(199); - param0->unk_08++; - } else { - param0->unk_08++; - } - break; - case 1: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - if (CommTiming_IsSyncState(199) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - param0->unk_08++; - } - } else { - param0->unk_08++; - } - break; - case 2: - ov108_02242BF0(param0); - param0->unk_08++; - break; - case 3: - ov108_02242D5C(param0); - param0->unk_08++; - break; - case 4: - ov108_02242E10(param0); - param0->unk_08++; - break; - case 5: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - CommTiming_StartSync(201); - param0->unk_08++; - } else { - param0->unk_08++; - } - break; - case 6: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - if (CommTiming_IsSyncState(201) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - param0->unk_08++; - } - } else { - param0->unk_08++; - } - break; - case 7: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - if (ov108_02242A38(param0, 30, 0) == 1) { - param0->unk_08++; - } - } else { - StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 6, 1 * 3, HEAP_ID_103); - param0->unk_08++; - } - break; - case 8: - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - if (param0->unk_0F >= 2) { - param0->unk_0F = 0; - StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_IN, FADE_TYPE_BRIGHTNESS_IN, COLOR_BLACK, 6, 1 * 3, HEAP_ID_103); - param0->unk_08++; - } - } else { - param0->unk_08++; - } - break; - case 9: - if (IsScreenFadeDone() == TRUE) { - return 1; - } - break; - } - - return 0; -} - -static BOOL ov108_02241F28(UnkStruct_ov108_02241DB0 *param0) -{ - u16 v0, v1; - u16 v2; - int v3; - u32 v4, v5; - u16 v6[4]; - - switch (param0->unk_08) { - case 0: - param0->unk_0B = 0; - param0->unk_0D = param0->unk_16; - ov108_022429C8(param0, param0->unk_0D); - param0->unk_08 = 1; - break; - case 1: - param0->unk_0B++; - - if (param0->unk_0B >= 10) { - param0->unk_0B = 0; - param0->unk_08 = 2; - } - break; - case 2: - for (v3 = 0; v3 < (4 * 4); v3++) { - if (param0->unk_33C[v3] != NULL) { - ov108_022435F4(param0->unk_33C[v3], 32); - ov108_022435A8(param0->unk_33C[v3], 1); - } - } - - ov108_02242884(param0, 3); - Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); - - param0->unk_0B = 24; - param0->unk_08 = 3; - break; - case 3: - param0->unk_0B--; - - if (param0->unk_0B > 0) { - break; - } - - for (v3 = 0; v3 < (4 * 4); v3++) { - if (param0->unk_33C[v3] != NULL) { - ov108_022435F4(param0->unk_33C[v3], 33); - } - } - - Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); - param0->unk_0B = 24; - param0->unk_08 = 4; - break; - case 4: - param0->unk_0B--; - - if (param0->unk_0B > 0) { - break; - } - - for (v3 = 0; v3 < (4 * 4); v3++) { - if (param0->unk_33C[v3] != NULL) { - ov108_022435F4(param0->unk_33C[v3], 34); - } - } - - Sound_PlayEffect(SEQ_SE_DP_WIN_OPEN2); - - param0->unk_0B = 24; - param0->unk_08 = 5; - break; - case 5: - param0->unk_0B--; - - if (param0->unk_0B > 0) { - break; - } - - for (v3 = 0; v3 < (4 * 4); v3++) { - if (param0->unk_33C[v3] != NULL) { - ov108_022435F4(param0->unk_33C[v3], param0->unk_34[v3]); - } - } - - ov108_022435A8(param0->unk_338, 1); - Sound_PlayEffect(SEQ_SE_DP_UG_020); - ov108_022435F4(param0->unk_3BC, 0); - param0->unk_08 = 6; - break; - case 6: - ov108_02242964(param0, gSystem.pressedKeys); - - if (CommSys_CurNetId() == 0) { - if (param0->unk_18 > 0) { - param0->unk_18--; - } - - if (param0->unk_18 == 0) { - (void)0; - } - } - - if ((ov108_02242FE8(param0) == 1) || (param0->unk_18 == 0)) { - ov108_022429FC(param0); - - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 0) { - param0->unk_08 = 7; - break; - } else { - param0->unk_2F_1 = 1; - return 1; - } - } - break; - case 7: - ov108_02242BA0(param0, param0->unk_0D); - param0->unk_0B = 30; - param0->unk_08 = 8; - break; - case 8: - param0->unk_0B--; - - if (param0->unk_0B == 0) { - return 1; - } - break; - } - - return 0; -} - -static BOOL ov108_02242104(UnkStruct_ov108_02241DB0 *param0) -{ - switch (param0->unk_08) { - case 0: - if (ov108_02242A38(param0, 31, param0->unk_14) == 1) { - param0->unk_2F_1 = 0; - param0->unk_08++; - } - break; - case 1: - param0->unk_08++; - break; - case 2: - if (param0->unk_0E == 0xff) { - break; - } - - param0->unk_0F = 0; - ov108_02242BA0(param0, param0->unk_0E); - param0->unk_08++; - break; - case 3: - CommTool_ClearReceivedTempDataAllPlayers(); - CommTiming_StartSync(151); - param0->unk_08++; - break; - case 4: - if (CommTiming_IsSyncState(151) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - CommTool_Init(103); - param0->unk_0E = 0xff; - return 1; - } - break; - } - - return 0; -} - -static BOOL ov108_02242198(UnkStruct_ov108_02241DB0 *param0) -{ - switch (param0->unk_08) { - case 0: - param0->unk_0B = 15; - param0->unk_08++; - break; - case 1: - if (param0->unk_0B > 0) { - param0->unk_0B--; - } - - if (param0->unk_0B == 0) { - CommTool_ClearReceivedTempDataAllPlayers(); - CommTiming_StartSync(152); - param0->unk_08++; - } - break; - case 2: - if (CommTiming_IsSyncState(152) == 1) { - CommTool_ClearReceivedTempDataAllPlayers(); - return 1; - } - break; - } - - return 0; -} - -static BOOL ov108_022421F0(UnkStruct_ov108_02241DB0 *param0) -{ - int v0; - - switch (param0->unk_08) { - case 0: - StartScreenFade(FADE_BOTH_SCREENS, FADE_TYPE_BRIGHTNESS_OUT, FADE_TYPE_BRIGHTNESS_OUT, COLOR_BLACK, 6, 1, HEAP_ID_103); - param0->unk_08++; - break; - case 1: - if (IsScreenFadeDone() == TRUE) { - return 1; - } - break; - } - - return 0; -} - -static void ov108_02242238(UnkStruct_ov108_02241DB0 *param0) -{ - u8 v0; - int v1; - - if (param0->unk_338 != NULL) { - ov108_02243594(param0->unk_338); - } - - if (param0->unk_3BC != NULL) { - ov108_02243594(param0->unk_3BC); - } - - for (v1 = 0; v1 < (4 * 4); v1++) { - if (param0->unk_33C[v1] != NULL) { - ov108_02243594(param0->unk_33C[v1]); - } - } - - v0 = ov104_0223BD70(param0->unk_09, 1); - - for (v1 = 0; v1 < v0; v1++) { - if (param0->unk_37C[v1] != NULL) { - ov108_02243594(param0->unk_37C[v1]); - } - - if (param0->unk_38C[v1] != NULL) { - ov108_02243594(param0->unk_38C[v1]); - } - - if (param0->unk_39C[v1] != NULL) { - ov108_02243594(param0->unk_39C[v1]); - } - - if (param0->unk_3AC[v1] != NULL) { - ov108_02243594(param0->unk_3AC[v1]); - } - } - - NetworkIcon_Destroy(); - PaletteData_FreeBuffer(param0->unk_D4, 2); - PaletteData_FreeBuffer(param0->unk_D4, 0); - PaletteData_Free(param0->unk_D4); - - param0->unk_D4 = NULL; - ov108_02243194(¶m0->unk_E8); - - MessageLoader_Free(param0->unk_68); - StringTemplate_Free(param0->unk_6C); - String_Free(param0->unk_70); - String_Free(param0->unk_74); - - for (v1 = 0; v1 < 2; v1++) { - String_Free(param0->unk_78[v1]); - } - - ov108_02243660(param0->unk_94); - ov108_022426D4(param0->unk_90); - - NARC_dtor(param0->unk_3D0); - return; -} - -static void ov108_02242344(void) -{ - SetVBlankCallback(NULL, NULL); - SetHBlankCallback(NULL, NULL); - - GXLayers_DisableEngineALayers(); - GXLayers_DisableEngineBLayers(); - - GX_SetVisiblePlane(0); - GXS_SetVisiblePlane(0); - - return; -} - -static void ov108_0224237C(UnkStruct_ov108_02241DB0 *param0) -{ - u8 v0; - u16 v1, v2, v3, v4; - int v5, v6; - Window *v7; - Pokemon *v8; - - param0->unk_3D0 = NARC_ctor(NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_BG, HEAP_ID_103); - - ov108_02242658(param0); - ov108_022426B0(param0); - - param0->unk_68 = MessageLoader_Init(MSG_LOADER_LOAD_ON_DEMAND, NARC_INDEX_MSGDATA__PL_MSG, TEXT_BANK_DUMMY_0536, HEAP_ID_103); - param0->unk_6C = StringTemplate_Default(HEAP_ID_103); - param0->unk_70 = String_Init(600, HEAP_ID_103); - param0->unk_74 = String_Init(600, HEAP_ID_103); - - for (v5 = 0; v5 < 2; v5++) { - param0->unk_78[v5] = String_Init(32, HEAP_ID_103); - } - - Font_LoadTextPalette(0, 13 * 32, HEAP_ID_103); - Font_LoadScreenIndicatorsPalette(0, 12 * 32, HEAP_ID_103); - - ov108_02243630(param0->unk_90, param0->unk_94); - param0->unk_338 = ov108_0224351C(¶m0->unk_E8, 1, 1, 1, 35, 68, 36, 0, 2, 0); - ov108_022435A8(param0->unk_338, 0); - - for (v5 = 0; v5 < (4 * 4); v5++) { - param0->unk_33C[v5] = ov108_0224351C(¶m0->unk_E8, 1, 1, 1, 32, 68 + (40 * (v5 % 4)), 36 + (40 * (v5 / 4)), 1, 2, 0); - ov108_022435A8(param0->unk_33C[v5], 0); - } - - v0 = ov104_0223BD70(param0->unk_09, 1); - - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 0) { - v3 = 46; - v4 = 50; - } else { - v3 = 22; - v4 = 26; - } - - for (v5 = 0; v5 < v0; v5++) { - param0->unk_39C[v5] = ov108_0224351C(¶m0->unk_E8, 2, 2, 2, 0, 24, v4 + (40 * v5), 0, 2, 0); - param0->unk_3AC[v5] = ov108_0224351C(¶m0->unk_E8, 2, 2, 2, 0, 246, v4 + (40 * v5), 0, 2, 0); - param0->unk_37C[v5] = ov108_0224351C(¶m0->unk_E8, 3 + v5, 3, 3, 1, 16, v3 + (40 * v5), 1, 2, 0); - param0->unk_38C[v5] = ov108_0224351C(¶m0->unk_E8, 7 + v5, 3, 3, 1, 238, v3 + (40 * v5), 1, 2, 0); - - ov108_02243610(param0->unk_37C[v5], Party_GetPokemonBySlotIndex(param0->unk_3C8, v5)); - ov108_02243610(param0->unk_38C[v5], Party_GetPokemonBySlotIndex(param0->unk_3CC, v5)); - - ov108_02243624(param0->unk_37C[v5], 0); - ov108_02243624(param0->unk_38C[v5], 0); - } - - ov108_02242F38(param0); - param0->unk_3BC = ov108_0224351C(¶m0->unk_E8, 0, 0, 0, 2, 128, 96, 0, 0, 1); - - if (CommSys_IsInitialized()) { - ReserveVramForWirelessIconChars(NNS_G2D_VRAM_TYPE_2DMAIN, GX_OBJVRAMMODE_CHAR_1D_32K); - ReserveSlotsForWirelessIconPalette(NNS_G2D_VRAM_TYPE_2DMAIN); - sub_02039734(); - } - - SetVBlankCallback(ov108_02242708, (void *)param0); - return; -} - -static void ov108_02242658(UnkStruct_ov108_02241DB0 *param0) -{ - ov108_02242740(); - ov108_02242760(param0->unk_90); - - param0->unk_D4 = PaletteData_New(HEAP_ID_103); - - PaletteData_AllocBuffer(param0->unk_D4, 2, 32 * 16, HEAP_ID_103); - PaletteData_AllocBuffer(param0->unk_D4, 0, 32 * 16, HEAP_ID_103); - - ov108_02242828(param0, 3); - ov108_022428C0(); - ov108_022428F4(param0, 4); - - return; -} - -static void ov108_022426B0(UnkStruct_ov108_02241DB0 *param0) -{ - ov108_02243030(¶m0->unk_E8, param0->unk_3C8, param0->unk_3CC, BattleArcade_IsMultiPlayerChallenge(param0->unk_09)); - return; -} - -static void ov108_022426D4(BgConfig *param0) -{ - GXLayers_EngineAToggleLayers(GX_PLANEMASK_BG0 | GX_PLANEMASK_BG1 | GX_PLANEMASK_BG2 | GX_PLANEMASK_BG3 | GX_PLANEMASK_OBJ, 0); - GXLayers_EngineBToggleLayers(GX_PLANEMASK_BG0 | GX_PLANEMASK_BG1 | GX_PLANEMASK_BG2 | GX_PLANEMASK_BG3 | GX_PLANEMASK_OBJ, 0); - - Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_3); - Bg_FreeTilemapBuffer(param0, BG_LAYER_MAIN_1); - Bg_FreeTilemapBuffer(param0, BG_LAYER_SUB_0); - Heap_Free(param0); - - return; -} - -static void ov108_02242708(void *param0) -{ - UnkStruct_ov108_02241DB0 *v0 = param0; - - if (v0->unk_D4 != NULL) { - PaletteData_CommitFadedBuffers(v0->unk_D4); - } - - Bg_RunScheduledUpdates(v0->unk_90); - VramTransfer_Process(); - RenderOam_Transfer(); - - OS_SetIrqCheckFlag(OS_IE_V_BLANK); -} - -static void ov108_02242740(void) -{ - GXBanks v0 = { - GX_VRAM_BG_128_C, - GX_VRAM_BGEXTPLTT_NONE, - GX_VRAM_SUB_BG_32_H, - GX_VRAM_SUB_BGEXTPLTT_NONE, - GX_VRAM_OBJ_64_E, - GX_VRAM_OBJEXTPLTT_NONE, - GX_VRAM_SUB_OBJ_16_I, - GX_VRAM_SUB_OBJEXTPLTT_NONE, - GX_VRAM_TEX_01_AB, - GX_VRAM_TEXPLTT_01_FG - }; - - GXLayers_SetBanks(&v0); - return; -} - -static void ov108_02242760(BgConfig *param0) -{ - { - GraphicsModes v0 = { - GX_DISPMODE_GRAPHICS, - GX_BGMODE_0, - GX_BGMODE_0, - GX_BG0_AS_2D - }; - - SetAllGraphicsModes(&v0); - } - - { - BgTemplate v1 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0x0000, - .charBase = GX_BG_CHARBASE_0x04000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 0, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_MAIN_1, &v1, 0); - Bg_ClearTilesRange(BG_LAYER_MAIN_1, 32, 0, HEAP_ID_103); - Bg_ClearTilemap(param0, BG_LAYER_MAIN_1); - } - - { - BgTemplate v2 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0x2000, - .charBase = GX_BG_CHARBASE_0x0c000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 2, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_MAIN_3, &v2, 0); - Bg_ClearTilemap(param0, BG_LAYER_MAIN_3); - } - - { - BgTemplate v3 = { - .x = 0, - .y = 0, - .bufferSize = 0x800, - .baseTile = 0, - .screenSize = BG_SCREEN_SIZE_256x256, - .colorMode = GX_BG_COLORMODE_16, - .screenBase = GX_BG_SCRBASE_0x3000, - .charBase = GX_BG_CHARBASE_0x10000, - .bgExtPltt = GX_BG_EXTPLTT_01, - .priority = 0, - .areaOver = 0, - .mosaic = FALSE, - }; - - Bg_InitFromTemplate(param0, BG_LAYER_SUB_0, &v3, 0); - Bg_ClearTilemap(param0, BG_LAYER_SUB_0); - } - - G2_SetBG0Priority(0); - GXLayers_EngineAToggleLayers(GX_PLANEMASK_BG0, 0); - - return; -} - -static void ov108_02242828(UnkStruct_ov108_02241DB0 *param0, u32 param1) -{ - u32 v0; - - Graphics_LoadTilesToBgLayerFromOpenNARC(param0->unk_3D0, 120, param0->unk_90, param1, 0, 0, 1, HEAP_ID_103); - - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 0) { - v0 = 116; - } else { - v0 = 118; - } - - Graphics_LoadTilemapToBgLayerFromOpenNARC(param0->unk_3D0, v0, param0->unk_90, param1, 0, 0, 1, HEAP_ID_103); - return; -} - -static void ov108_02242884(UnkStruct_ov108_02241DB0 *param0, u32 param1) -{ - u32 v0; - - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 0) { - v0 = 117; - } else { - v0 = 119; - } - - Graphics_LoadTilemapToBgLayerFromOpenNARC(param0->unk_3D0, v0, param0->unk_90, param1, 0, 0, 1, HEAP_ID_103); - return; -} - -static void ov108_022428C0(void) -{ - void *v0; - NNSG2dPaletteData *v1; - - v0 = Graphics_GetPlttData(NARC_INDEX_RESOURCE__ENG__FRONTIER_GRAPHIC__FRONTIER_BG, 167, &v1, HEAP_ID_103); - - DC_FlushRange(v1->pRawData, sizeof(u16) * 16 * 7); - GX_LoadBGPltt(v1->pRawData, 0, sizeof(u16) * 16 * 7); - Heap_Free(v0); - - return; -} - -static void ov108_022428F4(UnkStruct_ov108_02241DB0 *param0, u32 param1) -{ - Graphics_LoadTilesToBgLayerFromOpenNARC(param0->unk_3D0, 122, param0->unk_90, param1, 0, 0, 1, HEAP_ID_103); - Graphics_LoadPaletteFromOpenNARC(param0->unk_3D0, 168, 4, 0, sizeof(u16) * 16 * 2, HEAP_ID_103); - Graphics_LoadTilemapToBgLayerFromOpenNARC(param0->unk_3D0, 121, param0->unk_90, param1, 0, 0, 1, HEAP_ID_103); - - return; -} - -static void ov108_0224295C(UnkStruct_ov108_02241DB0 *param0, int *param1, int param2) -{ - param0->unk_08 = 0; - *param1 = param2; - return; -} - -static void ov108_02242964(UnkStruct_ov108_02241DB0 *param0, int param1) -{ - u8 v0 = *param0->unk_1C; - param0->unk_10++; - - if (param0->unk_10 >= Unk_ov108_0224368F[v0][0]) { - param0->unk_10 = 0; - - if (param0->unk_0C == 1) { - param0->unk_0D = (LCRNG_Next() % (4 * 4)); - } else { - param0->unk_0D++; - } - - Sound_PlayEffect(SEQ_SE_DP_BUTTON3); - - if (param0->unk_0D >= param0->unk_2E) { - param0->unk_0D = 0; - } - - ov108_022429C8(param0, param0->unk_0D); - } - - return; -} - -static void ov108_022429C8(UnkStruct_ov108_02241DB0 *param0, u8 param1) -{ - ov108_022435B4(param0->unk_338, 68 + (40 * (param1 % 4)), 36 + (40 * (param1 / 4))); - return; -} - -static void ov108_022429FC(UnkStruct_ov108_02241DB0 *param0) -{ - param0->unk_14 = param0->unk_0D; - return; -} - -static u8 ov108_02242A04(u8 param0, u8 param1) -{ - if (param1 < param0) { - return param1; - } - - return param1 - param0; -} - -static u16 ov108_02242A14(UnkStruct_ov108_02241DB0 *param0) -{ - u16 v0 = param0->unk_28; - - if (BattleArcade_IsMultiPlayerChallenge(param0->unk_09) == 1) { - if (param0->unk_426 > param0->unk_28) { - v0 = param0->unk_426; - } - } - - return v0; -} - -BOOL ov108_02242A38(UnkStruct_ov108_02241DB0 *param0, u16 param1, u16 param2) -{ - int v0, v1; - - switch (param1) { - case 30: - v1 = 71; - ov108_02242A7C(param0, param1); - break; - case 31: - v1 = 72; - ov108_02242AE8(param0, param1, param2); - break; - case 32: - v1 = 73; - ov108_02242B74(param0, param1); - break; - } - - if (CommSys_SendData(v1, param0->unk_3D4, 40) == 1) { - v0 = 1; - } else { - v0 = 0; - } - - return v0; -} - -void ov108_02242A7C(UnkStruct_ov108_02241DB0 *param0, u16 param1) -{ - int v0, v1; - TrainerInfo *v2; - - v1 = 0; - v2 = SaveData_GetTrainerInfo(param0->saveData); - - param0->unk_3D4[v1] = param1; - - v1 += 1; - v1 += 1; - - for (v0 = 0; v0 < (4 * 4); v0++) { - param0->unk_3D4[v1 + v0] = param0->unk_34[v0]; - } - - v1 += (4 * 4); - param0->unk_3D4[v1] = param0->unk_16; - v1 += 1; - - return; -} - -void ov108_02242AB0(int param0, int param1, void *param2, void *param3) -{ - int v0, v1; - UnkStruct_ov108_02241DB0 *v2 = param3; - const u16 *v3 = param2; - - v1 = 0; - v2->unk_0F++; - - if (CommSys_CurNetId() == param0) { - return; - } - - v1 += 1; - v1 += 1; - - if (CommSys_CurNetId() != 0) { - for (v0 = 0; v0 < (4 * 4); v0++) { - v2->unk_34[v0] = (u8)v3[v1 + v0]; - } - - v1 += (4 * 4); - v2->unk_16 = (u16)v3[v1]; - v1 += 1; - } - - for (v0 = 0; v0 < (4 * 4); v0++) { - (void)0; - } - - return; -} - -void ov108_02242AE8(UnkStruct_ov108_02241DB0 *param0, u16 param1, u16 param2) -{ - u8 v0; - - param0->unk_3D4[0] = param1; - param0->unk_3D4[1] = param2; - - if (CommSys_CurNetId() == 0) { - if (param0->unk_0E == 0xff) { - param0->unk_0E = param2; - } - } - - param0->unk_3D4[2] = param0->unk_0E; - param0->unk_3D4[3] = *param0->unk_24; - - return; -} - -static u16 ov108_02242B1C(UnkStruct_ov108_02241DB0 *param0) -{ - return LCRNG_Next(); -} - -void ov108_02242B24(int param0, int param1, void *param2, void *param3) -{ - int v0, v1; - UnkStruct_ov108_02241DB0 *v2 = param3; - const u16 *v3 = param2; - - v1 = 0; - v2->unk_0F++; - - if (CommSys_CurNetId() == param0) { - return; - } - - v2->unk_425 = v3[1]; - - if (CommSys_CurNetId() == 0) { - if (v2->unk_0E != 0xff) { - v2->unk_425 = 0; - } else { - v2->unk_0E = v2->unk_425 + v2->unk_2E; - } - } else { - v2->unk_0E = v3[2]; - - (*v2->unk_24) = v3[3]; - } - - return; -} - -void ov108_02242B74(UnkStruct_ov108_02241DB0 *param0, u16 param1) -{ - param0->unk_3D4[0] = param1; - - if (param0->unk_0D == (param0->unk_2E - 1)) { - param0->unk_3D4[1] = param0->unk_0D; - } else { - param0->unk_3D4[1] = param0->unk_0D; - } - - return; -} - -void ov108_02242B84(int param0, int param1, void *param2, void *param3) -{ - UnkStruct_ov108_02241DB0 *v0 = param3; - const u16 *v1 = param2; - - if (CommSys_CurNetId() == param0) { - return; - } - - v0->unk_424 = (u8)v1[1]; - return; -} - -static void ov108_02242BA0(UnkStruct_ov108_02241DB0 *param0, u8 param1) -{ - int v0; - u8 v1, v2, v3, v4; - u16 v5[4]; - - v2 = param0->unk_2E; - v3 = ov108_02242A04(v2, param1); - v4 = param0->unk_34[v3]; - - (*param0->unk_20) = v4; - - for (v0 = 0; v0 < (4 * 4); v0++) { - if (param0->unk_33C[v0] != NULL) { - ov108_022435F4(param0->unk_33C[v0], v4); - } - } - - ov108_022429C8(param0, v3); - Sound_PlayEffect(SEQ_SE_DP_PIRORIRO2); - - return; -} - -static void ov108_02242BF0(UnkStruct_ov108_02241DB0 *param0) -{ - int v0, v1, v2; - u16 v3, v4, v5; - u8 v6, v7; - - for (v0 = 0; v0 < (NELEMS(Unk_ov108_02243718)); v0++) { - switch (param0->unk_2A) { - case 0: - v7 = Unk_ov108_02243718[v0].unk_00_0; - break; - case 1: - v7 = Unk_ov108_02243718[v0].unk_00_1; - break; - case 2: - v7 = Unk_ov108_02243718[v0].unk_00_2; - break; - case 3: - v7 = Unk_ov108_02243718[v0].unk_00_3; - break; - case 4: - v7 = Unk_ov108_02243718[v0].unk_00_4; - break; - case 5: - v7 = Unk_ov108_02243718[v0].unk_00_5; - break; - default: - v7 = Unk_ov108_02243718[v0].unk_00_6; - break; - } - - if (v7 == 1) { - v6 = 0xff; - - switch (v0) { - case 27: - v6 = 0; - break; - case 24: - v6 = 1; - break; - case 25: - v6 = 2; - break; - case 26: - v6 = 3; - break; - case 28: - v6 = 4; - break; - case 29: - v6 = 5; - break; - case 31: - v6 = 6; - break; - } - - v5 = ov108_02242A14(param0); - v4 = (v5 % 7); - - if (v5 >= 9999) { - v4 = 6; - } - - if (v6 != 0xff) { - switch (v4) { - case 0: - v7 = Unk_ov108_02243680[v6].unk_00_0; - break; - case 1: - v7 = Unk_ov108_02243680[v6].unk_00_1; - break; - case 2: - v7 = Unk_ov108_02243680[v6].unk_00_2; - break; - case 3: - v7 = Unk_ov108_02243680[v6].unk_00_3; - break; - case 4: - v7 = Unk_ov108_02243680[v6].unk_00_4; - break; - case 5: - v7 = Unk_ov108_02243680[v6].unk_00_5; - break; - case 6: - case 7: - v7 = Unk_ov108_02243680[v6].unk_00_6; - break; - default: - GF_ASSERT(0); - v7 = 1; - break; - } - } else { - v7 = 1; - } - - if (v7 == 1) { - param0->unk_44[param0->unk_64] = v0; - param0->unk_64++; - } - } - } - - return; -} - -static void ov108_02242D5C(UnkStruct_ov108_02241DB0 *param0) -{ - int v0, v1; - - for (v0 = 0; v0 < (NELEMS(Unk_ov108_0224367C)); v0++) { - if (param0->unk_12 >= Unk_ov108_0224367C[v0]) { - break; - } - } - - param0->unk_11 = v0; - - for (v1 = 0; v1 < param0->unk_64; v1++) { - continue; - } - - for (v0 = 0; v0 < param0->unk_64; v0++) { - if (ov104_0223C148(param0->unk_44[v0]) == 0) { - param0->unk_30[0]++; - } else if (ov104_0223C148(param0->unk_44[v0]) == 1) { - param0->unk_30[1]++; - } else if (ov104_0223C148(param0->unk_44[v0]) == 2) { - param0->unk_30[2]++; - } else if (ov104_0223C148(param0->unk_44[v0]) == 3) { - param0->unk_30[3]++; - } - } - - return; -} - -static void ov108_02242E10(UnkStruct_ov108_02241DB0 *param0) -{ - int v0, v1, v2, v3; - u16 v4, v5; - u8 v6 = 0, v7; - - for (v1 = 0; v1 < (4 * 4); v1++) { - v7 = ov108_02242EF4(param0, param0->unk_11); - v2 = 0; - v3 = 0; - v3 = param0->unk_30[v7]; - - if (v7 == 0) { - v2 = 0; - } else if (v7 == 1) { - v2 += param0->unk_30[0]; - } else if (v7 == 2) { - v2 += param0->unk_30[0]; - v2 += param0->unk_30[1]; - } else if (v7 == 3) { - v2 += param0->unk_30[0]; - v2 += param0->unk_30[1]; - v2 += param0->unk_30[2]; - } - - v4 = (LCRNG_Next() % v3); - v4 += v2; - v6 = v4; - v0 = 0; - - while (TRUE) { - if (v0 >= 50) { - GF_ASSERT(0); - param0->unk_34[v1] = 0; - v0 = 0; - break; - } - - if (ov104_0223C148(param0->unk_44[v6]) == v7) { - param0->unk_34[v1] = param0->unk_44[v6]; - v0 = 0; - break; - } - - v6++; - v0++; - - if (v6 >= param0->unk_64) { - v6 = 0; - } - - if (v6 == v4) { - v7++; - - if (v7 >= 4) { - v7 = 0; - } - } - } - } - - return; -} - -static u8 ov108_02242EF4(UnkStruct_ov108_02241DB0 *param0, u8 param1) -{ - u8 v0, v1; - u16 v2; - - v0 = 0; - v2 = (LCRNG_Next() % 100); - - for (v1 = 0; v1 < 4; v1++) { - v0 += Unk_ov108_022436B0[param1][v1]; - - if (v2 < v0) { - break; - } - } - - if (v1 >= 4) { - GF_ASSERT(0); - v1 = 0; - } - - return v1; -} - -static void ov108_02242F38(UnkStruct_ov108_02241DB0 *param0) -{ - u8 v0, v1, v2; - Pokemon *v3; - - v0 = ov104_0223BD70(param0->unk_09, 1); - v1 = ov104_0223BDA4(param0->unk_09, 1); - - for (v2 = 0; v2 < v0; v2++) { - v3 = Party_GetPokemonBySlotIndex(param0->unk_3C8, v2); - - if (Pokemon_GetValue(v3, MON_DATA_HELD_ITEM, NULL) == 0) { - ov108_022435A8(param0->unk_39C[v2], 0); - } else { - ov108_022435A8(param0->unk_39C[v2], 1); - } - } - - for (v2 = 0; v2 < v1; v2++) { - v3 = Party_GetPokemonBySlotIndex(param0->unk_3CC, v2); - - if (Pokemon_GetValue(v3, MON_DATA_HELD_ITEM, NULL) == 0) { - ov108_022435A8(param0->unk_3AC[v2], 0); - } else { - ov108_022435A8(param0->unk_3AC[v2], 1); - } - } - - return; -} - -static BOOL ov108_02242FE8(UnkStruct_ov108_02241DB0 *param0) -{ - int v0 = TouchScreen_CheckPressedHitTableID(Unk_ov108_02243687); - - if (v0 == 0) { - ov108_02243008(param0); - return 1; - } - - return 0; -} - -static void ov108_02243008(UnkStruct_ov108_02241DB0 *param0) -{ - Sound_StopEffect(1500, 0); - Sound_PlayEffect(SEQ_SE_DP_BUTTON9); - ov108_022435F4(param0->unk_3BC, 1); - - return; -} diff --git a/src/overlay108/ov108_02243030.c b/src/overlay108/ov108_02243030.c deleted file mode 100644 index 8be80dec74..0000000000 --- a/src/overlay108/ov108_02243030.c +++ /dev/null @@ -1,224 +0,0 @@ -#include "overlay108/ov108_02243030.h" - -#include -#include - -#include "applications/party_menu/main.h" -#include "overlay108/struct_ov108_02243030.h" - -#include "char_transfer.h" -#include "gx_layers.h" -#include "narc.h" -#include "party.h" -#include "pltt_transfer.h" -#include "pokemon.h" -#include "pokemon_icon.h" -#include "render_oam.h" -#include "sprite.h" -#include "sprite_resource.h" -#include "sprite_transfer.h" -#include "sprite_util.h" -#include "vram_transfer.h" - -static const u8 Unk_ov108_02243760[4] = { - 11, - 11, - 11, - 11, -}; - -void ov108_02243030(UnkStruct_ov108_02243030 *param0, Party *param1, Party *param2, u8 param3); -Sprite *ov108_022430F0(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u32 param5, int param6, u8 param7); -void ov108_02243194(UnkStruct_ov108_02243030 *param0); -static void ov108_022431FC(void); -static void ov108_02243230(UnkStruct_ov108_02243030 *param0); -static void ov108_022432B4(UnkStruct_ov108_02243030 *param0); -static void ov108_02243360(UnkStruct_ov108_02243030 *param0, Party *param1, Party *param2, u8 param3); -static void ov108_02243490(UnkStruct_ov108_02243030 *param0); - -void ov108_02243030(UnkStruct_ov108_02243030 *param0, Party *param1, Party *param2, u8 param3) -{ - int v0; - - VramTransfer_New(32, HEAP_ID_103); - ov108_022431FC(); - - NNS_G2dInitOamManagerModule(); - RenderOam_Init(0, 128, 0, 32, 0, 128, 0, 32, 103); - - param0->unk_00 = SpriteList_InitRendering(((4 * 4) + 1 + 8 + 8 + 1), ¶m0->unk_04, HEAP_ID_103); - - for (v0 = 0; v0 < 4; v0++) { - param0->unk_190[v0] = SpriteResourceCollection_New(Unk_ov108_02243760[v0], v0, HEAP_ID_103); - } - - ov108_02243490(param0); - ov108_02243230(param0); - ov108_022432B4(param0); - ov108_02243360(param0, param1, param2, param3); - - for (v0 = 0; v0 < 11; v0++) { - SpriteTransfer_RequestChar(param0->unk_1A0[v0][0]); - } - - for (v0 = 0; v0 < 4; v0++) { - SpriteTransfer_RequestPlttWholeRange(param0->unk_1A0[v0][1]); - } - - GXLayers_EngineBToggleLayers(GX_PLANEMASK_OBJ, 1); - GXLayers_EngineAToggleLayers(GX_PLANEMASK_OBJ, 1); - - return; -} - -Sprite *ov108_022430F0(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u32 param5, int param6, u8 param7) -{ - int v0; - SpriteResourcesHeader v1; - Sprite *v2; - - SpriteResourcesHeader_Init(&v1, param1, param2, param3, param3, 0xffffffff, 0xffffffff, 0, param6, param0->unk_190[0], param0->unk_190[1], param0->unk_190[2], param0->unk_190[3], NULL, NULL); - - { - AffineSpriteListTemplate v3; - - v3.list = param0->unk_00; - v3.resourceData = &v1; - v3.position.x = 0; - v3.position.y = 0; - v3.position.z = 0; - v3.affineScale.x = FX32_ONE; - v3.affineScale.y = FX32_ONE; - v3.affineScale.z = FX32_ONE; - v3.affineZRotation = 0; - v3.priority = param5; - v3.heapID = HEAP_ID_103; - - if (param7 == 0) { - v3.vramType = NNS_G2D_VRAM_TYPE_2DMAIN; - } else { - v3.vramType = NNS_G2D_VRAM_TYPE_2DSUB; - v3.position.y += (192 << FX32_SHIFT); - } - - v2 = SpriteList_AddAffine(&v3); - - Sprite_SetAnimateFlag(v2, 1); - Sprite_SetAnimSpeed(v2, FX32_ONE); - Sprite_SetAnim(v2, param4); - } - - return v2; -} - -void ov108_02243194(UnkStruct_ov108_02243030 *param0) -{ - u8 v0; - - for (v0 = 0; v0 < 11; v0++) { - SpriteTransfer_ResetCharTransfer(param0->unk_1A0[v0][0]); - } - - for (v0 = 0; v0 < 4; v0++) { - SpriteTransfer_ResetPlttTransfer(param0->unk_1A0[v0][1]); - } - - for (v0 = 0; v0 < 4; v0++) { - SpriteResourceCollection_Delete(param0->unk_190[v0]); - } - - SpriteList_Delete(param0->unk_00); - RenderOam_Free(); - CharTransfer_Free(); - PlttTransfer_Free(); - - return; -} - -static void ov108_022431FC(void) -{ - { - CharTransferTemplate v0 = { - 32, 1024, 1024, 103 - }; - - CharTransfer_InitWithVramModes(&v0, GX_OBJVRAMMODE_CHAR_1D_32K, GX_OBJVRAMMODE_CHAR_1D_32K); - } - - PlttTransfer_Init((8 + 2 + 1 + 3), HEAP_ID_103); - CharTransfer_ClearBuffers(); - PlttTransfer_Clear(); - - return; -} - -static void ov108_02243230(UnkStruct_ov108_02243030 *param0) -{ - param0->unk_1A0[1][0] = SpriteResourceCollection_AddTiles(param0->unk_190[0], 151, 18, 1, 1, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_103); - param0->unk_1A0[1][1] = SpriteResourceCollection_AddPalette(param0->unk_190[1], 151, 40, 0, 1, NNS_G2D_VRAM_TYPE_2DMAIN, 8, HEAP_ID_103); - param0->unk_1A0[1][2] = SpriteResourceCollection_Add(param0->unk_190[2], 151, 20, 1, 1, 2, HEAP_ID_103); - param0->unk_1A0[1][3] = SpriteResourceCollection_Add(param0->unk_190[3], 151, 19, 1, 1, 3, HEAP_ID_103); - - return; -} - -static void ov108_022432B4(UnkStruct_ov108_02243030 *param0) -{ - NARC *v0; - u32 v1; - - v0 = NARC_ctor(NARC_INDEX_GRAPHIC__PL_PLIST_GRA, HEAP_ID_103); - - param0->unk_1A0[2][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_190[0], v0, sub_02081930(), 0, 2, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_103); - param0->unk_1A0[2][1] = SpriteResourceCollection_AddPalette(param0->unk_190[1], 20, sub_02081934(), 0, 2, NNS_G2D_VRAM_TYPE_2DMAIN, 3, HEAP_ID_103); - param0->unk_1A0[2][2] = SpriteResourceCollection_AddFrom(param0->unk_190[2], v0, sub_02081938(), 0, 2, 2, HEAP_ID_103); - param0->unk_1A0[2][3] = SpriteResourceCollection_AddFrom(param0->unk_190[3], v0, sub_0208193C(), 0, 2, 3, HEAP_ID_103); - - NARC_dtor(v0); - return; -} - -static void ov108_02243360(UnkStruct_ov108_02243030 *param0, Party *param1, Party *param2, u8 param3) -{ - Pokemon *v0; - Pokemon *v1; - NARC *v2; - u32 v3; - - v2 = NARC_ctor(NARC_INDEX_POKETOOL__ICONGRA__PL_POKE_ICON, HEAP_ID_103); - - param0->unk_1A0[3][1] = SpriteResourceCollection_AddPalette(param0->unk_190[1], 19, PokeIconPalettesFileIndex(), 0, 3, NNS_G2D_VRAM_TYPE_2DMAIN, 3, HEAP_ID_103); - param0->unk_1A0[3][2] = SpriteResourceCollection_AddFrom(param0->unk_190[2], v2, PokeIcon32KCellsFileIndex(), 0, 3, 2, HEAP_ID_103); - param0->unk_1A0[3][3] = SpriteResourceCollection_AddFrom(param0->unk_190[3], v2, PokeIcon32KAnimationFileIndex(), 0, 3, 3, HEAP_ID_103); - - for (v3 = 0; v3 < (2 * 2); v3++) { - if (v3 == 3) { - if (param3 == 0) { - v0 = Party_GetPokemonBySlotIndex(param1, 0); - v1 = Party_GetPokemonBySlotIndex(param2, 0); - } else { - v0 = Party_GetPokemonBySlotIndex(param1, v3); - v1 = Party_GetPokemonBySlotIndex(param2, v3); - } - } else { - v0 = Party_GetPokemonBySlotIndex(param1, v3); - v1 = Party_GetPokemonBySlotIndex(param2, v3); - } - - param0->unk_1A0[3 + v3][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_190[0], v2, Pokemon_IconSpriteIndex(v0), 0, 3 + v3, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_103); - param0->unk_1A0[7 + v3][0] = SpriteResourceCollection_AddTilesFrom(param0->unk_190[0], v2, Pokemon_IconSpriteIndex(v1), 0, 7 + v3, NNS_G2D_VRAM_TYPE_2DMAIN, HEAP_ID_103); - } - - NARC_dtor(v2); - return; -} - -static void ov108_02243490(UnkStruct_ov108_02243030 *param0) -{ - param0->unk_1A0[0][0] = SpriteResourceCollection_AddTiles(param0->unk_190[0], 151, 21, 1, 0, NNS_G2D_VRAM_TYPE_2DSUB, HEAP_ID_103); - param0->unk_1A0[0][1] = SpriteResourceCollection_AddPalette(param0->unk_190[1], 151, 41, 0, 0, NNS_G2D_VRAM_TYPE_2DSUB, 2, HEAP_ID_103); - param0->unk_1A0[0][2] = SpriteResourceCollection_Add(param0->unk_190[2], 151, 23, 1, 0, 2, HEAP_ID_103); - param0->unk_1A0[0][3] = SpriteResourceCollection_Add(param0->unk_190[3], 151, 22, 1, 0, 3, HEAP_ID_103); - - return; -} diff --git a/src/overlay108/ov108_0224351C.c b/src/overlay108/ov108_0224351C.c deleted file mode 100644 index c55ec40a9a..0000000000 --- a/src/overlay108/ov108_0224351C.c +++ /dev/null @@ -1,120 +0,0 @@ -#include "overlay108/ov108_0224351C.h" - -#include -#include - -#include "overlay108/ov108_02243030.h" -#include "overlay108/struct_ov108_02243030.h" -#include "overlay108/struct_ov108_02243594_decl.h" - -#include "heap.h" -#include "pokemon.h" -#include "pokemon_icon.h" -#include "sprite.h" - -struct UnkStruct_ov108_02243594_t { - u32 unk_00; - u32 unk_04; - u16 unk_08; - u8 unk_0A; - u8 unk_0B; - u16 unk_0C; - u16 unk_0E; - Sprite *unk_10; -}; - -UnkStruct_ov108_02243594 *ov108_0224351C(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u16 param5, u16 param6, u32 param7, int param8, u8 param9); -void *ov108_02243594(UnkStruct_ov108_02243594 *param0); -void ov108_022435A8(UnkStruct_ov108_02243594 *param0, int param1); -void ov108_022435B4(UnkStruct_ov108_02243594 *param0, u16 param1, u16 param2); -void ov108_022435F4(UnkStruct_ov108_02243594 *param0, u32 param1); -void ov108_02243610(UnkStruct_ov108_02243594 *param0, Pokemon *param1); -void ov108_02243624(UnkStruct_ov108_02243594 *param0, u8 param1); - -UnkStruct_ov108_02243594 *ov108_0224351C(UnkStruct_ov108_02243030 *param0, u32 param1, u32 param2, u32 param3, u32 param4, u16 param5, u16 param6, u32 param7, int param8, u8 param9) -{ - UnkStruct_ov108_02243594 *v0; - VecFx32 v1; - - v0 = Heap_Alloc(HEAP_ID_103, sizeof(UnkStruct_ov108_02243594)); - memset(v0, 0, sizeof(UnkStruct_ov108_02243594)); - - v0->unk_10 = ov108_022430F0(param0, param1, param2, param3, param4, param7, param8, param9); - v0->unk_0C = param5; - v0->unk_0E = param6; - v0->unk_0B = param9; - - v1.x = (param5 * FX32_ONE); - v1.y = (param6 * FX32_ONE); - - if (param9 == 1) { - v1.y += (192 << FX32_SHIFT); - } - - Sprite_SetPosition(v0->unk_10, &v1); - - return v0; -} - -void *ov108_02243594(UnkStruct_ov108_02243594 *param0) -{ - Sprite_Delete(param0->unk_10); - Heap_Free(param0); - - return NULL; -} - -void ov108_022435A8(UnkStruct_ov108_02243594 *param0, int param1) -{ - Sprite_SetDrawFlag(param0->unk_10, param1); - return; -} - -void ov108_022435B4(UnkStruct_ov108_02243594 *param0, u16 param1, u16 param2) -{ - VecFx32 v0; - - v0 = *(Sprite_GetPosition(param0->unk_10)); - - v0.x = (param1 * FX32_ONE); - v0.y = (param2 * FX32_ONE); - - if (param0->unk_0B == 1) { - v0.y += (192 << FX32_SHIFT); - } - - Sprite_SetPosition(param0->unk_10, &v0); - return; -} - -void ov108_022435F4(UnkStruct_ov108_02243594 *param0, u32 param1) -{ - Sprite_SetAnimSpeed(param0->unk_10, FX32_ONE); - Sprite_SetAnimNoRestart(param0->unk_10, param1); - - return; -} - -void ov108_02243610(UnkStruct_ov108_02243594 *param0, Pokemon *param1) -{ - Sprite_SetExplicitPaletteOffsetAutoAdjust(param0->unk_10, Pokemon_IconPaletteIndex(param1)); - return; -} - -static const VecFx32 Unk_ov111_021D3834[] = { - { FX32_ONE, FX32_ONE, FX32_ONE }, - { FX32_ONE + (FX32_ONE / 2), FX32_ONE + (FX32_ONE / 2), FX32_ONE + (FX32_ONE / 2) }, - { FX32_ONE + (FX32_ONE / 4), FX32_ONE + (FX32_ONE / 4), FX32_ONE + (FX32_ONE / 4) }, - { FX32_ONE + (FX32_ONE / 5), FX32_ONE + (FX32_ONE / 5), FX32_ONE + (FX32_ONE / 5) }, - { FX32_ONE + (FX32_ONE / 7), FX32_ONE + (FX32_ONE / 7), FX32_ONE + (FX32_ONE / 7) }, - { FX32_ONE - (FX32_ONE / 2), FX32_ONE - (FX32_ONE / 2), FX32_ONE - (FX32_ONE / 2) }, - { FX32_ONE - (FX32_ONE / 4), FX32_ONE - (FX32_ONE / 4), FX32_ONE - (FX32_ONE / 4) }, - { FX32_ONE - (FX32_ONE / 5), FX32_ONE - (FX32_ONE / 5), FX32_ONE - (FX32_ONE / 5) }, - { FX32_ONE - (FX32_ONE / 7), FX32_ONE - (FX32_ONE / 7), FX32_ONE - (FX32_ONE / 7) } -}; - -void ov108_02243624(UnkStruct_ov108_02243594 *param0, u8 param1) -{ - Sprite_SetAnimateFlag(param0->unk_10, param1); - return; -} diff --git a/src/overlay108/ov108_02243630.c b/src/overlay108/ov108_02243630.c deleted file mode 100644 index 02b784e9c4..0000000000 --- a/src/overlay108/ov108_02243630.c +++ /dev/null @@ -1,38 +0,0 @@ -#include "overlay108/ov108_02243630.h" - -#include -#include - -#include "bg_window.h" - -void ov108_02243630(BgConfig *param0, Window *param1); -void ov108_02243660(Window *param0); - -static const WindowTemplate Unk_ov108_02243774[] = { - { 0x1, 0x2, 0x13, 0x1B, 0x4, 0xC, 0x1 }, - { 0x1, 0x18, 0xD, 0x7, 0x4, 0xD, 0x6D } -}; - -void ov108_02243630(BgConfig *param0, Window *param1) -{ - u8 v0; - const WindowTemplate *v1 = Unk_ov108_02243774; - - for (v0 = 0; v0 < 2; v0++) { - Window_AddFromTemplate(param0, ¶m1[v0], &v1[v0]); - Window_FillTilemap(¶m1[v0], 0); - } - - return; -} - -void ov108_02243660(Window *param0) -{ - u16 v0; - - for (v0 = 0; v0 < 2; v0++) { - Window_Remove(¶m0[v0]); - } - - return; -} diff --git a/src/unk_0209BA80.c b/src/unk_0209BA80.c index c1927aa5e9..3ef367e2fd 100644 --- a/src/unk_0209BA80.c +++ b/src/unk_0209BA80.c @@ -9,13 +9,13 @@ #include "struct_defs/struct_02039A58.h" #include "struct_defs/struct_0209BBA4.h" +#include "applications/frontier/battle_arcade/main.h" #include "applications/frontier/battle_castle/opponent_app.h" #include "applications/frontier/battle_castle/self_app.h" #include "applications/frontier/battle_factory/main.h" #include "applications/frontier/battle_hall/main.h" #include "overlay104/ov104_0222ECE8.h" #include "overlay104/ov104_0223C164.h" -#include "overlay108/ov108_02241AE0.h" #include "communication_system.h" #include "party.h" @@ -89,9 +89,9 @@ static const CommCmdTable Unk_020F8BF0[] = { { ov104_0222FA5C, CommPacketSizeOf_Variable, NULL }, { ov104_0222FAA8, CommPacketSizeOf_Variable, NULL }, { ov104_0222FB34, CommPacketSizeOf_Variable, ov104_0222FBC4 }, - { ov108_02242AB0, CommPacketSizeOf_Variable, NULL }, - { ov108_02242B24, CommPacketSizeOf_Variable, NULL }, - { ov108_02242B84, CommPacketSizeOf_Variable, NULL } + { BattleArcadeApp_HandleInitialLayoutCmd, CommPacketSizeOf_Variable, NULL }, + { BattleArcadeApp_HandleResultCmd, CommPacketSizeOf_Variable, NULL }, + { BattleArcadeApp_HandleUnusedCmd, CommPacketSizeOf_Variable, NULL } }; void sub_0209BA80(void *param0)