summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/contest.c2761
-rw-r--r--src/easy_chat.c807
-rw-r--r--src/field_player_avatar.c581
-rw-r--r--src/pokemon_storage_system.c523
-rw-r--r--src/pokemon_summary_screen.c2
-rw-r--r--src/slot_machine.c1366
-rw-r--r--src/tv.c4
7 files changed, 6022 insertions, 22 deletions
diff --git a/src/contest.c b/src/contest.c
new file mode 100644
index 000000000..8513fc4a9
--- /dev/null
+++ b/src/contest.c
@@ -0,0 +1,2761 @@
+#include "global.h"
+#include "gpu_regs.h"
+#include "bg.h"
+#include "malloc.h"
+#include "constants/items.h"
+#include "constants/event_objects.h"
+#include "constants/moves.h"
+#include "constants/songs.h"
+#include "constants/species.h"
+#include "constants/flags.h"
+#include "battle.h"
+#include "battle_anim.h"
+#include "blend_palette.h"
+#include "contest.h"
+#include "data2.h"
+#include "decompress.h"
+#include "graphics.h"
+#include "link.h"
+#include "m4a.h"
+#include "main.h"
+#include "menu.h"
+#include "overworld.h"
+#include "palette.h"
+#include "random.h"
+#include "script.h"
+#include "sound.h"
+#include "sprite.h"
+#include "string_util.h"
+#include "task.h"
+#include "text.h"
+#include "tv.h"
+#include "scanline_effect.h"
+#include "util.h"
+#include "contest_link_80F57C4.h"
+#include "dma3.h"
+#include "battle_message.h"
+#include "event_scripts.h"
+#include "event_data.h"
+#include "strings.h"
+#include "contest_effect.h"
+#include "contest_link_80FC4F4.h"
+#include "script_pokemon_util_80F87D8.h"
+#include "international_string_util.h"
+#include "data2.h"
+#include "constants/rgb.h"
+
+extern void (*gFieldCallback)(void);
+
+void sub_80D782C(void);
+void sub_80D7C7C(u8 taskId);
+void sub_80D7CB4(u8 taskId);
+void sub_80D7DAC(u8 taskId);
+void sub_80D7DC8(u8 taskId);
+void sub_80D7DE8(u8 taskId);
+bool8 sub_80D7E44(u8 *);
+void sub_80D80C8(u8 taskId);
+void sub_80D8108(u8 taskId);
+void vblank_cb_battle(void);
+void sub_80D823C(void);
+void sub_80D833C(u8 taskId);
+void sub_80D8424(u8 taskId);
+void sub_80D8610(u8 taskId);
+void sub_80D8490(u8 taskId);
+void sub_80D880C(s8);
+void sub_80D883C(s8);
+void sub_80D8894(u8 taskId);
+void sub_80D892C(u8 taskId);
+void sub_80D895C(u8 taskId);
+void sub_80D8A04(u8 taskId);
+void sub_80D8A50(u8 taskId);
+void sub_80D8A88(u8 taskId);
+void sub_80D8B38(u8 taskId);
+void sub_80DA110(u8);
+void sub_80DA134(struct Sprite *);
+void sub_80DA164(struct Sprite *);
+void sub_80DA198(u8);
+void sub_80DA25C(u8);
+void sub_80DA28C(u8);
+void sub_80DA31C(u8);
+void sub_80DA348(u8);
+void sub_80DA38C(u8);
+void sub_80DA3CC(u8);
+void sub_80DA464(u8);
+void sub_80DA49C(u8);
+void sub_80DA4CC(u8);
+void sub_80DA51C(u8);
+void sub_80DA5B4(u8);
+void sub_80DA5E8(u8);
+void sub_80DA6B4(u8);
+void sub_80DA700(u8);
+void sub_80DA740(u8);
+void sub_80DA7A0(u8);
+void sub_80DA7EC(u8);
+void sub_80DA830(u8);
+void sub_80DA874(void);
+bool8 sub_80DA8A4(void);
+void sub_80DAF04(u8);
+void sub_80DAF1C(u8 a0, u8 a1);
+void sub_80DAF88(u8);
+void sub_80DAFA0(u8, u8);
+u8 sub_80DB0C4(void);
+u8 sub_80DB120(void);
+u8 sub_80DB174(u16, u32, u32, u32);
+void sub_80DB2BC(void);
+void prints_contest_move_description(u16);
+u16 sub_80DE84C(u16);
+void sub_80DB89C(void);
+u16 sub_80DB8B8(u8);
+void sub_80DB918(void);
+bool8 sub_80DBCA8(u8);
+void sub_80DBF68(void);
+void sub_80DBF90(void);
+void sub_80DC2BC(void);
+void sub_80DC490(bool8);
+void sub_80DC4F0(void);
+void sub_80DC594(void);
+void sub_80DC5E8(void);
+void sub_80DC7EC(void);
+void sub_80DCD48(void);
+void sub_80DCE58(u8);
+void sub_80DD04C(void);
+void sub_80DD590(void);
+void sub_80DDB0C(void);
+void sub_80DDBE8(void);
+bool8 sub_80DE1E8(u8);
+void sub_80DE224(void);
+void sub_80DE350(void);
+void sub_80DE424(u8);
+void sub_80DE69C(u8);
+void sub_80DEA20(void);
+void Contest_PrintTextToBg0WindowAt(u32, u8 *, s32, u8, u8);
+void Contest_StartTextPrinter(const u8 *, u8);
+void ContestBG_FillBoxWithIncrementingTile(u8, u16, u8, u8, u8, u8, u8, u8);
+bool32 Contest_RunTextPrinters(void);
+void Contest_SetBgCopyFlags(u32);
+void sub_80FC9F8(u8);
+bool8 AreMovesContestCombo(u16, u16);
+void sub_80DBD18(void);
+void sub_80DF250(void);
+void sub_80DF4F8(void);
+void sub_80DD080(u8);
+void sub_80DF080(u8);
+void sub_80DF750(void);
+void sub_80DE9DC(u8);
+void sub_80DCBE8(u8, u8);
+u8 sub_80DC9EC(u8);
+u16 sub_80DE834(u16);
+void sub_80DE864(u8);
+void sub_80DEAA8(u16);
+void sub_80DE9B0(u8);
+void sub_80DC674(u8);
+void sub_80DE12C(void);
+void sub_80DD45C(u8, u8);
+void sub_80DD720(u8);
+void sub_80DE008(bool8);
+void sub_80DC028(s16, s16, u8);
+bool8 sub_80DB5B8(u8, u8);
+bool8 sub_80DB798(u8);
+void sub_80DB884(void);
+void sub_80DC9B4(u8);
+void sub_80DDED0(s8, s8);
+void sub_80DDCDC(s8);
+void sub_80DDE0C(void);
+void sub_80DD940(void);
+void sub_80DB944(void);
+void sub_80DBA18(void);
+void sub_80DC3AC(void);
+bool8 sub_80DC3C4(void);
+void sub_80DF9D4(u8 *);
+void sub_80DF9E0(u8 *, s32);
+void ContestBG_FillBoxWithTile(u8, u16, u8, u8, u8, u8, u8);
+void Contest_PrintTextToBg0WindowStd(u8, const u8 *);
+
+EWRAM_DATA struct ContestPokemon gContestMons[4] = {0};
+EWRAM_DATA s16 gContestMonConditions[4] = {0};
+EWRAM_DATA s16 gUnknown_02039F08[4] = {0};
+EWRAM_DATA s16 gUnknown_02039F10[4] = {0};
+EWRAM_DATA s16 gUnknown_02039F18[4] = {0};
+EWRAM_DATA u8 gContestFinalStandings[4] = {0};
+EWRAM_DATA u8 gUnknown_02039F24 = 0;
+EWRAM_DATA u8 gContestPlayerMonIndex = 0;
+EWRAM_DATA u8 gUnknown_02039F26[4] = {0};
+EWRAM_DATA u8 gIsLinkContest = 0;
+// Bit 0: Is a link contest
+// Bit 1: Link contest uses wireless adapter
+EWRAM_DATA u8 gUnknown_02039F2B = 0;
+EWRAM_DATA u16 gSpecialVar_ContestCategory = 0;
+EWRAM_DATA u16 gSpecialVar_ContestRank = 0;
+EWRAM_DATA u8 gUnknown_02039F30 = 0;
+EWRAM_DATA u8 gUnknown_02039F31 = 0;
+EWRAM_DATA struct ContestResources * gContestResources = NULL;
+EWRAM_DATA u8 sContestBgCopyFlags = 0;
+EWRAM_DATA struct ContestWinner gUnknown_02039F3C = {0};
+
+u32 gContestRngValue;
+
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG0_Y;
+extern u16 gBattle_BG1_X;
+extern s16 gBattle_BG1_Y;
+extern u16 gBattle_BG2_X;
+extern u16 gBattle_BG2_Y;
+extern u16 gBattle_BG3_X;
+extern u16 gBattle_BG3_Y;
+extern u16 gBattle_WIN0H;
+extern u16 gBattle_WIN0V;
+extern u16 gBattle_WIN1H;
+extern u16 gBattle_WIN1V;
+
+extern const u8 gContestMiscGfx[];
+extern const u8 gContestAudienceGfx[];
+extern const u8 gUnknown_08C16FA8[];
+extern const u8 gUnknown_08C16E90[];
+extern const u8 gUnknown_08C17170[];
+extern const u16 gUnknown_08587C30[];
+extern const struct BgTemplate gUnknown_08587F34[4];
+extern const struct WindowTemplate gUnknown_08587F44[];
+extern const u8 *const gUnknown_08587D90[];
+extern const u8 *const gUnknown_08587F08[];
+extern const u8 *const gUnknown_08587F1C[];
+extern const u8 gText_0827D55A[];
+extern const u8 gText_0827E793[];
+extern const u8 gText_0827E32E[];
+extern const u8 gText_0827E35B[];
+extern const u8 gText_0827E38D[];
+extern const u8 gText_0827E2FE[];
+extern const u8 gText_0827E6E3[];
+extern const u8 gText_0827E73C[];
+extern const u8 gText_0827E717[];
+extern const u8 gText_0827E76A[];
+extern const u8 gText_0827E7EA[];
+extern const u8 gText_0827E817[];
+extern const u8 gText_0827E58A[];
+extern const u8 gText_0827D56F[];
+extern const u8 gText_0827D597[];
+extern const struct ContestPokemon gContestOpponents[96];
+extern const u8 gUnknown_085898A4[96];
+extern const struct CompressedSpriteSheet gUnknown_08587C00;
+extern const u8 gContest2Pal[];
+extern const struct SpriteTemplate gSpriteTemplate_8587BE8;
+extern const struct CompressedSpriteSheet gUnknown_08587C08;
+extern const struct CompressedSpritePalette gUnknown_08587C10;
+extern const struct SpriteTemplate gSpriteTemplate_8587C18;
+extern const union AffineAnimCmd *const gUnknown_082FF6C0[];
+extern const union AffineAnimCmd *const gUnknown_082FF694[];
+extern const u8 *const gContestEffectDescriptionPointers[];
+
+void TaskDummy1(u8 taskId)
+{
+}
+
+void ResetLinkContestBoolean(void)
+{
+ gIsLinkContest = 0;
+}
+
+void sub_80D7678(void)
+{
+ u16 savedIme;
+
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP);
+ SetGpuReg(REG_OFFSET_BLDCNT, 0);
+ SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+ SetGpuReg(REG_OFFSET_BLDY, 0);
+ SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG0 | WININ_WIN0_BG1 | WININ_WIN0_BG2 | WININ_WIN0_BG3 | WININ_WIN0_OBJ | WININ_WIN0_CLR | WININ_WIN1_BG0 | WININ_WIN1_BG1 | WININ_WIN1_BG2 | WININ_WIN1_BG3 | WININ_WIN1_OBJ | WININ_WIN1_CLR);
+ SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR | WINOUT_WINOBJ_BG0 | WINOUT_WINOBJ_BG1 | WINOUT_WINOBJ_BG2 | WINOUT_WINOBJ_BG3 | WINOUT_WINOBJ_OBJ | WINOUT_WINOBJ_CLR);
+ SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON | DISPCNT_BG1_ON | DISPCNT_BG2_ON | DISPCNT_BG3_ON | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
+
+ gBattle_BG0_X = 0;
+ gBattle_BG0_Y = 0;
+ gBattle_BG1_X = 0;
+ gBattle_BG1_Y = 0;
+ gBattle_BG2_X = 0;
+ gBattle_BG2_Y = 0;
+ gBattle_BG3_X = 0;
+ gBattle_BG3_Y = 0;
+ gBattle_WIN0H = 0;
+ gBattle_WIN0V = 0;
+ gBattle_WIN1H = 0;
+ gBattle_WIN1V = 0;
+}
+
+void LoadContestBgAfterMoveAnim(void)
+{
+ s32 i;
+
+ LZDecompressVram(gContestMiscGfx, (void *)VRAM);
+ LZDecompressVram(gContestAudienceGfx, (void *)(VRAM + 0x2000));
+ CopyToBgTilemapBuffer(3, gUnknown_08C16FA8, 0, 0);
+ CopyBgTilemapBufferToVram(3);
+ LoadCompressedPalette(gUnknown_08C16E90, 0, 0x200);
+ sub_80D782C();
+ for (i = 0; i < 4; i++)
+ {
+ u32 var = 5 + i;
+
+ LoadPalette(shared18000.unk18004[var], 16 * (5 + gUnknown_02039F26[i]), 16 * sizeof(u16));
+ }
+}
+
+void sub_80D779C(void)
+{
+ s32 i;
+
+ ResetBgsAndClearDma3BusyFlags(0);
+ InitBgsFromTemplates(0, gUnknown_08587F34, ARRAY_COUNT(gUnknown_08587F34));
+ SetBgAttribute(3, BG_CTRL_ATTR_PRIORITY, 1);
+ for (i = 0; i < 4; i++)
+ {
+ SetBgTilemapBuffer(i, gContestResources->field_24[i]);
+ }
+}
+
+void sub_80D77E4(void)
+{
+ InitWindows(gUnknown_08587F44);
+ DeactivateAllTextPrinters();
+ if (gIsLinkContest & 1)
+ {
+ gTextFlags.flag_0 = FALSE;
+ }
+ else
+ {
+ gTextFlags.flag_0 = TRUE;
+ }
+}
+
+void sub_80D782C(void)
+{
+ s32 i;
+
+ LoadPalette(gUnknown_08587C30, 0xf0, 0x20);
+ FillPalette(RGB_BLACK, 0, 2);
+ for (i = 10; i < 14; i++)
+ LoadPalette(gPlttBufferUnfaded + 241, 240 + i, 2);
+ FillPalette(RGB(31, 17, 31), 0xF3, 2);
+}
+
+void sub_80D787C(void)
+{
+ s32 i;
+
+ *gContestResources->field_0 = (struct Contest){};
+ for (i = 0; i < 4; i++)
+ {
+ gContestResources->field_0->unk19206[i] = 0xFF;
+ }
+ for (i = 0; i < 4; i++)
+ {
+ gContestResources->field_4[i] = (struct ContestantStatus){};
+ }
+ for (i = 0; i < 4; i++)
+ {
+ gContestResources->field_4[i].unkB_0 = 0;
+ gContestResources->field_4[i].effectStringId = CONTEST_STRING_NONE;
+ gContestResources->field_4[i].effectStringId2 = CONTEST_STRING_NONE;
+ }
+ *gContestResources->field_8 = (struct UnknownContestStruct7){};
+ *gContestResources->field_C = (struct ContestAIInfo){};
+ *gContestResources->field_10 = (struct UnknownContestStruct5){};
+ memset(gContestResources->field_14, 0, 4 * sizeof(struct UnknownContestStruct4));
+ if (!(gIsLinkContest & 1))
+ sub_80DCE58(0);
+ for (i = 0; i < 4; i++)
+ {
+ gContestResources->field_4[i].nextTurnOrder = 0xFF;
+ gContestResources->field_0->unk19218[i] = gUnknown_02039F26[i];
+ }
+ sub_80DD590();
+ *gContestResources->field_1c = (struct ContestResourcesField1C){};
+}
+
+void sub_80D7988(void)
+{
+ gContestResources = AllocZeroed(sizeof(struct ContestResources));
+ gContestResources->field_0 = AllocZeroed(sizeof(struct Contest));
+ gContestResources->field_4 = AllocZeroed(sizeof(struct ContestantStatus) * 4);
+ gContestResources->field_8 = AllocZeroed(sizeof(struct UnknownContestStruct7));
+ gContestResources->field_C = AllocZeroed(sizeof(struct ContestAIInfo));
+ gContestResources->field_10 = AllocZeroed(sizeof(struct UnknownContestStruct5) * 4);
+ gContestResources->field_14 = AllocZeroed(sizeof(struct UnknownContestStruct4) * 4);
+ gContestResources->field_18 = AllocZeroed(sizeof(struct ContestStruct_field_18));
+ gContestResources->field_1c = AllocZeroed(sizeof(struct ContestResourcesField1C));
+ gContestResources->field_20 = AllocZeroed(sizeof(struct ContestResourcesField20));
+ gContestResources->field_24[0] = AllocZeroed(0x1000);
+ gContestResources->field_24[1] = AllocZeroed(0x1000);
+ gContestResources->field_24[2] = AllocZeroed(0x1000);
+ gContestResources->field_24[3] = AllocZeroed(0x1000);
+ gContestResources->field_34 = AllocZeroed(0x800);
+ gContestResources->field_38 = AllocZeroed(0x800);
+ gContestResources->field_3c = AllocZeroed(0x2000);
+ gUnknown_0202305C = gContestResources->field_3c;
+ gUnknown_02023060 = gContestResources->field_24[1];
+}
+
+void sub_80D7A5C(void)
+{
+ FREE_AND_SET_NULL(gContestResources->field_0);
+ FREE_AND_SET_NULL(gContestResources->field_4);
+ FREE_AND_SET_NULL(gContestResources->field_8);
+ FREE_AND_SET_NULL(gContestResources->field_C);
+ FREE_AND_SET_NULL(gContestResources->field_10);
+ FREE_AND_SET_NULL(gContestResources->field_14);
+ FREE_AND_SET_NULL(gContestResources->field_18);
+ FREE_AND_SET_NULL(gContestResources->field_1c);
+ FREE_AND_SET_NULL(gContestResources->field_20);
+ FREE_AND_SET_NULL(gContestResources->field_24[0]);
+ FREE_AND_SET_NULL(gContestResources->field_24[1]);
+ FREE_AND_SET_NULL(gContestResources->field_24[2]);
+ FREE_AND_SET_NULL(gContestResources->field_24[3]);
+ FREE_AND_SET_NULL(gContestResources->field_34);
+ FREE_AND_SET_NULL(gContestResources->field_38);
+ FREE_AND_SET_NULL(gContestResources->field_3c);
+ FREE_AND_SET_NULL(gContestResources);
+ gUnknown_0202305C = NULL;
+ gUnknown_02023060 = NULL;
+}
+
+void sub_80D7B24(void)
+{
+ switch (gMain.state)
+ {
+ case 0:
+ sContestBgCopyFlags = 0;
+ sub_80D7988();
+ AllocateMonSpritesGfx();
+ FREE_AND_SET_NULL(gMonSpritesGfxPtr->firstDecompressed);
+ gMonSpritesGfxPtr->firstDecompressed = AllocZeroed(0x4000);
+ SetVBlankCallback(NULL);
+ sub_80D779C();
+ sub_80D77E4();
+ sub_80D7678();
+ ScanlineEffect_Clear();
+ ResetPaletteFade();
+ gPaletteFade.bufferTransferDisabled = TRUE;
+ ResetSpriteData();
+ ResetTasks();
+ FreeAllSpritePalettes();
+ gReservedSpritePaletteCount = 4;
+ //shared18000.unk18000 = 0;
+ gHeap[0x1a000] = 0;
+ ClearBattleMonForms();
+ sub_80D787C();
+ gMain.state++;
+ break;
+ case 1:
+ gMain.state++;
+ break;
+ case 2:
+ if (sub_80D7E44(&gContestResources->field_0->unk1925D))
+ {
+ gContestResources->field_0->unk1925D = 0;
+ gMain.state++;
+ }
+ break;
+ case 3:
+ sub_80DE224();
+ gBattle_BG1_X = 0;
+ gBattle_BG1_Y = 0;
+ BeginFastPaletteFade(2);
+ gPaletteFade.bufferTransferDisabled = FALSE;
+ SetVBlankCallback(vblank_cb_battle);
+ gContestResources->field_0->mainTaskId = CreateTask(sub_80D7C7C, 10);
+ SetMainCallback2(sub_80D823C);
+ if (gIsLinkContest & 2)
+ {
+ sub_800E0E8();
+ CreateWirelessStatusIndicatorSprite(8, 8);
+ }
+ break;
+ }
+}
+
+void sub_80D7C7C(u8 taskId)
+{
+ if (!gPaletteFade.active)
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80D7CB4;
+ }
+}
+
+void sub_80D7CB4(u8 taskId)
+{
+ if (gIsLinkContest & 1)
+ {
+ if (gIsLinkContest & 2)
+ {
+ switch (gTasks[taskId].data[0])
+ {
+ case 0:
+ sub_80DBF68();
+ gTasks[taskId].data[0]++;
+ // fallthrough
+ case 1:
+ if (sub_800A520())
+ {
+ sub_800ADF8();
+ gTasks[taskId].data[0]++;
+ }
+ return;
+ case 2:
+ if (sub_800A520() != TRUE)
+ return;
+ gTasks[taskId].data[0]++;
+ break;
+ }
+ }
+
+ if (!gPaletteFade.active)
+ {
+ gPaletteFade.bufferTransferDisabled = FALSE;
+ if (!(gIsLinkContest & 2))
+ sub_80DBF68();
+ CreateTask(sub_80D7DAC, 0);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = TaskDummy1;
+ }
+ }
+ else
+ {
+ gTasks[taskId].func = sub_80D80C8;
+ }
+}
+
+void sub_80D7DAC(u8 taskId)
+{
+ SetTaskFuncWithFollowupFunc(taskId, sub_80FC998, sub_80D7DC8);
+}
+
+void sub_80D7DC8(u8 taskId)
+{
+ gTasks[taskId].data[0] = 1;
+ gTasks[taskId].func = sub_80D7DE8;
+}
+
+void sub_80D7DE8(u8 taskId)
+{
+ gTasks[taskId].data[0]--;
+ if (gTasks[taskId].data[0] <= 0)
+ {
+ GetMultiplayerId(); // unused return value
+ DestroyTask(taskId);
+ gTasks[gContestResources->field_0->mainTaskId].func = sub_80D80C8;
+ gRngValue = gContestRngValue;
+ }
+}
+
+u8 sub_80D7E44(u8 *a)
+{
+ u16 sp0[16];
+ u16 sp20[16];
+
+ switch (*a)
+ {
+ case 0:
+ gPaletteFade.bufferTransferDisabled = TRUE;
+ RequestDma3Fill(0, (void *)VRAM, 0x8000, 1);
+ RequestDma3Fill(0, (void *)VRAM + 0x8000, 0x8000, 1);
+ RequestDma3Fill(0, (void *)VRAM + 0x10000, 0x8000, 1);
+ break;
+ case 1:
+ LZDecompressVram(gContestMiscGfx, (void *)VRAM);
+ break;
+ case 2:
+ LZDecompressVram(gContestAudienceGfx, (void *)(VRAM + 0x2000));
+ DmaCopyLarge32(3, (void *)(VRAM + 0x2000), shared15800, 0x2000, 0x1000);
+ break;
+ case 3:
+ CopyToBgTilemapBuffer(3, gUnknown_08C16FA8, 0, 0);
+ CopyBgTilemapBufferToVram(3);
+ break;
+ case 4:
+ CopyToBgTilemapBuffer(2, gUnknown_08C17170, 0, 0);
+ CopyBgTilemapBufferToVram(2);
+ DmaCopy32Defvars(3, gContestResources->field_24[2], shared18000.unk18A04, 0x800);
+ break;
+ case 5:
+ LoadCompressedPalette(gUnknown_08C16E90, 0, 0x200);
+ CpuCopy32(gPlttBufferUnfaded + 128, sp0, 16 * sizeof(u16));
+ CpuCopy32(gPlttBufferUnfaded + (5 + gContestPlayerMonIndex) * 16, sp20, 16 * sizeof(u16));
+ CpuCopy32(sp20, gPlttBufferUnfaded + 128, 16 * sizeof(u16));
+ CpuCopy32(sp0, gPlttBufferUnfaded + (5 + gContestPlayerMonIndex) * 16, 16 * sizeof(u16));
+ DmaCopy32Defvars(3, gPlttBufferUnfaded, shared18000.unk18004, 0x200);
+ sub_80D782C();
+ break;
+ case 6:
+ sub_80DD04C();
+ sub_80DBF90();
+ sub_80DB2BC();
+ gContestResources->field_0->unk19216 = sub_80DB120();
+ sub_80DC2BC();
+ sub_80DC4F0();
+ sub_80DC594();
+ sub_80DC5E8();
+ sub_80DC7EC();
+ gBattlerPositions[0] = 0;
+ gBattlerPositions[1] = 1;
+ gBattlerPositions[2] = 3;
+ gBattlerPositions[3] = 2;
+ gBattleTypeFlags = 0;
+ gBattlerAttacker = 2;
+ gBattlerTarget = 3;
+ gBattlerSpriteIds[gBattlerAttacker] = sub_80DB0C4();
+ sub_80DEA20();
+ CopyBgTilemapBufferToVram(3);
+ CopyBgTilemapBufferToVram(2);
+ CopyBgTilemapBufferToVram(1);
+ ShowBg(3);
+ ShowBg(2);
+ ShowBg(0);
+ ShowBg(1);
+ break;
+ default:
+ *a = 0;
+ return 1;
+ }
+
+ (*a)++;
+ return 0;
+}
+
+void sub_80D80C8(u8 taskId)
+{
+ gPaletteFade.bufferTransferDisabled = FALSE;
+ if (!gPaletteFade.active)
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].func = sub_80D8108;
+ }
+}
+
+
+void sub_80D8108(u8 taskId)
+{
+ switch (gTasks[taskId].data[0])
+ {
+ case 0:
+ if (gTasks[taskId].data[1]++ <= 60)
+ break;
+ gTasks[taskId].data[1] = 0;
+ PlaySE12WithPanning(SE_C_MAKU_U, 0);
+ gTasks[taskId].data[0]++;
+ break;
+ case 1:
+ if ((gBattle_BG1_Y += 7) <= 160)
+ break;
+ gTasks[taskId].data[0]++;
+ break;
+ case 2:
+ sub_80DE350();
+ gTasks[taskId].data[0]++;
+ break;
+ case 3:
+ {
+ u16 bg0Cnt = GetGpuReg(REG_OFFSET_BG0CNT);
+ u16 bg2Cnt = GetGpuReg(REG_OFFSET_BG2CNT);
+ ((struct BgCnt *)&bg0Cnt)->priority = 0;
+ ((struct BgCnt *)&bg2Cnt)->priority = 0;
+ SetGpuReg(REG_OFFSET_BG0CNT, bg0Cnt);
+ SetGpuReg(REG_OFFSET_BG2CNT, bg2Cnt);
+ sub_80DDB0C();
+ gTasks[taskId].data[0]++;
+ break;
+ }
+ case 4:
+ default:
+ if (gContestResources->field_0->unk1920A_6)
+ break;
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].func = sub_80D833C;
+ break;
+ }
+}
+
+void sub_80D823C(void)
+{
+ s32 i;
+
+ AnimateSprites();
+ RunTasks();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+
+ for (i = 0; i < 4; i++)
+ {
+ if ((sContestBgCopyFlags >> i) & 1)
+ CopyBgTilemapBufferToVram(i);
+ }
+ sContestBgCopyFlags = 0;
+}
+
+void vblank_cb_battle(void)
+{
+ SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_X);
+ SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_Y);
+ SetGpuReg(REG_OFFSET_BG1HOFS, gBattle_BG1_X);
+ SetGpuReg(REG_OFFSET_BG1VOFS, gBattle_BG1_Y);
+ SetGpuReg(REG_OFFSET_BG2HOFS, gBattle_BG2_X);
+ SetGpuReg(REG_OFFSET_BG2VOFS, gBattle_BG2_Y);
+ SetGpuReg(REG_OFFSET_BG3HOFS, gBattle_BG3_X);
+ SetGpuReg(REG_OFFSET_BG3VOFS, gBattle_BG3_Y);
+ SetGpuReg(REG_OFFSET_WIN0H, gBattle_WIN0H);
+ SetGpuReg(REG_OFFSET_WIN0V, gBattle_WIN0V);
+ SetGpuReg(REG_OFFSET_WIN1H, gBattle_WIN1H);
+ SetGpuReg(REG_OFFSET_WIN1V, gBattle_WIN1V);
+ TransferPlttBuffer();
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ ScanlineEffect_InitHBlankDmaTransfer();
+}
+
+void sub_80D833C(u8 taskId)
+{
+ if (gTasks[taskId].data[0] == 0)
+ {
+ gBattle_BG0_Y = 0;
+ gBattle_BG2_Y = 0;
+ sub_80DCD48();
+ DmaCopy32Defvars(3, gPlttBufferUnfaded, shared18000.unk18204, 0x400);
+ ConvertIntToDecimalStringN(gStringVar1, gContestResources->field_0->turnNumber + 1, STR_CONV_MODE_LEFT_ALIGN, 1);
+ if (!sub_80DBCA8(gContestPlayerMonIndex))
+ StringCopy(gDisplayedStringBattle, gText_0827D507);
+ else
+ StringCopy(gDisplayedStringBattle, gText_0827D531);
+ sub_80DB89C();
+ StringExpandPlaceholders(gStringVar4, gDisplayedStringBattle);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0]++;
+ }
+ else
+ {
+ if (!Contest_RunTextPrinters())
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80D8424;
+ }
+ }
+}
+
+void sub_80D8424(u8 taskId)
+{
+ if ((gMain.newKeys & A_BUTTON) || (gMain.newKeys == B_BUTTON))
+ {
+ PlaySE(SE_SELECT);
+ if (!sub_80DBCA8(gContestPlayerMonIndex))
+ {
+ sub_80DC490(TRUE);
+ gTasks[taskId].func = sub_80D8490;
+ }
+ else
+ {
+ gTasks[taskId].func = sub_80D8894;
+ }
+ }
+}
+
+void sub_80D8490(u8 taskId)
+{
+ u8 i;
+ u8 sp8[32];
+
+ gBattle_BG0_Y = 0xA0;
+ gBattle_BG2_Y = 0xA0;
+
+ for (i = 0; i < 4; i++)
+ {
+ u16 move = gContestMons[gContestPlayerMonIndex].moves[i];
+ u8 *r5 = sp8;
+
+ if (gContestResources->field_4[gContestPlayerMonIndex].prevMove != MOVE_NONE
+ && sub_80DE1E8(gContestPlayerMonIndex)
+ && AreMovesContestCombo(gContestResources->field_4[gContestPlayerMonIndex].prevMove, move) != 0
+ && gContestResources->field_4[gContestPlayerMonIndex].hasJudgesAttention)
+ {
+ r5 = StringCopy(sp8, gText_ColorLightShadowDarkGrey);
+ }
+ else if (move != 0
+ && gContestResources->field_4[gContestPlayerMonIndex].prevMove == move
+ && gContestMoves[move].effect != CONTEST_EFFECT_REPETITION_NOT_BORING)
+ {
+ // Gray the text because it is a repeated move
+ r5 = StringCopy(sp8, gText_ColorBlue);
+ }
+ r5 = StringCopy(r5, gMoveNames[move]);
+
+ FillWindowPixelBuffer(i + 5, 0);
+ Contest_PrintTextToBg0WindowAt(i + 5, sp8, 5, 1, 7);
+ }
+
+ sub_80D880C(gContestResources->field_0->playerMoveChoice);
+ prints_contest_move_description(gContestMons[gContestPlayerMonIndex].moves[gContestResources->field_0->playerMoveChoice]);
+ gTasks[taskId].func = sub_80D8610;
+}
+
+void sub_80D8610(u8 taskId)
+{
+ u8 numMoves = 0;
+ s32 i;
+
+ for (i = 0; i < 4; i++)
+ {
+ if (gContestMons[gContestPlayerMonIndex].moves[i] != MOVE_NONE)
+ numMoves++;
+ }
+
+ if (gMain.newKeys & A_BUTTON)
+ {
+ PlaySE(SE_SELECT);
+ gTasks[taskId].func = sub_80D8894;
+ }
+ else
+ {
+ switch (gMain.newAndRepeatedKeys)
+ {
+ case B_BUTTON:
+ PlaySE(SE_SELECT);
+ sub_80DC490(FALSE);
+ ConvertIntToDecimalStringN(gStringVar1, gContestResources->field_0->turnNumber + 1, STR_CONV_MODE_LEFT_ALIGN, 1);
+ if (!sub_80DBCA8(gContestPlayerMonIndex))
+ StringCopy(gDisplayedStringBattle, gText_0827D507);
+ else
+ StringCopy(gDisplayedStringBattle, gText_0827D531);
+ sub_80DB89C();
+ StringExpandPlaceholders(gStringVar4, gDisplayedStringBattle);
+ Contest_StartTextPrinter(gStringVar4, 0);
+ gBattle_BG0_Y = 0;
+ gBattle_BG2_Y = 0;
+ gTasks[taskId].func = sub_80D8424;
+ break;
+ case DPAD_LEFT:
+ case DPAD_RIGHT:
+ break;
+ case DPAD_UP:
+ sub_80D883C(gContestResources->field_0->playerMoveChoice);
+ if (gContestResources->field_0->playerMoveChoice == 0)
+ gContestResources->field_0->playerMoveChoice = numMoves - 1;
+ else
+ gContestResources->field_0->playerMoveChoice--;
+ sub_80D880C(gContestResources->field_0->playerMoveChoice);
+ prints_contest_move_description(gContestMons[gContestPlayerMonIndex].moves[gContestResources->field_0->playerMoveChoice]);
+ if (numMoves > 1)
+ PlaySE(SE_SELECT);
+ break;
+ case DPAD_DOWN:
+ sub_80D883C(gContestResources->field_0->playerMoveChoice);
+ if (gContestResources->field_0->playerMoveChoice == numMoves - 1)
+ gContestResources->field_0->playerMoveChoice = 0;
+ else
+ gContestResources->field_0->playerMoveChoice++;
+ sub_80D880C(gContestResources->field_0->playerMoveChoice);
+ prints_contest_move_description(gContestMons[gContestPlayerMonIndex].moves[gContestResources->field_0->playerMoveChoice]);
+ if (numMoves > 1)
+ PlaySE(SE_SELECT);
+ break;
+ }
+ }
+}
+
+void sub_80D880C(s8 a0)
+{
+ ContestBG_FillBoxWithIncrementingTile(2, 55, 0, 31 + a0 * 2, 2, 2, 17, 1);
+}
+
+void sub_80D883C(s8 a0)
+{
+ ContestBG_FillBoxWithIncrementingTile(2, 11, 0, 31 + a0 * 2, 2, 1, 17, 1);
+ ContestBG_FillBoxWithIncrementingTile(2, 11, 0, 32 + a0 * 2, 2, 1, 17, 1);
+}
+
+void sub_80D8894(u8 taskId)
+{
+ if (gIsLinkContest & 1)
+ {
+ u16 var = sub_80DB8B8(gContestPlayerMonIndex);
+ u8 taskId2;
+
+ gContestResources->field_4[gContestPlayerMonIndex].currMove = var;
+ taskId2 = CreateTask(sub_80FC9F8, 0);
+ SetTaskFuncWithFollowupFunc(taskId2, sub_80FC9F8, sub_80D892C);
+ gTasks[taskId].func = TaskDummy1;
+ sub_80DBF68();
+ sub_80DC490(FALSE);
+ }
+ else
+ {
+ sub_80DB918();
+ gTasks[taskId].func = sub_80D895C;
+ }
+}
+
+void sub_80D892C(u8 taskId)
+{
+ DestroyTask(taskId);
+ gTasks[gContestResources->field_0->mainTaskId].func = sub_80D895C;
+}
+
+void sub_80D895C(u8 taskId)
+{
+ s32 i;
+
+ sub_80DB89C();
+ gBattle_BG0_Y = 0;
+ gBattle_BG2_Y = 0;
+ sub_80DC490(FALSE);
+
+ for (i = 0; i < 4; i++)
+ {
+ FillWindowPixelBuffer(5 + i, 0);
+ PutWindowTilemap(5 + i);
+ CopyWindowToVram(5 + i, 2);
+ }
+ Contest_SetBgCopyFlags(0);
+
+ DmaCopy32Defvars(3, gPlttBufferFaded, shared18000.unk18604, 0x400);
+ LoadPalette(shared18000.unk18204, 0, 0x400);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].func = sub_80D8A04;
+}
+
+void sub_80D8A04(u8 taskId)
+{
+ if (++gTasks[taskId].data[0] > 2)
+ {
+ gTasks[taskId].data[0] = 0;
+ if (++gTasks[taskId].data[1] == 2)
+ {
+ sub_80DDBE8();
+ sub_80DE69C(1);
+ gTasks[taskId].func = sub_80D8A50;
+ }
+ }
+}
+
+void sub_80D8A50(u8 taskId)
+{
+ if (!gContestResources->field_0->unk1920A_6 && !gContestResources->field_0->unk1920B_1)
+ gTasks[taskId].func = sub_80D8A88;
+}
+
+void sub_80D8A88(u8 taskId)
+{
+ if (++gTasks[taskId].data[0] > 19)
+ {
+ gContestResources->field_0->unk19214 = 0;
+ gContestResources->field_0->unk1921C = gRngValue;
+ if ((gIsLinkContest & 1) && sub_80DA8A4())
+ {
+ s32 i;
+
+ for (i = 0; i + gUnknown_02039F30 < 4; i++)
+ {
+ gContestResources->field_4[gUnknown_02039F30 + i].currMove = sub_80DB8B8(gUnknown_02039F30 + i);
+ }
+ }
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80D8B38;
+ }
+}
+
+void sub_80D8B38(u8 taskId)
+{
+ u8 spriteId;
+ s32 i;
+ u8 r6 = gContestResources->field_0->unk19215;
+ s8 r3;
+
+ switch (gTasks[taskId].data[0])
+ {
+ case 0:
+ sub_80DCD48();
+ for (i = 0; gContestResources->field_0->unk19214 != gContestResources->field_8->turnOrder[i]; i++)
+ ;
+ gContestResources->field_0->unk19215 = i;
+ r6 = gContestResources->field_0->unk19215;
+ if (gIsLinkContest & 1)
+ {
+ u8 taskId2;
+
+ gContestResources->field_0->unk1920B_2 = 1;
+ if (sub_80DA8A4())
+ sub_80DD080(gContestResources->field_0->unk19215);
+ taskId2 = CreateTask(sub_80FCC88, 0);
+ SetTaskFuncWithFollowupFunc(taskId2, sub_80FCC88, sub_80DA110);
+ sub_80DBF68();
+ gTasks[taskId].data[0] = 1;
+ }
+ else
+ {
+ sub_80DD080(gContestResources->field_0->unk19215);
+ gTasks[taskId].data[0] = 2;
+ }
+ return;
+ case 1:
+ if (!gContestResources->field_0->unk1920B_2)
+ gTasks[taskId].data[0] = 2;
+ return;
+ case 2:
+ sub_80DF080(r6);
+ sub_80DF750();
+ if (gContestResources->field_4[r6].numTurnsSkipped != 0
+ || gContestResources->field_4[r6].noMoreTurns)
+ {
+ gTasks[taskId].data[0] = 31;
+ }
+ else
+ {
+ sub_80DB89C();
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 3;
+ }
+ return;
+ case 3:
+ for (i = 0; i < 4; i++)
+ gBattleMonForms[i] = 0;
+ memset(gContestResources->field_18, 0, sizeof(*gContestResources->field_18));
+ sub_80DE9DC(gContestResources->field_0->unk19215);
+ spriteId = sub_80DB174(
+ gContestMons[gContestResources->field_0->unk19215].species,
+ gContestMons[gContestResources->field_0->unk19215].otId,
+ gContestMons[gContestResources->field_0->unk19215].personality,
+ gContestResources->field_0->unk19215);
+ gSprites[spriteId].pos2.x = 120;
+ gSprites[spriteId].callback = sub_80DA134;
+ gTasks[taskId].data[2] = spriteId;
+ gBattlerSpriteIds[gBattlerAttacker] = spriteId;
+ sub_80DCBE8(sub_80DC9EC(gContestResources->field_0->unk19215), FALSE);
+ gTasks[taskId].data[0] = 4;
+ return;
+ case 4:
+ spriteId = gTasks[taskId].data[2];
+ if (gSprites[spriteId].callback == SpriteCallbackDummy)
+ {
+ if (!gContestResources->field_14[r6].unk2_1)
+ gTasks[taskId].data[0] = 5;
+ }
+ return;
+ case 5:
+ if (gContestResources->field_4[r6].nervous)
+ {
+ gTasks[taskId].data[0] = 33;
+ }
+ else
+ {
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ if (gContestResources->field_4[r6].currMove < MOVES_COUNT)
+ StringCopy(gStringVar2, gMoveNames[gContestResources->field_4[r6].currMove]);
+ else
+ StringCopy(gStringVar2, gUnknown_08587F1C[gContestResources->field_4[r6].moveCategory]);
+ StringExpandPlaceholders(gStringVar4, gText_0827D55A);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0] = 6;
+ }
+ return;
+ case 6:
+ if (!Contest_RunTextPrinters())
+ {
+ gContestResources->field_0->unk1925E = 0;
+ gTasks[taskId].data[0] = 7;
+ }
+ return;
+ case 7:
+ {
+ u16 move = sub_80DE834(gContestResources->field_4[gContestResources->field_0->unk19215].currMove);
+
+ sub_80DE864(gContestResources->field_0->unk19215);
+ sub_80DE9DC(gContestResources->field_0->unk19215);
+ sub_80DEAA8(move);
+ DoMoveAnim(move);
+ gTasks[taskId].data[0] = 8;
+ }
+ return;
+ case 8:
+ gAnimScriptCallback();
+ if (!gAnimScriptActive)
+ {
+ sub_80DE9B0(r6);
+ if (gContestResources->field_0->unk1925E != 0)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 9;
+ }
+ else
+ {
+ if (!gContestResources->field_4[r6].hasJudgesAttention)
+ sub_80DC674(r6);
+ sub_80DE12C();
+ gTasks[taskId].data[0] = 23;
+ }
+ }
+ return;
+ case 9:
+ if (gTasks[taskId].data[10]++ > 30)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 7;
+ }
+ return;
+ case 23:
+ gTasks[taskId].data[1] = 0;
+ if (gContestResources->field_4[r6].effectStringId != CONTEST_STRING_NONE)
+ {
+ sub_80DD45C(r6, gContestResources->field_4[r6].effectStringId);
+ gContestResources->field_4[r6].effectStringId = CONTEST_STRING_NONE;
+ gTasks[taskId].data[0] = 24;
+ }
+ else
+ {
+ if (gContestResources->field_4[r6].effectStringId2 != CONTEST_STRING_NONE)
+ {
+ for (i = 0; i < 4; i++)
+ {
+ if (i != r6 && gContestResources->field_4[i].effectStringId != CONTEST_STRING_NONE)
+ break;
+ }
+ if (i == 4)
+ {
+ sub_80DD45C(r6, gContestResources->field_4[r6].effectStringId2);
+ gContestResources->field_4[r6].effectStringId2 = CONTEST_STRING_NONE;
+ gTasks[taskId].data[0] = 24;
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 48;
+ }
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 48;
+ }
+ }
+ return;
+ case 24:
+ if (!Contest_RunTextPrinters())
+ gTasks[taskId].data[0] = 23;
+ return;
+ case 48:
+ if (gContestResources->field_4[r6].turnOrderModAction == 1)
+ {
+ sub_80DD720(5);
+ }
+ else if (gContestResources->field_4[r6].turnOrderModAction == 2)
+ {
+ sub_80DD720(6);
+ }
+ else if (gContestResources->field_4[r6].turnOrderModAction == 3)
+ {
+ sub_80DD720(7);
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 47;
+ return;
+ }
+ gTasks[taskId].data[0] = 49;
+ return;
+ case 49:
+ if (!gContestResources->field_0->unk1920A_4)
+ gTasks[taskId].data[0] = 47;
+ return;
+ case 47:
+ sub_80DE008(TRUE);
+ gTasks[taskId].data[0] = 12;
+ return;
+ case 12:
+ sub_80DC028(0, gContestResources->field_4[r6].appeal2, r6);
+ gTasks[taskId].data[0] = 13;
+ return;
+ case 13:
+ if (!gContestResources->field_14[gContestResources->field_0->unk19215].unk2_2)
+ gTasks[taskId].data[0] = 35;
+ return;
+ case 35:
+ if (gContestResources->field_4[r6].conditionMod == 1)
+ sub_80DD720(8);
+ gTasks[taskId].data[0] = 36;
+ return;
+ case 36:
+ if (!gContestResources->field_0->unk1920A_4)
+ gTasks[taskId].data[0] = 37;
+ return;
+ case 37:
+ if (sub_80DB5B8(r6, 1))
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 38;
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 50;
+ }
+ return;
+ case 38:
+ if (++gTasks[taskId].data[10] > 20)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 50;
+ }
+ return;
+ case 50:
+ if (sub_80DB798(r6))
+ PlaySE(SE_C_PASI);
+ gTasks[taskId].data[0] = 25;
+ return;
+ case 25:
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].data[0] = 26;
+ return;
+ case 26:
+ {
+ s32 r2 = 0;
+
+ r3 = 0;
+ for (i = gTasks[taskId].data[1]; i < 4; i++)
+ {
+ r3 = 0;
+ for (r2 = 0; r2 < 4; r2++)
+ {
+ if (r2 != r6 && gUnknown_02039F26[r2] == i
+ && gContestResources->field_4[r2].effectStringId != CONTEST_STRING_NONE)
+ {
+ r3 = 1;
+ break;
+ }
+ }
+ if (r3 != 0)
+ break;
+ }
+ if (r3)
+ {
+ gTasks[taskId].data[1] = gUnknown_02039F26[r2];
+ sub_80DD45C(r2, gContestResources->field_4[r2].effectStringId);
+ gContestResources->field_4[r2].effectStringId = CONTEST_STRING_NONE;
+ gTasks[taskId].data[0] = 27;
+ }
+ else
+ {
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 51;
+ sub_80DB884();
+ }
+ }
+ return;
+ case 27:
+ if (!Contest_RunTextPrinters())
+ gTasks[taskId].data[0] = 28;
+ return;
+ case 28:
+ for (i = 0; gTasks[taskId].data[1] != gUnknown_02039F26[i]; i++)
+ ;
+ sub_80DC028(gContestResources->field_4[i].appeal2 + gContestResources->field_4[i].jam, -gContestResources->field_4[i].jam, i);
+ gTasks[taskId].data[0] = 29;
+ return;
+ case 29:
+ for (i = 0; gTasks[taskId].data[1] != gUnknown_02039F26[i]; i++)
+ ;
+ if (!gContestResources->field_14[i].unk2_2)
+ gTasks[taskId].data[0] = 39;
+ return;
+ case 39:
+ for (i = 0; gTasks[taskId].data[1] != gUnknown_02039F26[i]; i++)
+ ;
+ if (sub_80DB5B8(i, 1))
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 40;
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 30;
+ }
+ return;
+ case 40:
+ if (++gTasks[taskId].data[10] > 20)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 30;
+ }
+ return;
+ case 30:
+ for (i = 0; i < 4; i++)
+ {
+ if (gUnknown_02039F26[i] == gTasks[taskId].data[1])
+ break;
+ }
+ if (sub_80DB798(i))
+ PlaySE(SE_C_PASI);
+ else
+ PlaySE(SE_C_SYU);
+ if (gContestResources->field_4[i].judgesAttentionWasRemoved)
+ {
+ sub_80DC674(i);
+ gContestResources->field_4[i].judgesAttentionWasRemoved = 0;
+ }
+ gTasks[taskId].data[1]++;
+ gTasks[taskId].data[0] = 26;
+ return;
+ case 51:
+ if (gTasks[taskId].data[10]++ > 9)
+ {
+ gTasks[taskId].data[10] = 0;
+ if (gContestResources->field_4[r6].numTurnsSkipped != 0
+ || gContestResources->field_4[r6].turnSkipped)
+ {
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringExpandPlaceholders(gStringVar4, gText_0827E793);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ }
+ gTasks[taskId].data[0] = 52;
+ }
+ return;
+ case 52:
+ if (!Contest_RunTextPrinters())
+ {
+ if (!gContestResources->field_4[r6].unk15_6)
+ gTasks[taskId].data[0] = 17;
+ else
+ gTasks[taskId].data[0] = 14;
+ }
+ return;
+ case 14:
+ r3 = gContestResources->field_4[r6].unk16;
+ if (gContestResources->field_4[r6].unk16 != 0)
+ {
+ sub_80DB89C();
+ if (r3 == 1)
+ Contest_StartTextPrinter(gText_0827E32E, 1);
+ else if (r3 == 2)
+ Contest_StartTextPrinter(gText_0827E35B, 1);
+ else
+ Contest_StartTextPrinter(gText_0827E38D, 1);
+ sub_80DD720(3);
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 45;
+ }
+ else
+ {
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringExpandPlaceholders(gStringVar4, gText_0827E2FE);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ sub_80DD720(2);
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 45;
+ }
+ return;
+ case 45:
+ if (!gContestResources->field_0->unk1920A_4)
+ {
+ sub_80DC9B4(gContestResources->field_0->unk19215);
+ gTasks[taskId].data[0] = 15;
+ }
+ return;
+ case 15:
+ if (!Contest_RunTextPrinters())
+ {
+ if (++gTasks[taskId].data[10] > 50)
+ {
+ if (!gContestResources->field_4[r6].hasJudgesAttention)
+ {
+ sub_80DC028(
+ gContestResources->field_4[r6].appeal2,
+ gContestResources->field_4[r6].unk17,
+ r6);
+ gContestResources->field_4[r6].appeal2 += gContestResources->field_4[r6].unk17;
+ }
+ gTasks[taskId].data[0] = 16;
+ }
+ }
+ return;
+ case 16:
+ if (!gContestResources->field_14[r6].unk2_2)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 17;
+ }
+ return;
+ case 17:
+ if (gContestResources->field_4[r6].disappointedRepeat)
+ {
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringExpandPlaceholders(gStringVar4, gText_0827E6E3);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[10] = 0;
+ sub_80DD720(0);
+ gTasks[taskId].data[0] = 46;
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 41;
+ }
+ return;
+ case 46:
+ if (!gContestResources->field_0->unk1920A_4)
+ gTasks[taskId].data[0] = 19;
+ return;
+ case 19:
+ if (!Contest_RunTextPrinters())
+ {
+ sub_80DC028(gContestResources->field_4[r6].appeal2, -gContestResources->field_4[r6].unk18, r6);
+ gContestResources->field_4[r6].appeal2 -= gContestResources->field_4[r6].unk18;
+ gTasks[taskId].data[0] = 18;
+ }
+ return;
+ case 18:
+ sub_80DCD48();
+ if (!gContestResources->field_14[r6].unk2_2)
+ {
+ gTasks[taskId].data[10] = 0;
+ sub_80DB89C();
+ gTasks[taskId].data[0] = 41;
+ }
+ return;
+ case 41:
+ if (gContestResources->field_10->excitementFrozen && r6 != gContestResources->field_10->excitementFreezer)
+ {
+ gTasks[taskId].data[0] = 57;
+ }
+ else
+ {
+ r3 = gContestResources->field_10->bits_0;
+ if (gContestResources->field_4[r6].overrideCategoryExcitementMod)
+ {
+ r3 = 1;
+ StringCopy(gStringVar3, gMoveNames[gContestResources->field_4[r6].currMove]);
+ }
+ else
+ {
+ StringCopy(gStringVar3, gUnknown_08587F08[gContestMoves[gContestResources->field_4[r6].currMove].contestCategory]);
+ }
+ if (r3 > 0)
+ {
+ if (gContestResources->field_4[r6].disappointedRepeat)
+ r3 = 0;
+ }
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ gContestResources->field_0->applauseLevel += r3;
+ if (gContestResources->field_0->applauseLevel < 0)
+ gContestResources->field_0->applauseLevel = 0;
+ if (r3 == 0)
+ {
+ gTasks[taskId].data[0] = 55;
+ }
+ else
+ {
+ if (r3 < 0)
+ StringExpandPlaceholders(gStringVar4, gText_0827E73C);
+ else if (r3 > 0 && gContestResources->field_0->applauseLevel <= 4)
+ StringExpandPlaceholders(gStringVar4, gText_0827E717);
+ else
+ StringExpandPlaceholders(gStringVar4, gText_0827E76A);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[11] = 0;
+ if (r3 < 0)
+ gTasks[taskId].data[0] = 53;
+ else
+ gTasks[taskId].data[0] = 54;
+ }
+ }
+ return;
+ case 53:
+ switch (gTasks[taskId].data[10])
+ {
+ case 0:
+ sub_80DDED0(-1, 1);
+ PlayFanfare(MUS_ME_ZANNEN);
+ gTasks[taskId].data[10]++;
+ break;
+ case 1:
+ if (!gContestResources->field_0->unk1920B_0 && !Contest_RunTextPrinters())
+ {
+ sub_80DDCDC(-1);
+ gTasks[taskId].data[10]++;
+ }
+ break;
+ case 2:
+ if (!gContestResources->field_0->unk1920A_5)
+ {
+ if (gTasks[taskId].data[11]++ > 29)
+ {
+ gTasks[taskId].data[11] = 0;
+ sub_80DDED0(-1, -1);
+ gTasks[taskId].data[10]++;
+ }
+ }
+ break;
+ case 3:
+ if (!gPaletteFade.active)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[11] = 0;
+ gTasks[taskId].data[0] = 43;
+ }
+ break;
+ }
+ return;
+ case 54:
+ switch (gTasks[taskId].data[10])
+ {
+ case 0:
+ if (!Contest_RunTextPrinters())
+ {
+ sub_80DDED0(1, 1);
+ gTasks[taskId].data[10]++;
+ }
+ break;
+ case 1:
+ if (!gContestResources->field_0->unk1920B_0)
+ {
+ sub_80DDE0C();
+ PlaySE(SE_W227B);
+ sub_80DDCDC(1);
+ gTasks[taskId].data[10]++;
+ }
+ break;
+ case 2:
+ if (!gContestResources->field_0->unk1920A_5)
+ {
+ if (gTasks[taskId].data[11]++ > 29)
+ {
+ gTasks[taskId].data[11] = 0;
+ sub_80DC028(gContestResources->field_4[r6].appeal2, gContestResources->field_10->unk2, r6);
+ gContestResources->field_4[r6].appeal2 += gContestResources->field_10->unk2;
+ gTasks[taskId].data[10]++;
+ }
+ }
+ break;
+ case 3:
+ if (!gContestResources->field_14[r6].unk2_2)
+ {
+ if (!gContestResources->field_0->unk1920A_7)
+ {
+ sub_80DDED0(1, -1);
+ gTasks[taskId].data[10]++;
+ }
+ }
+ break;
+ case 4:
+ if (!gPaletteFade.active)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[11] = 0;
+ gTasks[taskId].data[0] = 43;
+ }
+ break;
+ }
+ return;
+ case 43:
+ if (!gContestResources->field_14[r6].unk2_2)
+ {
+ sub_80DB89C();
+ gTasks[taskId].data[0] = 55;
+ }
+ return;
+ case 57:
+ sub_80DB89C();
+ StringCopy(gStringVar3, gContestMons[gContestResources->field_10->excitementFreezer].nickname);
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringCopy(gStringVar2, gMoveNames[gContestResources->field_4[r6].currMove]);
+ StringExpandPlaceholders(gStringVar4, gText_0827E7EA);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0] = 58;
+ return;
+ case 58:
+ if (!Contest_RunTextPrinters())
+ {
+ sub_80DB89C();
+ StringExpandPlaceholders(gStringVar4, gText_0827E817);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0] = 59;
+ }
+ return;
+ case 59:
+ if (!Contest_RunTextPrinters())
+ {
+ sub_80DB89C();
+ gTasks[taskId].data[0] = 55;
+ }
+ return;
+ case 33:
+ if (gContestResources->field_4[r6].hasJudgesAttention)
+ gContestResources->field_4[r6].hasJudgesAttention = 0;
+ sub_80DC9B4(r6);
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringCopy(gStringVar2, gMoveNames[gContestResources->field_4[r6].currMove]);
+ StringExpandPlaceholders(gStringVar4, gText_0827E58A);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0] = 34;
+ return;
+ case 34:
+ if (!Contest_RunTextPrinters())
+ gTasks[taskId].data[0] = 55;
+ return;
+ case 55:
+ sub_80DDBE8();
+ gTasks[taskId].data[0] = 56;
+ return;
+ case 56:
+ if (!gContestResources->field_0->unk1920A_6)
+ {
+ if (gContestResources->field_0->applauseLevel > 4)
+ {
+ gContestResources->field_0->applauseLevel = 0;
+ sub_80DD940();
+ }
+ gTasks[taskId].data[0] = 10;
+ }
+ return;
+ case 10:
+ spriteId = gTasks[taskId].data[2];
+ gSprites[spriteId].callback = sub_80DA164;
+ gTasks[taskId].data[0] = 11;
+ return;
+ case 11:
+ spriteId = gTasks[taskId].data[2];
+ if (gSprites[spriteId].invisible)
+ {
+ FreeSpriteOamMatrix(&gSprites[spriteId]);
+ DestroySprite(&gSprites[spriteId]);
+ gTasks[taskId].data[0] = 20;
+ }
+ return;
+ case 20:
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 21;
+ return;
+ case 31:
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[r6].nickname);
+ StringExpandPlaceholders(gStringVar4, gText_0827D56F);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0] = 32;
+ return;
+ case 32:
+ if (!Contest_RunTextPrinters())
+ gTasks[taskId].data[0] = 21;
+ return;
+ case 21:
+ if (++gTasks[taskId].data[10] > 29)
+ {
+ gTasks[taskId].data[10] = 0;
+ gTasks[taskId].data[0] = 22;
+ }
+ return;
+ case 22:
+ if (++gContestResources->field_0->unk19214 == 4)
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_80DA198;
+ }
+ else
+ {
+ gTasks[taskId].data[0] = 0;
+ }
+ return;
+ }
+}
+
+void sub_80DA110(u8 taskId)
+{
+ sContest.unk1920B_2 = 0;
+ DestroyTask(taskId);
+}
+
+void sub_80DA134(struct Sprite *sprite)
+{
+ if (sprite->pos2.x != 0)
+ {
+ sprite->pos2.x -= 2;
+ }
+ else
+ {
+ if (++sprite->data[0] == 31)
+ {
+ sprite->data[0] = 0;
+ sprite->callback = SpriteCallbackDummy;
+ }
+ }
+}
+
+void sub_80DA164(struct Sprite *sprite)
+{
+ sprite->pos2.x -= 6;
+ if (sprite->pos1.x + sprite->pos2.x < -32)
+ {
+ sprite->callback = SpriteCallbackDummy;
+ sprite->invisible = TRUE;
+ }
+}
+
+void sub_80DA198(u8 taskId)
+{
+ switch (gTasks[taskId].data[0])
+ {
+ case 0:
+ if (gIsLinkContest & 1)
+ {
+ u8 taskId2;
+
+ sContest.unk1920B_2 = 1;
+ if (sub_80DA8A4())
+ {
+ sub_80DB944();
+ sub_80DBA18();
+ }
+ taskId2 = CreateTask(sub_80FCC88, 0);
+ SetTaskFuncWithFollowupFunc(taskId2, sub_80FCC88, sub_80DA110);
+ sub_80DBF68();
+ gTasks[taskId].data[0] = 1;
+ }
+ else
+ {
+ sub_80DB944();
+ sub_80DBA18();
+ gTasks[taskId].data[0] = 2;
+ }
+ break;
+ case 1:
+ if (!sContest.unk1920B_2)
+ gTasks[taskId].data[0] = 2;
+ break;
+ case 2:
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80DA25C;
+ break;
+ }
+}
+
+void sub_80DA25C(u8 taskId)
+{
+ sub_80DE008(FALSE);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].func = sub_80DA28C;
+}
+
+void sub_80DA28C(u8 taskId)
+{
+ switch (gTasks[taskId].data[0])
+ {
+ case 0:
+ if (++gTasks[taskId].data[1] > 20)
+ {
+ sub_80DE69C(2);
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].data[0]++;
+ }
+ break;
+ case 1:
+ if (!sContest.unk1920B_1)
+ {
+ if (++gTasks[taskId].data[1] > 20)
+ {
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].data[0]++;
+ }
+ }
+ break;
+ case 2:
+ sub_80DC3AC();
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ gTasks[taskId].func = sub_80DA31C;
+ break;
+ }
+}
+
+void sub_80DA31C(u8 taskId)
+{
+ if (sub_80DC3C4())
+ gTasks[taskId].func = sub_80DA348;
+}
+
+void sub_80DA348(u8 taskId)
+{
+ DmaCopy32Defvars(3, shared18000.unk18204, gPlttBufferUnfaded, 0x400);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 2;
+ gTasks[taskId].func = sub_80DA38C;
+}
+
+void sub_80DA38C(u8 taskId)
+{
+ if (++gTasks[taskId].data[0] > 2)
+ {
+ gTasks[taskId].data[0] = 0;
+ if (--gTasks[taskId].data[1] == 0)
+ gTasks[taskId].func = sub_80DA3CC;
+ }
+}
+
+void sub_80DA3CC(u8 taskId)
+{
+ if (gTasks[taskId].data[0] == 0)
+ {
+ u8 r4 = sContestantStatus[gContestPlayerMonIndex].attentionLevel;
+
+ sub_80DB89C();
+ StringCopy(gStringVar1, gContestMons[gContestPlayerMonIndex].nickname);
+ StringExpandPlaceholders(gStringVar4, gUnknown_08587D90[r4]);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[0]++;
+ }
+ else
+ {
+ if (!Contest_RunTextPrinters())
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80DA464;
+ sub_80DCD48();
+ }
+ }
+}
+
+void sub_80DA464(u8 taskId)
+{
+ if (gTasks[taskId].data[0]++ > 29)
+ {
+ gTasks[taskId].data[0] = 0;
+ sub_80DC3AC();
+ gTasks[taskId].func = sub_80DA49C;
+ }
+}
+
+void sub_80DA49C(u8 taskId)
+{
+ if (sub_80DC3C4())
+ {
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80DA4CC;
+ }
+}
+
+void sub_80DA4CC(u8 taskId)
+{
+ sub_80DE224();
+ gTasks[taskId].func = sub_80DE424;
+}
+
+void sub_80DA4F4(u8 taskId)
+{
+ sub_80DE350();
+ gTasks[taskId].func = sub_80DA51C;
+}
+
+void sub_80DA51C(u8 taskId)
+{
+ vu16 sp0 = GetGpuReg(REG_OFFSET_BG0CNT);
+ vu16 sp2 = GetGpuReg(REG_OFFSET_BG2CNT);
+ ((vBgCnt *)&sp0)->priority = 0;
+ ((vBgCnt *)&sp2)->priority = 0;
+ SetGpuReg(REG_OFFSET_BG0CNT, sp0);
+ SetGpuReg(REG_OFFSET_BG2CNT, sp2);
+ sContest.turnNumber++;
+ if (sContest.turnNumber == 5)
+ {
+ gTasks[taskId].func = sub_80DA5E8;
+ }
+ else
+ {
+ sub_80DDB0C();
+ gTasks[taskId].func = sub_80DA5B4;
+ }
+}
+
+void sub_80DA5B4(u8 taskId)
+{
+ if (!sContest.unk1920A_6)
+ gTasks[taskId].func = sub_80D833C;
+}
+
+void sub_80DA5E8(u8 taskId)
+{
+ s32 i;
+
+ gBattle_BG0_Y = 0;
+ gBattle_BG2_Y = 0;
+ for (i = 0; i < 4; i++)
+ gUnknown_02039F10[i] = sContestantStatus[i].unk4;
+ sub_80DBD18();
+ sub_80DB89C();
+ if (!(gIsLinkContest & 1))
+ BravoTrainerPokemonProfile_BeforeInterview1(sContestantStatus[gContestPlayerMonIndex].prevMove);
+ else
+ {
+ sub_80DF250();
+ sub_80DF4F8();
+ sub_80DF750();
+ }
+ gContestRngValue = gRngValue;
+ StringExpandPlaceholders(gStringVar4, gText_0827D597);
+ Contest_StartTextPrinter(gStringVar4, 1);
+ gTasks[taskId].data[2] = 0;
+ gTasks[taskId].func = sub_80DA6B4;
+}
+
+void sub_80DA6B4(u8 taskId)
+{
+ if (!Contest_RunTextPrinters())
+ {
+ sub_80DE224();
+ gBattle_BG1_X = 0;
+ gBattle_BG1_Y = 160;
+ PlaySE12WithPanning(SE_C_MAKU_D, 0);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].func = sub_80DA700;
+ }
+}
+
+void sub_80DA700(u8 taskId)
+{
+ gBattle_BG1_Y -= 7;
+ if (gBattle_BG1_Y < 0)
+ gBattle_BG1_Y = 0;
+ if (*(u16 *)&gBattle_BG1_Y == 0) // Why cast?
+ {
+ gTasks[taskId].func = sub_80DA740;
+ gTasks[taskId].data[0] = 0;
+ }
+}
+
+void sub_80DA740(u8 taskId)
+{
+ if (gTasks[taskId].data[0]++ >= 50)
+ {
+ gTasks[taskId].data[0] = 0;
+ if (gIsLinkContest & 1)
+ {
+ gTasks[taskId].func = sub_80DA7A0;
+ }
+ else
+ {
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
+ gTasks[taskId].func = sub_80DA830;
+ }
+ }
+}
+
+void sub_80DA7A0(u8 taskId)
+{
+ u8 taskId2 = CreateTask(sub_80FCACC, 0);
+
+ SetTaskFuncWithFollowupFunc(taskId2, sub_80FCACC, sub_80DA7EC);
+ gTasks[taskId].func = TaskDummy1;
+ sub_80DBF68();
+ sub_80DC490(FALSE);
+}
+
+void sub_80DA7EC(u8 taskId)
+{
+ DestroyTask(taskId);
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0);
+ gTasks[sContest.mainTaskId].func = sub_80DA830;
+}
+
+void sub_80DA830(u8 taskId)
+{
+ if (!gPaletteFade.active)
+ {
+ DestroyTask(taskId);
+ gFieldCallback = sub_80DA874;
+ FreeAllWindowBuffers();
+ sub_80D7A5C();
+ FreeMonSpritesGfx();
+ SetMainCallback2(CB2_ReturnToField);
+ }
+}
+
+void sub_80DA874(void)
+{
+ ScriptContext2_Disable();
+ EnableBothScriptContexts();
+}
+
+void sub_80DA884(void)
+{
+ if (!(gIsLinkContest & 1))
+ gContestPlayerMonIndex = 3;
+}
+
+bool8 sub_80DA8A4(void)
+{
+ if (gContestPlayerMonIndex == gUnknown_02039F2B)
+ return TRUE;
+ return FALSE;
+}
+
+
+void sub_80DA8C8(u8 partyIndex)
+{
+ u8 name[20];
+ u16 heldItem;
+ s16 cool;
+ s16 beauty;
+ s16 cute;
+ s16 smart;
+ s16 tough;
+
+ StringCopy(name, gSaveBlock2Ptr->playerName);
+ if (gIsLinkContest & 1)
+ {
+ sub_80DF9D4(name);
+ }
+ memcpy(gContestMons[gContestPlayerMonIndex].trainerName, name, 8);
+ if (gSaveBlock2Ptr->playerGender == MALE)
+ gContestMons[gContestPlayerMonIndex].trainerGfxId = EVENT_OBJ_GFX_LINK_BRENDAN;
+ else
+ gContestMons[gContestPlayerMonIndex].trainerGfxId = EVENT_OBJ_GFX_LINK_MAY;
+ gContestMons[gContestPlayerMonIndex].flags = 0;
+ gContestMons[gContestPlayerMonIndex].unk2C[0] = 0;
+ gContestMons[gContestPlayerMonIndex].species = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SPECIES);
+ GetMonData(&gPlayerParty[partyIndex], MON_DATA_NICKNAME, name);
+ StringGetEnd10(name);
+ if (gIsLinkContest & 1)
+ {
+ sub_80DF9E0(name, GetMonData(&gPlayerParty[partyIndex], MON_DATA_LANGUAGE));
+ }
+ memcpy(gContestMons[gContestPlayerMonIndex].nickname, name, POKEMON_NAME_LENGTH + 1);
+ StringCopy(gContestMons[gContestPlayerMonIndex].nickname, name);
+ gContestMons[gContestPlayerMonIndex].cool = GetMonData(&gPlayerParty[partyIndex], MON_DATA_COOL);
+ gContestMons[gContestPlayerMonIndex].beauty = GetMonData(&gPlayerParty[partyIndex], MON_DATA_BEAUTY);
+ gContestMons[gContestPlayerMonIndex].cute = GetMonData(&gPlayerParty[partyIndex], MON_DATA_CUTE);
+ gContestMons[gContestPlayerMonIndex].smart = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SMART);
+ gContestMons[gContestPlayerMonIndex].tough = GetMonData(&gPlayerParty[partyIndex], MON_DATA_TOUGH);
+ gContestMons[gContestPlayerMonIndex].sheen = GetMonData(&gPlayerParty[partyIndex], MON_DATA_SHEEN);
+ gContestMons[gContestPlayerMonIndex].moves[0] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE1);
+ gContestMons[gContestPlayerMonIndex].moves[1] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE2);
+ gContestMons[gContestPlayerMonIndex].moves[2] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE3);
+ gContestMons[gContestPlayerMonIndex].moves[3] = GetMonData(&gPlayerParty[partyIndex], MON_DATA_MOVE4);
+ gContestMons[gContestPlayerMonIndex].personality = GetMonData(&gPlayerParty[partyIndex], MON_DATA_PERSONALITY);
+ gContestMons[gContestPlayerMonIndex].otId = GetMonData(&gPlayerParty[partyIndex], MON_DATA_OT_ID);
+
+ heldItem = GetMonData(&gPlayerParty[partyIndex], MON_DATA_HELD_ITEM);
+ cool = gContestMons[gContestPlayerMonIndex].cool;
+ beauty = gContestMons[gContestPlayerMonIndex].beauty;
+ cute = gContestMons[gContestPlayerMonIndex].cute;
+ smart = gContestMons[gContestPlayerMonIndex].smart;
+ tough = gContestMons[gContestPlayerMonIndex].tough;
+ if (heldItem == ITEM_RED_SCARF)
+ cool += 20;
+ else if (heldItem == ITEM_BLUE_SCARF)
+ beauty += 20;
+ else if (heldItem == ITEM_PINK_SCARF)
+ cute += 20;
+ else if (heldItem == ITEM_GREEN_SCARF)
+ smart += 20;
+ else if (heldItem == ITEM_YELLOW_SCARF)
+ tough += 20;
+ if (cool > 255)
+ cool = 255;
+ if (beauty > 255)
+ beauty = 255;
+ if (cute > 255)
+ cute = 255;
+ if (smart > 255)
+ smart = 255;
+ if (tough > 255)
+ tough = 255;
+ gContestMons[gContestPlayerMonIndex].cool = cool;
+ gContestMons[gContestPlayerMonIndex].beauty = beauty;
+ gContestMons[gContestPlayerMonIndex].cute = cute;
+ gContestMons[gContestPlayerMonIndex].smart = smart;
+ gContestMons[gContestPlayerMonIndex].tough = tough;
+}
+
+void sub_80DAB8C(u8 contestType, u8 rank)
+{
+ s32 i;
+ u8 opponentsCount = 0;
+ u8 opponents[100];
+ bool8 r7 = FALSE;
+ const u8 * r3;
+
+ sub_80DA884();
+
+ if (FlagGet(FLAG_SYS_GAME_CLEAR) && !(gIsLinkContest & 1))
+ r7 = TRUE;
+
+ // Find all suitable opponents
+ r3 = gUnknown_085898A4;
+ for (i = 0; i < ARRAY_COUNT(gContestOpponents); i++)
+ {
+ if (rank == gContestOpponents[i].whichRank)
+ {
+ if (r7 == TRUE)
+ {
+ if (r3[i] == 1)
+ continue;
+ }
+ else
+ {
+ if (r3[i] == 2)
+ continue;
+ }
+ if (contestType == CONTEST_CATEGORY_COOL && gContestOpponents[i].aiPool_Cool)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_BEAUTY && gContestOpponents[i].aiPool_Beauty)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_CUTE && gContestOpponents[i].aiPool_Cute)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_SMART && gContestOpponents[i].aiPool_Smart)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_TOUGH && gContestOpponents[i].aiPool_Tough)
+ opponents[opponentsCount++] = i;
+ }
+ }
+ opponents[opponentsCount] = 0xFF;
+
+ // Choose three random opponents from the list
+ for (i = 0; i < 3; i++)
+ {
+ u16 rnd = Random() % opponentsCount;
+ s32 j;
+
+ gContestMons[i] = gContestOpponents[opponents[rnd]];
+ for (j = rnd; opponents[j] != 0xFF; j++)
+ opponents[j] = opponents[j + 1];
+ opponentsCount--;
+ }
+
+ sub_80DA8C8(gUnknown_02039F24);
+}
+
+#ifdef NONMATCHING
+void sub_80DACBC(u8 contestType, u8 rank, bool32 isPostgame)
+{
+ s32 i;
+ u8 opponentsCount = 0;
+ u8 opponents[100];
+ const u8 * r6;
+
+ if (gUnknown_02039F30 == 4)
+ return;
+
+ r6 = gUnknown_085898A4;
+ for (i = 0; i < ARRAY_COUNT(gContestOpponents); i++)
+ {
+ if (rank != gContestOpponents[i].whichRank)
+ continue;
+ if (isPostgame == TRUE)
+ {
+ if (r6[i] == 1)
+ continue;
+ }
+ else
+ {
+ if (r6[i] == 2)
+ continue;
+ }
+ if (contestType == CONTEST_CATEGORY_COOL && gContestOpponents[i].aiPool_Cool)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_BEAUTY && gContestOpponents[i].aiPool_Beauty)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_CUTE && gContestOpponents[i].aiPool_Cute)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_SMART && gContestOpponents[i].aiPool_Smart)
+ opponents[opponentsCount++] = i;
+ else if (contestType == CONTEST_CATEGORY_TOUGH && gContestOpponents[i].aiPool_Tough)
+ opponents[opponentsCount++] = i;
+ }
+ opponents[opponentsCount] = 0xFF;
+ for (i = 0; i < 4 - gUnknown_02039F30; i++)
+ {
+ u16 rnd = sub_80F903C() % opponentsCount;
+ s32 j;
+
+ gContestMons[gUnknown_02039F30 + i] = gContestOpponents[opponents[rnd]];
+ sub_80DF9D4(gContestMons[gUnknown_02039F30 + i].trainerName);
+ sub_80DF9E0(gContestMons[gUnknown_02039F30 + i].nickname, GAME_LANGUAGE);
+ for (j = rnd; opponents[j] != 0xFF; j++)
+ opponents[j] = opponents[j + 1];
+ opponentsCount--;
+ }
+}
+#else
+NAKED void sub_80DACBC(u8 contestType, u8 rank, bool32 isPostgame)
+{
+ asm_unified("\tpush {r4-r7,lr}\n"
+ "\tmov r7, r9\n"
+ "\tmov r6, r8\n"
+ "\tpush {r6,r7}\n"
+ "\tsub sp, 0x64\n"
+ "\tmov r8, r2\n"
+ "\tlsls r0, 24\n"
+ "\tlsrs r4, r0, 24\n"
+ "\tlsls r1, 24\n"
+ "\tlsrs r2, r1, 24\n"
+ "\tmovs r7, 0\n"
+ "\tldr r0, =gUnknown_02039F30\n"
+ "\tldrb r1, [r0]\n"
+ "\tmov r9, r0\n"
+ "\tcmp r1, 0x4\n"
+ "\tbne _080DACDE\n"
+ "\tb _080DADF6\n"
+ "_080DACDE:\n"
+ "\tmovs r5, 0\n"
+ "\tldr r3, =gContestOpponents\n"
+ "\tldr r6, =gUnknown_085898A4\n"
+ "_080DACE4:\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 30\n"
+ "\tlsrs r0, 30\n"
+ "\tcmp r2, r0\n"
+ "\tbne _080DAD56\n"
+ "\tmov r0, r8\n"
+ "\tcmp r0, 0x1\n"
+ "\tbne _080DAD08\n"
+ "\tldrb r0, [r6]\n"
+ "\tcmp r0, 0x1\n"
+ "\tbeq _080DAD56\n"
+ "\tb _080DAD0E\n"
+ "\t.pool\n"
+ "_080DAD08:\n"
+ "\tldrb r0, [r6]\n"
+ "\tcmp r0, 0x2\n"
+ "\tbeq _080DAD56\n"
+ "_080DAD0E:\n"
+ "\tcmp r4, 0\n"
+ "\tbne _080DAD1A\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 29\n"
+ "\tcmp r0, 0\n"
+ "\tblt _080DAD4A\n"
+ "_080DAD1A:\n"
+ "\tcmp r4, 0x1\n"
+ "\tbne _080DAD26\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 28\n"
+ "\tcmp r0, 0\n"
+ "\tblt _080DAD4A\n"
+ "_080DAD26:\n"
+ "\tcmp r4, 0x2\n"
+ "\tbne _080DAD32\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 27\n"
+ "\tcmp r0, 0\n"
+ "\tblt _080DAD4A\n"
+ "_080DAD32:\n"
+ "\tcmp r4, 0x3\n"
+ "\tbne _080DAD3E\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 26\n"
+ "\tcmp r0, 0\n"
+ "\tblt _080DAD4A\n"
+ "_080DAD3E:\n"
+ "\tcmp r4, 0x4\n"
+ "\tbne _080DAD56\n"
+ "\tldrb r0, [r3, 0x1C]\n"
+ "\tlsls r0, 25\n"
+ "\tcmp r0, 0\n"
+ "\tbge _080DAD56\n"
+ "_080DAD4A:\n"
+ "\tadds r0, r7, 0\n"
+ "\tadds r1, r0, 0x1\n"
+ "\tlsls r1, 24\n"
+ "\tlsrs r7, r1, 24\n"
+ "\tadd r0, sp\n"
+ "\tstrb r5, [r0]\n"
+ "_080DAD56:\n"
+ "\tadds r3, 0x40\n"
+ "\tadds r6, 0x1\n"
+ "\tadds r5, 0x1\n"
+ "\tcmp r5, 0x5F\n"
+ "\tbls _080DACE4\n"
+ "\tmov r3, sp\n"
+ "\tadds r1, r3, r7\n"
+ "\tmovs r0, 0xFF\n"
+ "\tstrb r0, [r1]\n"
+ "\tmovs r5, 0\n"
+ "\tmov r0, r9\n"
+ "\tldrb r1, [r0]\n"
+ "\tmovs r0, 0x4\n"
+ "\tsubs r0, r1\n"
+ "\tcmp r5, r0\n"
+ "\tbge _080DADF6\n"
+ "\tldr r3, =gContestMons\n"
+ "\tmov r8, r3\n"
+ "\tmov r6, r9\n"
+ "\tmovs r0, 0x2\n"
+ "\tadd r0, r8\n"
+ "\tmov r9, r0\n"
+ "_080DAD82:\n"
+ "\tbl sub_80F903C\n"
+ "\tlsls r0, 16\n"
+ "\tlsrs r0, 16\n"
+ "\tadds r1, r7, 0\n"
+ "\tbl __modsi3\n"
+ "\tadds r1, r0, 0\n"
+ "\tlsls r1, 16\n"
+ "\tlsrs r1, 16\n"
+ "\tldrb r0, [r6]\n"
+ "\tadds r0, r5\n"
+ "\tlsls r0, 6\n"
+ "\tadd r0, r8\n"
+ "\tldr r2, =gContestOpponents\n"
+ "\tmov r3, sp\n"
+ "\tadds r4, r3, r1\n"
+ "\tldrb r1, [r4]\n"
+ "\tlsls r1, 6\n"
+ "\tadds r1, r2\n"
+ "\tmovs r2, 0x40\n"
+ "\tbl memcpy\n"
+ "\tldrb r0, [r6]\n"
+ "\tadds r0, r5\n"
+ "\tlsls r0, 6\n"
+ "\tmov r1, r8\n"
+ "\tadds r1, 0xD\n"
+ "\tadds r0, r1\n"
+ "\tbl sub_80DF9D4\n"
+ "\tldrb r0, [r6]\n"
+ "\tadds r0, r5\n"
+ "\tlsls r0, 6\n"
+ "\tadd r0, r9\n"
+ "\tmovs r1, 0x2\n"
+ "\tbl sub_80DF9E0\n"
+ "\tldrb r0, [r4]\n"
+ "\tadds r3, r5, 0x1\n"
+ "\tsubs r1, r7, 0x1\n"
+ "\tcmp r0, 0xFF\n"
+ "\tbeq _080DADE6\n"
+ "\tadds r2, r4, 0\n"
+ "_080DADDA:\n"
+ "\tldrb r0, [r2, 0x1]\n"
+ "\tstrb r0, [r2]\n"
+ "\tadds r2, 0x1\n"
+ "\tldrb r0, [r2]\n"
+ "\tcmp r0, 0xFF\n"
+ "\tbne _080DADDA\n"
+ "_080DADE6:\n"
+ "\tlsls r0, r1, 24\n"
+ "\tlsrs r7, r0, 24\n"
+ "\tadds r5, r3, 0\n"
+ "\tldrb r1, [r6]\n"
+ "\tmovs r0, 0x4\n"
+ "\tsubs r0, r1\n"
+ "\tcmp r5, r0\n"
+ "\tblt _080DAD82\n"
+ "_080DADF6:\n"
+ "\tadd sp, 0x64\n"
+ "\tpop {r3,r4}\n"
+ "\tmov r8, r3\n"
+ "\tmov r9, r4\n"
+ "\tpop {r4-r7}\n"
+ "\tpop {r0}\n"
+ "\tbx r0\n"
+ "\t.pool");
+}
+#endif
+
+// GetContestAvailability?
+u8 sub_80DAE0C(struct Pokemon *pkmn)
+{
+ u8 ribbon;
+ u8 retVal;
+
+ if (GetMonData(pkmn, MON_DATA_IS_EGG))
+ return 3;
+ if (GetMonData(pkmn, MON_DATA_HP) == 0)
+ return 4;
+ switch (gSpecialVar_ContestCategory)
+ {
+ case CONTEST_CATEGORY_COOL:
+ ribbon = GetMonData(pkmn, MON_DATA_COOL_RIBBON);
+ break;
+ case CONTEST_CATEGORY_BEAUTY:
+ ribbon = GetMonData(pkmn, MON_DATA_BEAUTY_RIBBON);
+ break;
+ case CONTEST_CATEGORY_CUTE:
+ ribbon = GetMonData(pkmn, MON_DATA_CUTE_RIBBON);
+ break;
+ case CONTEST_CATEGORY_SMART:
+ ribbon = GetMonData(pkmn, MON_DATA_SMART_RIBBON);
+ break;
+ case CONTEST_CATEGORY_TOUGH:
+ ribbon = GetMonData(pkmn, MON_DATA_TOUGH_RIBBON);
+ break;
+ default:
+ return 0;
+ }
+
+ // Couldn't get this to match any other way.
+ // Returns 2, 1, or 0 respectively if ribbon's rank is above, equal, or below
+ // the current contest rank.
+ if (ribbon > gSpecialVar_ContestRank)
+ retVal = 2;
+ else if (ribbon >= gSpecialVar_ContestRank)
+ retVal = 1;
+ else
+ retVal = 0;
+ return retVal;
+}
+
+void sub_80DAEA4(void)
+{
+ s32 i;
+
+ for (i = 0; i < 4; i++)
+ {
+ FillWindowPixelBuffer(gUnknown_02039F26[i], 0);
+ sub_80DAF04(i);
+ sub_80DAF88(i);
+ }
+}
+
+u8 * sub_80DAED4(const u8 * src, u8 color)
+{
+ u8 * ptr = StringCopy(gDisplayedStringBattle, gText_ColorTransparent);
+ ptr[-1] = color;
+ ptr = StringCopy(ptr, src);
+
+ return ptr;
+}
+
+void sub_80DAF04(u8 a0)
+{
+ sub_80DAF1C(a0, a0 + 10);
+}
+
+void sub_80DAF1C(u8 a0, u8 a1)
+{
+ u8 buffer[32];
+ s32 offset;
+
+ StringCopy(buffer, gText_Slash);
+ StringAppend(buffer, gContestMons[a0].trainerName);
+ sub_80DAED4(buffer, a1);
+ offset = GetStringRightAlignXOffset(7, gDisplayedStringBattle, 0x60);
+ if (offset > 55)
+ offset = 55;
+ Contest_PrintTextToBg0WindowAt(gUnknown_02039F26[a0], gDisplayedStringBattle, offset, 1, 7);
+}
+
+void sub_80DAF88(u8 a0)
+{
+ sub_80DAFA0(a0, a0 + 10);
+}
+
+void sub_80DAFA0(u8 a0, u8 a1)
+{
+ sub_80DAED4(gContestMons[a0].nickname, a1);
+ Contest_PrintTextToBg0WindowAt(gUnknown_02039F26[a0], gDisplayedStringBattle, 5, 1, 7);
+}
+
+u16 sub_80DAFE0(u8 who, u8 contestCategory)
+{
+ u8 statMain;
+ u8 statSub1;
+ u8 statSub2;
+
+ switch (contestCategory)
+ {
+ case CONTEST_CATEGORY_COOL:
+ statMain = gContestMons[who].cool;
+ statSub1 = gContestMons[who].tough;
+ statSub2 = gContestMons[who].beauty;
+ break;
+ case CONTEST_CATEGORY_BEAUTY:
+ statMain = gContestMons[who].beauty;
+ statSub1 = gContestMons[who].cool;
+ statSub2 = gContestMons[who].cute;
+ break;
+ case CONTEST_CATEGORY_CUTE:
+ statMain = gContestMons[who].cute;
+ statSub1 = gContestMons[who].beauty;
+ statSub2 = gContestMons[who].smart;
+ break;
+ case CONTEST_CATEGORY_SMART:
+ statMain = gContestMons[who].smart;
+ statSub1 = gContestMons[who].cute;
+ statSub2 = gContestMons[who].tough;
+ break;
+ case CONTEST_CATEGORY_TOUGH:
+ default:
+ statMain = gContestMons[who].tough;
+ statSub1 = gContestMons[who].smart;
+ statSub2 = gContestMons[who].cool;
+ break;
+ }
+ return statMain + (statSub1 + statSub2 + gContestMons[who].sheen) / 2;
+}
+
+void sub_80DB09C(u8 a0)
+{
+ s32 i;
+
+ for (i = 0; i < 4; i++)
+ gContestMonConditions[i] = sub_80DAFE0(i, a0);
+}
+
+u8 sub_80DB0C4(void)
+{
+ u8 spriteId;
+
+ LoadCompressedObjectPic(&gUnknown_08587C00);
+ LoadCompressedPalette(gContest2Pal, 0x110, 32);
+ spriteId = CreateSprite(&gSpriteTemplate_8587BE8, 112, 36, 30);
+ gSprites[spriteId].oam.paletteNum = 1;
+ gSprites[spriteId].callback = SpriteCallbackDummy;
+ return spriteId;
+}
+
+u8 sub_80DB120(void)
+{
+ u8 spriteId;
+
+ LoadCompressedObjectPic(&gUnknown_08587C08);
+ LoadCompressedObjectPalette(&gUnknown_08587C10);
+ spriteId = CreateSprite(&gSpriteTemplate_8587C18, 96, 10, 29);
+ gSprites[spriteId].invisible = TRUE;
+ gSprites[spriteId].data[0] = gSprites[spriteId].oam.tileNum;
+ return spriteId;
+}
+
+u8 sub_80DB174(u16 species, u32 otId, u32 personality, u32 index)
+{
+ u8 spriteId;
+ species = sub_80DE84C(species);
+
+ if (index == gContestPlayerMonIndex)
+ HandleLoadSpecialPokePic_2(gMonBackPicTable + species, gMonSpritesGfxPtr->sprites[0], species, personality);
+ else
+ HandleLoadSpecialPokePic_DontHandleDeoxys(gMonBackPicTable + species, gMonSpritesGfxPtr->sprites[0], species, personality);
+
+ LoadCompressedPalette(GetFrontSpritePalFromSpeciesAndPersonality(species, otId, personality), 0x120, 0x20);
+ SetMultiuseSpriteTemplateToPokemon(species, 0);
+
+ spriteId = CreateSprite(&gMultiuseSpriteTemplate, 0x70, sub_80A600C(2, species, 0), 30);
+ gSprites[spriteId].oam.paletteNum = 2;
+ gSprites[spriteId].oam.priority = 2;
+ gSprites[spriteId].subpriority = sub_80A82E4(2);
+ gSprites[spriteId].callback = SpriteCallbackDummy;
+ gSprites[spriteId].data[0] = gSprites[spriteId].oam.paletteNum;
+ gSprites[spriteId].data[2] = species;
+ if (IsSpeciesNotUnown(species))
+ gSprites[spriteId].affineAnims = gUnknown_082FF6C0;
+ else
+ gSprites[spriteId].affineAnims = gUnknown_082FF694;
+ StartSpriteAffineAnim(gSprites + spriteId, 0);
+
+ return spriteId;
+}
+
+bool8 IsSpeciesNotUnown(u16 species)
+{
+ if (species == SPECIES_UNOWN)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+void sub_80DB2BC(void)
+{
+ CpuCopy16(gContestResources->field_24[0], gContestResources->field_24[0] + 0x500, 0x280);
+ CpuCopy16(gContestResources->field_24[2], gContestResources->field_24[2] + 0x500, 0x280);
+}
+
+u16 sub_80DB2EC(u16 a0, u8 a1)
+{
+ u16 var;
+
+ switch (gContestEffects[gContestMoves[a0].effect].effectType)
+ {
+ case 0:
+ case 1:
+ case 8:
+ var = 0x9082;
+ break;
+ case 2:
+ case 3:
+ var = 0x9088;
+ break;
+ default:
+ var = 0x9086;
+ break;
+ }
+ var += 0x9000 + (a1 << 12);
+ return var;
+}
+
+void prints_contest_move_description(u16 a)
+{
+ u8 category;
+ u16 categoryTile;
+ u8 numHearts;
+
+ category = gContestMoves[a].contestCategory;
+ if (category == CONTEST_CATEGORY_COOL)
+ categoryTile = 0x4040;
+ else if (category == CONTEST_CATEGORY_BEAUTY)
+ categoryTile = 0x4045;
+ else if (category == CONTEST_CATEGORY_CUTE)
+ categoryTile = 0x404A;
+ else if (category == CONTEST_CATEGORY_SMART)
+ categoryTile = 0x406A;
+ else
+ categoryTile = 0x408A;
+
+ ContestBG_FillBoxWithIncrementingTile(0, categoryTile, 0x0b, 0x1f, 0x05, 0x01, 0x11, 0x01);
+ ContestBG_FillBoxWithIncrementingTile(0, categoryTile + 0x10, 0x0b, 0x20, 0x05, 0x01, 0x11, 0x01);
+
+ if (gContestEffects[gContestMoves[a].effect].appeal == 0xFF)
+ numHearts = 0;
+ else
+ numHearts = gContestEffects[gContestMoves[a].effect].appeal / 10;
+ if (numHearts > 8)
+ numHearts = 8;
+ ContestBG_FillBoxWithTile(0, 0x5035, 0x15, 0x1f, 0x08, 0x01, 0x11);
+ ContestBG_FillBoxWithTile(0, 0x5012, 0x15, 0x1f, numHearts, 0x01, 0x11);
+
+ if (gContestEffects[gContestMoves[a].effect].jam == 0xFF)
+ numHearts = 0;
+ else
+ numHearts = gContestEffects[gContestMoves[a].effect].jam / 10;
+ if (numHearts > 8)
+ numHearts = 8;
+ ContestBG_FillBoxWithTile(0, 0x5036, 0x15, 0x20, 0x08, 0x01, 0x11);
+ ContestBG_FillBoxWithTile(0, 0x5014, 0x15, 0x20, numHearts, 0x01, 0x11);
+
+ FillWindowPixelBuffer(10, 0);
+ Contest_PrintTextToBg0WindowStd(10, gContestEffectDescriptionPointers[gContestMoves[a].effect]);
+ Contest_PrintTextToBg0WindowStd(9, gText_Slash);
+}
+
+void sub_80DB4E0(u16 move, u8 b)
+{
+ u8 r7 = gUnknown_02039F26[b] * 5 + 2;
+
+ if (!sub_80DBCA8(b) && move != MOVE_NONE)
+ {
+ u16 tile = sub_80DB2EC(move, b);
+
+ ContestBG_FillBoxWithIncrementingTile(0, tile, 20, r7, 2, 1, 17, 1);
+ ContestBG_FillBoxWithIncrementingTile(0, tile + 16, 20, r7 + 1, 2, 1, 17, 1);
+ }
+ else
+ {
+ ContestBG_FillBoxWithTile(0, 0, 20, r7, 2, 2, 17);
+ }
+}
+
+void sub_80DB584(void)
+{
+ s32 i;
+
+ for (i = 0; i < 4; i++)
+ sub_80DB4E0(gContestResources->field_4[i].currMove, i);
+}
+
+u16 sub_80DB5B0(void)
+{
+ return 0x2034;
+}
+
+bool8 sub_80DB5B8(u8 contestantIdx, bool8 resetMod)
+{
+ u8 r6;
+ s32 r4;
+
+ if (sContestantStatus[contestantIdx].conditionMod == 0)
+ return FALSE;
+ r6 = gUnknown_02039F26[contestantIdx] * 5 + 2;
+ r4 = sContestantStatus[contestantIdx].condition / 10;
+ if (sContestantStatus[contestantIdx].conditionMod == 1)
+ {
+ ContestBG_FillBoxWithTile(0, sub_80DB5B0(), 19, r6, 1, r4, 17);
+ if (resetMod)
+ {
+ PlaySE(SE_EXPMAX);
+ sContestantStatus[contestantIdx].conditionMod = 0;
+ }
+ }
+ else
+ {
+ ContestBG_FillBoxWithTile(0, 0, 19, r6 + r4, 1, 3 - r4, 17);
+ if (resetMod)
+ {
+ PlaySE(SE_FU_ZAKU2);
+ sContestantStatus[contestantIdx].conditionMod = 0;
+ }
+ }
+ return TRUE;
+}
+
+void sub_80DB69C(void)
+{
+ s32 i;
+ s32 r6;
+
+ for (i = 0; i < 4; i++)
+ {
+ u8 r4 = gUnknown_02039F26[i] * 5 + 2;
+ u16 r5 = sub_80DB5B0();
+
+ r6 = sContestantStatus[i].condition / 10;
+ ContestBG_FillBoxWithTile(0, r5, 19, r4, 1, r6, 17);
+ ContestBG_FillBoxWithTile(0, 0, 19, r4 + r6, 1, 3 - r6, 17);
+ }
+}
+
+u16 sub_80DB748(u8 status)
+{
+ u16 var = 0;
+
+ switch (status)
+ {
+ case 0:
+ var = 0x80;
+ break;
+ case 1:
+ var = 0x84;
+ break;
+ case 2:
+ var = 0x86;
+ break;
+ case 3:
+ var = 0x88;
+ break;
+ case 4:
+ var = 0x82;
+ break;
+ }
+ var += 0x9000;
+ return var;
+}
+
+bool8 sub_80DB798(u8 a)
+{
+ bool8 r9 = TRUE;
+ u16 r8 = 0;
+ u8 r7 = gUnknown_02039F26[a] * 5 + 2;
+
+ if (sContestantStatus[a].resistant != 0 || sContestantStatus[a].immune != 0 || sContestantStatus[a].jamSafetyCount != 0 || sContestantStatus[a].jamReduction != 0)
+ r8 = sub_80DB748(0);
+ else if (sContestantStatus[a].nervous)
+ r8 = sub_80DB748(1);
+ else if (sContestantStatus[a].numTurnsSkipped != 0 || sContestantStatus[a].noMoreTurns)
+ r8 = sub_80DB748(2);
+ else
+ r9 = FALSE;
+ if (r9)
+ {
+ ContestBG_FillBoxWithIncrementingTile(0, r8, 20, r7, 2, 1, 17, 1);
+ ContestBG_FillBoxWithIncrementingTile(0, r8 + 16, 20, r7 + 1, 2, 1, 17, 1);
+ }
+ else
+ {
+ ContestBG_FillBoxWithTile(0, 0, 20, r7, 2, 2, 17);
+ }
+ return r9;
+}
diff --git a/src/easy_chat.c b/src/easy_chat.c
new file mode 100644
index 000000000..fbf4c0e70
--- /dev/null
+++ b/src/easy_chat.c
@@ -0,0 +1,807 @@
+
+// Includes
+#include "global.h"
+#include "malloc.h"
+#include "constants/songs.h"
+#include "sound.h"
+#include "overworld.h"
+#include "task.h"
+#include "main.h"
+#include "link.h"
+#include "field_weather.h"
+#include "window.h"
+#include "palette.h"
+#include "event_data.h"
+#include "easy_chat.h"
+
+// Static type declarations
+
+#define EZCHAT_TASK_STATE 0
+#define EZCHAT_TASK_KIND 1
+#define EZCHAT_TASK_WORDS 2
+#define EZCHAT_TASK_MAINCALLBACK 4
+#define EZCHAT_TASK_UNK06 6
+#define EZCHAT_TASK_SIZE 7
+
+// Static RAM declarations
+
+EWRAM_DATA struct
+{
+ u8 kind;
+ u8 unk_01;
+ u8 unk_02;
+ u8 unk_03;
+ u8 unk_04;
+ s8 unk_05;
+ s8 unk_06;
+ u8 unk_07;
+ u8 unk_08;
+ u8 unk_09;
+ u8 unk_0a;
+ u8 unk_0b;
+ u8 unk_0c;
+ u8 unk_0d;
+ u8 unk_0e[0x4];
+ u8 sizeParam;
+ u8 unk_13;
+ u8 unk_14[0x20];
+ const u8 *src;
+ const u16 *words;
+ u16 ecWordBuffer[9];
+} *gUnknown_0203A118 = NULL;
+
+// Static ROM declarations
+
+static void sub_811A2C0(u8);
+static void sub_811A278(void);
+static bool8 sub_811A428(u8);
+static void sub_811A2FC(u8);
+static void sub_811A4D0(MainCallback);
+static bool32 sub_811A88C(u16);
+static void sub_811A8A4(u16);
+void sub_811A8F0(void);
+static bool8 EasyChat_AllocateResources(u8, u16 *, u8);
+static void EasyChat_FreeResources(void);
+static u16 sub_811AAAC(void);
+static u16 sub_811AB68(void);
+u16 sub_811ACDC(void);
+u16 sub_811AE44(void);
+u16 sub_811AF00(void);
+u16 sub_811AF8C(void);
+u16 sub_811AFEC(void);
+u16 sub_811B040(void);
+u16 sub_811B08C(void);
+u16 sub_811B0BC(void);
+u16 sub_811B0E8(void);
+u16 sub_811B0F8(void);
+u16 sub_811B150(void);
+u16 sub_811B1B4(void);
+u8 sub_811BA68(void);
+u8 sub_811BCC8(u8);
+void sub_811BDF0(u8 *);
+void sub_811BF78(void);
+bool8 sub_811BF8C(void);
+bool8 sub_811BFA4(void);
+void sub_811C13C(void);
+/*static*/ void sub_811C158(u16);
+/*static*/ bool8 sub_811C170(void);
+bool8 sub_811F28C(void);
+void sub_811F2B8(void);
+u8 sub_811F3AC(void);
+
+// .rodata
+
+extern const struct {
+ u16 word;
+ MainCallback callback;
+} gUnknown_08597530[4];
+extern const struct {
+ u8 unk_00;
+ u8 unk_01;
+ u8 unk_02;
+ u8 unk_03;
+ u8 *data;
+ u8 filler_08[16];
+} gUnknown_08597550[];
+
+// .text
+
+void sub_811A20C(u8 kind, u16 *words, MainCallback callback, u8 sizeParam)
+{
+ u8 taskId;
+
+ ResetTasks();
+ taskId = CreateTask(sub_811A2C0, 0);
+ gTasks[taskId].data[EZCHAT_TASK_KIND] = kind;
+ gTasks[taskId].data[EZCHAT_TASK_SIZE] = sizeParam;
+ SetWordTaskArg(taskId, EZCHAT_TASK_WORDS, (u32)words);
+ SetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK, (u32)callback);
+ SetMainCallback2(sub_811A278);
+}
+
+static void sub_811A278(void)
+{
+ RunTasks();
+ AnimateSprites();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+}
+
+static void sub_811A290(void)
+{
+ TransferPlttBuffer();
+ LoadOam();
+ ProcessSpriteCopyRequests();
+}
+
+static void sub_811A2A4(u8 taskId, TaskFunc taskFunc)
+{
+ gTasks[taskId].func = taskFunc;
+ gTasks[taskId].data[EZCHAT_TASK_STATE] = 0;
+}
+
+static void sub_811A2C0(u8 taskId)
+{
+ if (!is_c1_link_related_active())
+ {
+ while (sub_811A428(taskId));
+ }
+ else
+ {
+ if (sub_811A428(taskId) == TRUE)
+ {
+ return;
+ }
+ }
+ sub_811A2A4(taskId, sub_811A2FC);
+}
+
+static void sub_811A2FC(u8 taskId)
+{
+ u16 v0;
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ switch (data[EZCHAT_TASK_STATE])
+ {
+ case 0:
+ SetVBlankCallback(sub_811A290);
+ BlendPalettes(0xFFFFFFFF, 16, 0);
+ BeginNormalPaletteFade(-1, -1, 16, 0, 0);
+ data[EZCHAT_TASK_STATE] = 5;
+ break;
+ case 1:
+ v0 = sub_811AAAC();
+ if (sub_811A88C(v0))
+ {
+ BeginNormalPaletteFade(-1, -2, 0, 16, 0);
+ data[EZCHAT_TASK_STATE] = 3;
+ data[EZCHAT_TASK_UNK06] = v0;
+ }
+ else if (v0 == 0x18)
+ {
+ BeginNormalPaletteFade(-1, -1, 0, 16, 0);
+ data[EZCHAT_TASK_STATE] = 4;
+ }
+ else if (v0 != 0)
+ {
+ PlaySE(SE_SELECT);
+ sub_811C158(v0);
+ data[EZCHAT_TASK_STATE] ++;
+ }
+ break;
+ case 2:
+ if (!sub_811C170())
+ {
+ data[EZCHAT_TASK_STATE] = 1;
+ }
+ break;
+ case 3:
+ if (!gPaletteFade.active)
+ {
+ sub_811A8A4(data[EZCHAT_TASK_UNK06]);
+ }
+ break;
+ case 4:
+ if (!gPaletteFade.active)
+ {
+ sub_811A4D0((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+ }
+ break;
+ case 5:
+ if (!gPaletteFade.active)
+ {
+ data[EZCHAT_TASK_STATE] = 1;
+ }
+ break;
+ }
+}
+
+static bool8 sub_811A428(u8 taskId)
+{
+ s16 *data;
+
+ data = gTasks[taskId].data;
+ switch (data[EZCHAT_TASK_STATE])
+ {
+ case 0:
+ SetVBlankCallback(NULL);
+ ResetSpriteData();
+ FreeAllSpritePalettes();
+ ResetPaletteFade();
+ break;
+ case 1:
+ if (!sub_811F28C())
+ {
+ sub_811A4D0((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+ }
+ break;
+ case 2:
+ if (!EasyChat_AllocateResources(data[EZCHAT_TASK_KIND], (u16 *)GetWordTaskArg(taskId, EZCHAT_TASK_WORDS), data[EZCHAT_TASK_SIZE]))
+ {
+ sub_811A4D0((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+ }
+ break;
+ case 3:
+ if (!sub_811BF8C())
+ {
+ sub_811A4D0((MainCallback)GetWordTaskArg(taskId, EZCHAT_TASK_MAINCALLBACK));
+ }
+ break;
+ case 4:
+ if (sub_811BFA4())
+ {
+ return TRUE;
+ }
+ break;
+ default:
+ return FALSE;
+ }
+ data[EZCHAT_TASK_STATE] ++;
+ return TRUE;
+}
+
+static void sub_811A4D0(MainCallback callback)
+{
+ sub_811C13C();
+ EasyChat_FreeResources();
+ sub_811F2B8();
+ FreeAllWindowBuffers();
+ SetMainCallback2(callback);
+}
+
+void easy_chat_input_maybe(void)
+{
+ int i;
+ u16 *words;
+ struct MauvilleManBard *bard;
+ u8 sizeParam = 3;
+ switch (gSpecialVar_0x8004)
+ {
+ case 0:
+ words = gSaveBlock1Ptr->unk2BB0;
+ break;
+ case 1:
+ words = gSaveBlock1Ptr->unk2BBC;
+ break;
+ case 2:
+ words = gSaveBlock1Ptr->unk2BC8;
+ break;
+ case 3:
+ words = gSaveBlock1Ptr->unk2BD4;
+ break;
+ case 4:
+ words = gSaveBlock1Ptr->mail[gSpecialVar_0x8005].words;
+ break;
+ case 6:
+ bard = &gSaveBlock1Ptr->oldMan.bard;
+ for (i = 0; i < 6; i ++)
+ {
+ bard->temporaryLyrics[i] = bard->songLyrics[i];
+ }
+ words = bard->temporaryLyrics;
+ break;
+ case 5:
+ words = gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].bravoTrainer.words;
+ sizeParam = gSpecialVar_0x8006;
+ break;
+ case 7:
+ words = &gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].fanclubOpinions.words[gSpecialVar_0x8006];
+ sizeParam = 1;
+ break;
+ case 8:
+ words = gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].unkShow04.words;
+ sizeParam = 0;
+ break;
+ case 9:
+ words = (u16 *)gStringVar3;
+ words[0] = gSaveBlock1Ptr->easyChatPairs[0].words[0];
+ words[1] = gSaveBlock1Ptr->easyChatPairs[0].words[1];
+ break;
+ case 10:
+ words = gSaveBlock1Ptr->gabbyAndTyData.quote;
+ *words = -1;
+ sizeParam = 1;
+ break;
+ case 11:
+ words = &gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].bravoTrainer.words[gSpecialVar_0x8006];
+ sizeParam = 0;
+ break;
+ case 12:
+ words = gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].fanclubOpinions.words18;
+ sizeParam = 1;
+ break;
+ case 13:
+ words = (u16 *)gStringVar3;
+ InitializeEasyChatWordArray(words, 2);
+ break;
+ case 14:
+ words = gSaveBlock1Ptr->tvShows[gSpecialVar_0x8005].fanClubSpecial.words;
+ words[0] = -1;
+ sizeParam = 2;
+ break;
+ case 15:
+ words = &gSaveBlock1Ptr->lilycoveLady.quiz.unk_016;
+ break;
+ case 16:
+ return;
+ case 17:
+ words = gSaveBlock1Ptr->lilycoveLady.quiz.unk_002;
+ break;
+ case 18:
+ words = &gSaveBlock1Ptr->lilycoveLady.quiz.unk_014;
+ break;
+ case 19:
+ words = (u16 *)&gSaveBlock2Ptr->field_DC[0].field_0[0x28];
+ break;
+ case 20:
+ words = sub_801B058();
+ break;
+ default:
+ return;
+ }
+ overworld_free_bg_tilemaps();
+ sub_811A20C(gSpecialVar_0x8004, words, CB2_ReturnToFieldContinueScript, sizeParam);
+}
+
+static void sub_811A7E4(void)
+{
+ LilycoveLady *lilycoveLady;
+
+ UpdatePaletteFade();
+ switch (gMain.state)
+ {
+ case 0:
+ FadeScreen(1, 0);
+ break;
+ case 1:
+ if (!gPaletteFade.active)
+ {
+ lilycoveLady = &gSaveBlock1Ptr->lilycoveLady;
+ lilycoveLady->quiz.unk_016 = -1;
+ overworld_free_bg_tilemaps();
+ sub_811A8F0();
+ }
+ return;
+ }
+ gMain.state ++;
+}
+
+void sub_811A858(void)
+{
+ SetMainCallback2(sub_811A7E4);
+}
+
+static int sub_811A868(u16 word)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_COUNT(gUnknown_08597530); i ++)
+ {
+ if (word == gUnknown_08597530[i].word)
+ return i;
+ }
+ return -1;
+}
+
+static bool32 sub_811A88C(u16 word)
+{
+ return sub_811A868(word) == -1 ? FALSE : TRUE;
+}
+
+static void sub_811A8A4(u16 word)
+{
+ int i;
+
+ i = sub_811A868(word);
+ ResetTasks();
+ sub_811A4D0(gUnknown_08597530[i].callback);
+}
+
+void sub_811A8CC(void)
+{
+ sub_811A20C(0xF, &gSaveBlock1Ptr->lilycoveLady.quiz.unk_016, CB2_ReturnToFieldContinueScript, 3);
+}
+
+void sub_811A8F0(void)
+{
+ sub_811A20C(0x10, gSaveBlock1Ptr->lilycoveLady.quiz.unk_002, CB2_ReturnToFieldContinueScript, 3);
+}
+
+void sub_811A914(void)
+{
+ sub_811A20C(0x12, &gSaveBlock1Ptr->lilycoveLady.quiz.unk_014, CB2_ReturnToFieldContinueScript, 3);
+}
+
+void sub_811A938(void)
+{
+ sub_811A20C(0x11, gSaveBlock1Ptr->lilycoveLady.quiz.unk_002, CB2_ReturnToFieldContinueScript, 3);
+}
+
+static bool8 EasyChat_AllocateResources(u8 kind, u16 *words, u8 sizeParam)
+{
+ u8 r6;
+ int i;
+
+ gUnknown_0203A118 = malloc(sizeof(*gUnknown_0203A118));
+ if (gUnknown_0203A118 == NULL)
+ {
+ return FALSE;
+ }
+ gUnknown_0203A118->kind = kind;
+ gUnknown_0203A118->words = words;
+ gUnknown_0203A118->unk_05 = 0;
+ gUnknown_0203A118->unk_06 = 0;
+ gUnknown_0203A118->unk_09 = 0;
+ gUnknown_0203A118->sizeParam = sizeParam;
+ gUnknown_0203A118->unk_13 = 0;
+ r6 = sub_811BCC8(kind);
+ if (kind == 0x10)
+ {
+ sub_811BDF0(gUnknown_0203A118->unk_14);
+ gUnknown_0203A118->src = gUnknown_0203A118->unk_14;
+ gUnknown_0203A118->unk_04 = 7;
+ }
+ else
+ {
+ gUnknown_0203A118->unk_04 = 0;
+ gUnknown_0203A118->src = gUnknown_08597550[r6].data;
+ }
+ gUnknown_0203A118->unk_02 = gUnknown_08597550[r6].unk_01;
+ gUnknown_0203A118->unk_03 = gUnknown_08597550[r6].unk_02;
+ gUnknown_0203A118->unk_07 = gUnknown_0203A118->unk_02 * gUnknown_0203A118->unk_03;
+ gUnknown_0203A118->unk_01 = r6;
+ if (gUnknown_0203A118->unk_07 > 9)
+ {
+ gUnknown_0203A118->unk_07 = 9;
+ }
+ if (words != NULL)
+ {
+ CpuCopy16(words, gUnknown_0203A118->ecWordBuffer, gUnknown_0203A118->unk_07 * sizeof(u16));
+ }
+ else
+ {
+ for (i = 0; i < gUnknown_0203A118->unk_07; i ++)
+ {
+ gUnknown_0203A118->ecWordBuffer[i] = -1;
+ }
+ gUnknown_0203A118->words = gUnknown_0203A118->ecWordBuffer;
+ }
+ gUnknown_0203A118->unk_0d = (sub_811F3AC() - 1) / 2 + 1;
+ return TRUE;
+}
+
+static void EasyChat_FreeResources(void)
+{
+ if (gUnknown_0203A118 != NULL)
+ FREE_AND_SET_NULL(gUnknown_0203A118);
+}
+
+static u16 sub_811AAAC(void)
+{
+ switch (gUnknown_0203A118->unk_04)
+ {
+ case 0:
+ return sub_811AB68();
+ case 1:
+ return sub_811ACDC();
+ case 2:
+ return sub_811AE44();
+ case 3:
+ return sub_811AF00();
+ case 4:
+ return sub_811AF8C();
+ case 5:
+ return sub_811B040();
+ case 6:
+ return sub_811AFEC();
+ case 7:
+ return sub_811B08C();
+ case 8:
+ return sub_811B0BC();
+ case 9:
+ return sub_811B0E8();
+ case 10:
+ return sub_811B0F8();
+ }
+ return 0;
+}
+
+bool32 sub_811AB44(void)
+{
+ switch (sub_811BA68())
+ {
+ case 2:
+ case 7:
+ case 8:
+ return TRUE;
+ }
+ return FALSE;
+}
+
+#ifdef NONMATCHING
+static u16 sub_811AB68(void)
+{
+ if (gMain.newKeys & A_BUTTON)
+ {
+ sub_811BF78();
+ gUnknown_0203A118->unk_04 = 2;
+ gUnknown_0203A118->unk_0a = 0;
+ gUnknown_0203A118->unk_0b = 0;
+ gUnknown_0203A118->unk_0c = 0;
+ return 9;
+ }
+ else if (gMain.newKeys & B_BUTTON)
+ { // FIXME: See note below
+ return sub_811B150();
+ }
+ else if (gMain.newKeys & START_BUTTON)
+ { // FIXME: See note below
+ return sub_811B1B4();
+ }
+ else if (gMain.newKeys & DPAD_UP)
+ {
+ gUnknown_0203A118->unk_06--;
+ }
+ else if (gMain.newKeys & DPAD_LEFT)
+ { // FIXME: See note below
+ gUnknown_0203A118->unk_05--;
+ }
+ else if (gMain.newKeys & DPAD_DOWN)
+ { // FIXME: See note below
+ gUnknown_0203A118->unk_06++;
+ }
+ else if (gMain.newKeys & DPAD_RIGHT)
+ { // FIXME: See note below
+ gUnknown_0203A118->unk_05++;
+ }
+ else
+ {
+ return 0;
+ }
+ if (gUnknown_0203A118->unk_06 < 0)
+ {
+ gUnknown_0203A118->unk_06 = gUnknown_08597550[gUnknown_0203A118->unk_01].unk_02;
+ }
+ if (gUnknown_0203A118->unk_06 > gUnknown_08597550[gUnknown_0203A118->unk_01].unk_02)
+ {
+ gUnknown_0203A118->unk_06 = 0;
+ }
+ if (gUnknown_0203A118->unk_06 == gUnknown_08597550[gUnknown_0203A118->unk_01].unk_02)
+ {
+ if (gUnknown_0203A118->unk_05 > 2)
+ {
+ gUnknown_0203A118->unk_05 = 2;
+ }
+ gUnknown_0203A118->unk_04 = 1;
+ return 3;
+ }
+ /*
+ * FIXME: right, down, left, b, and start
+ * should be inserted here, but aren't
+ */
+ if (gUnknown_0203A118->unk_05 < 0)
+ {
+ gUnknown_0203A118->unk_05 = gUnknown_08597550[gUnknown_0203A118->unk_01].unk_01 - 1;
+ }
+ if (gUnknown_0203A118->unk_05 >= gUnknown_08597550[gUnknown_0203A118->unk_01].unk_01)
+ {
+ gUnknown_0203A118->unk_05 = 0;
+ }
+ if (sub_811AB44() && gUnknown_0203A118->unk_05 == 1 && gUnknown_0203A118->unk_06 == 4)
+ {
+ gUnknown_0203A118->unk_05 = 0;
+ }
+ return 2;
+}
+#else
+__attribute__((naked)) static u16 sub_811AB68(void)
+{
+ asm_unified("\tpush {r4-r7,lr}\n"
+ "\tldr r0, =gMain\n"
+ "\tldrh r1, [r0, 0x2E]\n"
+ "\tmovs r0, 0x1\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbeq _0811ABB8\n"
+ "\tbl sub_811BF78\n"
+ "\tldr r1, =gUnknown_0203A118\n"
+ "\tldr r3, [r1]\n"
+ "\tmovs r2, 0\n"
+ "\tmovs r0, 0x2\n"
+ "\tstrb r0, [r3, 0x4]\n"
+ "\tldr r0, [r1]\n"
+ "\tstrb r2, [r0, 0xA]\n"
+ "\tldr r0, [r1]\n"
+ "\tstrb r2, [r0, 0xB]\n"
+ "\tldr r0, [r1]\n"
+ "\tstrb r2, [r0, 0xC]\n"
+ "\tmovs r0, 0x9\n"
+ "\tb _0811ACCC_return_r0\n"
+ "\t.pool\n"
+ "_0811AB9C:\n"
+ "\tmovs r0, 0x20\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbne _0811AC68_dpad_left\n"
+ "\tmovs r0, 0x80\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbne _0811AC58_dpad_down\n"
+ "\tmovs r0, 0x10\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbne _0811AC48_dpad_right\n"
+ "\tmovs r0, 0\n"
+ "\tb _0811ACCC_return_r0\n"
+ "_0811ABB8:\n"
+ "\tmovs r0, 0x2\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbne _0811AC78_b_button\n"
+ "\tmovs r0, 0x8\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbne _0811AC7E_start_button\n"
+ "\tmovs r0, 0x40\n"
+ "\tands r0, r1\n"
+ "\tcmp r0, 0\n"
+ "\tbeq _0811AB9C\n"
+ "\tldr r2, =gUnknown_0203A118\n"
+ "\tldr r1, [r2]\n"
+ "\tldrb r0, [r1, 0x6]\n"
+ "\tsubs r0, 0x1\n"
+ "_0811ABD8:\n"
+ "\tstrb r0, [r1, 0x6]\n"
+ "_0811ABDA:\n"
+ "\tadds r7, r2, 0\n"
+ "\tadds r4, r7, 0\n"
+ "\tldr r2, [r4]\n"
+ "\tmovs r0, 0x6\n"
+ "\tldrsb r0, [r2, r0]\n"
+ "\tldr r6, =gUnknown_08597550\n"
+ "\tcmp r0, 0\n"
+ "\tbge _0811ABF8\n"
+ "\tldrb r0, [r2, 0x1]\n"
+ "\tlsls r1, r0, 1\n"
+ "\tadds r1, r0\n"
+ "\tlsls r1, 3\n"
+ "\tadds r1, r6\n"
+ "\tldrb r0, [r1, 0x2]\n"
+ "\tstrb r0, [r2, 0x6]\n"
+ "_0811ABF8:\n"
+ "\tldr r3, [r4]\n"
+ "\tmovs r2, 0x6\n"
+ "\tldrsb r2, [r3, r2]\n"
+ "\tadds r5, r6, 0\n"
+ "\tldrb r1, [r3, 0x1]\n"
+ "\tlsls r0, r1, 1\n"
+ "\tadds r0, r1\n"
+ "\tlsls r0, 3\n"
+ "\tadds r0, r5\n"
+ "\tldrb r0, [r0, 0x2]\n"
+ "\tcmp r2, r0\n"
+ "\tble _0811AC14\n"
+ "\tmovs r0, 0\n"
+ "\tstrb r0, [r3, 0x6]\n"
+ "_0811AC14:\n"
+ "\tldr r3, [r4]\n"
+ "\tmovs r2, 0x6\n"
+ "\tldrsb r2, [r3, r2]\n"
+ "\tldrb r1, [r3, 0x1]\n"
+ "\tlsls r0, r1, 1\n"
+ "\tadds r0, r1\n"
+ "\tlsls r0, 3\n"
+ "\tadds r1, r0, r5\n"
+ "\tldrb r0, [r1, 0x2]\n"
+ "\tcmp r2, r0\n"
+ "\tbne _0811AC88\n"
+ "\tmovs r0, 0x5\n"
+ "\tldrsb r0, [r3, r0]\n"
+ "\tcmp r0, 0x2\n"
+ "\tble _0811AC36\n"
+ "\tmovs r0, 0x2\n"
+ "\tstrb r0, [r3, 0x5]\n"
+ "_0811AC36:\n"
+ "\tldr r1, [r4]\n"
+ "\tmovs r0, 0x1\n"
+ "\tstrb r0, [r1, 0x4]\n"
+ "\tmovs r0, 0x3\n"
+ "\tb _0811ACCC_return_r0\n"
+ "\t.pool\n"
+ "_0811AC48_dpad_right:\n"
+ "\tldr r2, =gUnknown_0203A118\n"
+ "\tldr r1, [r2]\n"
+ "\tldrb r0, [r1, 0x5]\n"
+ "\tadds r0, 0x1\n"
+ "\tstrb r0, [r1, 0x5]\n"
+ "\tb _0811ABDA\n"
+ "\t.pool\n"
+ "_0811AC58_dpad_down:\n"
+ "\tldr r2, =gUnknown_0203A118\n"
+ "\tldr r1, [r2]\n"
+ "\tldrb r0, [r1, 0x6]\n"
+ "\tadds r0, 0x1\n"
+ "\tb _0811ABD8\n"
+ "\t.pool\n"
+ "_0811AC68_dpad_left:\n"
+ "\tldr r2, =gUnknown_0203A118\n"
+ "\tldr r1, [r2]\n"
+ "\tldrb r0, [r1, 0x5]\n"
+ "\tsubs r0, 0x1\n"
+ "\tstrb r0, [r1, 0x5]\n"
+ "\tb _0811ABDA\n"
+ "\t.pool\n"
+ "_0811AC78_b_button:\n"
+ "\tbl sub_811B150\n"
+ "\tb _0811AC82\n"
+ "_0811AC7E_start_button:\n"
+ "\tbl sub_811B1B4\n"
+ "_0811AC82:\n"
+ "\tlsls r0, 16\n"
+ "\tlsrs r0, 16\n"
+ "\tb _0811ACCC_return_r0\n"
+ "_0811AC88:\n"
+ "\tmovs r0, 0x5\n"
+ "\tldrsb r0, [r3, r0]\n"
+ "\tcmp r0, 0\n"
+ "\tbge _0811AC96\n"
+ "\tldrb r0, [r1, 0x1]\n"
+ "\tsubs r0, 0x1\n"
+ "\tstrb r0, [r3, 0x5]\n"
+ "_0811AC96:\n"
+ "\tldr r3, [r4]\n"
+ "\tmovs r2, 0x5\n"
+ "\tldrsb r2, [r3, r2]\n"
+ "\tldrb r1, [r3, 0x1]\n"
+ "\tlsls r0, r1, 1\n"
+ "\tadds r0, r1\n"
+ "\tlsls r0, 3\n"
+ "\tadds r0, r6\n"
+ "\tldrb r0, [r0, 0x1]\n"
+ "\tcmp r2, r0\n"
+ "\tblt _0811ACB0\n"
+ "\tmovs r0, 0\n"
+ "\tstrb r0, [r3, 0x5]\n"
+ "_0811ACB0:\n"
+ "\tbl sub_811AB44\n"
+ "\tcmp r0, 0\n"
+ "\tbeq _0811ACCA\n"
+ "\tldr r2, [r7]\n"
+ "\tldr r0, [r2, 0x4]\n"
+ "\tldr r1, =0x00ffff00\n"
+ "\tands r0, r1\n"
+ "\tldr r1, =0x00040100\n"
+ "\tcmp r0, r1\n"
+ "\tbne _0811ACCA\n"
+ "\tmovs r0, 0\n"
+ "\tstrb r0, [r2, 0x5]\n"
+ "_0811ACCA:\n"
+ "\tmovs r0, 0x2\n"
+ "_0811ACCC_return_r0:\n"
+ "\tpop {r4-r7}\n"
+ "\tpop {r1}\n"
+ "\tbx r1\n"
+ "\t.pool");
+}
+#endif
diff --git a/src/field_player_avatar.c b/src/field_player_avatar.c
new file mode 100644
index 000000000..6ab721643
--- /dev/null
+++ b/src/field_player_avatar.c
@@ -0,0 +1,581 @@
+#include "global.h"
+#include "global.fieldmap.h"
+#include "sprite.h"
+#include "event_object_movement.h"
+#include "bike.h"
+#include "metatile_behavior.h"
+#include "metatile_behaviors.h"
+#include "constants/flags.h"
+#include "event_data.h"
+#include "fieldmap.h"
+#include "overworld.h"
+#include "rotating_gate.h"
+#include "constants/event_object_movement_constants.h"
+#include "field_player_avatar.h"
+
+extern void task_add_bump_boulder(u8, u8);
+static bool8 ShouldJumpLedge(s16, s16, u8);
+static bool8 sub_808B1BC(s16, s16, u8);
+static u8 sub_808B164(struct EventObject *, s16, s16, u8, u8);
+static u8 sub_808B238(s16, s16, u8);
+static void check_acro_bike_metatile(s16, s16, u8, u8 *);
+extern void PlayerNotOnBikeCollide(u8);
+extern void PlayerNotOnBikeCollideWithFarawayIslandMew(u8);
+extern void PlayerRun(u8);
+static void MovePlayerNotOnBike(u8, u16);
+static u8 CheckMovementInputNotOnBike(u8);
+extern void sub_808C5B0(void);
+extern void sub_808C4D8(void);
+static u8 CheckForPlayerAvatarCollision(u8);
+static u8 EventObjectCB2_NoMovement2();
+extern void sub_808C280(struct EventObject *);
+static bool8 TryInterruptEventObjectSpecialAnim(struct EventObject *, u8);
+void npc_clear_strange_bits(struct EventObject *);
+extern void DoPlayerAvatarTransition(void);
+static bool8 TryDoMetatileBehaviorForcedMovement();
+static void MovePlayerAvatarUsingKeypadInput(u8, u16, u16);
+static void PlayerAllowForcedMovementIfMovingSameDirection();
+static u8 sub_808B028(u8);
+static u8 GetForcedMovementByMetatileBehavior();
+static void PlayerNotOnBikeNotMoving(u8, u16);
+static void PlayerNotOnBikeTurningInPlace(u8, u16);
+static void PlayerNotOnBikeMoving(u8, u16);
+extern void sub_808C750(u8);
+
+static bool8 (*const gUnknown_084973FC[])(u8) =
+{
+ MetatileBehavior_IsTrickHouseSlipperyFloor,
+ MetatileBehavior_IsIce_2,
+ MetatileBehavior_IsWalkSouth,
+ MetatileBehavior_IsWalkNorth,
+ MetatileBehavior_IsWalkWest,
+ MetatileBehavior_IsWalkEast,
+ MetatileBehavior_IsSouthwardCurrent,
+ MetatileBehavior_IsNorthwardCurrent,
+ MetatileBehavior_IsWestwardCurrent,
+ MetatileBehavior_IsEastwardCurrent,
+ MetatileBehavior_IsSlideSouth,
+ MetatileBehavior_IsSlideNorth,
+ MetatileBehavior_IsSlideWest,
+ MetatileBehavior_IsSlideEast,
+ MetatileBehavior_IsWaterfall,
+ MetatileBehavior_IsSecretBaseJumpMat,
+ MetatileBehavior_IsSecretBaseSpinMat,
+ MetatileBehavior_IsMuddySlope,
+};
+
+static bool8 (*const gUnknown_08497444[])(void) =
+{
+ ForcedMovement_None,
+ ForcedMovement_Slip,
+ ForcedMovement_Slip,
+ ForcedMovement_WalkSouth,
+ ForcedMovement_WalkNorth,
+ ForcedMovement_WalkWest,
+ ForcedMovement_WalkEast,
+ ForcedMovement_PushedSouthByCurrent,
+ ForcedMovement_PushedNorthByCurrent,
+ ForcedMovement_PushedWestByCurrent,
+ ForcedMovement_PushedEastByCurrent,
+ ForcedMovement_SlideSouth,
+ ForcedMovement_SlideNorth,
+ ForcedMovement_SlideWest,
+ ForcedMovement_SlideEast,
+ ForcedMovement_PushedSouthByCurrent,
+ ForcedMovement_0xBB,
+ ForcedMovement_0xBC,
+ ForcedMovement_MuddySlope,
+};
+
+static void (*const gUnknown_08497490[])(u8, u16) =
+{
+ PlayerNotOnBikeNotMoving,
+ PlayerNotOnBikeTurningInPlace,
+ PlayerNotOnBikeMoving,
+};
+
+static bool8 (*const gUnknown_0849749C[])(u8) =
+{
+ MetatileBehavior_IsBumpySlope,
+ MetatileBehavior_IsIsolatedVerticalRail,
+ MetatileBehavior_IsIsolatedHorizontalRail,
+ MetatileBehavior_IsVerticalRail,
+ MetatileBehavior_IsHorizontalRail,
+};
+
+static const u8 gUnknown_084974B0[] = {9, 10, 11, 12, 13, 0, 0, 0};
+
+void MovementType_Player(struct Sprite *sprite)
+{
+ UpdateEventObjectCurrentMovement(&gEventObjects[sprite->data[0]], sprite, EventObjectCB2_NoMovement2);
+}
+
+static u8 EventObjectCB2_NoMovement2()
+{
+ return 0;
+}
+
+void player_step(u8 direction, u16 newKeys, u16 heldKeys)
+{
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ sub_808C280(playerEventObj);
+ if (gPlayerAvatar.preventStep == FALSE)
+ {
+ Bike_TryAcroBikeHistoryUpdate(newKeys, heldKeys);
+ if (TryInterruptEventObjectSpecialAnim(playerEventObj, direction) == 0)
+ {
+ npc_clear_strange_bits(playerEventObj);
+ DoPlayerAvatarTransition();
+ if (TryDoMetatileBehaviorForcedMovement() == 0)
+ {
+ MovePlayerAvatarUsingKeypadInput(direction, newKeys, heldKeys);
+ PlayerAllowForcedMovementIfMovingSameDirection();
+ }
+ }
+ }
+}
+
+static bool8 TryInterruptEventObjectSpecialAnim(struct EventObject *playerEventObj, u8 direction)
+{
+ #ifdef NONMATCHING
+ u8 r5 = direction;
+ u8 r6 = direction;
+ #else
+ u8 r5 = direction;
+ register u8 r6 asm("r6") = direction;
+ #endif
+ //a very bad HACK
+
+ if (EventObjectIsMovementOverridden(playerEventObj)
+ && !EventObjectClearHeldMovementIfFinished(playerEventObj))
+ {
+ u8 heldMovementActionId = EventObjectGetHeldMovementActionId(playerEventObj);
+ if (heldMovementActionId > MOVEMENT_ACTION_WALK_FAST_RIGHT && heldMovementActionId < MOVEMENT_ACTION_WALK_IN_PLACE_NORMAL_DOWN)
+ {
+ if (direction == DIR_NONE)
+ {
+ return TRUE;
+ }
+
+ if (playerEventObj->movementDirection != r5)
+ {
+ EventObjectClearHeldMovement(playerEventObj);
+ return FALSE;
+ }
+
+ if (!sub_808B028(r6))
+ {
+ EventObjectClearHeldMovement(playerEventObj);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+void npc_clear_strange_bits(struct EventObject *eventObj)
+{
+ eventObj->inanimate = 0;
+ eventObj->disableAnim = 0;
+ eventObj->facingDirectionLocked = 0;
+ gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_DASH;
+}
+
+static void MovePlayerAvatarUsingKeypadInput(u8 direction, u16 newKeys, u16 heldKeys)
+{
+ if ((gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_MACH_BIKE)
+ || (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_ACRO_BIKE))
+ MovePlayerOnBike(direction, newKeys, heldKeys);
+ else
+ MovePlayerNotOnBike(direction, heldKeys);
+}
+
+static void PlayerAllowForcedMovementIfMovingSameDirection(void)
+{
+ if (gPlayerAvatar.runningState == MOVING)
+ gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_5;
+}
+
+static bool8 TryDoMetatileBehaviorForcedMovement()
+{
+ return gUnknown_08497444[GetForcedMovementByMetatileBehavior()]();
+}
+
+static u8 GetForcedMovementByMetatileBehavior(void)
+{
+ u8 i;
+
+ if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_5))
+ {
+ u8 metatileBehavior = gEventObjects[gPlayerAvatar.eventObjectId].currentMetatileBehavior;
+
+ for (i = 0; i < 18; i++)
+ {
+ if (gUnknown_084973FC[i](metatileBehavior))
+ return i + 1;
+ }
+ }
+ return 0;
+}
+
+bool8 ForcedMovement_None(void)
+{
+ if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_6)
+ {
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ playerEventObj->facingDirectionLocked = 0;
+ playerEventObj->enableAnim = 1;
+ SetEventObjectDirection(playerEventObj, playerEventObj->facingDirection);
+ gPlayerAvatar.flags &= ~PLAYER_AVATAR_FLAG_6;
+ }
+ return FALSE;
+}
+
+static u8 DoForcedMovement(u8 direction, void (*b)(u8))
+{
+ struct PlayerAvatar *playerAvatar = &gPlayerAvatar;
+ u8 collisionType = CheckForPlayerAvatarCollision(direction);
+
+ playerAvatar->flags |= PLAYER_AVATAR_FLAG_6;
+ if (collisionType != 0)
+ {
+ ForcedMovement_None();
+ if (collisionType <= 4)
+ {
+ return 0;
+ }
+ else
+ {
+ if (collisionType == COLLISION_LEDGE_JUMP)
+ PlayerJumpLedge(direction);
+ playerAvatar->flags |= PLAYER_AVATAR_FLAG_6;
+ playerAvatar->runningState = MOVING;
+ return 1;
+ }
+ }
+ else
+ {
+ playerAvatar->runningState = MOVING;
+ b(direction);
+ return 1;
+ }
+}
+
+u8 DoForcedMovementInCurrentDirection(void (*a)(u8))
+{
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ playerEventObj->disableAnim = 1;
+ return DoForcedMovement(playerEventObj->movementDirection, a);
+}
+
+bool8 ForcedMovement_Slip(void)
+{
+ return DoForcedMovementInCurrentDirection(PlayerGoSpeed2);
+}
+
+bool8 ForcedMovement_WalkSouth(void)
+{
+ return DoForcedMovement(DIR_SOUTH, PlayerGoSpeed1);
+}
+
+bool8 ForcedMovement_WalkNorth(void)
+{
+ return DoForcedMovement(DIR_NORTH, PlayerGoSpeed1);
+}
+
+bool8 ForcedMovement_WalkWest(void)
+{
+ return DoForcedMovement(DIR_WEST, PlayerGoSpeed1);
+}
+
+bool8 ForcedMovement_WalkEast(void)
+{
+ return DoForcedMovement(DIR_EAST, PlayerGoSpeed1);
+}
+
+bool8 ForcedMovement_PushedSouthByCurrent(void)
+{
+ return DoForcedMovement(DIR_SOUTH, PlayerGoSpeed3);
+}
+
+bool8 ForcedMovement_PushedNorthByCurrent(void)
+{
+ return DoForcedMovement(DIR_NORTH, PlayerGoSpeed3);
+}
+
+bool8 ForcedMovement_PushedWestByCurrent(void)
+{
+ return DoForcedMovement(DIR_WEST, PlayerGoSpeed3);
+}
+
+bool8 ForcedMovement_PushedEastByCurrent(void)
+{
+ return DoForcedMovement(DIR_EAST, PlayerGoSpeed3);
+}
+
+u8 ForcedMovement_Slide(u8 direction, void (*b)(u8))
+{
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ playerEventObj->disableAnim = 1;
+ playerEventObj->facingDirectionLocked = 1;
+ return DoForcedMovement(direction, b);
+}
+
+bool8 ForcedMovement_SlideSouth(void)
+{
+ return ForcedMovement_Slide(DIR_SOUTH, PlayerGoSpeed2);
+}
+
+bool8 ForcedMovement_SlideNorth(void)
+{
+ return ForcedMovement_Slide(DIR_NORTH, PlayerGoSpeed2);
+}
+
+bool8 ForcedMovement_SlideWest(void)
+{
+ return ForcedMovement_Slide(DIR_WEST, PlayerGoSpeed2);
+}
+
+bool8 ForcedMovement_SlideEast(void)
+{
+ return ForcedMovement_Slide(DIR_EAST, PlayerGoSpeed2);
+}
+
+bool8 ForcedMovement_0xBB(void)
+{
+ sub_808C4D8();
+ return TRUE;
+}
+
+bool8 ForcedMovement_0xBC(void)
+{
+ sub_808C5B0();
+ return TRUE;
+}
+
+bool8 ForcedMovement_MuddySlope(void)
+{
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ if (playerEventObj->movementDirection != DIR_NORTH || GetPlayerSpeed() <= 3)
+ {
+ Bike_UpdateBikeCounterSpeed(0);
+ playerEventObj->facingDirectionLocked = 1;
+ return DoForcedMovement(1, PlayerGoSpeed2);
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+static void MovePlayerNotOnBike(u8 direction, u16 heldKeys)
+{
+ gUnknown_08497490[CheckMovementInputNotOnBike(direction)](direction, heldKeys);
+}
+
+static u8 CheckMovementInputNotOnBike(u8 direction)
+{
+ if (direction == DIR_NONE)
+ {
+ gPlayerAvatar.runningState = NOT_MOVING;
+ return 0;
+ }
+ else if (direction != GetPlayerMovementDirection() && gPlayerAvatar.runningState != MOVING)
+ {
+ gPlayerAvatar.runningState = TURN_DIRECTION;
+ return 1;
+ }
+ else
+ {
+ gPlayerAvatar.runningState = MOVING;
+ return 2;
+ }
+}
+
+static void PlayerNotOnBikeNotMoving(u8 direction, u16 heldKeys)
+{
+ PlayerFaceDirection(GetPlayerFacingDirection());
+}
+
+static void PlayerNotOnBikeTurningInPlace(u8 direction, u16 heldKeys)
+{
+ PlayerTurnInPlace(direction);
+}
+
+static void PlayerNotOnBikeMoving(u8 direction, u16 heldKeys)
+{
+ u8 r0 = CheckForPlayerAvatarCollision(direction);
+
+ if (r0 != 0)
+ {
+ if (r0 == 6)
+ {
+ PlayerJumpLedge(direction);
+ return;
+ }
+ else if (r0 == 4 && IsPlayerCollidingWithFarawayIslandMew(direction) != 0)
+ {
+ PlayerNotOnBikeCollideWithFarawayIslandMew(direction);
+ return;
+ }
+ else
+ {
+ u8 r4 = r0 - 5;
+
+ if (r4 > 3)
+ {
+ PlayerNotOnBikeCollide(direction);
+ return;
+ }
+ else
+ {
+ return;
+ }
+ }
+ }
+
+ if (gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+ {
+ // speed 2 is fast, same speed as running
+ PlayerGoSpeed2(direction);
+ return;
+ }
+
+ if (!(gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_4) && (heldKeys & B_BUTTON) && FlagGet(FLAG_SYS_B_DASH)
+ && IsRunningDisallowed(gEventObjects[gPlayerAvatar.eventObjectId].currentMetatileBehavior) == 0)
+ {
+ PlayerRun(direction);
+ gPlayerAvatar.flags |= PLAYER_AVATAR_FLAG_DASH;
+ return;
+ }
+ else
+ {
+ PlayerGoSpeed1(direction);
+ }
+}
+
+static u8 CheckForPlayerAvatarCollision(u8 direction)
+{
+ s16 x, y;
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ x = playerEventObj->currentCoords.x;
+ y = playerEventObj->currentCoords.y;
+ MoveCoords(direction, &x, &y);
+ return CheckForEventObjectCollision(playerEventObj, x, y, direction, MapGridGetMetatileBehaviorAt(x, y));
+}
+
+static u8 sub_808B028(u8 direction)
+{
+ s16 x, y;
+ struct EventObject *playerEventObj = &gEventObjects[gPlayerAvatar.eventObjectId];
+
+ x = playerEventObj->currentCoords.x;
+ y = playerEventObj->currentCoords.y;
+ MoveCoords(direction, &x, &y);
+ return sub_808B164(playerEventObj, x, y, direction, MapGridGetMetatileBehaviorAt(x, y));
+}
+
+u8 CheckForEventObjectCollision(struct EventObject *a, s16 x, s16 y, u8 direction, u8 e)
+{
+ u8 collision;
+
+ collision = GetCollisionAtCoords(a, x, y, direction);
+ if (collision == 3 && sub_808B1BC(x, y, direction))
+ return 5;
+ if (ShouldJumpLedge(x, y, direction))
+ {
+ IncrementGameStat(GAME_STAT_JUMPED_DOWN_LEDGES);
+ return COLLISION_LEDGE_JUMP;
+ }
+ if (collision == 4 && sub_808B238(x, y, direction))
+ return 7;
+
+ if (collision == 0)
+ {
+ if (CheckForRotatingGatePuzzleCollision(direction, x, y))
+ return 8;
+ check_acro_bike_metatile(x, y, e, &collision);
+ }
+ return collision;
+}
+
+static u8 sub_808B164(struct EventObject *a, s16 x, s16 y, u8 direction, u8 e)
+{
+ u8 collision = GetCollisionAtCoords(a, x, y, direction);
+
+ if (collision == 0)
+ {
+ if (CheckForRotatingGatePuzzleCollisionWithoutAnimation(direction, x, y) != 0)
+ return 8;
+ check_acro_bike_metatile(x, y, e, &collision);
+ }
+ return collision;
+}
+
+static bool8 sub_808B1BC(s16 x, s16 y, u8 direction)
+{
+ if ((gPlayerAvatar.flags & PLAYER_AVATAR_FLAG_SURFING)
+ && MapGridGetZCoordAt(x, y) == 3
+ && GetEventObjectIdByXYZ(x, y, 3) == 16)
+ {
+ sub_808C750(direction);
+ return TRUE;
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+static bool8 ShouldJumpLedge(s16 x, s16 y, u8 z)
+{
+ if (GetLedgeJumpDirection(x, y, z) != 0)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+static u8 sub_808B238(s16 x, s16 y, u8 direction)
+{
+ if (FlagGet(FLAG_SYS_USE_STRENGTH))
+ {
+ u8 eventObjectId = GetEventObjectIdByXY(x, y);
+
+ if (eventObjectId != 16 && gEventObjects[eventObjectId].graphicsId == 0x57)
+ {
+ x = gEventObjects[eventObjectId].currentCoords.x;
+ y = gEventObjects[eventObjectId].currentCoords.y;
+ MoveCoords(direction, &x, &y);
+ if (GetCollisionAtCoords(&gEventObjects[eventObjectId], x, y, direction) == 0
+ && MetatileBehavior_IsNonAnimDoor(MapGridGetMetatileBehaviorAt(x, y)) == 0)
+ {
+ task_add_bump_boulder(eventObjectId, direction);
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+static void check_acro_bike_metatile(s16 unused1, s16 unused2, u8 c, u8 *d)
+{
+ u8 i;
+
+ for (i = 0; i < 5; i++)
+ {
+ if (gUnknown_0849749C[i](c))
+ {
+ *d = gUnknown_084974B0[i];
+ return;
+ }
+ }
+}
diff --git a/src/pokemon_storage_system.c b/src/pokemon_storage_system.c
index 7f8c24ab7..7c622c223 100644
--- a/src/pokemon_storage_system.c
+++ b/src/pokemon_storage_system.c
@@ -7,17 +7,49 @@
#include "text.h"
#include "strings.h"
#include "window.h"
+#include "menu.h"
+#include "bg.h"
+#include "main.h"
+#include "palette.h"
+#include "overworld.h"
+#include "field_screen.h"
+#include "field_weather.h"
+#include "script.h"
+#include "international_string_util.h"
+#include "walda_phrase.h"
+#include "sound.h"
+#include "gpu_regs.h"
+#include "constants/songs.h"
IWRAM_DATA u8 gUnknown_03000F78[0x188];
-struct OptionAndDescription
-{
- const u8 *optionTxt;
- const u8 *descriptionTxt;
-};
+extern const u8 gText_PartyFull[];
+extern const u8 gText_Box[];
+extern const u8 gText_JustOnePkmn[];
+
+extern u8 gUnknown_02039D00;
+
+// This file's functions.
+void StorageSystemCreatePrimaryMenu(u8 whichMenu, s16 *windowIdPtr);
+void sub_80C7D74(u8);
+u8 sub_80CAEA0(void);
+void SetBoxWallpaper(u8 boxId, u8 wallpaperId);
+void SetCurrentBox(u8 boxId);
+void ClearMonInBox(u8 boxId, u8 boxPos);
+void ResetWaldaWallpaper(void);
+void sub_80C7958(u8 curBox);
+void sub_80C7B14(void);
+void sub_80C7BB4(void);
+void sub_80CA028(void);
+void sub_80C7B80(void);
+void sub_80D2AA4(void);
+void sub_80C7BE4(void);
+void sub_80CAA14(void);
+void sub_80C7CF4(struct Sprite *sprite);
+struct Sprite *sub_80CD2E8(u16 x, u16 y, u8 animId, u8 priority, u8 subpriority);
// const rom data
-const struct OptionAndDescription gUnknown_085716C0[] =
+const struct PSS_MenuStringPtrs gUnknown_085716C0[] =
{
{gText_WithdrawPokemon, gText_WithdrawMonDescription},
{gText_DepositPokemon, gText_DepositMonDescription},
@@ -74,6 +106,10 @@ static const union AffineAnimCmd *const sSpriteAffineAnimTable_8571730[] =
const u8 gUnknown_08571734[] = {4, 0xF, 0xE};
const u8 gUnknown_08571737[] = _("/30");
+const u16 gBoxSelectionPopupPalette[] = INCBIN_U16("graphics/unknown/unknown_57173C.gbapal");
+const u8 gBoxSelectionPopupCenterTiles[] = INCBIN_U8("graphics/pokemon_storage/box_selection_popup_center.4bpp");
+const u8 gBoxSelectionPopupSidesTiles[] = INCBIN_U8("graphics/pokemon_storage/box_selection_popup_sides.4bpp");
+
// code
u8 CountMonsInBox(u8 boxId)
{
@@ -166,24 +202,473 @@ static u8 *StringCopyAndFillWithSpaces(u8 *dst, const u8 *src, u16 n)
return str;
}
-/* can't match
-static void sub_80C7128(u16 *dst, u16 dstToAdd, u16 dstToMul, const u16 *src, u16 srcToAdd, u16 srcToMul, u32 size, u16 count, u16 srcBy)
+static void sub_80C7128(u16 *dest, u16 dest_left, u16 dest_top, const u16 *src, u16 src_left, u16 src_top, u16 dest_width, u16 dest_height, u16 src_width)
+{
+ u16 i;
+
+ dest_width *= 2;
+ dest += dest_top * 0x20 + dest_left;
+ src += src_top * src_width + src_left;
+ for (i = 0; i < dest_height; i++)
+ {
+ CpuCopy16(src, dest, dest_width);
+ dest += 0x20;
+ src += src_width;
+ }
+}
+
+#define MAX_DMA_BLOCK_SIZE 0x1000
+#define Dma3FillLarge_(value, dest, size, bit) \
+{ \
+ void *_dest = dest; \
+ u32 _size = size; \
+ while (1) \
+ { \
+ if (_size <= MAX_DMA_BLOCK_SIZE) \
+ { \
+ DmaFill##bit(3, value, _dest, _size); \
+ break; \
+ } \
+ DmaFill##bit(3, value, _dest, MAX_DMA_BLOCK_SIZE); \
+ _dest += MAX_DMA_BLOCK_SIZE; \
+ _size -= MAX_DMA_BLOCK_SIZE; \
+ } \
+}
+
+#define Dma3FillLarge16_(value, dest, size) Dma3FillLarge_(value, dest, size, 16)
+#define Dma3FillLarge32_(value, dest, size) Dma3FillLarge_(value, dest, size, 32)
+
+void sub_80C71A4(u16 *dest, u16 dest_left, u16 dest_top, u16 width, u16 height)
+{
+ u16 i;
+
+ dest += dest_top * 0x20 + dest_left;
+ width *= 2;
+ for (i = 0; i < height; dest += 0x20, i++)
+ Dma3FillLarge16_(0, dest, width);
+}
+
+void Task_PokemonStorageSystem(u8 taskId)
+{
+ struct Task *task = gTasks + taskId;
+ switch (task->data[0])
+ {
+ case 0:
+ StorageSystemCreatePrimaryMenu(task->data[1], &task->data[15]);
+ sub_81973A4();
+ NewMenuHelpers_DrawDialogueFrame(0, 0);
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, TEXT_SPEED_FF, NULL, 2, 1, 3);
+ CopyWindowToVram(0, 3);
+ CopyWindowToVram(task->data[15], 3);
+ task->data[0]++;
+ break;
+ case 1:
+ if (IsWeatherNotFadingIn())
+ {
+ task->data[0]++;
+ }
+ break;
+ case 2:
+ task->data[2] = ProcessMenuInput();
+ switch(task->data[2])
+ {
+ case -2:
+ task->data[3] = task->data[1];
+ if (gMain.newKeys & DPAD_UP && --task->data[3] < 0)
+ task->data[3] = 4;
+
+ if (gMain.newKeys & DPAD_DOWN && ++task->data[3] > 4)
+ task->data[3] = 0;
+ if (task->data[1] != task->data[3])
+ {
+ task->data[1] = task->data[3];
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+ }
+ break;
+ case -1:
+ case 4:
+ sub_819746C(task->data[15], TRUE);
+ ScriptContext2_Disable();
+ EnableBothScriptContexts();
+ RemoveWindow(task->data[15]);
+ DestroyTask(taskId);
+ break;
+ default:
+ if (task->data[2] == 0 && CountPartyMons() == PARTY_SIZE)
+ {
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gText_PartyFull, 0, NULL, 2, 1, 3);
+ task->data[0] = 3;
+ }
+ else if (task->data[2] == 1 && CountPartyMons() == 1)
+ {
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gText_JustOnePkmn, 0, NULL, 2, 1, 3);
+ task->data[0] = 3;
+ }
+ else
+ {
+ FadeScreen(1, 0);
+ task->data[0] = 4;
+ }
+ break;
+ }
+ break;
+ case 3:
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+ task->data[0] = 2;
+ }
+ else if (gMain.newKeys & DPAD_UP)
+ {
+ if (--task->data[1] < 0)
+ task->data[1] = 4;
+ MoveMenuCursor(-1);
+ task->data[1] = GetMenuCursorPos();
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+ task->data[0] = 2;
+ }
+ else if (gMain.newKeys & DPAD_DOWN)
+ {
+ if (++task->data[1] > 3)
+ task->data[1] = 0;
+ MoveMenuCursor(1);
+ task->data[1] = GetMenuCursorPos();
+ FillWindowPixelBuffer(0, 0x11);
+ AddTextPrinterParameterized(0, 1, gUnknown_085716C0[task->data[1]].desc, 0, NULL, 2, 1, 3);
+ task->data[0] = 2;
+ }
+ break;
+ case 4:
+ if (!gPaletteFade.active)
+ {
+ overworld_free_bg_tilemaps();
+ sub_80C7D74(task->data[2]);
+ RemoveWindow(task->data[15]);
+ DestroyTask(taskId);
+ }
+ break;
+ }
+}
+
+void ShowPokemonStorageSystem(void)
+{
+ u8 taskId = CreateTask(Task_PokemonStorageSystem, 80);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = 0;
+ ScriptContext2_Enable();
+}
+
+void mapldr_0808C6D8(void)
+{
+ u8 taskId;
+ MainCallback vblankCb = gMain.vblankCallback;
+
+ SetVBlankCallback(NULL);
+ taskId = CreateTask(Task_PokemonStorageSystem, 80);
+ gTasks[taskId].data[0] = 0;
+ gTasks[taskId].data[1] = gUnknown_02039D00;
+ Task_PokemonStorageSystem(taskId);
+ SetVBlankCallback(vblankCb);
+ pal_fill_black();
+}
+
+void StorageSystemCreatePrimaryMenu(u8 whichMenu, s16 *windowIdPtr)
+{
+ s16 windowId;
+ struct WindowTemplate winTemplate = gUnknown_085716E8;
+ winTemplate.width = GetMaxWidthInMenuTable((void *)gUnknown_085716C0, ARRAY_COUNT(gUnknown_085716C0));
+ windowId = AddWindow(&winTemplate);
+
+ NewMenuHelpers_DrawStdWindowFrame(windowId, FALSE);
+ PrintMenuTable(windowId, ARRAY_COUNT(gUnknown_085716C0), (void *)gUnknown_085716C0);
+ InitMenuInUpperLeftCornerPlaySoundWhenAPressed(windowId, ARRAY_COUNT(gUnknown_085716C0), whichMenu);
+ *windowIdPtr = windowId;
+}
+
+void sub_80C7678(void)
+{
+ gUnknown_02039D00 = sub_80CAEA0();
+ gFieldCallback = mapldr_0808C6D8;
+ SetMainCallback2(CB2_ReturnToField);
+}
+
+s16 StorageSystemGetNextMonIndex(struct BoxPokemon *box, s8 startIdx, u8 stopIdx, u8 mode)
+{
+ s16 i;
+ s16 direction;
+ if (mode == 0 || mode == 1)
+ {
+ direction = 1;
+ }
+ else
+ {
+ direction = -1;
+ }
+ if (mode == 1 || mode == 3)
+ {
+ for (i = startIdx + direction; i >= 0 && i <= stopIdx; i += direction)
+ {
+ if (GetBoxMonData(box + i, MON_DATA_SPECIES) != 0)
+ return i;
+ }
+ }
+ else
+ {
+ for (i = startIdx + direction; i >= 0 && i <= stopIdx; i += direction)
+ {
+ if (GetBoxMonData(box + i, MON_DATA_SPECIES) != 0 && !GetBoxMonData(box + i, MON_DATA_IS_EGG))
+ return i;
+ }
+ }
+ return -1;
+}
+
+void ResetPokemonStorageSystem(void)
+{
+ u16 boxId;
+ u16 boxMon;
+
+ SetCurrentBox(0);
+ for (boxId = 0; boxId < TOTAL_BOXES_COUNT; boxId++)
+ {
+ for (boxMon = 0; boxMon < IN_BOX_COUNT; boxMon++)
+ ClearMonInBox(boxId, boxMon);
+ }
+ for (boxId = 0; boxId < TOTAL_BOXES_COUNT; boxId++)
+ {
+ u8 *dest = StringCopy(GetBoxNamePtr(boxId), gText_Box);
+ ConvertIntToDecimalStringN(dest, boxId + 1, STR_CONV_MODE_LEFT_ALIGN, 2);
+ }
+ for (boxId = 0; boxId < TOTAL_BOXES_COUNT; boxId++)
+ {
+ SetBoxWallpaper(boxId, boxId % 4);
+ }
+ ResetWaldaWallpaper();
+}
+
+void sub_80C77E8(struct UnkPSSStruct_2002370 *a0, u16 tileTag, u16 palTag, u8 a3, bool32 loadPal)
+{
+ struct SpritePalette palette =
+ {
+ gBoxSelectionPopupPalette, palTag
+ };
+ struct SpriteSheet sheets[] =
+ {
+ {gBoxSelectionPopupCenterTiles, 0x800, tileTag},
+ {gBoxSelectionPopupSidesTiles, 0x180, tileTag + 1},
+ {}
+ };
+
+ if (loadPal)
+ LoadSpritePalette(&palette);
+
+ LoadSpriteSheets(sheets);
+ gUnknown_02039D04 = a0;
+ a0->unk_0240 = tileTag;
+ a0->unk_0242 = palTag;
+ a0->unk_0246 = a3;
+ a0->unk_023c = loadPal;
+}
+
+void sub_80C7890(void)
+{
+ if (gUnknown_02039D04->unk_023c)
+ FreeSpritePaletteByTag(gUnknown_02039D04->unk_0242);
+ FreeSpriteTilesByTag(gUnknown_02039D04->unk_0240);
+ FreeSpriteTilesByTag(gUnknown_02039D04->unk_0240 + 1);
+}
+
+void sub_80C78D4(u8 curBox)
+{
+ sub_80C7958(curBox);
+}
+
+void sub_80C78E4(void)
+{
+ sub_80C7B14();
+}
+
+u8 sub_80C78F0(void)
+{
+ if (gMain.newKeys & B_BUTTON)
+ {
+ PlaySE(SE_SELECT);
+ return 201;
+ }
+ if (gMain.newKeys & A_BUTTON)
+ {
+ PlaySE(SE_SELECT);
+ return gUnknown_02039D04->curBox;
+ }
+ if (gMain.newKeys & DPAD_LEFT)
+ {
+ PlaySE(SE_SELECT);
+ sub_80C7BB4();
+ }
+ else if (gMain.newKeys & DPAD_RIGHT)
+ {
+ PlaySE(SE_SELECT);
+ sub_80C7B80();
+ }
+ return 200;
+}
+
+void sub_80C7958(u8 curBox)
{
u16 i;
+ u8 spriteId;
+ struct SpriteTemplate template;
+ struct OamData oamData = {};
+ oamData.size = 3;
+ oamData.paletteNum = 1;
+ template = (struct SpriteTemplate){
+ 0, 0, &oamData, gDummySpriteAnimTable, NULL, gDummySpriteAffineAnimTable, SpriteCallbackDummy
+ };
+
+ gUnknown_02039D04->curBox = curBox;
+ template.tileTag = gUnknown_02039D04->unk_0240;
+ template.paletteTag = gUnknown_02039D04->unk_0242;
+
+ spriteId = CreateSprite(&template, 0xA0, 0x60, 0);
+ gUnknown_02039D04->unk_0000 = gSprites + spriteId;
+
+ oamData.shape = ST_OAM_V_RECTANGLE;
+ oamData.size = 1;
+ template.tileTag = gUnknown_02039D04->unk_0240 + 1;
+ template.anims = sSpriteAnimTable_8571710;
+ for (i = 0; i < 4; i++)
+ {
+ u16 r5;
+ spriteId = CreateSprite(&template, 0x7c, 0x50, gUnknown_02039D04->unk_0246);
+ gUnknown_02039D04->unk_0004[i] = gSprites + spriteId;
+ r5 = 0;
+ if (i & 2)
+ {
+ gUnknown_02039D04->unk_0004[i]->pos1.x = 0xc4;
+ r5 = 2;
+ }
+ if (i & 1)
+ {
+ gUnknown_02039D04->unk_0004[i]->pos1.y = 0x70;
+ gUnknown_02039D04->unk_0004[i]->oam.size = 0;
+ r5++;
+ }
+ StartSpriteAnim(gUnknown_02039D04->unk_0004[i], r5);
+ }
+ for (i = 0; i < 2; i++)
+ {
+ gUnknown_02039D04->unk_0020[i] = sub_80CD2E8(72 * i + 0x7c, 0x58, i, 0, gUnknown_02039D04->unk_0246);
+ if (gUnknown_02039D04->unk_0020[i])
+ {
+ gUnknown_02039D04->unk_0020[i]->data[0] = (i == 0 ? -1 : 1);
+ gUnknown_02039D04->unk_0020[i]->callback = sub_80C7CF4;
+ }
+ }
+ sub_80C7BE4();
+}
+
+void sub_80C7B14(void)
+{
+ u16 i;
+ if (gUnknown_02039D04->unk_0000)
+ {
+ DestroySprite(gUnknown_02039D04->unk_0000);
+ gUnknown_02039D04->unk_0000 = NULL;
+ }
+ for (i = 0; i < 4; i++)
+ {
+ if (gUnknown_02039D04->unk_0004[i])
+ {
+ DestroySprite(gUnknown_02039D04->unk_0004[i]);
+ gUnknown_02039D04->unk_0004[i] = NULL;
+ }
+ }
+ for (i = 0; i < 2; i++)
+ {
+ if (gUnknown_02039D04->unk_0020[i])
+ DestroySprite(gUnknown_02039D04->unk_0020[i]);
+ }
+}
- size <<= 0x11;
- dst += (dstToMul * 32) + dstToAdd;
- src += (srcToMul * srcBy) + srcToAdd;
+void sub_80C7B80(void)
+{
+ if (++gUnknown_02039D04->curBox >= TOTAL_BOXES_COUNT)
+ gUnknown_02039D04->curBox = 0;
+ sub_80C7BE4();
+}
+
+void sub_80C7BB4(void)
+{
+ gUnknown_02039D04->curBox = (gUnknown_02039D04->curBox == 0 ? TOTAL_BOXES_COUNT - 1 : gUnknown_02039D04->curBox - 1);
+ sub_80C7BE4();
+}
- i = 0;
- if (i < count)
+void sub_80C7BE4(void)
+{
+ u8 text[16];
+ struct WindowTemplate winTemplate;
+ u8 windowId;
+ u8 *boxName = GetBoxNamePtr(gUnknown_02039D04->curBox);
+ u8 nPokemonInBox = CountMonsInBox(gUnknown_02039D04->curBox);
+ u32 winTileData;
+ s32 center;
+
+ memset(&winTemplate, 0, sizeof(winTemplate));
+ winTemplate.width = 8;
+ winTemplate.height = 4;
+
+ windowId = AddWindow(&winTemplate);
+ FillWindowPixelBuffer(windowId, 0x44);
+
+ center = GetStringCenterAlignXOffset(1, boxName, 0x40);
+ box_print(windowId, 1, center, 1, gUnknown_08571734, TEXT_SPEED_FF, boxName);
+
+ ConvertIntToDecimalStringN(text, nPokemonInBox, 1, 2);
+ StringAppend(text, gUnknown_08571737);
+ center = GetStringCenterAlignXOffset(1, text, 0x40);
+ box_print(windowId, 1, center, 0x11, gUnknown_08571734, TEXT_SPEED_FF, text);
+
+ winTileData = GetWindowAttribute(windowId, WINDOW_TILE_DATA);
+ CpuCopy32((void *)winTileData, (void *)OBJ_VRAM0 + 0x100 + (GetSpriteTileStartByTag(gUnknown_02039D04->unk_0240) * 32), 0x400);
+
+ RemoveWindow(windowId);
+}
+
+void sub_80C7CF4(struct Sprite *sprite)
+{
+ if (++sprite->data[1] > 3)
{
- size >>= 1;
- for (i = 0; i < count; i++)
+ sprite->data[1] = 0;
+ sprite->pos2.x += sprite->data[0];
+ if (++sprite->data[2] > 5)
{
- CpuSet(src, dst, size >> 0x10);
- dst += 0x20;
- src += srcBy;
+ sprite->data[2] = 0;
+ sprite->pos2.x = 0;
}
}
-}*/
+}
+
+void sub_80C7D28(void)
+{
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ sub_80D2AA4();
+ TransferPlttBuffer();
+ SetGpuReg(REG_OFFSET_BG2HOFS, gUnknown_02039D08->bg2_X);
+}
+
+void c2_Box(void)
+{
+ RunTasks();
+ do_scheduled_bg_tilemap_copies_to_vram();
+ sub_80CA028();
+ sub_80CAA14();
+ AnimateSprites();
+ BuildOamBuffer();
+}
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index 728b887f8..38b1fea4f 100644
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -29,6 +29,7 @@
#include "daycare.h"
#include "data2.h"
#include "contest.h"
+#include "contest_effect.h"
extern struct UnkSummaryStruct* gUnknown_0203CF1C;
extern struct BgTemplate gUnknown_0861CBB4;
@@ -41,7 +42,6 @@ extern struct UnkStruct_61CC04 gUnknown_0861CC10;
extern struct UnkStruct_61CC04 gUnknown_0861CBEC;
extern struct UnkStruct_61CC04 gUnknown_0861CBF8;
extern u16 gSummaryScreenWindow_Tilemap[];
-extern struct ContestMove gContestMoves[];
extern struct ContestEffect gContestEffects[];
extern struct WindowTemplate gUnknown_0861CC24;
extern u8 gUnknown_0861CD2C[][3];
diff --git a/src/slot_machine.c b/src/slot_machine.c
new file mode 100644
index 000000000..5422103c3
--- /dev/null
+++ b/src/slot_machine.c
@@ -0,0 +1,1366 @@
+#include "global.h"
+#include "constants/songs.h"
+#include "overworld.h"
+#include "field_effect.h"
+#include "random.h"
+#include "sound.h"
+#include "main.h"
+#include "slot_machine.h"
+#include "string_util.h"
+#include "decompress.h"
+#include "trig.h"
+#include "graphics.h"
+#include "palette.h"
+#include "util.h"
+#include "text.h"
+#include "menu.h"
+#include "malloc.h"
+#include "bg.h"
+#include "gpu_regs.h"
+#include "coins.h"
+#include "tv.h"
+#include "text_window.h"
+#include "constants/rgb.h"
+#include "main_menu.h"
+
+enum
+{
+ SLOT_MACHINE_TAG_7_RED,
+ SLOT_MACHINE_TAG_7_BLUE,
+ SLOT_MACHINE_TAG_AZURILL,
+ SLOT_MACHINE_TAG_LOTAD,
+ SLOT_MACHINE_TAG_CHERRY,
+ SLOT_MACHINE_TAG_POWER,
+ SLOT_MACHINE_TAG_REPLAY
+};
+
+enum
+{
+ SLOT_MACHINE_MATCHED_1CHERRY,
+ SLOT_MACHINE_MATCHED_2CHERRY,
+ SLOT_MACHINE_MATCHED_REPLAY,
+ SLOT_MACHINE_MATCHED_LOTAD,
+ SLOT_MACHINE_MATCHED_AZURILL,
+ SLOT_MACHINE_MATCHED_POWER,
+ SLOT_MACHINE_MATCHED_777_MIXED,
+ SLOT_MACHINE_MATCHED_777_RED,
+ SLOT_MACHINE_MATCHED_777_BLUE,
+ SLOT_MACHINE_MATCHED_NONE
+};
+
+struct SlotMachineEwramStruct
+{
+ /*0x00*/ u8 state;
+ /*0x01*/ u8 unk01;
+ /*0x02*/ u8 pikaPower;
+ /*0x03*/ u8 unk03;
+ /*0x04*/ u8 unk04;
+ /*0x05*/ u8 unk05;
+ /*0x06*/ u8 unk06;
+ /*0x07*/ u8 unk07;
+ /*0x08*/ u16 matchedSymbols;
+ /*0x0A*/ u8 unk0A;
+ /*0x0B*/ u8 unk0B;
+ /*0x0C*/ s16 coins;
+ /*0x0E*/ s16 payout;
+ /*0x10*/ s16 unk10;
+ /*0x12*/ s16 bet;
+ /*0x14*/ s16 unk14;
+ /*0x16*/ s16 unk16;
+ /*0x18*/ s16 unk18;
+ /*0x1A*/ s16 unk1A;
+ /*0x1C*/ s16 unk1C[3];
+ /*0x22*/ u16 unk22[3];
+ /*0x28*/ s16 reelPositions[3];
+ /*0x2E*/ s16 unk2E[3];
+ /*0x34*/ s16 unk34[3];
+ /*0x3A*/ u8 reelTasks[3];
+ /*0x3D*/ u8 unk3D;
+ /*0x3E*/ u8 unk3E;
+ /*0x3F*/ u8 unk3F;
+ /*0x40*/ u8 unk40;
+ /*0x41*/ u8 unk41;
+ /*0x42*/ u8 unk42;
+ /*0x43*/ u8 unk43;
+ /*0x44*/ u8 unk44[5];
+ /*0x49*/ u8 unk49[2];
+ /*0x49*/ u8 unk4B[3];
+ /*0x4E*/ u8 unk4E[2];
+ /*0x50*/ u8 unk50[2];
+ /*0x52*/ u8 unk52[2];
+ /*0x54*/ u8 unk54[4];
+ /*0x58*/ u16 win0h;
+ /*0x5a*/ u16 win0v;
+ /*0x5c*/ u16 winIn;
+ /*0x5e*/ u16 winOut;
+ /*0x60*/ u16 backupMapMusic;
+ /*0x64*/ MainCallback prevMainCb;
+};
+
+extern struct SlotMachineEwramStruct *sSlotMachine;
+
+struct UnkStruct1
+{
+ /*0x00*/ u8 unk00;
+ /*0x01*/ u8 unk01;
+ /*0x02*/ s16 unk02;
+};
+
+#define SLOTMACHINE_GFX_TILES 233
+
+/*static*/void CB2_SlotMachineSetup(void);
+/*static*/void CB2_SlotMachineLoop(void);
+/*static*/void PlaySlotMachine_Internal(u8 arg0, MainCallback cb);
+/*static*/void SlotMachineDummyTask(u8 taskId);
+/*static*/void SlotMachineSetup_0_0(void);
+/*static*/void SlotMachineSetup_6_2(void);
+/*static*/void SlotMachineSetup_1_0(void);
+/*static*/void SlotMachineSetup_2_0(void);
+/*static*/void SlotMachineSetup_2_1(void);
+/*static*/void SlotMachineSetup_0_1(void);
+/*static*/void SlotMachineSetup_3_0(void);
+/*static*/void SlotMachineSetup_4_0(void);
+/*static*/void SlotMachineSetup_5_0(void);
+/*static*/void SlotMachineSetup_6_0(void);
+/*static*/void SlotMachineSetup_6_1(void);
+/*static*/void SlotMachineSetup_8_0(void);
+/*static*/void SlotMachineSetup_9_0(void);
+/*static*/void SlotMachineSetup_10_0(void);
+/*static*/void SlotMachineSetup_10_1(void);
+/*static*/void sub_8101D04(void);
+/*static*/void sub_8104DA4(void);
+/*static*/void sub_8101D24(u8 taskId);
+/*static*/bool8 sub_8101D5C(struct Task *task);
+/*static*/bool8 sub_8101D8C(struct Task *task);
+/*static*/bool8 sub_8101DB0(struct Task *task);
+/*static*/bool8 sub_8101DF4(struct Task *task);
+/*static*/bool8 sub_8101E10(struct Task *task);
+/*static*/bool8 sub_8101E3C(struct Task *task);
+/*static*/bool8 sub_8101F44(struct Task *task);
+/*static*/bool8 sub_8101F60(struct Task *task);
+/*static*/bool8 sub_8101F88(struct Task *task);
+/*static*/bool8 sub_8101FA4(struct Task *task);
+/*static*/bool8 sub_8102008(struct Task *task);
+/*static*/bool8 sub_8102034(struct Task *task);
+/*static*/bool8 sub_8102058(struct Task *task);
+/*static*/bool8 sub_8102090(struct Task *task);
+bool8 sub_81020C8(struct Task *task);
+/*static*/bool8 sub_81021E0(struct Task *task);
+/*static*/bool8 sub_81021FC(struct Task *task);
+/*static*/bool8 sub_8102264(struct Task *task);
+/*static*/bool8 sub_81022A0(struct Task *task);
+/*static*/bool8 sub_81022CC(struct Task *task);
+/*static*/bool8 sub_81022F0(struct Task *task);
+/*static*/bool8 sub_8102318(struct Task *task);
+/*static*/bool8 sub_8102344(struct Task *task);
+/*static*/bool8 sub_810239C(struct Task *task);
+/*static*/bool8 sub_81023B8(struct Task *task);
+/*static*/bool8 sub_81023E0_(struct Task *task);
+/*static*/bool8 sub_81023FC(struct Task *task);
+/*static*/bool8 sub_8102424(struct Task *task);
+/*static*/bool8 sub_8102460(struct Task *task);
+/*static*/void sub_8102484(void);
+/*static*/void sub_81024F0(void);
+/*static*/bool8 sub_8102540_(void);
+/*static*/u8 sub_8102578(void);
+/*static*/u16 dp15_jump_random_unknown(void);
+/*static*/u8 sub_81025BC(void);
+/*static*/void CheckMatch(void);
+/*static*/void CheckMatch_CenterRow(void);
+/*static*/void CheckMatch_TopAndBottom(void);
+/*static*/void CheckMatch_Diagonals(void);
+/*static*/u8 GetMatchFromSymbolsInRow(u8 c1, u8 c2, u8 c3);
+/*static*/void sub_8102A24(void);
+/*static*/void sub_8102A64(u8 taskId);
+/*static*/bool8 sub_8102A44(void);
+/*static*/bool8 sub_8102A9C(struct Task *task);
+/*static*/bool8 sub_8102AD0(struct Task *task);
+/*static*/bool8 sub_8102B80(struct Task *task);
+/*static*/u8 GetTagOfReelSymbolOnScreenAtPos(u8 x, s16 y);
+/*static*/void sub_8102DA8(void);
+/*static*/void sub_8102DEC(u8 a0);
+/*static*/void sub_8102E1C(u8 a0);
+/*static*/bool8 sub_8102E40(u8 a0);
+/*static*/void sub_8102E68(u8 taskId);
+/*static*/bool8 sub_8102EA0(struct Task *task);
+/*static*/bool8 sub_8102EA4(struct Task *task);
+/*static*/bool8 sub_8102EC0(struct Task *task);
+/*static*/bool8 sub_8102F4C(struct Task *task);
+/*static*/bool8 sub_8103008(struct Task *task);
+/*static*/bool8 sub_810305C(void);
+/*static*/bool8 sub_8103154(u8 a0, u8 a1);
+/*static*/bool8 sub_81031B4(u8 a0, u8 a1);
+/*static*/bool8 sub_81032C0(void);
+/*static*/bool8 sub_81032E8(void);
+/*static*/bool8 sub_810333C(void);
+/*static*/bool8 sub_81033DC(void);
+/*static*/bool8 sub_810341C(u8 a0);
+/*static*/bool8 sub_810347C(u8 a0);
+/*static*/void sub_81034F4(void);
+/*static*/void sub_8103540(void);
+/*static*/void sub_8103564(void);
+/*static*/void j5_08111E84(void);
+/*static*/void sub_8103668(void);
+/*static*/void sub_810380C(void);
+/*static*/void sub_8103830(void);
+/*static*/void sub_8103910(void);
+/*static*/void sub_8103A78(void);
+/*static*/void sub_8103C14(u8 a0);
+/*static*/void sub_8103C48(u8 taskId);
+/*static*/void sub_8103D50(u8 a0);
+/*static*/void sub_8103C78(struct Task *task, u8 taskId);
+/*static*/void sub_8103CAC(struct Task *task, u8 taskId);
+/*static*/void sub_8103CC8(struct Task *task, u8 taskId);
+/*static*/void sub_8103D8C(u8 a0);
+/*static*/void sub_8103DC8(void);
+/*static*/void sub_8103E04(u8 a0);
+/*static*/bool8 sub_8103E38(void);
+/*static*/bool8 sub_8103E7C(void);
+/*static*/bool8 sub_8103EAC(u8 spriteId);
+/*static*/void sub_8103EE4(struct Sprite *sprite);
+/*static*/void sub_8103F70(void);
+/*static*/bool8 sub_8103FA0(void);
+/*static*/void sub_8103FE8(u8 taskId);
+/*static*/void sub_8104048(void);
+/*static*/void sub_8104064(u8 pikaPower);
+/*static*/bool8 sub_81040C8(void);
+/*static*/void sub_81040E8(u8 taskId);
+/*static*/void nullsub_68(struct Task *task);
+/*static*/void sub_810411C(struct Task *task);
+/*static*/void sub_8104144(struct Task *task);
+/*static*/void sub_81041AC(struct Task *task);
+/*static*/void sub_810421C(struct Task *task);
+/*static*/void sub_810423C(u8 pikaPower);
+/*static*/void sub_810430C(void);
+/*static*/bool8 sub_810432C(void);
+/*static*/void sub_810434C(u8 taskId);
+/*static*/void sub_810437C(struct Task *task);
+/*static*/void sub_81043EC(struct Task *task);
+/*static*/void sub_8104468(struct Task *task);
+/*static*/void sub_8104498(struct Task *task);
+/*static*/void sub_8104548(struct Task *task);
+/*static*/void sub_8104598(struct Task *task);
+/*static*/void sub_81045CC(struct Task *task);
+/*static*/void sub_810463C(struct Task *task);
+/*static*/void sub_81046C0(struct Task *task);
+/*static*/void sub_8104764(struct Task *task);
+/*static*/void sub_8104794(struct Task *task);
+/*static*/void sub_81047EC(struct Task *task);
+/*static*/void sub_8104860(struct Task *task);
+/*static*/void sub_81048A8(struct Task *task);
+/*static*/void sub_81048CC(struct Task *task);
+/*static*/void sub_8104940(struct Task *task);
+/*static*/void sub_81049C8(struct Task *task);
+/*static*/void sub_81049F8(struct Task *task);
+/*static*/void sub_8104A40(s16 a0, s16 a1);
+/*static*/void sub_8104A88(s16 a0);
+/*static*/void sub_8104AB8(u8 a0);
+/*static*/bool8 sub_8104AEC(void);
+/*static*/void sub_8104B0C(u8 taskId);
+/*static*/void sub_8104B3C(struct Task *task);
+/*static*/void sub_8104B60(struct Task *task);
+/*static*/void sub_8104B80(struct Task *task);
+/*static*/void sub_8104BC8(struct Task *task);
+/*static*/void sub_8104BFC(struct Task *task);
+/*static*/void sub_8104C44(struct Task *task);
+/*static*/void sub_8104C5C(void);
+/*static*/void sub_8104CAC(u8 arg0);
+/*static*/bool8 sub_8104E18(void);
+/*static*/void nullsub_69(struct Task *task);
+/*static*/void sub_8104E74(u8 taskId);
+/*static*/void sub_8104EA8(void);
+/*static*/void sub_8104F8C(void);
+/*static*/void sub_8104FF4(s16 x, s16 y, u8 a2, s16 a3);
+/*static*/void sub_81050C4(void);
+/*static*/void sub_8105100(void);
+/*static*/void sub_810514C(void);
+/*static*/void sub_81051C0(void);
+/*static*/void sub_8105284(void);
+/*static*/void sub_81052EC(void);
+/*static*/void sub_81053A0(void);
+/*static*/void sub_810545C(void);
+/*static*/void sub_81054B8(void);
+/*static*/void sub_8105524(void);
+/*static*/void sub_8105554(void);
+/*static*/void sub_8105578(void);
+/*static*/void sub_8105688(s16 a0);
+/*static*/void sub_81056C0(void);
+/*static*/void sub_81056F0(void);
+/*static*/void sub_81057E8(s16 a0);
+/*static*/void sub_8105804(void);
+/*static*/void sub_8105854(void);
+/*static*/void sub_81058A0(void);
+/*static*/void sub_81058C4(void);
+/*static*/void sub_81059B8(void);
+/*static*/void sub_81059E8(void);
+/*static*/bool8 sub_8105ACC(void);
+/*static*/void sub_8105AEC(void);
+/*static*/u8 sub_8105B1C(s16 x, s16 y);
+/*static*/void sub_8105B88(u8 spriteId);
+/*static*/u8 sub_8105BF8(u8 templateIdx, void (*callback)(struct Sprite*), s16 x, s16 y, s16 a4);
+/*static*/void sub_81063C0(void);
+/*static*/void sub_8106404(void);
+/*static*/void sub_8106448(void);
+/*static*/void sub_81064B8(void);
+/*static*/void sub_81065A8(s16 arg0, u16 arg1, u16 arg2, u16 arg3, u16 arg4);
+/*static*/void sub_81065DC(void);
+/*static*/extern const struct UnkStruct1 *const gUnknown_083ED048[];
+/*static*/extern const u16 gPalette_83EDE24[];
+/*static*/extern const u8 gUnknown_083ECD04[][3];
+/*static*/extern const u8 gUnknown_083ECE3A[];
+/*static*/extern const u16 gUnknown_083ECE42[];
+/*static*/extern const u16 gUnknown_083ECE48[];
+
+// code
+#define tState data[0]
+
+void Task_FadeToSlotMachine(u8 taskId)
+{
+ switch (gTasks[taskId].tState)
+ {
+ case 0:
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 0x10, 0);
+ gTasks[taskId].tState++;
+ break;
+ case 1:
+ if (!gPaletteFade.active)
+ {
+ SetMainCallback2(CB2_SlotMachineSetup);
+ DestroyTask(taskId);
+ }
+ break;
+ }
+}
+
+void PlaySlotMachine(u8 arg0, MainCallback cb)
+{
+ u8 taskId;
+
+ sSlotMachine = AllocZeroed(sizeof(*sSlotMachine));
+ PlaySlotMachine_Internal(arg0, cb);
+ taskId = CreateTask(Task_FadeToSlotMachine, 0);
+ gTasks[taskId].tState = 0;
+}
+
+#undef tState
+
+void CB2_SlotMachineSetup(void)
+{
+ switch (gMain.state)
+ {
+ case 0:
+ SlotMachineSetup_0_0();
+ SlotMachineSetup_0_1();
+ gMain.state++;
+ break;
+ case 1:
+ SlotMachineSetup_1_0();
+ gMain.state++;
+ break;
+ case 2:
+ SlotMachineSetup_2_0();
+ SlotMachineSetup_2_1();
+ gMain.state++;
+ break;
+ case 3:
+ SlotMachineSetup_3_0();
+ gMain.state++;
+ break;
+ case 4:
+ SlotMachineSetup_4_0();
+ gMain.state++;
+ break;
+ case 5:
+ SlotMachineSetup_5_0();
+ gMain.state++;
+ break;
+ case 6:
+ SlotMachineSetup_6_0();
+ gMain.state++;
+ break;
+ case 7:
+ BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
+ ShowBg(0);
+ ShowBg(1);
+ ShowBg(2);
+ ShowBg(3);
+ gMain.state++;
+ break;
+ case 8:
+ SlotMachineSetup_8_0();
+ gMain.state++;
+ break;
+ case 9:
+ SlotMachineSetup_9_0();
+ gMain.state++;
+ break;
+ case 10:
+ SlotMachineSetup_10_0();
+ SlotMachineSetup_10_1();
+ gMain.state++;
+ break;
+ case 11:
+ SetMainCallback2(CB2_SlotMachineLoop);
+ break;
+ }
+}
+
+void CB2_SlotMachineLoop(void)
+{
+ RunTasks();
+ AnimateSprites();
+ BuildOamBuffer();
+ UpdatePaletteFade();
+}
+
+void SlotMachine_VBlankCallback(void)
+{
+ LoadOam();
+ ProcessSpriteCopyRequests();
+ TransferPlttBuffer();
+ SetGpuReg(REG_OFFSET_WIN0H, sSlotMachine->win0h);
+ SetGpuReg(REG_OFFSET_WIN0V, sSlotMachine->win0v);
+ SetGpuReg(REG_OFFSET_WININ, sSlotMachine->winIn);
+ SetGpuReg(REG_OFFSET_WINOUT, sSlotMachine->winOut);
+}
+
+void PlaySlotMachine_Internal(u8 arg0, MainCallback cb)
+{
+ struct Task *task = gTasks + CreateTask(SlotMachineDummyTask, 0xFF);
+ task->data[0] = arg0;
+ StoreWordInTwoHalfwords(task->data + 1, (intptr_t)cb);
+}
+
+void sub_81019EC(void)
+{
+ struct Task *task = gTasks + FindTaskIdByFunc(SlotMachineDummyTask);
+ sSlotMachine->unk01 = task->data[0];
+ LoadWordFromTwoHalfwords((u16 *)(task->data + 1), (u32 *)&sSlotMachine->prevMainCb);
+}
+
+void SlotMachineDummyTask(u8 taskId)
+{
+}
+
+extern const struct BgTemplate gUnknown_085A7424[4];
+extern const struct WindowTemplate gUnknown_085A7434[];
+
+void SlotMachineSetup_0_0(void)
+{
+ SetVBlankCallback(NULL);
+ SetHBlankCallback(NULL);
+ CpuFill32(0, (void *)VRAM, VRAM_SIZE);
+ ResetBgsAndClearDma3BusyFlags(0);
+ InitBgsFromTemplates(0, gUnknown_085A7424, ARRAY_COUNT(gUnknown_085A7424));
+ InitWindows(gUnknown_085A7434);
+ DeactivateAllTextPrinters();
+}
+
+void SlotMachineSetup_6_0(void)
+{
+ SetVBlankCallback(SlotMachine_VBlankCallback);
+ EnableInterrupts(INTR_FLAG_VBLANK);
+ SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_OBJ_1D_MAP | DISPCNT_OBJ_ON | DISPCNT_WIN0_ON);
+}
+
+void SlotMachineSetup_1_0(void)
+{
+ DmaClearLarge16(3, (u16 *)(BG_VRAM), BG_VRAM_SIZE, 0x1000);
+}
+
+void SlotMachineSetup_2_0(void)
+{
+ DmaClear16(3, (u16 *)OAM, OAM_SIZE);
+}
+
+void SlotMachineSetup_2_1(void)
+{
+ SetGpuReg(REG_OFFSET_BG0CNT, 0);
+ SetGpuReg(REG_OFFSET_BG1CNT, 0);
+ SetGpuReg(REG_OFFSET_BG2CNT, 0);
+ SetGpuReg(REG_OFFSET_BG3CNT, 0);
+ SetGpuReg(REG_OFFSET_BG0HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+ SetGpuReg(REG_OFFSET_BG1HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG1VOFS, 0);
+ SetGpuReg(REG_OFFSET_BG2HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG2VOFS, 0);
+ SetGpuReg(REG_OFFSET_BG3HOFS, 0);
+ SetGpuReg(REG_OFFSET_BG3VOFS, 0);
+ SetGpuReg(REG_OFFSET_WININ, WININ_WIN0_BG0 | WININ_WIN0_BG1 | WININ_WIN0_BG2 | WININ_WIN0_BG3 | WININ_WIN0_OBJ | WININ_WIN0_CLR);
+ SetGpuReg(REG_OFFSET_WINOUT, WINOUT_WIN01_BG0 | WINOUT_WIN01_BG1 | WINOUT_WIN01_BG2 | WINOUT_WIN01_BG3 | WINOUT_WIN01_OBJ | WINOUT_WIN01_CLR);
+ SetGpuReg(REG_OFFSET_BLDCNT, BLDCNT_TGT1_BG3 | BLDCNT_EFFECT_BLEND | BLDCNT_TGT2_OBJ);
+ SetGpuReg(REG_OFFSET_BLDALPHA, BLDALPHA_BLEND(9, 8));
+}
+
+extern const s16 gUnknown_083ECCF8[][2];
+
+void SlotMachineSetup_0_1(void)
+{
+ u8 i;
+
+ sub_81019EC();
+ sSlotMachine->state = 0;
+ sSlotMachine->pikaPower = 0;
+ sSlotMachine->unk03 = Random() & 1;
+ sSlotMachine->unk04 = 0;
+ sSlotMachine->matchedSymbols = 0;
+ sSlotMachine->unk0A = 0;
+ sSlotMachine->unk0B = 0;
+ sSlotMachine->coins = GetCoins();
+ sSlotMachine->payout = 0;
+ sSlotMachine->unk10 = 0;
+ sSlotMachine->bet = 0;
+ sSlotMachine->unk18 = 0;
+ sSlotMachine->unk1A = 8;
+ sSlotMachine->win0h = 0xf0;
+ sSlotMachine->win0v = 0xa0;
+ sSlotMachine->winIn = 0x3f;
+ sSlotMachine->winOut = 0x3f;
+ sSlotMachine->backupMapMusic = GetCurrentMapMusic();
+ for (i = 0; i < 3; i++)
+ {
+ sSlotMachine->unk22[i] = 0;
+ sSlotMachine->reelPositions[i] = gUnknown_083ECCF8[i][sSlotMachine->unk03] % 21;
+ sSlotMachine->unk1C[i] = 0x1f8 - sSlotMachine->reelPositions[i] * 24;
+ sSlotMachine->unk1C[i] %= 0x1f8;
+ }
+ sub_80EDE70(GetCoins());
+}
+
+extern u8 gOamLimit;
+
+void SlotMachineSetup_3_0(void)
+{
+ ResetPaletteFade();
+ ResetSpriteData();
+ gOamLimit = 0x80;
+ FreeAllSpritePalettes();
+ ResetTasks();
+}
+
+extern u16 *gUnknown_0203AAC8;
+extern u16 *gUnknown_0203AACC;
+extern u16 *gUnknown_0203AAD0;
+extern u16 *gUnknown_0203AADC;
+extern void *gUnknown_0203AAF4;
+extern void *gUnknown_0203AAF8;
+extern void *gUnknown_0203AAFC;
+extern void *gUnknown_0203AB00;
+extern void *gUnknown_0203AB04;
+extern void *gUnknown_0203AB08;
+extern void *gUnknown_0203AB0C;
+extern void *gUnknown_0203AB10;
+extern void *gUnknown_0203AB14;
+extern void *gUnknown_0203AB18;
+extern void *gUnknown_0203AB1C;
+extern void *gUnknown_0203AB20;
+extern void *gUnknown_0203AB24;
+extern void *gUnknown_0203AB28;
+extern void *gUnknown_0203AAE4;
+extern void *gUnknown_0203AAE8;
+extern void *gUnknown_0203AAEC;
+extern void *gUnknown_0203AAF0;
+extern void *gUnknown_0203AAD4;
+extern void *gUnknown_0203AAD8;
+extern void *gUnknown_0203AAE0;
+extern void *gUnknown_0203AB2C;
+extern void *gUnknown_0203AB30;
+
+void SlotMachineSetup_4_0(void)
+{
+ gUnknown_0203AACC = Alloc(8);
+ gUnknown_0203AAD0 = AllocZeroed(0xE);
+ gUnknown_0203AADC = AllocZeroed(8);
+
+ gUnknown_0203AAD0[0] = 0x2051;
+ gUnknown_0203AAD0[1] = 0x2851;
+ gUnknown_0203AAD0[2] = 0x2061;
+ gUnknown_0203AAD0[3] = 0x2861;
+ gUnknown_0203AAD0[4] = 0x20BE;
+ gUnknown_0203AAD0[5] = 0x28BE;
+ gUnknown_0203AAD0[6] = 0x20BF;
+}
+
+/*static*/void sub_812F908(void);
+/*static*/void sub_812F958(void);
+/*static*/void sub_812F7E4(void);
+
+void SlotMachineSetup_5_0(void)
+{
+ sub_812F908();
+ sub_812F958();
+ sub_812F7E4();
+ LoadMessageBoxGfx(0, 0x200, 0xF0);
+ LoadUserWindowBorderGfx(0, 0x214, 0xE0);
+ PutWindowTilemap(0);
+}
+
+void SlotMachineSetup_10_0(void)
+{
+ sub_8104EA8();
+ sub_8104F8C();
+ sub_8103DC8();
+ sub_81050C4();
+}
+
+void SlotMachineSetup_10_1(void)
+{
+ sub_8104048();
+ sub_8102DA8();
+ sub_8104C5C();
+ sub_8101D04();
+}
+
+void sub_8101D04(void)
+{
+ sub_8101D24(CreateTask(sub_8101D24, 0));
+}
+
+extern bool8 (*const gUnknown_083ECAAC[])(struct Task *task);
+
+void sub_8101D24(u8 taskId)
+{
+ while (gUnknown_083ECAAC[sSlotMachine->state](gTasks + taskId))
+ ;
+}
+
+bool8 sub_8101D5C(struct Task *task)
+{
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, RGB(0, 0, 0));
+ sub_810423C(sSlotMachine->pikaPower);
+ sSlotMachine->state++;
+ return FALSE;
+}
+
+bool8 sub_8101D8C(struct Task *task)
+{
+ if (!gPaletteFade.active)
+ sSlotMachine->state++;
+ return FALSE;
+}
+
+bool8 sub_8101DB0(struct Task *task)
+{
+ sSlotMachine->payout = 0;
+ sSlotMachine->bet = 0;
+ sSlotMachine->unk18 = 0;
+ sSlotMachine->unk04 &= 0xc0;
+ sSlotMachine->state = 4;
+ if (sSlotMachine->coins <= 0)
+ {
+ sSlotMachine->state = 25;
+ }
+ else if (sSlotMachine->unk0A)
+ {
+ sSlotMachine->state = 3;
+ sub_8104CAC(4);
+ }
+ return TRUE;
+}
+
+bool8 sub_8101DF4(struct Task *task)
+{
+ if (sub_8104E18())
+ sSlotMachine->state = 4;
+ return FALSE;
+}
+
+bool8 sub_8101E10(struct Task *task)
+{
+ sub_8104CAC(0);
+ sSlotMachine->state = 5;
+ if (sSlotMachine->coins >= 9999)
+ sSlotMachine->state = 23;
+ return TRUE;
+}
+
+bool8 sub_8101E3C(struct Task *task)
+{
+ s16 i;
+
+ if (gMain.newKeys & SELECT_BUTTON)
+ {
+ sub_8104AB8(0);
+ sSlotMachine->state = 8;
+ }
+ else if (gMain.newKeys & R_BUTTON)
+ {
+ if (sSlotMachine->coins - (3 - sSlotMachine->bet) >= 0)
+ {
+ for (i = sSlotMachine->bet; i < 3; i++)
+ sub_8103D50(i);
+ sSlotMachine->coins -= (3 - sSlotMachine->bet);
+ sSlotMachine->bet = 3;
+ sSlotMachine->state = 9;
+ PlaySE(SE_REGI);
+ }
+ else
+ {
+ sSlotMachine->state = 6;
+ }
+ }
+ else
+ {
+ if (gMain.newKeys & DPAD_DOWN && sSlotMachine->coins != 0)
+ {
+ PlaySE(SE_REGI);
+ sub_8103D50(sSlotMachine->bet);
+ sSlotMachine->coins--;
+ sSlotMachine->bet++;
+ }
+ if (sSlotMachine->bet >= 3 || (sSlotMachine->bet != 0 && gMain.newKeys & A_BUTTON))
+ sSlotMachine->state = 9;
+ if (gMain.newKeys & B_BUTTON)
+ sSlotMachine->state = 21;
+ }
+ return FALSE;
+}
+
+extern const u8 gText_YouDontHaveThreeCoins[];
+extern const u8 gText_QuitTheGame[];
+extern const u8 gText_YouveGot9999Coins[];
+extern const u8 gText_YouveRunOutOfCoins[];
+
+bool8 sub_8101F44(struct Task *task)
+{
+ NewMenuHelpers_DrawDialogueFrame(0, 0);
+ PrintTextOnWindow(0, 1, gText_YouDontHaveThreeCoins, 0, 1, 0, 0);
+ CopyWindowToVram(0, 3);
+ sSlotMachine->state = 7;
+ return FALSE;
+}
+
+bool8 sub_8101F60(struct Task *task)
+{
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ sub_8197434(0, TRUE);
+ sSlotMachine->state = 5;
+ }
+ return FALSE;
+}
+
+bool8 sub_8101F88(struct Task *task)
+{
+ if (sub_8104AEC())
+ sSlotMachine->state = 5;
+ return FALSE;
+}
+
+bool8 sub_8101FA4(struct Task *task)
+{
+ sub_8102484();
+ sub_8104DA4();
+ sub_8102DEC(0);
+ sub_8102DEC(1);
+ sub_8102DEC(2);
+ sub_80EEC80();
+ task->data[0] = 0;
+ if (sSlotMachine->unk04 & 0x20)
+ {
+ sub_810430C();
+ sSlotMachine->state = 10;
+ }
+ else
+ {
+ sub_8104CAC(1);
+ sSlotMachine->state = 11;
+ }
+ sSlotMachine->unk1A = 8;
+ if (sSlotMachine->unk0A)
+ sSlotMachine->unk1A = dp15_jump_random_unknown();
+ return FALSE;
+}
+
+bool8 sub_8102008(struct Task *task)
+{
+ if (sub_810432C())
+ {
+ sub_8104CAC(1);
+ sSlotMachine->unk04 &= 0xDF;
+ sSlotMachine->state = 11;
+ }
+ return FALSE;
+}
+
+bool8 sub_8102034(struct Task *task)
+{
+ if (++task->data[0] >= 30)
+ {
+ sub_81024F0();
+ sSlotMachine->state = 12;
+ }
+ return FALSE;
+}
+
+bool8 sub_8102058(struct Task *task)
+{
+ if (gMain.newKeys & A_BUTTON)
+ {
+ PlaySE(SE_JYUNI);
+ sub_8102E1C(sSlotMachine->unk18);
+ sub_8103C14(sSlotMachine->unk18);
+ sSlotMachine->state = 13;
+ }
+ return FALSE;
+}
+
+bool8 sub_8102090(struct Task *task)
+{
+ if (!sub_8102E40(sSlotMachine->unk18))
+ {
+ sSlotMachine->unk18++;
+ sSlotMachine->state = 12;
+ if (sSlotMachine->unk18 > 2)
+ {
+ sSlotMachine->state = 14;
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+bool8 sub_81020C8(struct Task *task)
+{
+ sSlotMachine->unk04 &= 0xc0;
+ CheckMatch();
+ if (sSlotMachine->unk0A)
+ {
+ sSlotMachine->unk0A--;
+ sSlotMachine->unk0B++;
+ }
+
+ if (sSlotMachine->matchedSymbols)
+ {
+ sSlotMachine->state = 15;
+ sub_8102A24();
+ sub_8103F70();
+ if ((sSlotMachine->unk10 -= sSlotMachine->payout) < 0)
+ {
+ sSlotMachine->unk10 = 0;
+ }
+ if (sSlotMachine->matchedSymbols & ((1 << SLOT_MACHINE_MATCHED_777_BLUE) | (1 << SLOT_MACHINE_MATCHED_777_RED)))
+ {
+ PlayFanfare(MUS_ME_B_BIG);
+ sub_8104CAC(6);
+ }
+ else if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_777_MIXED))
+ {
+ PlayFanfare(MUS_ME_B_BIG);
+ sub_8104CAC(5);
+ }
+ else
+ {
+ PlayFanfare(MUS_ME_B_SMALL);
+ sub_8104CAC(2);
+ }
+ if (sSlotMachine->matchedSymbols & ((1 << SLOT_MACHINE_MATCHED_777_MIXED) | (1 << SLOT_MACHINE_MATCHED_777_BLUE) | (1 << SLOT_MACHINE_MATCHED_777_RED)))
+ {
+ sSlotMachine->unk04 &= 0x3f;
+ if (sSlotMachine->matchedSymbols & ((1 << SLOT_MACHINE_MATCHED_777_BLUE) | (1 << SLOT_MACHINE_MATCHED_777_RED)))
+ {
+ sSlotMachine->unk0A = 0;
+ sSlotMachine->unk0B = 0;
+ sSlotMachine->unk03 = 0;
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_777_BLUE))
+ sSlotMachine->unk03 = 1;
+ }
+ }
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_POWER) && sSlotMachine->pikaPower < 16)
+ {
+ sSlotMachine->pikaPower++;
+ sub_8104064(sSlotMachine->pikaPower);
+ }
+ }
+ else
+ {
+ sub_8104CAC(3);
+ sSlotMachine->state = 20;
+ if ((sSlotMachine->unk10 += sSlotMachine->bet) > 9999)
+ sSlotMachine->unk10 = 9999;
+ }
+ return FALSE;
+}
+
+bool8 sub_81021E0(struct Task *task)
+{
+ if (sub_8102A44())
+ sSlotMachine->state = 16;
+ return FALSE;
+}
+
+bool8 sub_81021FC(struct Task *task)
+{
+ if (sub_8103FA0())
+ {
+ sSlotMachine->state = 19;
+ if (sSlotMachine->matchedSymbols & ((1 << SLOT_MACHINE_MATCHED_777_RED) | (1 << SLOT_MACHINE_MATCHED_777_BLUE)))
+ IncrementGameStat(GAME_STAT_SLOT_JACKPOTS);
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_REPLAY))
+ {
+ sSlotMachine->unk18 = 0;
+ sSlotMachine->state = 9;
+ }
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_POWER))
+ sSlotMachine->state = 17;
+ if (sSlotMachine->unk0A && sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_REPLAY))
+ {
+ sub_8104CAC(4);
+ sSlotMachine->state = 18;
+ }
+ }
+ return FALSE;
+}
+
+bool8 sub_8102264(struct Task *task)
+{
+ if (!sub_81040C8())
+ {
+ sSlotMachine->state = 19;
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_REPLAY))
+ {
+ sSlotMachine->state = 9;
+ if (sSlotMachine->unk0A)
+ {
+ sub_8104CAC(4);
+ sSlotMachine->state = 18;
+ }
+ }
+ }
+ return FALSE;
+}
+
+bool8 sub_81022A0(struct Task *task)
+{
+ if (sub_8104E18())
+ {
+ sSlotMachine->state = 19;
+ if (sSlotMachine->matchedSymbols & (1 << SLOT_MACHINE_MATCHED_REPLAY))
+ {
+ sSlotMachine->state = 9;
+ }
+ }
+ return FALSE;
+}
+
+bool8 sub_81022CC(struct Task *task)
+{
+ sub_8103D8C(0);
+ sub_8103D8C(1);
+ sub_8103D8C(2);
+ sSlotMachine->state = 2;
+ return FALSE;
+}
+
+bool8 sub_81022F0(struct Task *task)
+{
+ if (++task->data[1] > 64)
+ {
+ task->data[1] = 0;
+ sSlotMachine->state = 19;
+ }
+ return FALSE;
+}
+
+bool8 sub_8102318(struct Task *task)
+{
+ NewMenuHelpers_DrawDialogueFrame(0, 0);
+ PrintTextOnWindow(0, 1, gText_QuitTheGame, 0, 1, 0, 0);
+ CopyWindowToVram(0, 3);
+ sub_80323CC(0x15, 7, 0x214, 0x180, 0xE, 0xF);
+ sSlotMachine->state = 22;
+ return FALSE;
+}
+
+bool8 sub_8102344(struct Task *task)
+{
+ s8 input = ProcessMenuInputNoWrap_();
+ if (input == 0)
+ {
+ sub_8197434(0, TRUE);
+ sub_8103D8C(0);
+ sub_8103D8C(1);
+ sub_8103D8C(2);
+ sSlotMachine->coins += sSlotMachine->bet;
+ sSlotMachine->state = 27;
+ }
+ else if (input == 1 || input == -1)
+ {
+ sub_8197434(0, TRUE);
+ sSlotMachine->state = 5;
+ }
+ return FALSE;
+}
+
+bool8 sub_810239C(struct Task *task)
+{
+ NewMenuHelpers_DrawDialogueFrame(0, 0);
+ PrintTextOnWindow(0, 1, gText_YouveGot9999Coins, 0, 1, 0, 0);
+ CopyWindowToVram(0, 3);
+ sSlotMachine->state = 24;
+ return FALSE;
+}
+
+bool8 sub_81023B8(struct Task *task)
+{
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ sub_8197434(0, TRUE);
+ sSlotMachine->state = 5;
+ }
+ return FALSE;
+}
+
+bool8 sub_81023E0_(struct Task *task)
+{
+ NewMenuHelpers_DrawDialogueFrame(0, 0);
+ PrintTextOnWindow(0, 1, gText_YouveRunOutOfCoins, 0, 1, 0, 0);
+ CopyWindowToVram(0, 3);
+ sSlotMachine->state = 26;
+ return FALSE;
+}
+
+bool8 sub_81023FC(struct Task *task)
+{
+ if (gMain.newKeys & (A_BUTTON | B_BUTTON))
+ {
+ sub_8197434(0, TRUE);
+ sSlotMachine->state = 27;
+ }
+ return FALSE;
+}
+
+bool8 sub_8102424(struct Task *task)
+{
+ SetCoins(sSlotMachine->coins);
+ sub_80EDD78(GetCoins());
+ BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, RGB(0, 0, 0));
+ sSlotMachine->state++;
+ return FALSE;
+}
+
+bool8 sub_8102460(struct Task *task)
+{
+ if (!gPaletteFade.active)
+ {
+ SetMainCallback2(sSlotMachine->prevMainCb);
+ FREE_AND_SET_NULL(gUnknown_0203AAF4);
+ FREE_AND_SET_NULL(gUnknown_0203AAF8);
+ FREE_AND_SET_NULL(gUnknown_0203AAFC);
+ FREE_AND_SET_NULL(gUnknown_0203AB00);
+ FREE_AND_SET_NULL(gUnknown_0203AB04);
+ FREE_AND_SET_NULL(gUnknown_0203AB08);
+ FREE_AND_SET_NULL(gUnknown_0203AB0C);
+ FREE_AND_SET_NULL(gUnknown_0203AB10);
+ FREE_AND_SET_NULL(gUnknown_0203AB14);
+ FREE_AND_SET_NULL(gUnknown_0203AB18);
+ FREE_AND_SET_NULL(gUnknown_0203AB1C);
+ FREE_AND_SET_NULL(gUnknown_0203AB20);
+ FREE_AND_SET_NULL(gUnknown_0203AB24);
+ FREE_AND_SET_NULL(gUnknown_0203AB28);
+ if (gUnknown_0203AAE4 != NULL)
+ FREE_AND_SET_NULL(gUnknown_0203AAE4);
+ if (gUnknown_0203AAE8 != NULL)
+ FREE_AND_SET_NULL(gUnknown_0203AAE8);
+ if (gUnknown_0203AAEC != NULL)
+ FREE_AND_SET_NULL(gUnknown_0203AAEC);
+ if (gUnknown_0203AAF0 != NULL)
+ FREE_AND_SET_NULL(gUnknown_0203AAF0);
+ FREE_AND_SET_NULL(gUnknown_0203AAC8);
+ FREE_AND_SET_NULL(gUnknown_0203AACC);
+ FREE_AND_SET_NULL(gUnknown_0203AAD0);
+ FREE_AND_SET_NULL(gUnknown_0203AAD4);
+ FREE_AND_SET_NULL(gUnknown_0203AAD8);
+ FREE_AND_SET_NULL(gUnknown_0203AADC);
+ FREE_AND_SET_NULL(gUnknown_0203AAE0);
+ FREE_AND_SET_NULL(gUnknown_0203AB2C);
+ FREE_AND_SET_NULL(gUnknown_0203AB30);
+
+ FREE_AND_SET_NULL(sSlotMachine);
+ }
+ return FALSE;
+}
+
+void sub_8102484(void)
+{
+ u8 r3;
+
+ if (sSlotMachine->unk0A == 0)
+ {
+ if (!(sSlotMachine->unk04 & 0xc0))
+ {
+ if (sub_8102540_())
+ {
+ r3 = sub_8102578();
+ if (r3 != 3)
+ {
+ sSlotMachine->unk04 |= gUnknown_083ECE42[r3];
+ if (r3 != 1)
+ {
+ return;
+ }
+ }
+ }
+ r3 = sub_81025BC();
+ if (r3 != 5)
+ {
+ sSlotMachine->unk04 |= gUnknown_083ECE48[r3];
+ }
+ }
+ }
+}
+
+void sub_81024F0(void)
+{
+ sSlotMachine->unk06 = 0;
+ if (sSlotMachine->unk04)
+ sSlotMachine->unk06 = 1;
+}
+
+u8 sub_810250C(u8 a0)
+{
+ u8 i;
+
+ for (i = 0; i < 8; i++)
+ {
+ if (a0 & 1)
+ return gUnknown_083ECE3A[i];
+ a0 >>= 1;
+ }
+ return 0;
+}
+
+bool8 sub_8102540_(void)
+{
+ u8 rval = Random();
+ if (gUnknown_083ECD04[sSlotMachine->unk01][sSlotMachine->bet - 1] > rval)
+ return TRUE;
+ return FALSE;
+}
+
+extern const u8 gUnknown_083ECD16[][6];
+extern const u8 gUnknown_083ECD28[][6];
+extern const u8 gUnknown_083ECD46[][17];
+extern const u8 gUnknown_083ECDAC[][17];
+
+u8 sub_8102578(void)
+{
+ s16 i;
+
+ for (i = 0; i < 3; i++)
+ {
+ s16 rval = Random() & 0xff;
+ s16 value = gUnknown_083ECD16[i][sSlotMachine->unk01];
+ if (value > rval)
+ break;
+ }
+ return i;
+}
+
+u8 sub_81025BC(void)
+{
+ s16 i;
+
+ for (i = 0; i < 5; i++)
+ {
+ s16 rval = Random() & 0xff;
+ s16 r3 = gUnknown_083ECD28[i][sSlotMachine->unk01];
+ if (i == 0 && sSlotMachine->unk03 == 1)
+ {
+ r3 += 10;
+ if (r3 > 0x100)
+ r3 = 0x100;
+ }
+ else if (i == 4 && sSlotMachine->unk03 == 1)
+ {
+ r3 -= 10;
+ if (r3 < 0)
+ r3 = 0;
+ }
+ if (r3 > rval)
+ break;
+ }
+ return i;
+}
+
+u8 sub_810264C(u8 a0)
+{
+ if (sSlotMachine->unk03 == 0)
+ return gUnknown_083ECD46[a0][sSlotMachine->pikaPower];
+ else
+ return gUnknown_083ECDAC[a0][sSlotMachine->pikaPower];
+}
+
+void sub_8102680(void)
+{
+ u8 rval;
+ s16 i;
+
+ sSlotMachine->unk05 = 0;
+ rval = Random();
+ if (rval < sub_810264C(0))
+ return;
+ for (i = 5; i > 0; i--)
+ {
+ rval = Random();
+ if (rval < sub_810264C(i))
+ break;
+ }
+ sSlotMachine->unk05 = i;
+}
+
+extern const u16 gUnknown_083ECE12[];
+extern const u16 gUnknown_083ECE1C[][2];
+extern const u16 gUnknown_083ECE30[];
+extern const u16 sSlotMatchFlags[];
+extern const u16 sSlotPayouts[];
+
+bool8 sub_81026DC(u16 a0)
+{
+ u16 rval = Random() & 0xff;
+ if (rval < gUnknown_083ECE12[a0])
+ return TRUE;
+ else
+ return FALSE;
+}
+
+u16 dp15_jump_random_unknown(void)
+{
+ u8 r4 = 0;
+ u8 rval;
+ u8 value;
+ if (sSlotMachine->unk10 >= 300)
+ r4 = 4;
+ else if (sSlotMachine->unk10 >= 250)
+ r4 = 3;
+ else if (sSlotMachine->unk10 >= 200)
+ r4 = 2;
+ else if (sSlotMachine->unk10 >= 150)
+ r4 = 1;
+ rval = Random() % 100;
+ value = gUnknown_083ECE1C[r4][0];
+ if (rval < value)
+ return 4;
+ rval = Random() % 100;
+ value = gUnknown_083ECE1C[r4][1] + gUnknown_083ECE30[sSlotMachine->unk0B];
+ if (rval < value)
+ return 2;
+ return 8;
+}
+
+void CheckMatch(void)
+{
+ sSlotMachine->matchedSymbols = 0;
+ CheckMatch_CenterRow();
+ if (sSlotMachine->bet > 1)
+ CheckMatch_TopAndBottom();
+ if (sSlotMachine->bet > 2)
+ CheckMatch_Diagonals();
+}
+
+void CheckMatch_CenterRow(void)
+{
+ u8 c1, c2, c3, match;
+
+ c1 = GetTagOfReelSymbolOnScreenAtPos(0, 2);
+ c2 = GetTagOfReelSymbolOnScreenAtPos(1, 2);
+ c3 = GetTagOfReelSymbolOnScreenAtPos(2, 2);
+ match = GetMatchFromSymbolsInRow(c1, c2, c3);
+ if (match != SLOT_MACHINE_MATCHED_NONE)
+ {
+ sSlotMachine->payout += sSlotPayouts[match];
+ sSlotMachine->matchedSymbols |= sSlotMatchFlags[match];
+ sub_8103E04(0);
+ }
+}
+
+void CheckMatch_TopAndBottom(void)
+{
+ u8 c1, c2, c3, match;
+
+ c1 = GetTagOfReelSymbolOnScreenAtPos(0, 1);
+ c2 = GetTagOfReelSymbolOnScreenAtPos(1, 1);
+ c3 = GetTagOfReelSymbolOnScreenAtPos(2, 1);
+ match = GetMatchFromSymbolsInRow(c1, c2, c3);
+ if (match != SLOT_MACHINE_MATCHED_NONE)
+ {
+ if (match == SLOT_MACHINE_MATCHED_1CHERRY)
+ match = SLOT_MACHINE_MATCHED_2CHERRY;
+ sSlotMachine->payout += sSlotPayouts[match];
+ sSlotMachine->matchedSymbols |= sSlotMatchFlags[match];
+ sub_8103E04(1);
+ }
+ c1 = GetTagOfReelSymbolOnScreenAtPos(0, 3);
+ c2 = GetTagOfReelSymbolOnScreenAtPos(1, 3);
+ c3 = GetTagOfReelSymbolOnScreenAtPos(2, 3);
+ match = GetMatchFromSymbolsInRow(c1, c2, c3);
+ if (match != SLOT_MACHINE_MATCHED_NONE)
+ {
+ if (match == SLOT_MACHINE_MATCHED_1CHERRY)
+ match = SLOT_MACHINE_MATCHED_2CHERRY;
+ sSlotMachine->payout += sSlotPayouts[match];
+ sSlotMachine->matchedSymbols |= sSlotMatchFlags[match];
+ sub_8103E04(2);
+ }
+}
+
+void CheckMatch_Diagonals(void)
+{
+ u8 c1, c2, c3, match;
+
+ c1 = GetTagOfReelSymbolOnScreenAtPos(0, 1);
+ c2 = GetTagOfReelSymbolOnScreenAtPos(1, 2);
+ c3 = GetTagOfReelSymbolOnScreenAtPos(2, 3);
+ match = GetMatchFromSymbolsInRow(c1, c2, c3);
+ if (match != SLOT_MACHINE_MATCHED_NONE)
+ {
+ if (match != SLOT_MACHINE_MATCHED_1CHERRY)
+ {
+ sSlotMachine->payout += sSlotPayouts[match];
+ sSlotMachine->matchedSymbols |= sSlotMatchFlags[match];
+ }
+ sub_8103E04(3);
+ }
+ c1 = GetTagOfReelSymbolOnScreenAtPos(0, 3);
+ c2 = GetTagOfReelSymbolOnScreenAtPos(1, 2);
+ c3 = GetTagOfReelSymbolOnScreenAtPos(2, 1);
+ match = GetMatchFromSymbolsInRow(c1, c2, c3);
+ if (match != SLOT_MACHINE_MATCHED_NONE)
+ {
+ if (match != SLOT_MACHINE_MATCHED_1CHERRY)
+ {
+ sSlotMachine->payout += sSlotPayouts[match];
+ sSlotMachine->matchedSymbols |= sSlotMatchFlags[match];
+ }
+ sub_8103E04(4);
+ }
+}
+
+extern const u8 sSym2Match[];
+
+u8 GetMatchFromSymbolsInRow(u8 c1, u8 c2, u8 c3)
+{
+ if (c1 == c2 && c1 == c3)
+ return sSym2Match[c1];
+ if (c1 == SLOT_MACHINE_TAG_7_RED && c2 == SLOT_MACHINE_TAG_7_RED && c3 == SLOT_MACHINE_TAG_7_BLUE)
+ return SLOT_MACHINE_MATCHED_777_MIXED;
+ if (c1 == SLOT_MACHINE_TAG_7_BLUE && c2 == SLOT_MACHINE_TAG_7_BLUE && c3 == SLOT_MACHINE_TAG_7_RED)
+ return SLOT_MACHINE_MATCHED_777_MIXED;
+ if (c1 == SLOT_MACHINE_TAG_CHERRY)
+ return SLOT_MACHINE_MATCHED_1CHERRY;
+ return SLOT_MACHINE_MATCHED_NONE;
+}
+
+void sub_8102A24(void)
+{
+ sub_8102A64(CreateTask(sub_8102A64, 4));
+}
+
+bool8 sub_8102A44(void)
+{
+ if (FindTaskIdByFunc(sub_8102A64) == 0xff)
+ return TRUE;
+ else
+ return FALSE;
+}
diff --git a/src/tv.c b/src/tv.c
index 2e915697e..d09e72abc 100644
--- a/src/tv.c
+++ b/src/tv.c
@@ -1448,8 +1448,8 @@ void ContestLiveUpdates_BeforeInterview_5(u8 a0, u8 a1)
sCurTVShowSlot = FindEmptyTVSlotWithinFirstFiveShowsOfArray(gSaveBlock1Ptr->tvShows);
if (sCurTVShowSlot != -1)
{
- show->contestLiveUpdates.winningSpecies = gUnknown_02039E00[a1].unk_00;
- StringCopy(show->contestLiveUpdates.winningTrainerName, gUnknown_02039E00[a1].unk_0d);
+ show->contestLiveUpdates.winningSpecies = gContestMons[a1].species;
+ StringCopy(show->contestLiveUpdates.winningTrainerName, gContestMons[a1].trainerName);
StripExtCtrlCodes(show->contestLiveUpdates.winningTrainerName);
show->contestLiveUpdates.appealFlags2 = a0;
if (a1 + 1 > gUnknown_02039F30)
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-07 23:54:00 +0000