diff options
Diffstat (limited to 'src')
46 files changed, 8620 insertions, 440 deletions
diff --git a/src/code.c b/src/code.c new file mode 100644 index 0000000..649f81c --- /dev/null +++ b/src/code.c @@ -0,0 +1,32 @@ +#include "global.h" + +extern void xxx_dungeon_8042F6C(u32 r0); +extern void NDS_LoadOverlay_GroundMain(); +extern u32 xxx_script_related_8098468(u32); + +void NDS_LoadOverlay_GroundMain() +{ + +} + +void nullsub_2(u32 r0) +{ + +} + +u32 xxx_script_related_8001334(u32 r0) +{ + return xxx_script_related_8098468(r0); +} + +void xxx_dungeon_8001340(u32 r0) +{ + nullsub_2(r0); + xxx_dungeon_8042F6C(r0); + NDS_LoadOverlay_GroundMain(); +} + +void nullsub_3(void) +{ + +} diff --git a/src/code_80001E0.c b/src/code_80001E0.c new file mode 100644 index 0000000..417853a --- /dev/null +++ b/src/code_80001E0.c @@ -0,0 +1,8 @@ +#include "global.h" + +extern u32 gUnknown_3004000; + +u32 *sub_80001E0(void) +{ + return &gUnknown_3004000; +} diff --git a/src/code_800558C.c b/src/code_800558C.c new file mode 100644 index 0000000..13e3255 --- /dev/null +++ b/src/code_800558C.c @@ -0,0 +1,73 @@ +#include "global.h" +#include "code_800558C.h" + +extern u32 gUnknown_203B47C; + +extern u8 gUnknown_2026E38; +extern u32 gUnknown_2026E3C; +extern u16 gUnknown_2026E4E; +extern bool32 gUnknown_2026E50; +extern bool32 gUnknown_2026E54; +extern u32 gUnknown_2026E58; + +extern void sub_800CC44(s32 r0, s32 r1); + +// Unused +void sub_80060A8(void) +{ + + bool32 temp; + bool32 preload; + bool32 preload2; + + gUnknown_2026E3C = gUnknown_2026E58; + + preload = gUnknown_2026E54; + temp = FALSE; + if (!gUnknown_2026E54) + { + temp = TRUE; + } + gUnknown_2026E54 = temp; + + preload2 = gUnknown_2026E50; + temp = FALSE; + if (!gUnknown_2026E50) + { + temp = TRUE; + } + gUnknown_2026E50 = temp; + + gUnknown_2026E38 = FALSE; +} + +void sub_80060EC(void) +{ + bool32 temp; + bool32 preload; + bool32 preload2; + + gUnknown_2026E3C = gUnknown_2026E58; + + preload = gUnknown_2026E54; + temp = FALSE; + + if (!gUnknown_2026E54) + { + temp = TRUE; + } + gUnknown_2026E54 = temp; + + + preload2 = gUnknown_2026E50; + temp = FALSE; + + if (!gUnknown_2026E50) + { + temp = TRUE; + } + gUnknown_2026E50 = temp; + + sub_800CC44((gUnknown_2026E4E & (0xF8 << 5)) >> 8, gUnknown_2026E4E & 0x1F); + gUnknown_2026E38 = TRUE; +} diff --git a/src/code_800B5F0.c b/src/code_800B5F0.c new file mode 100644 index 0000000..35b5282 --- /dev/null +++ b/src/code_800B5F0.c @@ -0,0 +1,99 @@ +#include "global.h" + +extern bool8 gInterruptsEnabled; +extern u32 gIntrTable[]; +extern u32 IntrMain; +extern u8 gUnknown_202D4B8; +extern u32 gUnknown_202D5F0[]; + +bool8 EnableInterrupts(void) +{ + if(gInterruptsEnabled == FALSE) + { + return FALSE; + } + + if((REG_IME & 1) != 0) + { + return FALSE; + } + else + { + REG_IME = 1; + return TRUE; + } +} + +bool8 DisableInterrupts(void) +{ + if(gInterruptsEnabled == 0) + { + return FALSE; + } + + if((REG_IME & 1) == 0) + { + return FALSE; + } + else + { + REG_IME = 0; + return TRUE; + } + +} + +bool8 sub_800B650(void) +{ + if(gInterruptsEnabled == FALSE) + { + return FALSE; + } + + if((REG_IME & 1) != 0) + { + return FALSE; + } + else + { + return TRUE; + } +} + +void SetInterruptFlag(u16 flag) +{ + if(gInterruptsEnabled == FALSE) + { + return; + } + + REG_IME = 0; + INTR_CHECK |= flag; + REG_IME = 1; +} + +void sub_800B6B0(const u32 *r0) +{ + CpuCopy32(r0, &gIntrTable, 0x18); // 0x18 = 0x6 * 4 (0x4f00 is 32 bits) + CpuCopy32(&IntrMain, &gUnknown_202D4B8, 0x120); // 0x120 = 0x48 * 4 (0x4f00 is 32 bits) + INTR_VECTOR = &gUnknown_202D4B8; +} + +u32 *sub_800B6E8(u32 r0) +{ + return &gIntrTable[r0]; +} + +u32 sub_800B6F4(u32 r0, u32 r1) +{ + u32 temp; + u32 interrupt_var; + + interrupt_var = DisableInterrupts(); + temp = gUnknown_202D5F0[r0]; + gUnknown_202D5F0[r0] = r1; + if(interrupt_var != FALSE){ + EnableInterrupts(); + } + return temp; +} diff --git a/src/code_800C9CC.c b/src/code_800C9CC.c new file mode 100644 index 0000000..27445f0 --- /dev/null +++ b/src/code_800C9CC.c @@ -0,0 +1,237 @@ +#include "global.h" +#include "input.h" + +struct unkStruct_809CC88 +{ + u16 padding; + u16 unk2; + u16 unk4; + u16 unk6; +}; + +extern u16 gUnknown_203B0BC; +extern u8 gUnknown_202D6B8; +extern u8 gUnknown_202D6B9; +extern u16 gUnknown_202D7FA; + +extern struct unkStruct_809CC88 gUnknown_202D698; +extern struct unkStruct_809CC88 gUnknown_202D6A0; +extern struct unkStruct_809CC88 gUnknown_202D6A8; +extern struct unkStruct_809CC88 gUnknown_202D6B0; + +void ReadKeyInput(struct UnkInputStruct1 *r0) +{ + u16 keyInput = REG_KEYINPUT ^ KEYS_MASK; + r0->unk0 = 0; + + if((keyInput & DPAD_UP) != 0) + { + r0->unk0 = DPAD_UP; + } + + if((keyInput & DPAD_DOWN) != 0) + { + r0->unk0 |= DPAD_DOWN; + } + + if((keyInput & DPAD_LEFT) != 0) + { + r0->unk0 |= DPAD_LEFT; + } + + if((keyInput & DPAD_RIGHT) != 0) + { + r0->unk0 |= DPAD_RIGHT; + } + + if((keyInput & A_BUTTON) != 0) + { + r0->unk0 |= A_BUTTON; + } + + if((keyInput & B_BUTTON) != 0) + { + r0->unk0 |= B_BUTTON; + } + + if((keyInput & START_BUTTON) != 0) + { + r0->unk0 |= START_BUTTON; + } + + if((keyInput & SELECT_BUTTON) != 0) + { + r0->unk0 |= SELECT_BUTTON; + } + + if((keyInput & R_BUTTON) != 0) + { + r0->unk0 |= R_BUTTON; + } + + if((keyInput & L_BUTTON) != 0) + { + r0->unk0 |= L_BUTTON; + } + gUnknown_203B0BC = keyInput; +} + +void sub_800CC44(s32 r0, s32 r1) +{ + u32 preload1; + u8 preload2; + u8 preload3; + + if(r0 < 0) + { + r0 = 0; + } + else + { + if(r0 > 0x10) + { + r0 = 0x10; + } + } + if(r1 < 0) + { + r1 = 0; + } + else + { + if(r1 > 0x10) + { + r1 = 0x10; + } + } + gUnknown_202D6B8 = r0; + gUnknown_202D6B9 = r1; + + // Forcing the correct loads + preload1 = gUnknown_202D7FA; + preload2 = gUnknown_202D6B8; + preload3 = gUnknown_202D6B9; + + gUnknown_202D7FA = (gUnknown_202D6B9 << 8) | gUnknown_202D6B8; + +} + +void sub_800CC88(u32 r0, u32 r1) +{ + gUnknown_202D698.unk4 = r0; + gUnknown_202D698.unk6 = r1; +} + +void sub_800CC94(u32 r0, u32 r1) +{ + gUnknown_202D6A0.unk4 = r0; + gUnknown_202D6A0.unk6 = r1; +} + +void sub_800CCA0(u32 r0, u32 r1) +{ + gUnknown_202D6A8.unk4 = r0; + gUnknown_202D6A8.unk6 = r1; +} + +void sub_800CCAC(u32 r0, u32 r1) +{ + gUnknown_202D6B0.unk4 = r0; + gUnknown_202D6B0.unk6 = r1; +} + +void sub_800CCB8(s32 r0, u32 r1, u32 r2) +{ + if(r0 == 1) + { + goto _0800CCD4; + } + if(r0 <= 1) + { + goto _0800CCCA; + } + if(r0 == 2) + { + goto _0800CCDE; + } + if(r0 == 3) + { + goto _0800CCE8; + } + + _0800CCCA: + sub_800CC88(r1, r2); + return; + _0800CCD4: + sub_800CC94(r1, r2); + return; + _0800CCDE: + sub_800CCA0(r1, r2); + return; + _0800CCE8: + sub_800CCAC(r1, r2); +} + +void sub_800CCF4(s32 r0, u32 r1) +{ + if(r0 == 1) + { + goto _0800CD10; + } + if(r0 <= 1) + { + goto _0800CD06; + } + if(r0 == 2) + { + goto _0800CD18; + } + if(r0 == 3) + { + goto _0800CD20; + } + + _0800CD06: + gUnknown_202D698.unk4 = r1; + return; + _0800CD10: + gUnknown_202D6A0.unk4 = r1; + return; + _0800CD18: + gUnknown_202D6A8.unk4 = r1; + return; + _0800CD20: + gUnknown_202D6B0.unk4 = r1; +} + +void sub_800CD2C(s32 r0, u32 r1) +{ + if(r0 == 1) + { + goto _0800CD48; + } + if(r0 <= 1) + { + goto _0800CD3E; + } + if(r0 == 2) + { + goto _0800CD50; + } + if(r0 == 3) + { + goto _0800CD58; + } + + _0800CD3E: + gUnknown_202D698.unk6 = r1; + return; + _0800CD48: + gUnknown_202D6A0.unk6 = r1; + return; + _0800CD50: + gUnknown_202D6A8.unk6 = r1; + return; + _0800CD58: + gUnknown_202D6B0.unk6 = r1; +} diff --git a/src/code_800D090.c b/src/code_800D090.c new file mode 100644 index 0000000..1031a2d --- /dev/null +++ b/src/code_800D090.c @@ -0,0 +1,65 @@ +#include "global.h" + +extern void SoundBiasReset(void); +extern void SoundBiasSet(void); + +void Hang(void) +{ + while(1) + { + asm("swi 0x2"); + } +} + + +// Unused +void sub_800D098(void) +{ + u32 dispcnt_save; + u32 ie_store; + + while(REG_VCOUNT <= 159) + ; + + // Save DISPCNT and set to 0 + dispcnt_save = REG_DISPCNT; + REG_DISPCNT = 0; + + *(u16 *)BG_PLTT = 0xefff; + + while(REG_KEYINPUT != 0x3ff) // 0011 1111 1111 (all buttons) + ; + + + REG_IME = 0; + + // Save IE Register + ie_store = REG_IE; + REG_IE = INTR_FLAG_KEYPAD | INTR_FLAG_GAMEPAK; + + REG_KEYCNT = 0xC304; // TODO 1100 0011 0000 0100 + // Select: + // * Select button + // * L/R Button + // Enable IRQ + // Logical AND + // So do something when all buttons above are pressed + + REG_IME = 1; + + SoundBiasReset(); + asm("swi 0x3"); + SoundBiasSet(); + + REG_IME = 0; + + REG_IE = ie_store; // restore IE + REG_KEYCNT = 0; // reset KEYCNT + + REG_IME = 1; + + // Good after here + while(REG_VCOUNT <= 159){} + REG_DISPCNT = dispcnt_save; // restore DISPCNT + while(REG_KEYINPUT != 0x3ff){} // All buttons +} diff --git a/src/code_80118A4.c b/src/code_80118A4.c new file mode 100644 index 0000000..73cb8b2 --- /dev/null +++ b/src/code_80118A4.c @@ -0,0 +1,268 @@ +#include "global.h" + +void sub_8011924(void); +void nullsub_26(void); + +extern u8 sub_80023E4(u8); +extern void sub_800BDFC(u16 r0); +extern void FadeInNewBGM(u16 r0, u16 r1); +extern void sub_800BF48(u16 r0); +extern void sub_800BF80(void); +extern void sub_800BFD0(u16 r0); +extern void sub_800C3F8(u16 r0, u16 r1); +extern void sub_801199C(u16 r0); +extern u16 sub_800C068(); +extern void sub_800C074(u16 r0, u16 r1); +extern void sub_800C298(u16 r0); +extern void sub_800C93C(); +extern u8 sub_800C5D0(u16 r0); +extern void sub_800C9CC(); + +extern void nullsub_27(void); +extern void nullsub_29(void); +extern void nullsub_30(void); +extern void nullsub_31(void); +extern void nullsub_32(void); +extern void nullsub_28(void); + +extern int sprintf(char *, const char *, ...); + +struct DebugLocation +{ + char *file; + u32 line; + char *func; +}; + + +extern u16 gUnknown_80D4144[]; +extern s16 gUnknown_202DE20; +extern s16 gUnknown_202DE22; +extern s16 gUnknown_202DE24; +extern u32 gUnknown_202DE1C; +extern u32 gUnknown_203B14C; +extern const char gNotEntryText[]; +extern const char gUnknown_80D418C[]; +extern const char gUnknown_80D41C4[]; + +void sub_8011760(void) +{ + if(sub_80023E4(0xD) != 0) + { + sub_800BDFC(0x13); + return; + } + if(sub_80023E4(0xC) != 0) + { + sub_800BDFC(0x7); // Pokemon Square Theme + } +} + +void sub_801178C(void) +{ + if(sub_80023E4(0xD) != 0) + { + sub_800BDFC(0x13); + return; + } + sub_800BDFC(0x7); // Pokemon Square Theme +} + +void sub_80117AC(void) +{ + if(sub_80023E4(0xD) == 0) + { + sub_800BFD0(0x1E); + } +} + +void sub_80117C4(void) +{ + sub_800BFD0(0x1E); +} + +void sub_80117D0(void) +{ + sub_800C074(0x97 << 1, 0x80 << 1); +} + +void sub_80117E4(void) +{ + sub_800C074(0x12f, 0x80 << 1); +} + +void sub_80117F8(void) +{ + sub_800C074(0x12d, 0x80 << 1); +} + +void sub_801180C(void) +{ + gUnknown_202DE1C = 0; + gUnknown_202DE20 = 0; + gUnknown_202DE22 = 0; + gUnknown_202DE24 = 0; +} + +void sub_8011830(void) +{ + sub_800C93C(); + gUnknown_202DE20 = 0; + gUnknown_202DE22 = 0; + gUnknown_202DE24 = 0; +} + +void sub_8011854(void) +{ + sub_800C9CC(); +} + +void sub_8011860(void) +{ + if(gUnknown_202DE20 > 0) + { + gUnknown_202DE20--; + } + if(gUnknown_202DE22 > 0) + { + gUnknown_202DE22--; + } + if(gUnknown_202DE24 > 0) + { + gUnknown_202DE24--; + } +} + +void sub_80118A4(void) +{ + sub_8011924(); + sub_801199C(0x3e6); + sub_801199C(0x3e5); +} + +void sub_80118C4(u16 r0) +{ + sub_800BFD0(r0); + sub_800C3F8(0x3e6, r0); + sub_800C3F8(0x3e5, r0); +} + +void sub_80118F0(u16 r0) +{ + sub_800BDFC(r0); +} + +void sub_8011900(u16 songIndex, u16 speed) +{ + FadeInNewBGM(songIndex, speed); +} + +void sub_8011914(u16 r0) +{ + sub_800BF48(r0); +} + +void sub_8011924() +{ + sub_800BF80(); +} + +void sub_8011930(u16 r0) +{ + sub_800BFD0(r0); +} + +u32 sub_8011940(u16 r0) +{ + u32 temp; + temp = sub_800C068(); + + if(r0 == 999) + return temp != 999; + + return temp == r0; +} + +void sub_8011974(u16 r0, u16 r1) +{ + sub_800C074(r0, r1); +} + +void sub_8011988(u16 r0) +{ + sub_800C074(r0, 0x80 << 1); +} + +void sub_801199C(u16 r0) +{ + sub_800C298(r0); +} + +void sub_80119AC(u16 r0, u16 r1) +{ + sub_800C3F8(r0, r1); +} + +u8 sub_80119C0(u16 r0) +{ + return sub_800C5D0(r0); +} + +void sub_80119D4(u32 r0) +{ + if(gUnknown_202DE20 > 0) + return; + sub_800C074(gUnknown_80D4144[r0], 0x80 << 1); + gUnknown_202DE20 = 4; +} + +void sub_8011A04(void) +{ + if(gUnknown_202DE22 > 0) + return; + gUnknown_202DE22 = 3; + sub_800C074(0x131, 0x80 << 1); +} + +void sub_8011A2C(u32 r0) +{ + gUnknown_202DE1C = r0; +} + +void NDS_DebugInit(void) +{ + nullsub_26(); + nullsub_27(); + nullsub_29(); + nullsub_30(); + nullsub_31(); + nullsub_32(); + nullsub_28(); + gUnknown_203B14C = 1; // Maybe a flag saying Debug is on? +} + +void nullsub_25(void) +{ +} + +void nullsub_26(void) +{ +} + +// Unused +void PrintFuncFileLineOrNotEntry(char * r0, struct DebugLocation *r1) +{ + if(r1 != 0) + { + sprintf(r0, gUnknown_80D418C, r1->func, r1->file, r1->line); + } + else + { + sprintf(r0, gNotEntryText); + } +} + +void PrintFuncFileLine(char *buf, struct DebugLocation *loc, char* prefix) +{ + sprintf(buf, gUnknown_80D41C4, prefix, loc->func, loc->file, loc->line); +} diff --git a/src/code_80118A4_1.c b/src/code_80118A4_1.c new file mode 100644 index 0000000..89f4db5 --- /dev/null +++ b/src/code_80118A4_1.c @@ -0,0 +1,55 @@ +#include "global.h" + +extern u8 gUnknown_203B150; + +void PrintFuncFileLine(char *r0, const char *r1, ...); +extern const char gUnknown_80D421C; + +void nullsub_199(void) +{ +} + +void nullsub_27(void) +{ +} + +void sub_8011B08(void) +{ + gUnknown_203B150 = 1; +} + +void sub_8011B14(void) +{ + gUnknown_203B150 = 0; +} + +u8 sub_8011B20(void) +{ + gUnknown_203B150 = !gUnknown_203B150; + return gUnknown_203B150; +} + +// unused +u8 sub_8011B3C(void) +{ + return gUnknown_203B150; +} + +// unused +void nullsub_137(void) +{ + +} + +// TODO merge with fatal_system +void FatalErrorPrintFuncFileLine(const char *r0, const char *r1) +{ + char buf[0x100]; + if(r0 != 0){ + PrintFuncFileLine(buf, r1, r0); + } + else + { + PrintFuncFileLine(buf, r1, &gUnknown_80D421C); + } +} diff --git a/src/code_801D760.c b/src/code_801D760.c new file mode 100644 index 0000000..c2266ec --- /dev/null +++ b/src/code_801D760.c @@ -0,0 +1,161 @@ +#include "global.h" + +extern u32 sub_801BF48(void); +extern void sub_801BF98(void); +extern void sub_801D208(u8); +extern u32 sub_801DCE8(void); +extern void sub_801DD50(void); +extern u32 sub_80217EC(void); +extern void sub_8021830(void); +extern u32 sub_8022860(); +extern void sub_8022908(); +extern u32 sub_80244E4(void); +extern void sub_802453C(void); +extern u32 sub_8025354(void); +extern u8 sub_802540C(void); +extern void sub_8025418(void); +extern u32 sub_8025F68(); +extern u8 sub_802604C(); +extern void sub_8026058(); +extern void sub_8027168(); +extern u32 sub_80270A4(); +extern u32 sub_802C898(void); +extern void sub_802C8F4(void); + +struct unk_203B250 +{ + u32 unk0; + u16 unk4; + u8 unk6; + u8 unk7; +}; + +struct unk_203B250 *gUnknown_203B250; + +void sub_801D760() +{ + u32 temp; + temp = sub_8022860(); + if (temp <= 1) + return; + if (temp > 3) + return; + sub_8022908(); + sub_801D208(1); + +} + +void sub_801D77C() +{ + u32 temp; + temp = sub_80270A4(); + if (temp <= 1) + return; + if (temp > 3) + return; + sub_8027168(); + sub_801D208(1); + +} + +void sub_801D798(void) +{ + u32 temp; + temp = sub_8025F68(); + if (temp <= 1) + return; + if (temp > 3) + return; + if(sub_802604C() != 0) + gUnknown_203B250->unk7 = gUnknown_203B250->unk6; + sub_8026058(); + sub_801D208(2); +} + +void sub_801D7CC() +{ + u32 check; + u32 temp2; + + check = sub_8025354(); + if(check <= 1) + return; + if(check > 3) + return; + + temp2 = sub_802540C(); + gUnknown_203B250->unk7 = temp2; + + sub_8025418(); + + if(gUnknown_203B250->unk7 != 0) + { + sub_801D208(2); + } + else + { + sub_801D208(1); + } +} + +void sub_801D808(void) +{ + u32 check; + + check = sub_80244E4(); + if(check <= 1) + return; + if(check > 3) + return; + + sub_802453C(); + sub_801D208(1); +} + +void sub_801D824(void) +{ + u32 check; + check = sub_801BF48(); + if(check <= 1) + return; + if(check > 3) + return; + sub_801BF98(); + sub_801D208(1); +} + +void sub_801D840(void) +{ + u32 check; + check = sub_80217EC(); + if(check <= 1) + return; + if(check > 3) + return; + sub_8021830(); + sub_801D208(1); +} + +void sub_801D85C(void) +{ + u32 check; + check = sub_802C898(); + if(check <= 1) + return; + if(check > 3) + return; + sub_802C8F4(); + sub_801D208(1); +} + +void sub_801D878(void) +{ + u32 check; + check = sub_801DCE8(); + if(check <= 1) + return; + if(check > 3) + return; + sub_801DD50(); + sub_801D208(1); +} diff --git a/src/code_8027C84_pre.c b/src/code_8027C84_pre.c new file mode 100644 index 0000000..2dbdd66 --- /dev/null +++ b/src/code_8027C84_pre.c @@ -0,0 +1,86 @@ +#include "global.h" + + +struct UnkOtherStructTemp +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ u32 unk4; + /* 0x8 */ u32 unk8; + /* 0xC */ u32 unkC; + /* 0x10 */ u32 unk10; + /* 0x14 */ u32 unk14; + /* 0x18 */ u32 unk18; + /* 0x1C */ u32 unk1C; + /* 0x20 */ u16 *unk20; + /* 0x24 */ u16 unk24; + /* 0x26 */ u16 unk26; + /* 0x28 */ u16 unk28; + /* 0x2A */ u16 unk2A; +}; + +struct UnkStructTemp +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ u32 unk4; + /* 0x8 */ u32 unk8; + /* 0xC */ u32 unkC; + /* 0x10 */ u32 unk10; + /* 0x14 */ u32 unk14; + /* 0x18 */ u32 unk18; + /* 0x1C */ u32 unk1C; + /* 0x20 */ struct UnkOtherStructTemp *unk20; + /* 0x24 */ u16 unk24; + /* 0x26 */ u16 unk26; + /* 0x28 */ u16 unk28; + /* 0x2A */ u16 unk2A; +}; + + +extern struct UnkStructTemp *gUnknown_203B2BC; +u32 sub_801B410(); +void sub_801B450(); +void sub_8027184(u8 r0); +u32 sub_801EF38(u8 r0); +struct UnkOtherStructTemp *sub_801F194(); +void sub_8027184(u8 r0); +void sub_801F214(); + +void sub_8027C84() +{ + u32 temp = sub_801B410(); + if(temp <= 1) + return; + if(temp > 3) + return; + sub_801B450(); + sub_8027184(0xB); +} + +//void sub_8027CA0() +//{ +// struct UnkOtherStructTemp *temp_store; +// u32 temp = sub_801EF38(1); +// if(temp > 4) +// return; +// switch(temp) +// { +// case 0: +// case 1: +// break; +// case 2: +// sub_801F214(); +// sub_8027184(0x2); +// return; +// case 3: +// case 4: +// temp_store = sub_801F194(); +// gUnknown_203B2BC->unk20 = temp_store; +// // TODO missing +// // lsls r0, 3 +// // adds r0, r1, r0 +// // Why are we shifting the pointer by 3? +// gUnknown_203B2BC->unk24 = temp_store->unk2A; +// sub_8027184(0x10); +// break; +// } +//} diff --git a/src/code_8040094.c b/src/code_8040094.c new file mode 100644 index 0000000..547569c --- /dev/null +++ b/src/code_8040094.c @@ -0,0 +1,26 @@ +#include "global.h" +#include "time.h" + +extern u8 *gUnknown_203B418; +extern struct PlayTimeStruct *gUnknown_203B47C; + +extern void sub_803F7BC(void); +extern void sub_80060EC(void); +extern void sub_800CB20(void); +extern void sub_800485C(void); +extern void xxx_call_update_bg_sound_input(void); +extern void sub_8083F58(void); +extern void sub_8011860(void); + +void sub_8040094(u8 r0) +{ + gUnknown_203B418[0x18217] = r0; + sub_803F7BC(); + sub_80060EC(); + IncrementPlayTime(gUnknown_203B47C); + sub_800CB20(); + sub_800485C(); + xxx_call_update_bg_sound_input(); + sub_8083F58(); + sub_8011860(); +} diff --git a/src/code_8041AD0.c b/src/code_8041AD0.c new file mode 100644 index 0000000..be254ef --- /dev/null +++ b/src/code_8041AD0.c @@ -0,0 +1,623 @@ +#include "global.h" + +struct unkStruct_8041D5C +{ + u8 padding[0x70]; + u8 *unk70[100]; +}; + +struct unk_struct_8041F08 +{ + u32 unk0; + u32 unk4; +}; + + +extern void sub_803ED30(u8, struct unkStruct_8041D5C *r0, u8, u8); +extern void sub_804151C(u32 r0, u32 r1, u8 r2); +extern void sub_80421C0(u32 r0, u32 r1); +extern u8 sub_8042768(void); +extern void sub_806CDD4(u32 r0, u8, u32); +extern u8 sub_8071858(u32, u8); + +extern void sub_8041550(u32 r0, u32, u32, u32); + + +void sub_8041AD0(u32 r0) +{ + sub_804151C(r0, 0xA2 << 1, 1); +} + +void sub_8041AE0(u32 r0) +{ + sub_804151C(r0, 0x143, 1); +} + +void sub_8041AF4(u32 r0) +{ + sub_804151C(r0, 0x25, 1); + sub_80421C0(r0, 0x197); +} + +void nullsub_57(void) +{ +} + +void sub_8041B18(u32 r0) +{ + sub_804151C(r0, 0x141, 1); +} + +void nullsub_58(void) +{ +} + +void nullsub_59(void) +{ +} + +void sub_8041B34(u32 r0) +{ + sub_804151C(r0, 7, 1); +} + +void nullsub_60(void) +{ +} + +void sub_8041B48(u32 r0) +{ + sub_804151C(r0, 4, 0); +} + +void nullsub_61(void) +{ +} + +void sub_8041B5C(u32 r0) +{ + sub_804151C(r0, 0x171, 1); +} + +void nullsub_62(void) +{ +} + +void sub_8041B74(u32 r0) +{ + sub_804151C(r0, 0x171, 0); +} + +void nullsub_63(void) +{ +} + +void nullsub_64(void) +{ +} + +void sub_8041B90(u32 r0) +{ + sub_804151C(r0, 0xD6 << 1, 0); +} + +void nullsub_65(void) +{ +} + +void nullsub_66(void) +{ +} + +void sub_8041BA8(u32 r0) +{ + sub_804151C(r0, 4, 1); +} + +void nullsub_67(void) +{ +} + +void sub_8041BBC(u32 r0) +{ + sub_804151C(r0, 0xD4 << 1, 1); +} + +void nullsub_68(void) +{ +} + +void sub_8041BD0(u32 r0, u8 r1) +{ + if(r1 == 0) + { + return; + } + sub_80421C0(r0, 0x1a5); +} + +void sub_8041BE8(u32 r0) +{ + sub_80421C0(r0, 0xCB << 1); +} + +void sub_8041BF8(u32 r0) +{ + sub_806CDD4(r0, 0xA, 8); +} + +void sub_8041C08(u32 r0) +{ + sub_804151C(r0, 0x1a7, 1); +} + +void sub_8041C1C(u32 r0) +{ + sub_804151C(r0, 0x1a7, 1); +} + +void nullsub_69(void) +{ +} + +void sub_8041C34(u32 r0) +{ + sub_804151C(r0, 0x4C, 1); +} + +void nullsub_70(void) +{ +} + +void nullsub_71(void) +{ +} + +void sub_8041C4C(u32 r0, u32 r1) +{ + sub_804151C(r0, r1, 1); +} + +void sub_8041C58(u32 r0) +{ + sub_804151C(r0, 0x1a9, 1); +} + +void sub_8041C6C(u32 r0) +{ + sub_804151C(r0, 0x9D << 1, 1); +} + +void sub_8041C7C(u32 r0) +{ + sub_804151C(r0, 0x9D << 1, 1); +} + +void nullsub_72(void) +{ +} + +void nullsub_73(void) +{ +} + +void sub_8041C94(u32 r0) +{ + sub_804151C(r0, 0x171, 1); +} + +void sub_8041CA8(u32 r0) +{ + sub_804151C(r0, 7, 1); +} + +void sub_8041CB8(u32 r0) +{ + sub_804151C(r0, 0x18b, 1); +} + +void sub_8041CCC(u32 r0) +{ + sub_804151C(r0, 0xC5 << 1, 1); +} + +void sub_8041CDC(u32 r0) +{ + sub_804151C(r0, 5, 1); +} + +void sub_8041CEC(u32 r0) +{ + sub_80421C0(r0, 0x19d); +} + +void nullsub_74(void) +{ +} + +void sub_8041D00(u32 r0, u32 r1) +{ + sub_804151C(r1, 0x2F, 1); + sub_804151C(r0, 0x30, 1); +} + +void nullsub_75(void) +{ +} + +void nullsub_76(void) +{ +} + +void nullsub_77(void) +{ +} + +void nullsub_78(void) +{ +} + +void nullsub_79(void) +{ +} + +void nullsub_80(void) +{ +} + +void sub_8041D38(u32 r0) +{ + sub_804151C(r0, 0x21, 1); +} + +void sub_8041D48(u32 r0) +{ + sub_80421C0(r0, 0x191); +} + +void nullsub_81(void) +{ +} + +void sub_8041D5C(struct unkStruct_8041D5C *r0) +{ + u8 *temp; + if(sub_8042768() == 0) + { + return; + } + temp = *r0->unk70; + sub_803ED30(temp[0x89 << 1] , r0, 1, 0xB); +} + +void sub_8041D84(u32 r0) +{ + sub_80421C0(r0, 0x19f); +} + +void nullsub_82(void) +{ +} + +void nullsub_83(void) +{ +} + +void sub_8041D9C(u32 r0) +{ + sub_804151C(r0, 0x131, 1); +} + +void sub_8041DB0(u32 r0) +{ + sub_804151C(r0, 0x30, 1); +} + +void nullsub_84(void) +{ +} + +void nullsub_85(void) +{ +} + +void nullsub_204(void) +{ +} + +void nullsub_86(void) +{ +} + +void nullsub_87(void) +{ +} + +void nullsub_88(void) +{ +} + +#ifndef NONMATCHING +NAKED +#endif +// TODO r1 is doing an lsr instead of an asr... maybe a signed arg? +void sub_8041DD8(u32 r0, u16 r1) +{ +#ifdef NONMATCHING + if(sub_8071858(r0, 0xE) != 0) + { + sub_804151C(r0, r1, 1); + return; + } + sub_804151C(r0, 0xE, 1); +#else + asm_unified("\tpush {r4,r5,lr}\n" + "\tadds r4, r0, 0\n" + "\tlsls r1, 16\n" + "\tasrs r5, r1, 16\n" + "\tmovs r1, 0xE\n" + "\tbl sub_8071858\n" + "\tlsls r0, 24\n" + "\tcmp r0, 0\n" + "\tbeq _08041DF8\n" + "\tadds r0, r4, 0\n" + "\tadds r1, r5, 0\n" + "\tmovs r2, 0x1\n" + "\tbl sub_804151C\n" + "\tb _08041E02\n" +"_08041DF8:\n" + "\tadds r0, r4, 0\n" + "\tmovs r1, 0xE\n" + "\tmovs r2, 0x1\n" + "\tbl sub_804151C\n" +"_08041E02:\n" + "\tpop {r4,r5}\n" + "\tpop {r0}\n" + "\tbx r0"); +#endif +} + +void nullsub_89(void) +{ +} + +void sub_8041E0C(u32 r0) +{ + sub_804151C(r0, 0x41, 1); +} + +void sub_8041E1C(u32 r0) +{ + sub_804151C(r0, 0x8F << 1, 1); + sub_80421C0(r0, 0xCE << 1); +} + +void sub_8041E3C(u32 r0) +{ + sub_804151C(r0, 0xD7 << 1, 1); +} + +void sub_8041E4C(u32 r0) +{ + sub_804151C(r0, 0x1b1, 1); +} + +void sub_8041E60(u32 r0) +{ + sub_804151C(r0, 0x1a9, 1); +} + +void sub_8041E74(u32 r0) +{ + sub_804151C(r0, 0xC9 << 1, 1); +} + +void sub_8041E84(u32 r0) +{ + sub_804151C(r0, 0xC7 << 1, 1); +} + +void sub_8041E94(u32 r0) +{ + sub_804151C(r0, 0xC8 << 1, 1); +} + +void sub_8041EA4(u32 r0) +{ + sub_804151C(r0, 0x15, 1); +} + +void sub_8041EB4(u32 r0) +{ + sub_804151C(r0, 0x171, 1); +} + +void sub_8041EC8(u32 r0) +{ + sub_80421C0(r0, 0x197); +} + +void sub_8041ED8(u32 r0) +{ + sub_80421C0(r0, 0x197); +} + +void sub_8041EE8(u32 r0) +{ + sub_804151C(r0, 0x15, 1); +} + +void sub_8041EF8(u32 r0) +{ + sub_804151C(r0, 0xF, 1); +} + +void sub_8041F08(u32 r0) +{ + volatile struct unk_struct_8041F08 temp; + temp.unk0 = 2; + temp.unk4 = 0; + sub_8041550(r0, 0x15, 1, 3); +} + +void nullsub_90(void) +{ +} + +void sub_8041F28(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xCA << 1, 1); + } + else + { + sub_804151C(r0, 0x193, 1); + } +} + +void sub_8041F4C(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0x18f, 1); + } + else + { + sub_804151C(r0, 0x191, 1); + } +} + +void sub_8041F70(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0x1a9, 1); + } + else + { + sub_804151C(r0, 0xC9 << 1, 1); + } +} + +void sub_8041F94(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xC7 << 1, 1); + } + else + { + sub_804151C(r0, 0xC8 << 1, 1); + } +} + +void sub_8041FB4(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0x1a9, 1); + } + else + { + sub_804151C(r0, 0xC9 << 1, 1); + } +} + +void sub_8041FD8(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xCA << 1, 1); + } + else + { + sub_804151C(r0, 0x193, 1); + } +} + +void sub_8041FFC(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xC7 << 1, 1); + } + else + { + sub_804151C(r0, 0xC8 << 1, 1); + } +} + +void sub_804201C(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0x18f, 1); + } + else + { + sub_804151C(r0, 0x191, 1); + } +} + +void sub_8042040(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xC6 << 1, 1); + } + else + { + sub_804151C(r0, 0xD, 1); + } +} + +void sub_8042060(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0x18d, 1); + } + else + { + sub_804151C(r0, 0xE, 1); + } +} + +void sub_8042080(u32 r0, u32 r1) +{ + if(r1 == 0) + { + sub_804151C(r0, 0xC6 << 1, 1); + } + else + { + sub_804151C(r0, 0xD, 1); + } +} + +void sub_80420A0(u32 r0, u32 r1) +{ + sub_804151C(r0, 0x143, 1); +} + +void nullsub_91(void) +{ +} + +void sub_80420B8(u32 r0, u32 r1) +{ + sub_804151C(r0, 0x19, 1); +} + +void sub_80420C8(u32 r0) +{ + volatile struct unk_struct_8041F08 temp; + temp.unk0 = 2; + temp.unk4 = 0; + sub_8041550(r0, 0x15, 1, 3); +} + +void nullsub_92(void) +{ +} diff --git a/src/code_80428A0.c b/src/code_80428A0.c new file mode 100644 index 0000000..08599b7 --- /dev/null +++ b/src/code_80428A0.c @@ -0,0 +1,145 @@ +#include "global.h" + +extern void sub_804151C(u32 r0, u32 r1, u8 r2); +extern void sub_803E708(u32 r0, u32 r1); +extern void sub_80416A4(u32 r0, u32 r1, u32 r2); +extern void sub_80421C0(u32 r0, u32 r1); + +void sub_80428A0(u32 r0) +{ + sub_804151C(r0, 0x29, 1); +} + +void sub_80428B0(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + + +void sub_80428C4(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + + +void sub_80428D8(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + +void sub_80428EC(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + +void sub_8042900(u32 r0) +{ + sub_804151C(r0, 0xD4 << 1, 0); +} + +void sub_8042910(u32 r0) +{ + sub_804151C(r0, 0x29, 0); +} + +void sub_8042920(u32 r0) +{ + sub_804151C(r0, 0x48, 0); +} + +void sub_8042930(u32 r0) +{ + sub_804151C(r0, 0xD3 << 1, 1); +} + +void sub_8042940(u32 r0) +{ + sub_804151C(r0, 0xC7 << 1, 0); +} + +void sub_8042950(u32 r0) +{ + sub_804151C(r0, 0xD8 << 1, 1); + sub_803E708(0xA, 0x42); +} + +void sub_8042968(u32 r0) +{ + sub_804151C(r0, 0xD4 << 1, 0); +} + +void sub_8042978(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + +void sub_804298C(u32 r0) +{ + sub_804151C(r0, 0x1a9, 0); +} + +void sub_80429A0(u32 r0) +{ + sub_804151C(r0, 0x199, 0); +} + +void sub_80429B4(u32 r0) +{ + sub_804151C(r0, 0x1ab, 0); +} + +void sub_80429C8(u32 r0) +{ + sub_804151C(r0, 0x4, 1); +} + +void sub_80429D8(u32 r0) +{ + sub_804151C(r0, 0x8F << 1, 1); +} + +void sub_80429E8(u32 r0) +{ + sub_804151C(r0, 0x11d, 1); +} + +void sub_80429FC(u32 r0) +{ + sub_80416A4(r0, 0xCF << 1, 1); + sub_80421C0(0, 0xD4); +} + +void sub_8042A14(u32 r0) +{ + sub_80416A4(r0, 0x36, 1); +} + +void sub_8042A24(u32 r0) +{ + sub_804151C(r0, 0x15, 1); +} + +void sub_8042A34(u32 r0) +{ + sub_80416A4(r0, 0x9F << 1, 0); +} + +void sub_8042A44(u32 r0) +{ + sub_804151C(r0, 0xDA << 1, 1); +} + +void sub_8042A54(u32 r0) +{ + sub_80416A4(r0, 0x37, 1); +} + +void sub_8042A64(u32 r0) +{ + sub_80416A4(r0, 0x29, 1); +} + +void sub_8042A74(u32 r0) +{ + sub_804151C(r0, 0x18, 1); +} diff --git a/src/code_8048480.c b/src/code_8048480.c new file mode 100644 index 0000000..aac957a --- /dev/null +++ b/src/code_8048480.c @@ -0,0 +1,47 @@ +#include "global.h" + +extern void sub_807D148(u32 r0, u32 r1, u32 r2, u32 r3); +extern void sub_8075FCC(void); +extern void sub_8077AE4(u32 r0, u32 r1, u32 r2); +extern void sub_8072008(u32 r0, u32 r1, u32 r2, u8 r3); +extern void sub_8076D10(void); +extern void sub_80522F4(u32 r0, u32 r1, u32 r2); +extern void sub_807232C(u32 r0, u32 r1, u32 r2); +extern u32 gUnknown_80F89F4; + +void sub_8048480(u32 r0, u32 r1) +{ + sub_807D148(r0, r1, 0, 0); +} + +void sub_8048490(void) +{ + sub_8075FCC(); +} + +void sub_804849C(u32 r0, u32 r1) +{ + sub_8077AE4(r0, r1, 1); +} + +void sub_80484A8(u32 r0, u32 r1) +{ + volatile u32 temp; + temp = 1; + sub_8072008(r0, r1, 1, 1); +} + +void sub_80484BC(void) +{ + sub_8076D10(); +} + +void sub_80484C8(u32 r0, u32 r1) +{ + sub_80522F4(r0, r1, gUnknown_80F89F4); +} + +void sub_80484DC(u32 r0, u32 r1) +{ + sub_807232C(r0, r1, 1); +} diff --git a/src/code_80521D0.c b/src/code_80521D0.c new file mode 100644 index 0000000..914b02d --- /dev/null +++ b/src/code_80521D0.c @@ -0,0 +1,90 @@ +#include "global.h" + +extern void sub_80526D0(u8 r0); +extern u8 sub_8045888(u32 r0); +extern void sub_80523A8(u32 r0, u32 r1, u8 r2); +extern u8 sub_8052DC0(u32); +extern u8 sub_803F428(u32); + +void sub_805229C(void) +{ + return sub_80526D0(0x50); +} + +void sub_80522A8(u32 r0, u32 r1) +{ + if (sub_8045888(r0) != 0){ + sub_80523A8(r0, r1, 1); + } +} + +void sub_80522C8(u32 r0, u32 r1) +{ + if (sub_8045888(r0) != 0){ + sub_80523A8(r0, r1, 0); + } +} + +void sub_80522E8(u32 r0, u32 r1) +{ + sub_80523A8(r0, r1, 0); +} + +void sub_80522F4(u32 r0, u32 r1, u32 r2) +{ + u8 temp; + u32 temp_reg; + u32 temp2; + temp = sub_8045888(r0); + temp_reg = (-temp | temp); + temp2 = temp_reg >> 31; + if(sub_8052DC0(r1) != 0) + { + temp2 = 1; + } + if(temp2 != 0) + { + sub_80523A8(r0, r2, 1); + } +} + +void sub_805232C(u32 r0, u32 r1, u32 r2) +{ + u8 temp; + u32 temp_reg; + u32 temp2; + temp = sub_8045888(r0); + temp_reg = (-temp | temp); + temp2 = temp_reg >> 31; + if(sub_8052DC0(r1) != 0) + { + temp2 = 1; + } + if(temp2 != 0) + { + sub_80523A8(r0, r2, 0); + } +} + +void sub_8052364(u32 r0, u32 r1, u32 r2) +{ + u8 temp; + u32 temp_reg; + u32 temp2; + temp = sub_8045888(r0); + temp_reg = (-temp | temp); + temp2 = temp_reg >> 31; + if(sub_803F428(r1) != 0) + { + temp2 = 1; + } + if(temp2 != 0) + { + sub_80523A8(r0, r2, 1); + } +} + +void sub_805239C(u32 r0, u32 r1) +{ + sub_80523A8(r0, r1, 1); +} diff --git a/src/code_808DAB4.c b/src/code_808DAB4.c new file mode 100644 index 0000000..e7e7110 --- /dev/null +++ b/src/code_808DAB4.c @@ -0,0 +1,10 @@ +#include "global.h" + +extern void sub_808DE50(void* r0, void * r1, u32 r2, u32 r3); + +extern void * gUnknown_203B45C; + +void sub_808DE30(void* r0, u32 r1) +{ + sub_808DE50(r0, gUnknown_203B45C + (r1 * 0x58), r1, r1 * 0x58); +} diff --git a/src/code_808EAB0.c b/src/code_808EAB0.c new file mode 100644 index 0000000..bf80687 --- /dev/null +++ b/src/code_808EAB0.c @@ -0,0 +1,134 @@ +#include "global.h" + +extern u32 gIQSkillNames[]; +extern u32 gIQSkillDescriptions[]; +extern u32 gTacticsDescriptions[]; +extern u8 *gTactics[]; +extern u8 gUnknown_810A36B[]; + +extern s16 gUnknown_810A378[]; +extern s32 gUnknown_810A390[]; + +u32 sub_808EAB0(u8 r0) +{ + return gIQSkillNames[r0]; +} + +void sub_808EAC0(char *r0, u8 r1) +{ + strncpy(r0, gTactics[r1], 0x14); +} + +u32 sub_808EADC(u8 r0) +{ + return gIQSkillDescriptions[r0]; +} + +u32 sub_808EAEC(u8 r0) +{ + return gTacticsDescriptions[r0]; +} + +u8 sub_808EAFC(u8 r0) +{ + return gUnknown_810A36B[r0]; +} + +void sub_808EB0C(u8 *r0, s32 r1) +{ + s32 counter; + s32 storage; + u32 index; + storage = 0; + index = 0; + for(counter = 0; counter <= 0xB; counter++) + { + if(gUnknown_810A378[index] <= r1) + { + r0[storage] = counter; + storage++; + } + index++; + } + if(storage > 0xB) + { + return; + } + while(storage <= 0xB) + { + r0[storage] = 0xB; + storage++; + } +} + +#ifndef NONMATCHING +NAKED +#endif +void sub_808EB48(u8 *r0, s32 r1) +{ +#ifdef NONMATCHING + // TODO array access and counter are mixed up in the regs.. so close + s32 counter; + u32 index; + + index = 0; + counter = 0xB; + while(counter >= 0) + { + if(gUnknown_810A378[index] <= r1) + { + r0[index] = TRUE; + } + else + { + r0[index] = FALSE; + } + index++; + counter--; + } +#else + asm_unified("\tpush {r4-r7,lr}\n" + "\tadds r4, r1, 0\n" + "\tmovs r6, 0x1\n" + "\tmovs r5, 0\n" + "\tadds r2, r0, 0\n" + "\tldr r1, _0808EB64\n" + "\tmovs r3, 0xB\n" +"_0808EB56:\n" + "\tmovs r7, 0\n" + "\tldrsh r0, [r1, r7]\n" + "\tcmp r0, r4\n" + "\tbgt _0808EB68\n" + "\tstrb r6, [r2]\n" + "\tb _0808EB6A\n" + "\t.align 2, 0\n" +"_0808EB64: .4byte gUnknown_810A378\n" +"_0808EB68:\n" + "\tstrb r5, [r2]\n" +"_0808EB6A:\n" + "\tadds r2, 0x1\n" + "\tadds r1, 0x2\n" + "\tsubs r3, 0x1\n" + "\tcmp r3, 0\n" + "\tbge _0808EB56\n" + "\tpop {r4-r7}\n" + "\tpop {r0}\n" + "\tbx r0"); +#endif +} + +bool8 sub_808EB7C(s32 r0, u8 r1) +{ + u8 return_var; + if(r1 == 0) + { + return FALSE; + } + + return_var = FALSE; + if(gUnknown_810A390[r1] <= r0) + { + return_var = TRUE; + } + return return_var; +} diff --git a/src/code_8092334.c b/src/code_8092334.c new file mode 100644 index 0000000..1fba58e --- /dev/null +++ b/src/code_8092334.c @@ -0,0 +1,84 @@ +#include "global.h" + +#define NUM_FRIEND_AREAS 58 + +extern u32 gUnformattedTypeStrings[]; // unformatted type names +extern u32 gFormattedTypeStrings[]; // formatted type names + +extern u8 gUnknown_810AC7C[]; +extern u8 gUnknown_810AC6A[]; + +extern u8 *gAbilityNames[]; +extern u8 *AbilityDescriptions[]; + +extern u8 gBoughtFriendAreas[NUM_FRIEND_AREAS]; +extern u8 *gUnknown_203B468; + +extern s16 gUnknown_810AA90[]; + +u32 GetUnformattedTypeString(u8 type) +{ + return gUnformattedTypeStrings[type]; +} + +u32 GetFormattedTypeString(u8 type) +{ + return gFormattedTypeStrings[type]; +} + +u8 sub_8092354(u8 r0) +{ + return gUnknown_810AC7C[r0]; +} + +u8 sub_8092364(u8 r0) +{ + return gUnknown_810AC6A[r0]; +} + +void sub_8092374(char *r0, u8 r1) +{ + strncpy(r0, gAbilityNames[r1], 0x50); +} + +u8 *sub_8092390(u8 r0) +{ + return AbilityDescriptions[r0]; +} + +void sub_80923A0(void) +{ + gUnknown_203B468 = gBoughtFriendAreas; +} + +u8 *sub_80923B0(void) +{ + return gBoughtFriendAreas; +} + +void sub_80923B8(void) +{ + s32 counter; + for(counter = 0; counter < NUM_FRIEND_AREAS; counter++) + { + gUnknown_203B468[counter] = 0; + } +} + +u8 sub_80923D4(s32 target) +{ + s32 counter; + s32 index; + s32 sum = 0; + index = 0; + for(counter = 0; counter < NUM_FRIEND_AREAS; counter++) + { + sum += gUnknown_810AA90[index]; + if(sum > target) + { + return counter; + } + index += 4; + } + return 0; +} diff --git a/src/code_8094F88.c b/src/code_8094F88.c new file mode 100644 index 0000000..95854d3 --- /dev/null +++ b/src/code_8094F88.c @@ -0,0 +1,138 @@ +#include "global.h" +#include "time.h" + +extern struct PlayTimeStruct *gUnknown_203B47C; +extern struct PlayTimeStruct gPlayTime; + +extern u8 gUnknown_2038C88; +extern u8 gUnknown_2039288; +extern u32 gUnknown_20392E8; +extern u32 gUnknown_20393C0; +extern u8 *gUnknown_203B480; +extern u8 *gUnknown_203B484; +extern u32 *gUnknown_203B488; +extern u32 *gUnknown_203B48C; + + +extern void sub_809488C(u32, u32, u32); +extern void sub_8094924(u32, u32, u32); + + +// Forward Declaration +void ResetPlayTime(struct PlayTimeStruct *Time); + + +void sub_8094F88(void) +{ + gUnknown_203B47C = &gPlayTime; + ResetPlayTime(&gPlayTime); +} + +struct PlayTimeStruct *sub_8094FA0(void) +{ + return &gPlayTime; +} + +void ResetPlayTime(struct PlayTimeStruct *Time) +{ + Time->frames = 0; + Time->seconds = 0; + Time->minutes = 0; + Time->hours = 0; +} + +void IncrementPlayTime(struct PlayTimeStruct *Time) +{ + u16 temp_store16; + + Time->frames++; + if(Time->frames <= 59) + return; + Time->frames = 0; + + Time->seconds++; + if(Time->seconds <= 59) + return; + Time->seconds = 0; + + Time->minutes++; + if(Time->minutes <= 59) + return; + Time->minutes = 0; + + // Casting here for unsigned comparison + temp_store16 = Time->hours; + if(Time->hours <= 9998) + { + temp_store16++; + Time->hours = temp_store16; + } + else + { + Time->seconds = 59; + Time->minutes = 59; + Time->hours= 9999; + } +} + +void DeconstructPlayTime(struct PlayTimeStruct *r0, u32 *outHours, u32 *outMinutes, u32 *outSeconds) +{ + if(r0->hours <= 9999) + { + *outHours = r0->hours; + *outMinutes = r0->minutes; + *outSeconds = r0->seconds; + } + else + { + *outHours = 9999; + *outMinutes = 59; + *outSeconds = 59; + } +} + +void sub_8095044(u32 r0) +{ + sub_809488C(r0, (u32)(gUnknown_203B47C) + 4, 0x6); + sub_809488C(r0, (u32)(gUnknown_203B47C) + 3, 0x6); + sub_809488C(r0, (u32)(gUnknown_203B47C) + 2, 0x6); + sub_809488C(r0, (u32)(gUnknown_203B47C), 0xE); +} + +void sub_8095080(u32 r0) +{ + sub_8094924(r0, (u32)(gUnknown_203B47C) + 4, 0x6); + sub_8094924(r0, (u32)(gUnknown_203B47C) + 3, 0x6); + sub_8094924(r0, (u32)(gUnknown_203B47C) + 2, 0x6); + sub_8094924(r0, (u32)(gUnknown_203B47C), 0xE); +} + +void sub_80950BC(void) +{ + gUnknown_203B480 = &gUnknown_2038C88; + gUnknown_203B484 = &gUnknown_2039288; + gUnknown_203B488 = &gUnknown_20392E8; + gUnknown_203B48C = &gUnknown_20393C0; +} + +u8 *sub_80950F8(void) +{ + return &gUnknown_2038C88; +} + +u8 *sub_8095100(void) +{ + return &gUnknown_2039288; +} + +u32 *sub_8095108(void) +{ + return &gUnknown_20392E8; +} + +u32 *sub_8095110(void) +{ + return &gUnknown_20393C0; +} + + diff --git a/src/code_809747C.c b/src/code_809747C.c new file mode 100644 index 0000000..56e057e --- /dev/null +++ b/src/code_809747C.c @@ -0,0 +1,81 @@ +#include "global.h" +#include "dungeon.h" + +extern u32 *gStoryMissionText[]; +extern const u8 gDummyScenarioText; +extern u32 gUnknown_8109CC0; +extern u8 sub_80A270C(); +extern void sub_80015C0(u8, u8); + +const u8 *sub_809747C(s16 r0) +{ + if(r0 == 0xD) + { + return &gDummyScenarioText; + } + else + { + return GetDungeonName1(sub_80A270C()); + } +} + +const u8 *sub_80974A0(s16 r0) +{ + if(r0 == 0xD) + { + return &gDummyScenarioText; + } + else + { + return GetDungeonName1(sub_80A270C()); + } +} + +#ifndef NONMATCHING +NAKED +#endif +u32 *sub_80974C4(s16 r0) +{ +#ifdef NONMATCHING + // TODO fix regswap memes of r0/r1 + if(r0 <= 0x1E) + { + return gStoryMissionText[(r0 << 1)]; + } + else + { + return &gUnknown_8109CC0; + } +#else + asm_unified("\tpush {lr}\n" + "\tlsls r0, 16\n" + "\tasrs r0, 16\n" + "\tcmp r0, 0x1E\n" + "\tble _080974D8\n" + "\tldr r0, _080974D4\n" + "\tb _080974E0\n" + "\t.align 2, 0\n" +"_080974D4: .4byte gUnknown_8109CC0\n" +"_080974D8:\n" + "\tlsls r0, 3\n" + "\tldr r1, _080974E4\n" + "\tadds r0, r1\n" + "\tldr r0, [r0]\n" +"_080974E0:\n" + "\tpop {r1}\n" + "\tbx r1\n" + "\t.align 2, 0\n" +"_080974E4: .4byte gStoryMissionText"); + +#endif +} + +void sub_80974E8(void) +{ + sub_80015C0(0, 0x2E); + sub_80015C0(0, 0x2F); +} + +void nullsub_208(void) +{ +} diff --git a/src/code_8097F40.c b/src/code_8097F40.c new file mode 100644 index 0000000..94d271c --- /dev/null +++ b/src/code_8097F40.c @@ -0,0 +1,28 @@ +#include "global.h" + +extern u8 gUnknown_810ACC0[]; +extern u8 *gUnknown_203B498; +extern u8 gUnknown_2039840; + +bool8 sub_8097F40(u32 r0) +{ + bool8 temp; + temp = FALSE; + if(gUnknown_810ACC0[r0] == 2) + { + temp = TRUE; + } + return temp; + +} + +void sub_8097F5C(void) +{ + gUnknown_203B498 = &gUnknown_2039840; +} + +u8 *sub_8097F6C(void) +{ + return &gUnknown_2039840; +} + diff --git a/src/code_8098BDC.c b/src/code_8098BDC.c new file mode 100644 index 0000000..491fdc9 --- /dev/null +++ b/src/code_8098BDC.c @@ -0,0 +1,323 @@ +#include "global.h" +#include "time.h" + +extern struct PlayTimeStruct *gUnknown_203B47C; +extern u32 gUnknown_20398A8; +extern u32 gUnknown_20398AC; +extern u32 gUnknown_20398B0; +extern u32 gUnknown_20398B4; +extern u8 gUnknown_20398B9; +extern u8 gUnknown_20398BA; +extern u32 gUnknown_20398C0; +extern s16 gUnknown_20398C4; +extern u16 gUnknown_20398BE; +extern u8 gUnknown_203B49D; +extern u8 gUnknown_203B49C; + +extern u32 gUnknown_8115F5C; +extern u32 gUnknown_8115F80; +extern u32 gUnknown_8115FA4; +extern u32 gUnknown_8115FC8; +extern u32 gUnknown_8115FE8; + +extern void Log(u32, u32*, s32, u32); + +extern void sub_809B57C(); +extern void GroundScript_Unlock(); +extern void sub_809D25C(); +extern void sub_80A59DC(); +extern void sub_809B614(); +extern void sub_809CA20(); +extern void sub_80A6E80(); +extern void sub_8099BE4(); +extern void sub_8099744(); +extern void sub_8011860(); +extern void sub_800CB20(); +extern void sub_800485C(); +extern void nullsub_120(); +extern void sub_80A5E70(); +extern void sub_809B638(); +extern void nullsub_106(); +extern void sub_80A73EC(); +extern void sub_8099750(); +extern void sub_8009908(); +extern void xxx_call_update_bg_sound_input(); +extern void sub_80A6E68(); +extern void GroundMap_Action(); +extern void nullsub_124(); +extern void GroundLives_Action(); +extern void GroundObject_Action(); +extern void GroundEffect_Action(); + +extern s32 sub_8001658(u8, u8); +extern s32 sub_8001784(u8, u8, u8); +extern void sub_809CB8C(); +extern void sub_8001D88(); +extern void sub_80015C0(u8, u8); +extern void sub_80018D8(u8, u8, u32); +extern void sub_800199C(u8, u8, u8, s32); +extern void sub_8098CC8(); +extern void sub_809674C(); +extern void sub_80961B4(); +extern void sub_8091FB4(); +extern s32 sub_80A2B18(s16); +extern u8 sub_8001CC4(u8, u8, u8); +extern void sub_8091980(u32); + +extern u8 sub_80023E4(u32); +extern void sub_80118C4(u16); +extern u8 sub_809C730(); +extern s16 sub_80A2750(s16); + +void sub_8098BDC(void) +{ + sub_809B57C(); + GroundScript_Unlock(); + sub_809D25C(); + sub_80A59DC(); + sub_809B614(); + sub_809CA20(); + sub_80A6E80(); + sub_8099BE4(); + sub_8099744(); + sub_8011860(); + IncrementPlayTime(gUnknown_203B47C); + sub_800CB20(); + sub_800485C(); + nullsub_120(); + sub_80A5E70(); + sub_809B638(); + nullsub_106(); + sub_80A73EC(); + sub_8099750(); + sub_8009908(); + xxx_call_update_bg_sound_input(); + sub_80A6E68(); + GroundMap_Action(); + nullsub_124(); + GroundLives_Action(); + GroundObject_Action(); + GroundEffect_Action(); +} + +void sub_8098C58(void) +{ + s32 temp; + sub_80015C0(0, 0x36); + sub_80015C0(0, 0x39); + sub_809CB8C(); + sub_8001D88(); + + if(sub_8001658(0, 0x2A) != 0) + { + temp = sub_8001658(0, 0x29); + temp++; + if(temp > 0xF){ + temp = 0; + } + sub_80018D8(0, 0x29, temp); + sub_80018D8(0, 0x2A, 0); + } + + // TODO this uses r2 but it should be r3 + // Else this matches so nonmatch for now +#ifdef NONMATCHING + temp = sub_8001784(0, 0x42, 0); + if(temp <= 0) + { + temp = 1; + } + sub_800199C(0, 0x42, 0, temp - 1); +#else + asm_unified("\tmovs r0, 0\n" + "\tmovs r1, 0x42\n" + "\tmovs r2, 0\n" + "\tbl sub_8001784\n" + "\tadds r3, r0, 0\n" + "\tcmp r3, 0\n" + "\tbgt _08098CB4\n" + "\tmovs r3, 0x1\n" +"_08098CB4:\n" + "\tsubs r3, 0x1\n" + "\tmovs r0, 0\n" + "\tmovs r1, 0x42\n" + "\tmovs r2, 0\n" + "\tbl sub_800199C"); +#endif + + sub_8098CC8(); +} + +void sub_8098CC8(void) +{ + u32 temp; + if(sub_8001CC4(0x3, 0xB, 0) != 0) + { + temp = 0; + } + else if(sub_8001CC4(0x3, 0xF, 0) != 0) + { + temp = 1; + } + else if(sub_8001CC4(0x3, 0x12, 0) != 0) + { + temp = 2; + } + else + { + temp = 3; + } + sub_8091980(temp); + sub_809674C(); + sub_80961B4(); + sub_8091FB4(); +} + +bool8 sub_8098D1C(s16 r0, u32 r1, u32 r2) +{ + s32 temp; + temp = r0; // force a asr shift + if(gUnknown_20398A8 == 0) + { + Log(0, &gUnknown_8115F5C, temp, r2); + gUnknown_20398A8 = 1; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r2; + gUnknown_20398B4 = 2; + gUnknown_20398BE = temp; + gUnknown_20398C0 = r1; + return TRUE; + } + return FALSE; +} + +bool8 sub_8098D80(u32 r0) +{ + if(gUnknown_20398A8 == 0) + { + gUnknown_20398A8 = 3; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r0; + sub_809C730(); + if(sub_80023E4(0xD) == 0) + { + sub_80118C4(r0); + } + return TRUE; + } + return FALSE; +} + +bool8 sub_8098DCC(u32 r0) +{ + if(gUnknown_20398A8 == 0) + { + gUnknown_20398A8 = 4; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r0; + sub_809C730(); + if(sub_80023E4(0xD) == 0) + { + sub_80118C4(r0); + } + return TRUE; + } + return FALSE; +} + +bool8 sub_8098E18(s16 r0, u32 r1) +{ + s32 r2 = r0, r5 = r2; + if(gUnknown_20398A8 == 0) + { + Log(0, &gUnknown_8115F80, r2, r1); + if(gUnknown_203B49D != 0) + { + gUnknown_20398A8 = 7; + } + else + { + if(gUnknown_203B49C == 0) + { + gUnknown_20398C4 = r5; + } + switch(sub_80A2750(gUnknown_20398C4)) + { + case 4: gUnknown_20398A8 = 8; break; + case 1: gUnknown_20398A8 = 5; break; + case 2: gUnknown_20398A8 = 6; break; + } + } + gUnknown_20398AC = 1; + gUnknown_20398B0 = r1; + sub_809C730(); + return TRUE; + } + return FALSE; +} + +// Unused +u32 sub_8098EB0(u32 r0, u32 r1, u32 r2, u32 r3) +{ + if(gUnknown_20398A8 == 0) + { + if(gUnknown_203B49D != 0) + { + Log(0, &gUnknown_8115FA4, r0, r3); + gUnknown_20398A8 = 7; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r0; + sub_809C730(); + return 1; + } + } + return 0; +} + +u32 sub_8098F00(u32 r0, u32 r1, u32 r2, u32 r3) +{ + if(gUnknown_20398A8 == 0) + { + Log(0, &gUnknown_8115FC8, r0, r3); + gUnknown_20398A8 = 9; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r0; + sub_809C730(); + return 1; + } + return 0; +} + +u32 sub_8098F44(u32 r0, u32 r1, u32 r2, u32 r3) +{ + if(gUnknown_20398A8 == 0) + { + Log(0, &gUnknown_8115FE8, r0, r3); + gUnknown_20398A8 = 0xA; + gUnknown_20398AC = 1; + gUnknown_20398B0 = r0; + sub_809C730(); + return 1; + } + return 0; +} + +u32 sub_8098F88(void) +{ + return gUnknown_20398B9; +} + +u32 sub_8098F94(void) +{ + return gUnknown_20398BA; +} + +s16 sub_8098FA0(void) +{ + return sub_8001658(0, 0x11); +} + +s32 sub_8098FB4(void) +{ + return sub_80A2B18(sub_8001658(0, 0x11)); +} diff --git a/src/code_809D148.c b/src/code_809D148.c new file mode 100644 index 0000000..5d3c908 --- /dev/null +++ b/src/code_809D148.c @@ -0,0 +1,297 @@ +#include "global.h" + +struct unkStruct_20399E8 +{ + u32 unk0; + u32 unk4; + u32 unk8; + u32 unkC; + u32 unk10; + u32 unk14; + u32 unk18; + u32 unk1C; + u32 unk20; + + u32 unk24; + u32 unk28; + u32 unk2C; + u32 unk30; + u32 unk34; + u32 unk38; + u32 unk3C; + u32 unk40; + u8 unk44; +}; + +struct unkStruct_809D158 +{ + u32 unk0; + u32 unk4; +}; + +extern struct unkStruct_20399E8 gUnknown_20399E8; + +void sub_809D0BC(void); + + +void sub_809D0AC(void) +{ + sub_809D0BC(); +} + +void nullsub_119(void) +{ +} + +#ifndef NONMATCHING +NAKED +#endif +void sub_809D0BC(void) +{ +#ifdef NONMATCHING + struct unkStruct_20399E8 *pre_load_203; + + u32 temp; + u32 temp1; + + pre_load_203 = &gUnknown_20399E8; + + // TODO regswap.. should be r2/r3, not r0, r1 + temp = gUnknown_8116478.unk0; + temp1 = gUnknown_8116478.unk4; + + pre_load_203->unk3C = temp; + pre_load_203->unk40 = temp1; + pre_load_203->unk44 = 0; + sub_809D158(0); + pre_load_203->unk8 = 0; + pre_load_203->unkC = 0; + pre_load_203->unk10 = 0; + pre_load_203->unk4 = -1; + pre_load_203->unk24 = 0; + pre_load_203->unk28 = 0; + pre_load_203->unk2C = 0; + pre_load_203->unk30 = 0; + pre_load_203->unk34 = 0; + pre_load_203->unk38 = 0; +#else + asm_unified("\tpush {r4,r5,lr}\n" + "\tldr r5, _0809D0F8\n" + "\tldr r1, _0809D0FC\n" + "\tldr r2, [r1]\n" + "\tldr r3, [r1, 0x4]\n" + "\tstr r2, [r5, 0x3C]\n" + "\tstr r3, [r5, 0x40]\n" + "\tadds r0, r5, 0\n" + "\tadds r0, 0x44\n" + "\tmovs r4, 0\n" + "\tstrb r4, [r0]\n" + "\tmovs r0, 0\n" + "\tbl sub_809D158\n" + "\tstr r4, [r5, 0x8]\n" + "\tstr r4, [r5, 0xC]\n" + "\tstr r4, [r5, 0x10]\n" + "\tmovs r0, 0x1\n" + "\tnegs r0, r0\n" + "\tstr r0, [r5, 0x4]\n" + "\tstr r4, [r5, 0x24]\n" + "\tstr r4, [r5, 0x28]\n" + "\tstr r4, [r5, 0x2C]\n" + "\tstr r4, [r5, 0x30]\n" + "\tstr r4, [r5, 0x34]\n" + "\tstr r4, [r5, 0x38]\n" + "\tpop {r4,r5}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.align 2, 0\n" +"_0809D0F8: .4byte gUnknown_20399E8\n" +"_0809D0FC: .4byte gUnknown_8116478\n"); +#endif +} + +void sub_809D100(u32 r0) +{ + if(gUnknown_20399E8.unk24 != r0) + { + gUnknown_20399E8.unk24 = r0; + gUnknown_20399E8.unk28 = 0; + gUnknown_20399E8.unk2C = 0; + gUnknown_20399E8.unk30 = 0; + gUnknown_20399E8.unk34 = 0; + gUnknown_20399E8.unk38 = 0; + } +} + +void sub_809D124(u32 r0, u32 r1, u32 r2) +{ + if(gUnknown_20399E8.unk24 != r0) + { + gUnknown_20399E8.unk24 = r0; + gUnknown_20399E8.unk30 = 0; + gUnknown_20399E8.unk34 = 0; + gUnknown_20399E8.unk38 = 0; + } + gUnknown_20399E8.unk28 = r1; + gUnknown_20399E8.unk2C = r2; +} + +void sub_809D148(u32 r0) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 0; + +} + +void sub_809D158(u32 r0, struct unkStruct_809D158 *r1) +{ + u32 temp; + u32 temp1; + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 0; + + // Load both first and then store + temp = r1->unk0; + temp1 = r1->unk4; + gUnknown_20399E8.unk1C = temp; + gUnknown_20399E8.unk20 = temp1; +} + +void sub_809D170(u32 r0, u32 r1) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 0; + gUnknown_20399E8.unk4 = r1; +} + +void sub_809D180(u32 r0, u32 r1) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 1; + gUnknown_20399E8.unkC = r1; +} + +void sub_809D190(u32 r0, struct unkStruct_809D158 *r1, u32 r2) +{ + u32 temp; + u32 temp1; + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 1; + gUnknown_20399E8.unkC = r2; + + // Load both first and then store + temp = r1->unk0; + temp1 = r1->unk4; + gUnknown_20399E8.unk14 = temp; + gUnknown_20399E8.unk18 = temp1; +} + +void sub_809D1A8(u32 r0, u32 r1, u32 r2) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 1; + gUnknown_20399E8.unkC = r2; + gUnknown_20399E8.unk4 = r1; +} + +void sub_809D1BC(u32 r0, u32 r1) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 2; + gUnknown_20399E8.unk10 = r1; +} + +void sub_809D1CC(u32 r0, struct unkStruct_809D158 *r1, u32 r2) +{ + u32 temp; + u32 temp1; + + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 2; + gUnknown_20399E8.unk10 = r2; + + // Load both first and then store + temp = r1->unk0; + temp1 = r1->unk4; + gUnknown_20399E8.unk14 = temp; + gUnknown_20399E8.unk18 = temp1; +} + +void sub_809D1E4(u32 r0, u32 r1, u32 r2) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 2; + gUnknown_20399E8.unk10 = r2; + gUnknown_20399E8.unk4 = r1; +} + +void sub_809D1F8(u32 r0, u32 r1) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 3; + gUnknown_20399E8.unkC = r1; +} + +void sub_809D208(u32 r0, struct unkStruct_809D158 *r1, u32 r2) +{ + u32 temp; + u32 temp1; + + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 3; + gUnknown_20399E8.unkC = r2; + + // Load both first and then store + temp = r1->unk0; + temp1 = r1->unk4; + gUnknown_20399E8.unk14 = temp; + gUnknown_20399E8.unk18 = temp1; +} + +void sub_809D220(u32 r0, u32 r1, u32 r2) +{ + gUnknown_20399E8.unk0 = r0; + gUnknown_20399E8.unk8 = 3; + gUnknown_20399E8.unkC = r2; + gUnknown_20399E8.unk4 = r1; +} + +u32 sub_809D234(void) +{ + u32 temp; + temp = gUnknown_20399E8.unk8; + if(temp != 0) + { + temp = 1; + } + return temp; +} + +// TODO regswap but matches otherwise +// Loads struct into R1... should be R3 +#ifndef NONMATCHING +NAKED +#endif +u8 sub_809D248(struct unkStruct_809D158 *r0) +{ +#ifdef NONMATCHING + u32 temp; + u32 temp1; + + temp = gUnknown_20399E8.unk3C; + temp1 = gUnknown_20399E8.unk40; + r0->unk0 = temp; + r0->unk4 = temp1; + return gUnknown_20399E8.unk44; +#else + asm_unified("\tldr r3, _0809D258\n" + "\tldr r1, [r3, 0x3C]\n" + "\tldr r2, [r3, 0x40]\n" + "\tstr r1, [r0]\n" + "\tstr r2, [r0, 0x4]\n" + "\tadds r3, 0x44\n" + "\tldrb r0, [r3]\n" + "\tbx lr\n" + "\t.align 2, 0\n" +"_0809D258: .4byte gUnknown_20399E8"); +#endif +} diff --git a/src/code_80A26CC.c b/src/code_80A26CC.c new file mode 100644 index 0000000..0217d51 --- /dev/null +++ b/src/code_80A26CC.c @@ -0,0 +1,255 @@ +#include "global.h" + +struct unkStruct_80A2608 +{ + /* 0x0 */ s16 unk0; + /* 0x2 */ u16 padding; + /* 0x4 */ u32 padding2; + /* 0x8 */ u16 padding3; + /* 0xA */ u16 padding4; + /* 0xC */ u8 unkC; + /* 0xD */ u8 padding5; + /* 0xE */ s16 unkE; + /* 0x10 */ u8 unk10; + /* 0x11 */ u8 unk11; +}; + +extern struct unkStruct_80A2608 *sub_80A2608(s32); +extern struct unkStruct_80A2608 *sub_80A2620(u32); +extern u8 sub_80023E4(u32); +extern u8 sub_80973F4(s16); +extern u8 sub_8097384(s16); +extern s16 gUnknown_8116F9A[]; + +s16 sub_80A26B8(s16 r0) +{ + // Useless cast that forces correct ordering + s32 temp; + temp = r0; + + return gUnknown_8116F9A[r0]; +} + +s16 sub_80A26CC(s16 r0) +{ + return (0xDC >> 2) + r0; +} + + +s32 sub_80A26D8(u8 r0) +{ + s32 counter; + s32 counter2; + s32 temp2; + struct unkStruct_80A2608 *temp; + for(counter = 0; counter <= 0x52; counter++) + { + temp2 = counter << 0x10; + counter2 = temp2 >> 0x10; + temp = sub_80A2608(counter2); + if(temp->unk11 != 0) + { + if(temp->unkC == r0) + { + return counter2; + } + } + } + return -1; +} + +u8 sub_80A270C(s16 r0) +{ + struct unkStruct_80A2608 *temp; + s32 temp_number; + + temp_number = r0; // forcing a shift before addressing + temp = sub_80A2608(gUnknown_8116F9A[temp_number]); + return temp->unkC; +} + +u8 sub_80A2728(s16 r0) +{ + struct unkStruct_80A2608 *temp; + s16 temp_number = (0xDC >> 2) + r0; + temp = sub_80A2608(temp_number); + return temp->unkC; +} + +u8 sub_80A2740(s16 r0) +{ + struct unkStruct_80A2608 *temp; + temp = sub_80A2608(r0); + return temp->unkC; +} + +u32 sub_80A2750(s16 r0) +{ + struct unkStruct_80A2608 *temp; + s32 temp_32; + s32 temp_2; + + // so dumb but it matches + temp_32 = r0; + temp_2 = temp_32; + + if(r0 == 0x50) + return 3; + if(r0 == 0x51) + return 2; + if(r0 == 0x52) + return 4; + if((u16)(r0 - 0x28) <= 0xE) + return 2; + if((u16)(r0 - 0x37) <= 0x18) + return 4; + + temp = sub_80A2608(temp_2); + if(temp->unkE == -1) + return 1; + if(sub_80023E4(5) != 0) + return 1; + if(sub_80973F4(temp->unkE) == 0) + return 1; + if(sub_80023E4(1) == 0) + return 1; + return 2; +} + +u32 sub_80A27CC(s16 r0) +{ + s32 temp; + s32 temp2; + struct unkStruct_80A2608 *return_var; + + // Same dumbness as above to get a match + temp2 = r0; + temp = temp2; + + return_var = sub_80A2620(r0); + if(return_var->unk0 == -1) + return 0; + if(sub_80023E4(5) != 0) + return 0; + if(sub_8097384(r0) != 0) + return 1; + if(sub_80023E4(1) == 0) + return 0; + if(sub_80973F4(temp) == 0) + return 0; + return 1; +} + +u32 sub_80A2824(u8 r0) +{ + s32 counter; + s32 counter2; + s32 temp2; + struct unkStruct_80A2608 *temp; + + if(sub_80023E4(5) != 0) + { + return 0; + } + if(sub_80023E4(1) != 0) + { + for(counter = 0; counter <= 0x2D; counter++) + { + temp2 = counter << 0x10; + counter2 = temp2 >> 0x10; + temp = sub_80A2620(counter2); + if(temp->unk11 != 0) + { + if(temp->unkC == r0) + { + if(sub_8097384(counter2) != 0) + { + return 1; + } + if(sub_80973F4(counter2) != 0) + { + return 1; + } + } + } + } + } + else + { + for(counter = 0; counter <= 0x2D; counter++) + { + temp2 = counter << 0x10; + counter2 = temp2 >> 0x10; + temp = sub_80A2620(counter2); + if(temp->unk11 != 0) + { + if(temp->unkC == r0) + { + if(sub_8097384(counter2) != 0) + { + return 1; + } + } + } + } + } + return 0; + +} + +u32 sub_80A28B4(s16 r0) +{ + s32 counter2; + s32 temp2; + struct unkStruct_80A2608 *temp; + + temp2 = r0 << 0x10; + counter2 = temp2 >> 0x10; + temp = sub_80A2620(counter2); + if(temp->unk0 != -1) + { + if(sub_8097384(counter2) == 0) + { + if(sub_80973F4(counter2) == 0) + { + return 0; + } + } + else + { + return 1; + } + return 1; + } + return 0; +} + +u32 sub_80A28F0(u8 r0) +{ + s32 counter; + s32 counter2; + s32 temp2; + struct unkStruct_80A2608 *temp; + + for(counter = 0; counter <= 0x2D; counter++) + { + temp2 = counter << 0x10; + counter2 = temp2 >> 0x10; + temp = sub_80A2620(counter2); + if(temp->unk11 != 0) + { + if(temp->unkC == r0) + { + if(sub_8097384(counter2) != 0) + { + return 1; + } + if(sub_80973F4(counter2) != 0) + { + return 1; + } + } + } + } + return 0; +} diff --git a/src/code_80A7714.c b/src/code_80A7714.c new file mode 100644 index 0000000..035f58b --- /dev/null +++ b/src/code_80A7714.c @@ -0,0 +1,84 @@ +#include "global.h" + +extern void sub_80A68A0(void); +extern void sub_80A7094(u32 r0, u32 r1, u32 r2, u32 r3); +extern void sub_80A7310(u32 r0, u32 r1, u32 r2, u32 r3); +extern void sub_80A7784(); +extern s16 gUnknown_2039DE0; + +extern u32 gUnknown_8117EFC; +extern u32 *gUnknown_811E258[]; + +void sub_80A7714(void) +{ + sub_80A68A0(); +} + +void sub_80A7720(u32 r0, u32 r1, u32 r2) +{ + sub_80A7094(r0, 0, r1, r2); + sub_80A7310(r0, r1, 0, r2); +} + +void sub_80A7744(void) +{ + gUnknown_2039DE0 = -1; +} + +void sub_80A7754(void) +{ + gUnknown_2039DE0 = -1; +} + +void sub_80A7764(s16 r0) +{ + s32 temp = r0; + sub_80A7784(); + if(temp != -1) + { + gUnknown_2039DE0 = temp; + } +} + +void sub_80A7784(void) +{ + if(gUnknown_2039DE0 != -1) + { + gUnknown_2039DE0 = -1; + } +} + +u8 sub_80A77A0(s16 r0, u32 r1) +{ + s32 temp; + s32 temp2; + temp = r0; + temp2 = temp; + if(gUnknown_2039DE0 != temp) + { + if(temp < 0) + { + sub_80A7784(); + + } + else + { + sub_80A7764(temp2); + } + return 1; + } + return 0; +} + +// TODO review this later +u32 *sub_80A77D0(s16 r0) +{ + if(r0 != -1) + { + return gUnknown_811E258[r0]; + } + else + { + return &gUnknown_8117EFC; + } +} diff --git a/src/code_8272724.c b/src/code_8272724.c new file mode 100644 index 0000000..945be97 --- /dev/null +++ b/src/code_8272724.c @@ -0,0 +1,17 @@ +#include "global.h" + +extern void sub_8272774(u32 *r0, u32 r1); +extern void sub_8272884(u32 *r0, u32 r1); + +extern u32 gUnknown_2027370; // TODO defined in text.c and join later + +void sub_8272760(u32 r0) +{ + sub_8272774(&gUnknown_2027370, r0); +} + +// TODO once sub_8272774 is decomped +//void sub_8272870(u32 r0) +//{ +// sub_8272884(&gUnknown_2027370, r0); +//} diff --git a/src/dungeon.c b/src/dungeon.c new file mode 100644 index 0000000..9684ef2 --- /dev/null +++ b/src/dungeon.c @@ -0,0 +1,67 @@ +#include "global.h" +#include "dungeon.h" + +const u8 *GetDungeonName1(u8 dungeon) +{ + return gDungeonNames[dungeon].name1; +} + +const u8 *GetDungeonName2(u8 dungeon) +{ + return gDungeonNames[dungeon].name2; +} + +u8 GetStairDirection(u8 dungeon) +{ + return gDungeons[dungeon].stairDirection; +} + +s16 GetUnkC(u8 dungeon) +{ + return gDungeons[dungeon].timer; +} + +bool8 GetSaveBeforeEntering(u8 dungeon) +{ + return gDungeons[dungeon].saveBeforeEntering; +} + +u8 GetUnk9(u8 dungeon) +{ + return gDungeons[dungeon].unk9; +} + +u8 GetLevelCondition(u8 dungeon) +{ + return gDungeons[dungeon].levelCondition; +} + +u8 GetMaxItemCount(u8 dungeon) +{ + return gDungeons[dungeon].maxItemCount; +} + +u8 GetMoneyCondition(u8 dungeon) +{ + return gDungeons[dungeon].moneyCondition; +} + +s8 GetUnk3(u8 dungeon) +{ + return gDungeons[dungeon].unk3; +} + +bool8 GetRecruitable(u8 dungeon) +{ + return gDungeons[dungeon].isRecruitable; +} + +u8 sub_8090158(u8 dungeon) +{ + return gDungeons[dungeon].unk8; +} + +s16 sub_8090168(u8 dungeon) +{ + return gDungeons[dungeon].unkE; +} diff --git a/src/event_flag.c b/src/event_flag.c new file mode 100644 index 0000000..501b1af --- /dev/null +++ b/src/event_flag.c @@ -0,0 +1,53 @@ +#include "global.h" +#include "memory.h" + +struct UnkEventStruct +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ s16 unk4; + /* 0x6 */ u16 unk6; + /* 0x8 */ u16 unk8; + /* 0xA */ s16 unkA; +}; + +struct UnkEventStruct2 +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ u32 *unk4; + /* 0x8 */ u16 unk8; + /* 0xA */ s16 unkA; +}; + +extern void sub_800226C(u8 r0, u8 r1, u32* r2, u8 u3); +extern void sub_800160C(struct UnkEventStruct2 *r0, u32 r1, u32 r2); + +extern u8 gUnknown_2000A88; + + +// TODO fix stack allocation from 0xC to 0x8 to make this match +//u8 sub_8002718(struct UnkEventStruct *r0) +//{ +// struct UnkEventStruct2 temp; +// sub_800160C(&temp, 0, 0); +// MemoryCopy8(&gUnknown_2000A88, (u8 *)r0, (0x80 << 3)); +// +// // TODO fix this comparison to make it match +// if(temp.unkA != *(temp.unk4)) +// return 0; +// return 1; +//} + +void sub_8002758(u32 *r0) +{ + sub_800226C(0, 0x1, r0, 0x9); +} + +u8 sub_800276C(void) +{ + return 0; +} + +void nullsub_140(void) +{ + +} diff --git a/src/fatal_system.c b/src/fatal_system.c new file mode 100644 index 0000000..2079a38 --- /dev/null +++ b/src/fatal_system.c @@ -0,0 +1,31 @@ +#include "global.h" + +extern const char gNotMountText; +extern void Hang(); + +void nullsub_28(void) +{ +} + +u32 sub_8011BA4(void) +{ + return 0; +} + +// Unused +u32 sub_8011BA8(void) +{ + return 0; +} + +// Unused +const char *sub_8011BAC(void) +{ + return &gNotMountText; +} + +// Unused +void sub_8011BB4(void) +{ + Hang(); +} diff --git a/src/file_system.c b/src/file_system.c index 61d9ec4..b10b207 100644 --- a/src/file_system.c +++ b/src/file_system.c @@ -6,11 +6,45 @@ extern struct OpenedFile gFileCache[64]; extern u32 gFileCacheCursorPosition; extern u32 gUnknown_202D2A4; +extern const u32 gByteShiftLookup[4]; + +extern u32 *gDecompressBufferPtr; +extern u32 *gDecompressBufferStart; +extern u32 gDecompressBufferCurrent; +extern u32 gDecompressBufferByteInInt; + extern int sprintf(char *, const char *, ...); +void DecompressAT_Init(u32 *buffer); +void DecompressAT_AppendByte(char value); +void DecompressAT_Finish(void); +char DecompressAT_GetByte(int index); + +u32 DecompressAT(char *result, u32 resultLength, const char *compressedData); +u32 DecompressATGlobal(u32 *result, u32 resultLength, const char *compressedData); u8 *GetSiroPtr(struct OpenedFile *); void NDS_DecompressRLE(void *); +struct UnkFileStruct +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ u32 unk4; +}; + +extern u32 gUnknown_80B96E4[]; + +void sub_800A894(struct UnkFileStruct *r0, s32 r1) +{ + s32 temp; + temp = r1; + if(r1 <= 0) + temp = 1; + if(temp > 299) + temp = 299; + r0->unk4 = gUnknown_80B96E4[temp]; + r0->unk0 = 0; +} + void InitFileSystem(void) { s32 i; @@ -173,3 +207,1408 @@ void *UnusedGetSir0Ptr(struct SiroArchive *siro) void NDS_DecompressRLE(void *unused) { } + +void nullsub_16(void) +{ +} + +void nullsub_175(void) +{ +} + +u32 DecompressATFile(char *result, u32 resultLength, struct OpenedFile *file) +{ + return DecompressAT(result, resultLength, file->data); +} + +// 800AAB4 +#ifndef NONMATCHING +NAKED +#endif +u32 DecompressAT(char *result, u32 resultLength, const char *compressedData) +{ +#ifdef NONMATCHING + + // This function is an absolute mess, the compiler does some extremely weird things + // which makes matching it difficult. + + // As-is, it's likely that this implementation is nonfunctional + // as I've shuffled things around a lot while trying to make some parts match. + + int flags1; + int flags2; + int flags3; + int flags4; + int flags5; + int flags6; + int flags7; + int flags8; + int flags9; + int compressedLength; + char c10; + char c11; + u32 curIndex; + int v12; + char c13; + const char *p; + int command; + int resultIndex; + int v16; + int cmdBit; + int currentByte; + + compressedLength = compressedData[5] + (compressedData[6] << 8); + resultIndex = 0; + currentByte = 0; + cmdBit = 8; + + if (compressedData[0] == 'A' + && compressedData[1] == 'T' + && compressedData[2] == '4' + && compressedData[3] == 'P') { + if (resultLength != compressedData[0x10] + (compressedData[0x11] << 8) && resultLength != 0) + return 0; + curIndex = 0x12; + } else if (compressedData[0] == 'A' + && compressedData[1] == 'T' + && compressedData[2] == '3' + && compressedData[3] == 'P') { + // Can't get this to match - compiler chooses beq, b pairs instead of bne + // I tried multiple if (... != 'x') return 0; + // I tried != chained with || + // I tried == chained with && + // I tried nested if (... == 'x') + // None of that produced matching code. + curIndex = 0x10; + } else { + return 0; + } + + if (compressedData[5] == 'N') { + // uncompressed mode, unused + int i; + for (i = 0; i < compressedLength; i++) + result[i] = compressedData[i + 7]; + return i; + } + + flags1 = compressedData[0x7] + 3; + flags2 = compressedData[0x8] + 3; + flags3 = compressedData[0x9] + 3; + flags4 = compressedData[0xa] + 3; + flags5 = compressedData[0xb] + 3; + flags6 = compressedData[0xc] + 3; + flags7 = compressedData[0xd] + 3; + flags8 = compressedData[0xe] + 3; + flags9 = compressedData[0xf] + 3; + + // Some mismatches regarding the signedness of these two conditionals, extremely fragile + if (curIndex < compressedLength) { + while (resultLength == 0 || resultIndex < resultLength) { + if (cmdBit == 8) { + currentByte = compressedData[curIndex++]; + cmdBit = 0; + } + if (currentByte & 0x80) { // some weird reordering happens here, couldn't figure it out + result[resultIndex++] = compressedData[curIndex++]; + goto end_800AE08; + } + p = &compressedData[curIndex]; + command = (*p >> 4) + 3; + if (command == flags1) command = 0x1f; + if (command == flags2) command = 0x1e; + if (command == flags3) command = 0x1d; + if (command == flags4) command = 0x1c; + if (command == flags5) command = 0x1b; + if (command == flags6) command = 0x1a; + if (command == flags7) command = 0x19; + if (command == flags8) command = 0x18; + if (command == flags9) command = 0x17; + + switch (command) { + case 0x1f: + c10 = *p & 0xf; + c10 = c10 | (c10 << 4); + result[resultIndex++] = c10; + result[resultIndex++] = c10; + curIndex++; + // if curIndex is incremented inside each case, the compiler leaves them inside, but if curIndex is moved after the switch + // then it moves the second result assignment (just the 'strb' instruction) after the switch. + // Can't figure out how to make the compiler move only one without the other. + break; + case 0x1e: + v12 = *p & 0xf; + v12 = (v12 + 1) & 0xf; + c10 = v12; + result[resultIndex++] = ((*p & 0xf) << 4) | c10; + result[resultIndex++] = (v12 << 4) | c10; + curIndex++; + break; + case 0x1d: + c11 = *p & 0xf; + c10 = c11 << 4; + result[resultIndex++] = ((c11 - 1) & 0xf) | c10; + result[resultIndex++] = c10 | c11; + curIndex++; + break; + case 0x1c: + v12 = *p & 0xf; + c10 = v12; + result[resultIndex++] = (v12 << 4) | c10; + result[resultIndex++] = ((v12 & 0xf) << 4) | c10; + v12--; + curIndex++; + break; + case 0x1b: + c10 = *p; + c11 = c10 & 0xf; + c13 = c11 << 4; + result[resultIndex++] = c13 | c11; + c10 = (c10 & 0xf) - 1; + result[resultIndex++] = c13 | (c10 & 0xf); + curIndex++; + break; + case 0x1a: + v12 = ((*p & 0xf) - 1) & 0xf; + c10 = v12; + result[resultIndex++] = ((*p & 0xf) << 4) | c10; + result[resultIndex++] = (v12 << 4) | c10; + curIndex++; + break; + case 0x19: + c11 = *p & 0xf; + c10 = c11 << 4; + result[resultIndex++] = ((c11 + 1) & 0xf) | c10; + result[resultIndex++] = c10 | c11; + curIndex++; + break; + case 0x18: + v12 = *p & 0xf; + c10 = v12; + result[resultIndex++] = (v12 << 4) | c10; + v12++; + curIndex++; + result[resultIndex++] = ((v12 & 0xf) << 4) | c10; + break; + case 0x17: + c10 = *p; + c11 = c10 & 0xf; + c13 = c11 << 4; + result[resultIndex++] = c11 | c13; + c10 = (c10 & 0xf) + 1; + result[resultIndex++] = c13 | (c10 & 0xf); + curIndex++; + break; + default: + v16 = curIndex + 1; + curIndex += 2; + v16 = ((*p & 0xf) << 8) + compressedData[v16] + (-0x1000) + resultIndex; + while (command) { + result[resultIndex++] = result[v16++]; + command--; + } + break; + } +end_800AE08: + cmdBit++; + currentByte <<= 1; + if (curIndex > compressedLength) + return resultIndex; + } + } + + return 0; +#else + asm_unified( + "DecompressAT:\n" + " push {r4-r7,lr}\n" + " mov r7, r10\n" + " mov r6, r9\n" + " mov r5, r8\n" + " push {r5-r7}\n" + " sub sp, 0x2C\n" + " mov r12, r0\n" + " str r1, [sp, 0x24]\n" + " mov r8, r2\n" + " ldrb r0, [r2, 0x5]\n" + " ldrb r1, [r2, 0x6]\n" + " lsls r1, 8\n" + " adds r0, r1\n" + " str r0, [sp, 0x28]\n" + " movs r6, 0\n" + " mov r10, r6\n" + " movs r0, 0x8\n" + " mov r9, r0\n" + " ldrb r0, [r2]\n" + " cmp r0, 0x41\n" + " bne _0800AB04\n" + " ldrb r0, [r2, 0x1]\n" + " adds r1, r0, 0\n" + " cmp r1, 0x54\n" + " bne _0800AB0C\n" + " ldrb r0, [r2, 0x2]\n" + " cmp r0, 0x34\n" + " bne _0800AB0C\n" + " ldrb r0, [r2, 0x3]\n" + " cmp r0, 0x50\n" + " bne _0800AB0C\n" + " ldrb r1, [r2, 0x10]\n" + " ldrb r0, [r2, 0x11]\n" + " lsls r0, 8\n" + " adds r1, r0\n" + " ldr r2, [sp, 0x24]\n" + " cmp r2, 0\n" + " beq _0800AB08\n" + " cmp r2, r1\n" + " beq _0800AB08\n" + "_0800AB04:\n" + " movs r0, 0\n" + " b _0800AE16\n" + "_0800AB08:\n" + " movs r1, 0x12\n" + " b _0800AB26\n" + "_0800AB0C:\n" + " mov r3, r8\n" + " ldrb r0, [r3]\n" + " cmp r0, 0x41\n" + " bne _0800AB04\n" + " cmp r1, 0x54\n" + " bne _0800AB04\n" + " ldrb r0, [r3, 0x2]\n" + " cmp r0, 0x33\n" + " bne _0800AB04\n" + " ldrb r0, [r3, 0x3]\n" + " cmp r0, 0x50\n" + " bne _0800AB04\n" + " movs r1, 0x10\n" + "_0800AB26:\n" + " mov r2, r8\n" + " ldrb r0, [r2, 0x4]\n" + " cmp r0, 0x4E\n" + " bne _0800AB4A\n" + " movs r7, 0\n" + " b _0800AB40\n" + "_0800AB32:\n" + " mov r1, r12\n" + " adds r0, r1, r7\n" + " mov r2, r8\n" + " adds r1, r7, r2\n" + " ldrb r1, [r1, 0x7]\n" + " strb r1, [r0]\n" + " adds r7, 0x1\n" + "_0800AB40:\n" + " ldr r3, [sp, 0x28]\n" + " cmp r7, r3\n" + " blt _0800AB32\n" + " adds r0, r7, 0\n" + " b _0800AE16\n" + "_0800AB4A:\n" + " mov r2, r8\n" + " ldrb r0, [r2, 0x7]\n" + " adds r0, 0x3\n" + " str r0, [sp]\n" + " ldrb r0, [r2, 0x8]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x4]\n" + " ldrb r0, [r2, 0x9]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x8]\n" + " ldrb r0, [r2, 0xA]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0xC]\n" + " ldrb r0, [r2, 0xB]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x10]\n" + " ldrb r0, [r2, 0xC]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x14]\n" + " ldrb r0, [r2, 0xD]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x18]\n" + " ldrb r0, [r2, 0xE]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x1C]\n" + " ldrb r0, [r2, 0xF]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x20]\n" + " adds r7, r1, 0\n" + " ldr r3, [sp, 0x28]\n" + " cmp r7, r3\n" + " blt _0800AB8C\n" + " b _0800AE14\n" + "_0800AB8C:\n" + " ldr r0, [sp, 0x24]\n" + " cmp r0, 0\n" + " beq _0800AB96\n" + " cmp r6, r0\n" + " bge _0800AB04\n" + "_0800AB96:\n" + " mov r1, r9\n" + " cmp r1, 0x8\n" + " bne _0800ABAA\n" + " mov r2, r8\n" + " adds r0, r2, r7\n" + " ldrb r0, [r0]\n" + " mov r10, r0\n" + " adds r7, 0x1\n" + " movs r3, 0\n" + " mov r9, r3\n" + "_0800ABAA:\n" + " movs r0, 0x80\n" + " mov r1, r10\n" + " ands r0, r1\n" + " cmp r0, 0\n" + " beq _0800ABB6\n" + " b _0800ADF0\n" + "_0800ABB6:\n" + " mov r3, r8\n" + " adds r2, r3, r7\n" + " ldrb r1, [r2]\n" + " lsrs r0, r1, 4\n" + " adds r3, r0, 0x3\n" + " movs r0, 0xF\n" + " ands r0, r1\n" + " lsls r5, r0, 8\n" + " ldr r0, [sp]\n" + " cmp r3, r0\n" + " bne _0800ABCE\n" + " movs r3, 0x1F\n" + "_0800ABCE:\n" + " ldr r0, [sp, 0x4]\n" + " cmp r3, r0\n" + " bne _0800ABD6\n" + " movs r3, 0x1E\n" + "_0800ABD6:\n" + " ldr r0, [sp, 0x8]\n" + " cmp r3, r0\n" + " bne _0800ABDE\n" + " movs r3, 0x1D\n" + "_0800ABDE:\n" + " ldr r0, [sp, 0xC]\n" + " cmp r3, r0\n" + " bne _0800ABE6\n" + " movs r3, 0x1C\n" + "_0800ABE6:\n" + " ldr r0, [sp, 0x10]\n" + " cmp r3, r0\n" + " bne _0800ABEE\n" + " movs r3, 0x1B\n" + "_0800ABEE:\n" + " ldr r0, [sp, 0x14]\n" + " cmp r3, r0\n" + " bne _0800ABF6\n" + " movs r3, 0x1A\n" + "_0800ABF6:\n" + " ldr r0, [sp, 0x18]\n" + " cmp r3, r0\n" + " bne _0800ABFE\n" + " movs r3, 0x19\n" + "_0800ABFE:\n" + " ldr r0, [sp, 0x1C]\n" + " cmp r3, r0\n" + " bne _0800AC06\n" + " movs r3, 0x18\n" + "_0800AC06:\n" + " ldr r0, [sp, 0x20]\n" + " cmp r3, r0\n" + " bne _0800AC0E\n" + " movs r3, 0x17\n" + "_0800AC0E:\n" + " adds r0, r3, 0\n" + " subs r0, 0x17\n" + " cmp r0, 0x8\n" + " bls _0800AC18\n" + " b _0800ADB0\n" + "_0800AC18:\n" + " lsls r0, 2\n" + " ldr r1, _0800AC24\n" + " adds r0, r1\n" + " ldr r0, [r0]\n" + " mov pc, r0\n" + " .align 2, 0\n" + "_0800AC24: .4byte _0800AC28\n" + " .align 2, 0\n" + "_0800AC28:\n" + " .4byte _0800AD7C\n" + " .4byte _0800AD48\n" + " .4byte _0800AD20\n" + " .4byte _0800ACFA\n" + " .4byte _0800ACD6\n" + " .4byte _0800ACB4\n" + " .4byte _0800AC8C\n" + " .4byte _0800AC66\n" + " .4byte _0800AC4C\n" + "_0800AC4C:\n" + " ldrb r1, [r2]\n" + " movs r0, 0xF\n" + " adds r7, 0x1\n" + " mov r3, r12\n" + " adds r2, r3, r6\n" + " ands r0, r1\n" + " lsls r1, r0, 4\n" + " orrs r1, r0\n" + " strb r1, [r2]\n" + " adds r6, 0x1\n" + " adds r0, r3, r6\n" + " strb r1, [r0]\n" + " b _0800ADA4\n" + "_0800AC66:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r3, r1, r6\n" + " movs r2, 0xF\n" + " lsls r0, r5, 4\n" + " adds r1, r5, 0x1\n" + " ands r1, r2\n" + " orrs r0, r1\n" + " strb r0, [r3]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r2, r3, r6\n" + " lsls r0, r1, 4\n" + " orrs r0, r1\n" + " strb r0, [r2]\n" + " b _0800ADA4\n" + "_0800AC8C:\n" + " ldrb r0, [r2]\n" + " movs r3, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r4, r1, r6\n" + " adds r2, r5, 0\n" + " ands r2, r3\n" + " lsls r1, r2, 4\n" + " subs r0, r5, 0x1\n" + " ands r0, r3\n" + " orrs r0, r1\n" + " strb r0, [r4]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r0, r3, r6\n" + " orrs r1, r2\n" + " strb r1, [r0]\n" + " b _0800ADA4\n" + "_0800ACB4:\n" + " ldrb r0, [r2]\n" + " movs r3, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r2, r1, r6\n" + " adds r1, r5, 0\n" + " ands r1, r3\n" + " lsls r0, r1, 4\n" + " orrs r0, r1\n" + " strb r0, [r2]\n" + " adds r6, 0x1\n" + " mov r0, r12\n" + " adds r2, r0, r6\n" + " subs r0, r5, 0x1\n" + " b _0800AD68\n" + "_0800ACD6:\n" + " ldrb r0, [r2]\n" + " movs r4, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r2, r12\n" + " adds r3, r2, r6\n" + " adds r1, r5, 0\n" + " ands r1, r4\n" + " lsls r2, r1, 4\n" + " adds r0, r2, 0\n" + " orrs r0, r1\n" + " strb r0, [r3]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r1, r3, r6\n" + " subs r0, r5, 0x1\n" + " b _0800AD9E\n" + "_0800ACFA:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r3, r1, r6\n" + " movs r2, 0xF\n" + " lsls r0, r5, 4\n" + " subs r1, r5, 0x1\n" + " ands r1, r2\n" + " orrs r0, r1\n" + " strb r0, [r3]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r2, r3, r6\n" + " lsls r0, r1, 4\n" + " orrs r0, r1\n" + " strb r0, [r2]\n" + " b _0800ADA4\n" + "_0800AD20:\n" + " ldrb r0, [r2]\n" + " movs r3, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r4, r1, r6\n" + " adds r2, r5, 0\n" + " ands r2, r3\n" + " lsls r1, r2, 4\n" + " adds r0, r5, 0x1\n" + " ands r0, r3\n" + " orrs r0, r1\n" + " strb r0, [r4]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r0, r3, r6\n" + " orrs r1, r2\n" + " strb r1, [r0]\n" + " b _0800ADA4\n" + "_0800AD48:\n" + " ldrb r0, [r2]\n" + " movs r3, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r1, r12\n" + " adds r2, r1, r6\n" + " adds r1, r5, 0\n" + " ands r1, r3\n" + " lsls r0, r1, 4\n" + " orrs r0, r1\n" + " strb r0, [r2]\n" + " adds r6, 0x1\n" + " mov r0, r12\n" + " adds r2, r0, r6\n" + " adds r0, r5, 0x1\n" + "_0800AD68:\n" + " ands r0, r3\n" + " lsls r0, 4\n" + " orrs r0, r1\n" + " strb r0, [r2]\n" + " adds r6, 0x1\n" + " mov r4, r9\n" + " adds r4, 0x1\n" + " mov r1, r10\n" + " lsls r2, r1, 1\n" + " b _0800AE08\n" + "_0800AD7C:\n" + " ldrb r0, [r2]\n" + " movs r4, 0xF\n" + " movs r5, 0xF\n" + " ands r5, r0\n" + " adds r7, 0x1\n" + " mov r2, r12\n" + " adds r3, r2, r6\n" + " adds r1, r5, 0\n" + " ands r1, r4\n" + " lsls r2, r1, 4\n" + " adds r0, r2, 0\n" + " orrs r0, r1\n" + " strb r0, [r3]\n" + " adds r6, 0x1\n" + " mov r3, r12\n" + " adds r1, r3, r6\n" + " adds r0, r5, 0x1\n" + "_0800AD9E:\n" + " ands r0, r4\n" + " orrs r2, r0\n" + " strb r2, [r1]\n" + "_0800ADA4:\n" + " adds r6, 0x1\n" + " mov r4, r9\n" + " adds r4, 0x1\n" + " mov r0, r10\n" + " lsls r2, r0, 1\n" + " b _0800AE08\n" + "_0800ADB0:\n" + " adds r7, 0x1\n" + " mov r1, r8\n" + " adds r0, r1, r7\n" + " ldrb r0, [r0]\n" + " adds r5, r0\n" + " adds r7, 0x1\n" + " ldr r2, _0800ADEC\n" + " adds r0, r5, r2\n" + " adds r5, r0, r6\n" + " mov r4, r9\n" + " adds r4, 0x1\n" + " mov r0, r10\n" + " lsls r2, r0, 1\n" + " cmp r3, 0\n" + " beq _0800AE08\n" + "_0800ADCE:\n" + " mov r1, r12\n" + " adds r1, r6\n" + " mov r10, r1\n" + " mov r0, r12\n" + " adds r0, r5\n" + " ldrb r1, [r0]\n" + " mov r0, r10\n" + " strb r1, [r0]\n" + " adds r6, 0x1\n" + " adds r5, 0x1\n" + " subs r3, 0x1\n" + " cmp r3, 0\n" + " bne _0800ADCE\n" + " b _0800AE08\n" + " .align 2, 0\n" + "_0800ADEC: .4byte 0xfffff000\n" + "_0800ADF0:\n" + " mov r1, r12\n" + " adds r0, r1, r6\n" + " mov r2, r8\n" + " adds r1, r2, r7\n" + " ldrb r1, [r1]\n" + " strb r1, [r0]\n" + " adds r6, 0x1\n" + " adds r7, 0x1\n" + " mov r4, r9\n" + " adds r4, 0x1\n" + " mov r3, r10\n" + " lsls r2, r3, 1\n" + "_0800AE08:\n" + " mov r9, r4\n" + " mov r10, r2\n" + " ldr r0, [sp, 0x28]\n" + " cmp r7, r0\n" + " bge _0800AE14\n" + " b _0800AB8C\n" + "_0800AE14:\n" + " adds r0, r6, 0\n" + "_0800AE16:\n" + " add sp, 0x2C\n" + " pop {r3-r5}\n" + " mov r8, r3\n" + " mov r9, r4\n" + " mov r10, r5\n" + " pop {r4-r7}\n" + " pop {r1}\n" + " bx r1"); +#endif +} + +u32 DecompressATGlobalFile(u32 *result, u32 resultLength, struct OpenedFile *file) +{ + return DecompressATGlobal(result, resultLength, file->data); +} + +// 800AE34 +#ifndef NONMATCHING +NAKED +#endif +u32 DecompressATGlobal(u32 *result, u32 resultLength, const char *compressedData) +{ +#ifdef NONMATCHING + + // This function has the same issues as above, except is possibly a bit nicer due to the function calls + // I'd say this one is more likely to be at least correct + + int flags1; + int flags2; + int flags3; + int flags4; + int flags5; + int flags6; + int flags7; + int flags8; + int flags9; + int compressedLength; + u32 c10; + char c11; + u32 curIndex; + const char *p; + int command; + int bytesWritten; + int v16; + int cmdBit; + int currentByte; + + compressedLength = compressedData[5] + (compressedData[6] << 8); + bytesWritten = 0; + currentByte = 0; + cmdBit = 8; + + DecompressAT_Init(result); + + if (compressedData[0] == 'A' + && compressedData[1] == 'T' + && compressedData[2] == '4' + && compressedData[3] == 'P') { + if (resultLength != compressedData[0x10] + (compressedData[0x11] << 8) && resultLength != 0) + return 0; + curIndex = 0x12; + } else if (compressedData[0] == 'A' + && compressedData[1] == 'T' + && compressedData[2] == '3' + && compressedData[3] == 'P') { + curIndex = 0x10; + } else { + return 0; + } + + if (compressedData[5] == 'N') { + // uncompressed mode, unused + int i; + for (i = 0; i < compressedLength; i++) + DecompressAT_AppendByte(compressedData[i + 7]); + DecompressAT_Finish(); + return i; + } + + flags1 = compressedData[0x7] + 3; + flags2 = compressedData[0x8] + 3; + flags3 = compressedData[0x9] + 3; + flags4 = compressedData[0xa] + 3; + flags5 = compressedData[0xb] + 3; + flags6 = compressedData[0xc] + 3; + flags7 = compressedData[0xd] + 3; + flags8 = compressedData[0xe] + 3; + flags9 = compressedData[0xf] + 3; + + // Some mismatches regarding the signedness of these two conditionals, extremely fragile + if (curIndex < compressedLength) { + while (resultLength == 0 || bytesWritten < resultLength) { + if (cmdBit == 8) { + currentByte = compressedData[curIndex++]; + cmdBit = 0; + } + if (currentByte & 0x80) { // some weird reordering happens here, couldn't figure it out + DecompressAT_AppendByte(compressedData[curIndex++]); + goto end_800B198; + } + p = &compressedData[curIndex]; + command = (*p >> 4) + 3; + if (command == flags1) command = 0x1f; + if (command == flags2) command = 0x1e; + if (command == flags3) command = 0x1d; + if (command == flags4) command = 0x1c; + if (command == flags5) command = 0x1b; + if (command == flags6) command = 0x1a; + if (command == flags7) command = 0x19; + if (command == flags8) command = 0x18; + if (command == flags9) command = 0x17; + + switch (command) { + case 0x1f: + c10 = *p & 0xf; + c10 = c10 | (c10 << 4); + DecompressAT_AppendByte(c10); + break; + case 0x1e: + c10 = ((*p & 0xf) + 1) & 0xf; + DecompressAT_AppendByte(((*p & 0xf) << 4) | c10); + c10 |= c10 << 4; + break; + case 0x1d: + c10 = *p & 0xf; + DecompressAT_AppendByte(((c10 - 1) & 0xf) | (c10 << 4)); + c10 |= c10 << 4; + break; + case 0x1c: + c10 = *p & 0xf; + DecompressAT_AppendByte((c10 << 4) | c10); + c10 |= ((c10 - 1) & 0xf) << 4; + break; + case 0x1b: + c11 = *p & 0xf; + c10 = c11 << 4; + DecompressAT_AppendByte(c10 | c11); + c11--; + c10 |= c11 & 0xf; + break; + case 0x1a: + c10 = ((*p & 0xf) - 1) & 0xf; + DecompressAT_AppendByte(((*p & 0xf) << 4) | c10); + c10 |= c10 << 4; + break; + case 0x19: + c10 = *p & 0xf; + DecompressAT_AppendByte(((c10 + 1) & 0xf) | (c10 << 4)); + c10 |= c10 << 4; + break; + case 0x18: + c10 = *p & 0xf; + DecompressAT_AppendByte((c10 << 4) | c10); + c10 |= ((c10 + 1) & 0xf) << 4; + break; + case 0x17: + c11 = *p & 0xf; + c10 = c11 << 4; + DecompressAT_AppendByte(c10 | c11); + c11++; + c10 |= c11 & 0xf; + break; + default: + v16 = curIndex + 1; + curIndex += 2; + v16 = ((*p & 0xf) << 8) + compressedData[v16] + (-0x1000) + bytesWritten; + while (command) { + char c = DecompressAT_GetByte(v16); + DecompressAT_AppendByte(c); + bytesWritten++; + v16++; + command--; + } + goto end_800B198; + } + curIndex++; + DecompressAT_AppendByte(c10); + bytesWritten += 2; +end_800B198: + cmdBit++; + currentByte <<= 1; + if (curIndex > compressedLength) + break; + } + DecompressAT_Finish(); + return bytesWritten; + } + + return 0; +#else + asm_unified( + "DecompressATGlobal:\n" + " push {r4-r7,lr}\n" + " mov r7, r10\n" + " mov r6, r9\n" + " mov r5, r8\n" + " push {r5-r7}\n" + " sub sp, 0x34\n" + " str r1, [sp, 0x24]\n" + " mov r10, r2\n" + " ldrb r2, [r2, 0x5]\n" + " mov r3, r10\n" + " ldrb r1, [r3, 0x6]\n" + " lsls r1, 8\n" + " adds r2, r1\n" + " str r2, [sp, 0x28]\n" + " movs r1, 0\n" + " mov r9, r1\n" + " movs r2, 0\n" + " str r2, [sp, 0x2C]\n" + " movs r3, 0x8\n" + " str r3, [sp, 0x30]\n" + " bl DecompressAT_Init\n" + " mov r1, r10\n" + " ldrb r0, [r1]\n" + " cmp r0, 0x41\n" + " bne _0800AE90\n" + " ldrb r0, [r1, 0x1]\n" + " adds r1, r0, 0\n" + " cmp r1, 0x54\n" + " bne _0800AE98\n" + " mov r2, r10\n" + " ldrb r0, [r2, 0x2]\n" + " cmp r0, 0x34\n" + " bne _0800AE98\n" + " ldrb r0, [r2, 0x3]\n" + " cmp r0, 0x50\n" + " bne _0800AE98\n" + " ldrb r1, [r2, 0x10]\n" + " ldrb r0, [r2, 0x11]\n" + " lsls r0, 8\n" + " adds r1, r0\n" + " ldr r3, [sp, 0x24]\n" + " cmp r3, 0\n" + " beq _0800AE94\n" + " cmp r3, r1\n" + " beq _0800AE94\n" + "_0800AE90:\n" + " movs r0, 0\n" + " b _0800B1AA\n" + "_0800AE94:\n" + " movs r1, 0x12\n" + " b _0800AEB2\n" + "_0800AE98:\n" + " mov r2, r10\n" + " ldrb r0, [r2]\n" + " cmp r0, 0x41\n" + " bne _0800AE90\n" + " cmp r1, 0x54\n" + " bne _0800AE90\n" + " ldrb r0, [r2, 0x2]\n" + " cmp r0, 0x33\n" + " bne _0800AE90\n" + " ldrb r0, [r2, 0x3]\n" + " cmp r0, 0x50\n" + " bne _0800AE90\n" + " movs r1, 0x10\n" + "_0800AEB2:\n" + " mov r3, r10\n" + " ldrb r0, [r3, 0x4]\n" + " cmp r0, 0x4E\n" + " bne _0800AEE0\n" + " movs r0, 0\n" + " mov r8, r0\n" + " ldr r1, [sp, 0x28]\n" + " cmp r8, r1\n" + " bge _0800AED8\n" + "_0800AEC4:\n" + " mov r0, r8\n" + " add r0, r10\n" + " ldrb r0, [r0, 0x7]\n" + " bl DecompressAT_AppendByte\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " ldr r3, [sp, 0x28]\n" + " cmp r8, r3\n" + " blt _0800AEC4\n" + "_0800AED8:\n" + " bl DecompressAT_Finish\n" + " mov r0, r8\n" + " b _0800B1AA\n" + "_0800AEE0:\n" + " mov r2, r10\n" + " ldrb r0, [r2, 0x7]\n" + " adds r0, 0x3\n" + " str r0, [sp]\n" + " ldrb r0, [r2, 0x8]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x4]\n" + " ldrb r0, [r2, 0x9]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x8]\n" + " ldrb r0, [r2, 0xA]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0xC]\n" + " ldrb r0, [r2, 0xB]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x10]\n" + " ldrb r0, [r2, 0xC]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x14]\n" + " ldrb r0, [r2, 0xD]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x18]\n" + " ldrb r0, [r2, 0xE]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x1C]\n" + " ldrb r0, [r2, 0xF]\n" + " adds r0, 0x3\n" + " str r0, [sp, 0x20]\n" + " mov r8, r1\n" + " ldr r3, [sp, 0x28]\n" + " cmp r8, r3\n" + " blt _0800AF22\n" + " b _0800B1A4\n" + "_0800AF22:\n" + " ldr r0, [sp, 0x24]\n" + " cmp r0, 0\n" + " beq _0800AF2C\n" + " cmp r9, r0\n" + " bge _0800AE90\n" + "_0800AF2C:\n" + " ldr r1, [sp, 0x30]\n" + " cmp r1, 0x8\n" + " bne _0800AF42\n" + " mov r0, r10\n" + " add r0, r8\n" + " ldrb r0, [r0]\n" + " str r0, [sp, 0x2C]\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " movs r3, 0\n" + " str r3, [sp, 0x30]\n" + "_0800AF42:\n" + " movs r0, 0x80\n" + " ldr r1, [sp, 0x2C]\n" + " ands r0, r1\n" + " cmp r0, 0\n" + " beq _0800AF4E\n" + " b _0800B180\n" + "_0800AF4E:\n" + " mov r2, r10\n" + " add r2, r8\n" + " ldrb r1, [r2]\n" + " lsrs r0, r1, 4\n" + " adds r3, r0, 0x3\n" + " movs r0, 0xF\n" + " ands r0, r1\n" + " lsls r7, r0, 8\n" + " ldr r0, [sp]\n" + " cmp r3, r0\n" + " bne _0800AF66\n" + " movs r3, 0x1F\n" + "_0800AF66:\n" + " ldr r0, [sp, 0x4]\n" + " cmp r3, r0\n" + " bne _0800AF6E\n" + " movs r3, 0x1E\n" + "_0800AF6E:\n" + " ldr r0, [sp, 0x8]\n" + " cmp r3, r0\n" + " bne _0800AF76\n" + " movs r3, 0x1D\n" + "_0800AF76:\n" + " ldr r0, [sp, 0xC]\n" + " cmp r3, r0\n" + " bne _0800AF7E\n" + " movs r3, 0x1C\n" + "_0800AF7E:\n" + " ldr r0, [sp, 0x10]\n" + " cmp r3, r0\n" + " bne _0800AF86\n" + " movs r3, 0x1B\n" + "_0800AF86:\n" + " ldr r0, [sp, 0x14]\n" + " cmp r3, r0\n" + " bne _0800AF8E\n" + " movs r3, 0x1A\n" + "_0800AF8E:\n" + " ldr r0, [sp, 0x18]\n" + " cmp r3, r0\n" + " bne _0800AF96\n" + " movs r3, 0x19\n" + "_0800AF96:\n" + " ldr r0, [sp, 0x1C]\n" + " cmp r3, r0\n" + " bne _0800AF9E\n" + " movs r3, 0x18\n" + "_0800AF9E:\n" + " ldr r0, [sp, 0x20]\n" + " cmp r3, r0\n" + " bne _0800AFA6\n" + " movs r3, 0x17\n" + "_0800AFA6:\n" + " adds r0, r3, 0\n" + " subs r0, 0x17\n" + " cmp r0, 0x8\n" + " bls _0800AFB0\n" + " b _0800B13C\n" + "_0800AFB0:\n" + " lsls r0, 2\n" + " ldr r1, _0800AFBC\n" + " adds r0, r1\n" + " ldr r0, [r0]\n" + " mov pc, r0\n" + " .align 2, 0\n" + "_0800AFBC: .4byte _0800AFC0\n" + " .align 2, 0\n" + "_0800AFC0:\n" + " .4byte _0800B104\n" + " .4byte _0800B0DE\n" + " .4byte _0800B0BA\n" + " .4byte _0800B090\n" + " .4byte _0800B06E\n" + " .4byte _0800B048\n" + " .4byte _0800B024\n" + " .4byte _0800AFFE\n" + " .4byte _0800AFE4\n" + "_0800AFE4:\n" + " ldrb r0, [r2]\n" + " movs r1, 0xF\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " ands r1, r0\n" + " lsls r4, r1, 4\n" + " orrs r4, r1\n" + " adds r0, r4, 0\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " b _0800B128\n" + "_0800AFFE:\n" + " ldrb r0, [r2]\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " movs r1, 0xF\n" + " lsls r0, r6, 4\n" + " adds r4, r6, 0x1\n" + " ands r4, r1\n" + " orrs r0, r4\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " lsls r0, r4, 4\n" + " orrs r0, r4\n" + " lsls r0, 24\n" + " lsrs r0, 24\n" + " b _0800B12A\n" + "_0800B024:\n" + " ldrb r0, [r2]\n" + " movs r1, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r5, r6, 0\n" + " ands r5, r1\n" + " lsls r4, r5, 4\n" + " subs r0, r6, 0x1\n" + " ands r0, r1\n" + " orrs r0, r4\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " orrs r4, r5\n" + " b _0800B128\n" + "_0800B048:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r4, r6, 0\n" + " ands r4, r5\n" + " lsls r0, r4, 4\n" + " orrs r0, r4\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " subs r0, r6, 0x1\n" + " ands r0, r5\n" + " lsls r0, 4\n" + " orrs r0, r4\n" + " b _0800B12A\n" + "_0800B06E:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r1, r6, 0\n" + " ands r1, r5\n" + " lsls r4, r1, 4\n" + " adds r0, r4, 0\n" + " orrs r0, r1\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " subs r0, r6, 0x1\n" + " b _0800B124\n" + "_0800B090:\n" + " ldrb r0, [r2]\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " movs r1, 0xF\n" + " lsls r0, r6, 4\n" + " subs r4, r6, 0x1\n" + " ands r4, r1\n" + " orrs r0, r4\n" + " lsls r0, 24\n" + " lsrs r0, 24\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " lsls r0, r4, 4\n" + " orrs r0, r4\n" + " lsls r0, 24\n" + " lsrs r0, 24\n" + " b _0800B12A\n" + "_0800B0BA:\n" + " ldrb r0, [r2]\n" + " movs r1, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r5, r6, 0\n" + " ands r5, r1\n" + " lsls r4, r5, 4\n" + " adds r0, r6, 0x1\n" + " ands r0, r1\n" + " orrs r0, r4\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " orrs r4, r5\n" + " b _0800B128\n" + "_0800B0DE:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r4, r6, 0\n" + " ands r4, r5\n" + " lsls r0, r4, 4\n" + " orrs r0, r4\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " adds r0, r6, 0x1\n" + " ands r0, r5\n" + " lsls r0, 4\n" + " orrs r0, r4\n" + " b _0800B12A\n" + "_0800B104:\n" + " ldrb r0, [r2]\n" + " movs r5, 0xF\n" + " movs r6, 0xF\n" + " ands r6, r0\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " adds r1, r6, 0\n" + " ands r1, r5\n" + " lsls r4, r1, 4\n" + " adds r0, r4, 0\n" + " orrs r0, r1\n" + " bl DecompressAT_AppendByte\n" + " movs r3, 0x1\n" + " add r9, r3\n" + " adds r0, r6, 0x1\n" + "_0800B124:\n" + " ands r0, r5\n" + " orrs r4, r0\n" + "_0800B128:\n" + " adds r0, r4, 0\n" + "_0800B12A:\n" + " bl DecompressAT_AppendByte\n" + " movs r0, 0x1\n" + " add r9, r0\n" + " ldr r5, [sp, 0x30]\n" + " adds r5, 0x1\n" + " ldr r1, [sp, 0x2C]\n" + " lsls r4, r1, 1\n" + " b _0800B198\n" + "_0800B13C:\n" + " movs r2, 0x1\n" + " add r8, r2\n" + " mov r0, r10\n" + " add r0, r8\n" + " ldrb r0, [r0]\n" + " adds r7, r0\n" + " add r8, r2\n" + " ldr r1, _0800B17C\n" + " adds r0, r7, r1\n" + " mov r2, r9\n" + " adds r7, r0, r2\n" + " ldr r5, [sp, 0x30]\n" + " adds r5, 0x1\n" + " ldr r0, [sp, 0x2C]\n" + " lsls r4, r0, 1\n" + " cmp r3, 0\n" + " beq _0800B198\n" + " adds r6, r3, 0\n" + "_0800B160:\n" + " adds r0, r7, 0\n" + " bl DecompressAT_GetByte\n" + " lsls r0, 24\n" + " lsrs r0, 24\n" + " bl DecompressAT_AppendByte\n" + " movs r1, 0x1\n" + " add r9, r1\n" + " adds r7, 0x1\n" + " subs r6, 0x1\n" + " cmp r6, 0\n" + " bne _0800B160\n" + " b _0800B198\n" + " .align 2, 0\n" + "_0800B17C: .4byte 0xfffff000\n" + "_0800B180:\n" + " mov r0, r10\n" + " add r0, r8\n" + " ldrb r0, [r0]\n" + " bl DecompressAT_AppendByte\n" + " movs r2, 0x1\n" + " add r9, r2\n" + " add r8, r2\n" + " ldr r5, [sp, 0x30]\n" + " adds r5, 0x1\n" + " ldr r3, [sp, 0x2C]\n" + " lsls r4, r3, 1\n" + "_0800B198:\n" + " str r5, [sp, 0x30]\n" + " str r4, [sp, 0x2C]\n" + " ldr r0, [sp, 0x28]\n" + " cmp r8, r0\n" + " bge _0800B1A4\n" + " b _0800AF22\n" + "_0800B1A4:\n" + " bl DecompressAT_Finish\n" + " mov r0, r9\n" + "_0800B1AA:\n" + " add sp, 0x34\n" + " pop {r3-r5}\n" + " mov r8, r3\n" + " mov r9, r4\n" + " mov r10, r5\n" + " pop {r4-r7}\n" + " pop {r1}\n" + " bx r1"); +#endif +} + +// 800B1BC +void DecompressAT_Init(u32 *buffer) { + gDecompressBufferPtr = buffer; + gDecompressBufferStart = buffer; + gDecompressBufferCurrent = 0; + gDecompressBufferByteInInt = 0; +} + +// 800B1E0 +char DecompressAT_GetByte(int index) { + u32 data; + int offset; + + offset = index < 0 ? index + 3 : index; + data = gDecompressBufferStart[offset >> 2]; + + switch (index & 3) { + case 0: return data; + case 1: return data >> 8; + case 2: return data >> 16; + case 3: return data >> 24; + } + + return data; +} + +// 800B220 +void DecompressAT_AppendByte(char value) { + gDecompressBufferCurrent |= value << gByteShiftLookup[gDecompressBufferByteInInt]; + *gDecompressBufferPtr = gDecompressBufferCurrent; + gDecompressBufferByteInInt++; + if (gDecompressBufferByteInInt == 4) { + gDecompressBufferPtr++; + gDecompressBufferCurrent = 0; + gDecompressBufferByteInInt = 0; + } +} + +// 800B270 +void DecompressAT_Finish(void) { + if (gDecompressBufferByteInInt) + *gDecompressBufferPtr = gDecompressBufferCurrent; +} + +// 800B294 +bool32 IsATxPCompressed_unused(char *data) { + if ((data[0] == 'A' && data[1] == 'T' && data[2] == '4' && data[3] == 'P')) return TRUE; + if ((data[0] == 'A' && data[1] == 'T' && data[2] == '3' && data[3] == 'P')) return TRUE; + return FALSE; +} + +// 800B2D4 +bool32 sub_800B2D4(char *arg0, char *arg1, int length) { + int i; + char a, b; + for (i = 0; i < length; i++) { + a = arg0[i]; + b = arg1[i]; + // convert to lowercase + if ('A' <= a && a <= 'Z') a += 0x20; + if ('A' <= b && b <= 'Z') b += 0x20; + if (a != b) + return TRUE; + if (a == '\0') + break; + } + return FALSE; +} diff --git a/src/input.c b/src/input.c new file mode 100644 index 0000000..99d894b --- /dev/null +++ b/src/input.c @@ -0,0 +1,144 @@ +#include "global.h" +#include "input.h" + +EWRAM_DATA struct Input gUnknown_2025600; +EWRAM_DATA struct UnkInputStruct1 gUnknown_20255F0; +EWRAM_DATA struct UnkInputStruct1 gUnknown_2025638; +EWRAM_DATA struct UnkInputStruct1 gUnknown_2025648; +EWRAM_DATA struct UnkInputStruct2 gUnknown_2025668; +EWRAM_DATA u32 gUnknown_202562C; + +void InitInput(void) +{ + gUnknown_20255F0.unk0 = 0; + gUnknown_20255F0.unk2 = 0; + gUnknown_20255F0.unk4 = 0; + gUnknown_20255F0.unk6 = 0; + + gUnknown_2025638.unk0 = 0; + gUnknown_2025638.unk2 = 0; + gUnknown_2025638.unk4 = 0; + gUnknown_2025638.unk6 = 0; + + gUnknown_202562C = 4854977; // ????? (0x4a14c1) + + gUnknown_2025600.unk20 = 0; + gUnknown_2025600.unk0 = 0xffff; // probably a mask + gUnknown_2025600.unk2 = -1; + gUnknown_2025600.unk4 = -1; + gUnknown_2025600.unk6 = -1; + gUnknown_2025600.unk1C = -1; + gUnknown_2025600.unk1E = -1; + gUnknown_2025600.unk8 = -1; + gUnknown_2025600.unkA = -1; + gUnknown_2025600.unkC = -1; + gUnknown_2025600.unkE = -1; + gUnknown_2025600.unk10 = -1; + gUnknown_2025600.unk12 = -1; + gUnknown_2025600.unk14 = -1; + gUnknown_2025600.unk16 = -1; + gUnknown_2025600.unk28 = 0; + gUnknown_2025600.unk29 = 0; + + gUnknown_2025668.unk0 = 0; + gUnknown_2025668.unk2 = 0; +} + +void sub_800485C(void) +{ + gUnknown_20255F0 = gUnknown_2025638; + + gUnknown_2025638.unk0 = 0; + gUnknown_2025638.unk2 = 0; + gUnknown_2025638.unk4 = 0; + gUnknown_2025638.unk6 = 0; + + gUnknown_2025600.unk0 = 0xffff; + gUnknown_2025600.unk2 = -1; + gUnknown_2025600.unk4 = -1; + gUnknown_2025600.unk6 = -1; + gUnknown_2025600.unk8 = -1; + gUnknown_2025600.unkA = -1; + gUnknown_2025600.unkC = -1; + gUnknown_2025600.unkE = -1; + gUnknown_2025600.unk10 = -1; + gUnknown_2025600.unk12 = -1; + gUnknown_2025600.unk14 = -1; + gUnknown_2025600.unk16 = -1; + + gUnknown_2025600.unk28 = 0; + gUnknown_2025600.unk29 = 0; +} + +// Unused +u8 sub_80048B8(void) +{ + return 0; +} + +u8 sub_80048BC(void) +{ + return 0; +} + +// Unused +u8 sub_80048C0(void) +{ + return 0; +} + +// Unused +u8 sub_80048C4(void) +{ + return 0; +} + +u8 sub_80048C8(void) +{ + return 0; +} + +// Unused +u8 sub_80048CC(void) +{ + return 0; +} + +void sub_80048D0(void) +{ + gUnknown_20255F0.unk4 = 0; + gUnknown_2025648.unkC = 0; + gUnknown_2025648.unk8 = 0; + gUnknown_2025668.unk0 = 0x3e7; + gUnknown_2025668.unk2 = 0x3e7; + +} + +void sub_80048F8(void) +{ + gUnknown_20255F0.unk2 = 0; + gUnknown_2025638.unk2 = 0; + gUnknown_2025648.unk2 = 0; +} + +void sub_8004914(void) +{ + gUnknown_2025600.unk20 = 0x5; + gUnknown_2025600.unk24 = 0; + gUnknown_2025600.unk0 = 0xffff; + gUnknown_2025600.unk2 = -1; + gUnknown_2025600.unk4 = -1; + gUnknown_2025600.unk6 = -1; + gUnknown_2025600.unk8 = -1; + gUnknown_2025600.unkA = -1; + gUnknown_2025600.unkC = -1; + gUnknown_2025600.unkE = -1; + gUnknown_2025600.unk10 = -1; + gUnknown_2025600.unk12 = -1; + gUnknown_2025600.unk14 = -1; + gUnknown_2025600.unk16 = -1; + + gUnknown_2025600.unk28 = 0; + gUnknown_2025600.unk29 = 0; + +} @@ -1,6 +1,8 @@ #include "gba/m4a_internal.h" #include "global.h" +extern const u8 gCgb3Vol[]; + extern char SoundMainRAM_Buffer[0x400]; extern struct SoundInfo gSoundInfo; @@ -351,7 +353,7 @@ void SampleFreqSet(u32 freq) { struct SoundInfo *soundInfo = SOUND_INFO_PTR; - freq = (freq & 0xF0000) >> 16; + freq = (freq & SOUND_MODE_FREQ) >> SOUND_MODE_FREQ_SHIFT; soundInfo->freq = freq; soundInfo->pcmSamplesPerVBlank = gPcmSamplesPerVBlankTable[freq - 1]; soundInfo->pcmDmaPeriod = PCM_DMA_BUF_SIZE / soundInfo->pcmSamplesPerVBlank; @@ -640,28 +642,18 @@ void FadeOutBody(struct MusicPlayerInfo *mplayInfo) { s32 i; struct MusicPlayerTrack *track; - u16 fadeOI = mplayInfo->fadeOI; - register u32 temp asm("r3"); - register u16 mask asm("r2"); + u16 fadeOV; - if (fadeOI == 0) + if (mplayInfo->fadeOI == 0) return; - - mplayInfo->fadeOC--; - - temp = 0xFFFF; - mask = temp; - - if (mplayInfo->fadeOC != 0) + if (--mplayInfo->fadeOC != 0) return; - mplayInfo->fadeOC = fadeOI; + mplayInfo->fadeOC = mplayInfo->fadeOI; if (mplayInfo->fadeOV & FADE_IN) { - mplayInfo->fadeOV += (4 << FADE_VOL_SHIFT); - - if ((u16)(mplayInfo->fadeOV & mask) >= (64 << FADE_VOL_SHIFT)) + if ((u16)(mplayInfo->fadeOV += (4 << FADE_VOL_SHIFT)) >= (64 << FADE_VOL_SHIFT)) { mplayInfo->fadeOV = (64 << FADE_VOL_SHIFT); mplayInfo->fadeOI = 0; @@ -669,16 +661,10 @@ void FadeOutBody(struct MusicPlayerInfo *mplayInfo) } else { - mplayInfo->fadeOV -= (4 << FADE_VOL_SHIFT); - - if ((s16)(mplayInfo->fadeOV & mask) <= 0) + if ((s16)(mplayInfo->fadeOV -= (4 << FADE_VOL_SHIFT)) <= 0) { - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - - while (i > 0) + for (i = mplayInfo->trackCount, track = mplayInfo->tracks; i > 0; i--, track++) { - register u32 fadeOV asm("r7"); u32 val; TrackStop(mplayInfo, track); @@ -689,9 +675,6 @@ void FadeOutBody(struct MusicPlayerInfo *mplayInfo) if (!val) track->flags = 0; - - i--; - track++; } if (mplayInfo->fadeOV & TEMPORARY_FADE) @@ -704,27 +687,22 @@ void FadeOutBody(struct MusicPlayerInfo *mplayInfo) } } - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - - while (i > 0) + for (i = mplayInfo->trackCount, track = mplayInfo->tracks; i > 0; i--, track++) { if (track->flags & MPT_FLG_EXIST) { - track->volX = (mplayInfo->fadeOV >> FADE_VOL_SHIFT); + fadeOV = mplayInfo->fadeOV; + + track->volX = (fadeOV >> FADE_VOL_SHIFT); track->flags |= MPT_FLG_VOLCHG; } - - i--; - track++; } } - void TrkVolPitSet(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) { if (track->flags & MPT_FLG_VOLSET) { - s32 x; + u32 x; s32 y; x = (u32)(track->vol * track->volX) >> 5; @@ -749,12 +727,11 @@ void TrkVolPitSet(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *tr if (track->flags & MPT_FLG_PITSET) { s32 bend = track->bend * track->bendRange; - register s32 x asm("r1") = track->tune; - x += bend; - x *= 4; - x += (track->keyShift << 8); - x += (track->keyShiftX << 8); - x += track->pitX; + s32 x = (track->tune + bend) + * 4 + + (track->keyShift << 8) + + (track->keyShiftX << 8) + + track->pitX; if (track->modT == 0) x += 16 * track->modM; @@ -944,4 +921,707 @@ void CgbModVol(struct CgbChannel *chan) "\tpop {r0}\n" "\tbx r0\n"); #endif -}
\ No newline at end of file +} + +void CgbSound(void) +{ + s32 ch; + struct CgbChannel *channels; + s32 evAdd; + s32 prevC15; + struct SoundInfo *soundInfo = SOUND_INFO_PTR; + vu8 *nrx0ptr; + vu8 *nrx1ptr; + vu8 *nrx2ptr; + vu8 *nrx3ptr; + vu8 *nrx4ptr; + + // Most comparision operations that cast to s8 perform 'and' by 0xFF. + int mask = 0xff; + + if (soundInfo->c15) + soundInfo->c15--; + else + soundInfo->c15 = 14; + + for (ch = 1, channels = soundInfo->cgbChans; ch <= 4; ch++, channels++) + { + if (!(channels->sf & 0xc7)) + continue; + + switch (ch) + { + case 1: + nrx0ptr = (vu8 *)(REG_ADDR_NR10); + nrx1ptr = (vu8 *)(REG_ADDR_NR11); + nrx2ptr = (vu8 *)(REG_ADDR_NR12); + nrx3ptr = (vu8 *)(REG_ADDR_NR13); + nrx4ptr = (vu8 *)(REG_ADDR_NR14); + break; + case 2: + nrx0ptr = (vu8 *)(REG_ADDR_NR10+1); + nrx1ptr = (vu8 *)(REG_ADDR_NR21); + nrx2ptr = (vu8 *)(REG_ADDR_NR22); + nrx3ptr = (vu8 *)(REG_ADDR_NR23); + nrx4ptr = (vu8 *)(REG_ADDR_NR24); + break; + case 3: + nrx0ptr = (vu8 *)(REG_ADDR_NR30); + nrx1ptr = (vu8 *)(REG_ADDR_NR31); + nrx2ptr = (vu8 *)(REG_ADDR_NR32); + nrx3ptr = (vu8 *)(REG_ADDR_NR33); + nrx4ptr = (vu8 *)(REG_ADDR_NR34); + break; + default: + nrx0ptr = (vu8 *)(REG_ADDR_NR30+1); + nrx1ptr = (vu8 *)(REG_ADDR_NR41); + nrx2ptr = (vu8 *)(REG_ADDR_NR42); + nrx3ptr = (vu8 *)(REG_ADDR_NR43); + nrx4ptr = (vu8 *)(REG_ADDR_NR44); + break; + } + + prevC15 = soundInfo->c15; + evAdd = *nrx2ptr; + + if (channels->sf & 0x80) + { + if (!(channels->sf & 0x40)) + { + channels->sf = 3; + channels->mo = 3; + CgbModVol(channels); + switch (ch) + { + case 1: + *nrx0ptr = channels->sw; + // fallthrough + case 2: + *nrx1ptr = ((u32)channels->wp << 6) + channels->le; + goto loc_82E0E30; + case 3: + if ((u32)channels->wp != channels->cp) + { + *nrx0ptr = 0x40; + REG_WAVE_RAM0 = channels->wp[0]; + REG_WAVE_RAM1 = channels->wp[1]; + REG_WAVE_RAM2 = channels->wp[2]; + REG_WAVE_RAM3 = channels->wp[3]; + channels->cp = (u32)channels->wp; + } + *nrx0ptr = 0; + *nrx1ptr = channels->le; + if (channels->le) + channels->n4 = -64; + else + channels->n4 = -128; + break; + default: + *nrx1ptr = channels->le; + *nrx3ptr = (u32)channels->wp << 3; + loc_82E0E30: + evAdd = channels->at + 8; + if (channels->le) + channels->n4 = 64; + else + channels->n4 = 0; + break; + } + channels->ec = channels->at; + if ((s8)(channels->at & mask)) + { + channels->ev = 0; + goto EC_MINUS; + } + else + { + goto loc_82E0F96; + } + } + else + { + goto loc_82E0E82; + } + } + else if (channels->sf & 0x04) + { + channels->echoLength--; + if ((s8)(channels->echoLength & mask) <= 0) + { + loc_82E0E82: + CgbOscOff(ch); + channels->sf = 0; + goto LAST_LABEL; + } + goto loc_82E0FD6; + } + else if ((channels->sf & 0x40) && (channels->sf & 0x03)) + { + channels->sf &= 0xfc; + channels->ec = channels->re; + if ((s8)(channels->re & mask)) + { + channels->mo |= 1; + if (ch != 3) + { + evAdd = channels->re; + } + goto EC_MINUS; + } + else + { + goto loc_82E0F02; + } + } + else + { + loc_82E0ED0: + if (channels->ec == 0) + { + if (ch == 3) + { + channels->mo |= 1; + } + CgbModVol(channels); + if ((channels->sf & 0x3) == 0) + { + channels->ev--; + if ((s8)(channels->ev & mask) <= 0) + { + loc_82E0F02: + channels->ev = ((channels->eg * channels->echoVolume) + 0xFF) >> 8; + if (channels->ev) + { + channels->sf |= 0x4; + channels->mo |= 1; + if (ch != 3) + { + evAdd = 8; + } + goto loc_82E0FD6; + } + else + { + goto loc_82E0E82; + } + } + else + { + channels->ec = channels->re; + } + } + else if ((channels->sf & 0x3) == 1) + { + loc_82E0F3A: + channels->ev = channels->sg; + channels->ec = 7; + } + else if ((channels->sf & 0x3) == 2) + { + int ev, sg; + + channels->ev--; + ev = (s8)(channels->ev & mask); + sg = (s8)(channels->sg); + if (ev <= sg) + { + loc_82E0F5A: + if (channels->su == 0) + { + channels->sf &= 0xfc; + goto loc_82E0F02; + } + else + { + channels->sf--; + channels->mo |= 1; + if (ch != 3) + { + evAdd = 8; + } + goto loc_82E0F3A; + } + } + else + { + channels->ec = channels->de; + } + } + else + { + channels->ev++; + if ((u8)(channels->ev & mask) >= channels->eg) + { + loc_82E0F96: + channels->sf--; + channels->ec = channels->de; + if ((u8)(channels->ec & mask)) + { + channels->mo |= 1; + channels->ev = channels->eg; + if (ch != 3) + { + evAdd = channels->de; + } + } + else + { + goto loc_82E0F5A; + } + } + else + { + channels->ec = channels->at; + } + } + } + } + + EC_MINUS: + channels->ec--; + if (prevC15 == 0) + { + prevC15--; + goto loc_82E0ED0; + } + + loc_82E0FD6: + if (channels->mo & 0x2) + { + if (ch < 4 && (channels->ty & 0x08)) + { + int biasH = REG_SOUNDBIAS_H; + + if (biasH < 64) + { + channels->fr = (channels->fr + 2) & 0x7fc; + } + else if (biasH < 128) + { + channels->fr = (channels->fr + 1) & 0x7fe; + } + } + if (ch != 4) + { + *nrx3ptr = channels->fr; + } + else + { + *nrx3ptr = (*nrx3ptr & 0x08) | channels->fr; + } + channels->n4 = (channels->n4 & 0xC0) + (*((u8*)(&channels->fr) + 1)); + *nrx4ptr = (s8)(channels->n4 & mask); + } + + if (channels->mo & 1) + { + REG_NR51 = (REG_NR51 & ~channels->panMask) | channels->pan; + if (ch == 3) + { + *nrx2ptr = gCgb3Vol[channels->ev]; + if (channels->n4 & 0x80) + { + *nrx0ptr = 0x80; + *nrx4ptr = channels->n4; + channels->n4 &= 0x7f; + } + } + else + { + evAdd &= 0xf; + *nrx2ptr = (channels->ev << 4) + evAdd; + *nrx4ptr = channels->n4 | 0x80; + if (ch == 1 && !(*nrx0ptr & 0x08)) + { + *nrx4ptr = channels->n4 | 0x80; + } + } + } + + LAST_LABEL: + channels->mo = 0; + } +} + +void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo) +{ + if (mplayInfo->ident == ID_NUMBER) + { + mplayInfo->ident++; + mplayInfo->tempoU = tempo; + mplayInfo->tempoI = (mplayInfo->tempoD * mplayInfo->tempoU) >> 8; + mplayInfo->ident = ID_NUMBER; + } +} + +void m4aMPlayVolumeControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u16 volume) +{ + s32 i; + u32 bit; + struct MusicPlayerTrack *track; + + if (mplayInfo->ident != ID_NUMBER) + return; + + mplayInfo->ident++; + + i = mplayInfo->trackCount; + track = mplayInfo->tracks; + bit = 1; + + while (i > 0) + { + if (trackBits & bit) + { + if (track->flags & MPT_FLG_EXIST) + { + track->volX = volume / 4; + track->flags |= MPT_FLG_VOLCHG; + } + } + + i--; + track++; + bit <<= 1; + } + + mplayInfo->ident = ID_NUMBER; +} + +void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch) +{ + s32 i; + u32 bit; + struct MusicPlayerTrack *track; + + if (mplayInfo->ident != ID_NUMBER) + return; + + mplayInfo->ident++; + + i = mplayInfo->trackCount; + track = mplayInfo->tracks; + bit = 1; + + while (i > 0) + { + if (trackBits & bit) + { + if (track->flags & MPT_FLG_EXIST) + { + track->keyShiftX = pitch >> 8; + track->pitX = pitch; + track->flags |= MPT_FLG_PITCHG; + } + } + + i--; + track++; + bit <<= 1; + } + + mplayInfo->ident = ID_NUMBER; +} + +void m4aMPlayPanpotControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s8 pan) +{ + s32 i; + u32 bit; + struct MusicPlayerTrack *track; + + if (mplayInfo->ident != ID_NUMBER) + return; + + mplayInfo->ident++; + + i = mplayInfo->trackCount; + track = mplayInfo->tracks; + bit = 1; + + while (i > 0) + { + if (trackBits & bit) + { + if (track->flags & MPT_FLG_EXIST) + { + track->panX = pan; + track->flags |= MPT_FLG_VOLCHG; + } + } + + i--; + track++; + bit <<= 1; + } + + mplayInfo->ident = ID_NUMBER; +} + +void ClearModM(struct MusicPlayerTrack *track) +{ + track->lfoSpeedC = 0; + track->modM = 0; + + if (track->modT == 0) + track->flags |= MPT_FLG_PITCHG; + else + track->flags |= MPT_FLG_VOLCHG; +} + +void m4aMPlayModDepthSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 modDepth) +{ + s32 i; + u32 bit; + struct MusicPlayerTrack *track; + + if (mplayInfo->ident != ID_NUMBER) + return; + + mplayInfo->ident++; + + i = mplayInfo->trackCount; + track = mplayInfo->tracks; + bit = 1; + + while (i > 0) + { + if (trackBits & bit) + { + if (track->flags & MPT_FLG_EXIST) + { + track->mod = modDepth; + + if (!track->mod) + ClearModM(track); + } + } + + i--; + track++; + bit <<= 1; + } + + mplayInfo->ident = ID_NUMBER; +} + +void m4aMPlayLFOSpeedSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 lfoSpeed) +{ + s32 i; + u32 bit; + struct MusicPlayerTrack *track; + + if (mplayInfo->ident != ID_NUMBER) + return; + + mplayInfo->ident++; + + i = mplayInfo->trackCount; + track = mplayInfo->tracks; + bit = 1; + + while (i > 0) + { + if (trackBits & bit) + { + if (track->flags & MPT_FLG_EXIST) + { + track->lfoSpeed = lfoSpeed; + + if (!track->lfoSpeed) + ClearModM(track); + } + } + + i--; + track++; + bit <<= 1; + } + + mplayInfo->ident = ID_NUMBER; +} + +#define MEMACC_COND_JUMP(cond) \ +if (cond) \ + goto cond_true; \ +else \ + goto cond_false; \ + +void ply_memacc(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + u32 op; + u8 *addr; + u8 data; + + op = *track->cmdPtr; + track->cmdPtr++; + + addr = mplayInfo->memAccArea + *track->cmdPtr; + track->cmdPtr++; + + data = *track->cmdPtr; + track->cmdPtr++; + + switch (op) + { + case 0: + *addr = data; + return; + case 1: + *addr += data; + return; + case 2: + *addr -= data; + return; + case 3: + *addr = mplayInfo->memAccArea[data]; + return; + case 4: + *addr += mplayInfo->memAccArea[data]; + return; + case 5: + *addr -= mplayInfo->memAccArea[data]; + return; + case 6: + MEMACC_COND_JUMP(*addr == data) + return; + case 7: + MEMACC_COND_JUMP(*addr != data) + return; + case 8: + MEMACC_COND_JUMP(*addr > data) + return; + case 9: + MEMACC_COND_JUMP(*addr >= data) + return; + case 10: + MEMACC_COND_JUMP(*addr <= data) + return; + case 11: + MEMACC_COND_JUMP(*addr < data) + return; + case 12: + MEMACC_COND_JUMP(*addr == mplayInfo->memAccArea[data]) + return; + case 13: + MEMACC_COND_JUMP(*addr != mplayInfo->memAccArea[data]) + return; + case 14: + MEMACC_COND_JUMP(*addr > mplayInfo->memAccArea[data]) + return; + case 15: + MEMACC_COND_JUMP(*addr >= mplayInfo->memAccArea[data]) + return; + case 16: + MEMACC_COND_JUMP(*addr <= mplayInfo->memAccArea[data]) + return; + case 17: + MEMACC_COND_JUMP(*addr < mplayInfo->memAccArea[data]) + return; + default: + return; + } + +cond_true: + { + void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[1]); + func(mplayInfo, track); + return; + } + +cond_false: + track->cmdPtr += 4; +} + +void ply_xcmd(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + u32 n = *track->cmdPtr; + track->cmdPtr++; + + gXcmdTable[n](mplayInfo, track); +} + +void ply_xxx(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[0]); + func(mplayInfo, track); +} + +#define READ_XCMD_BYTE(var, n) \ +{ \ + u32 byte = track->cmdPtr[(n)]; \ + byte <<= n * 8; \ + (var) &= ~(0xFF << (n * 8)); \ + (var) |= byte; \ +} + +void ply_xwave(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + u32 wav; + + READ_XCMD_BYTE(wav, 0) // UB: uninitialized variable + READ_XCMD_BYTE(wav, 1) + READ_XCMD_BYTE(wav, 2) + READ_XCMD_BYTE(wav, 3) + + track->tone.wav = (struct WaveData *)wav; + track->cmdPtr += 4; +} + +void ply_xtype(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.type = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xatta(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.attack = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xdeca(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.decay = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xsust(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.sustain = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xrele(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.release = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xiecv(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->echoVolume = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xiecl(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->echoLength = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xleng(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.length = *track->cmdPtr; + track->cmdPtr++; +} + +void ply_xswee(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) +{ + track->tone.pan_sweep = *track->cmdPtr; + track->cmdPtr++; +} + +void DummyFunc() +{ + ; +} diff --git a/src/m4a_4.c b/src/m4a_4.c deleted file mode 100644 index 595ea5a..0000000 --- a/src/m4a_4.c +++ /dev/null @@ -1,384 +0,0 @@ -#include "gba/m4a_internal.h" - -void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo) -{ - if (mplayInfo->ident == ID_NUMBER) - { - mplayInfo->ident++; - mplayInfo->tempoU = tempo; - mplayInfo->tempoI = (mplayInfo->tempoD * mplayInfo->tempoU) >> 8; - mplayInfo->ident = ID_NUMBER; - } -} - -void m4aMPlayVolumeControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u16 volume) -{ - s32 i; - u32 bit; - struct MusicPlayerTrack *track; - - if (mplayInfo->ident != ID_NUMBER) - return; - - mplayInfo->ident++; - - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - bit = 1; - - while (i > 0) - { - if (trackBits & bit) - { - if (track->flags & MPT_FLG_EXIST) - { - track->volX = volume / 4; - track->flags |= MPT_FLG_VOLCHG; - } - } - - i--; - track++; - bit <<= 1; - } - - mplayInfo->ident = ID_NUMBER; -} - -void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch) -{ - s32 i; - u32 bit; - struct MusicPlayerTrack *track; - - if (mplayInfo->ident != ID_NUMBER) - return; - - mplayInfo->ident++; - - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - bit = 1; - - while (i > 0) - { - if (trackBits & bit) - { - if (track->flags & MPT_FLG_EXIST) - { - track->keyShiftX = pitch >> 8; - track->pitX = pitch; - track->flags |= MPT_FLG_PITCHG; - } - } - - i--; - track++; - bit <<= 1; - } - - mplayInfo->ident = ID_NUMBER; -} - -void m4aMPlayPanpotControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s8 pan) -{ - s32 i; - u32 bit; - struct MusicPlayerTrack *track; - - if (mplayInfo->ident != ID_NUMBER) - return; - - mplayInfo->ident++; - - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - bit = 1; - - while (i > 0) - { - if (trackBits & bit) - { - if (track->flags & MPT_FLG_EXIST) - { - track->panX = pan; - track->flags |= MPT_FLG_VOLCHG; - } - } - - i--; - track++; - bit <<= 1; - } - - mplayInfo->ident = ID_NUMBER; -} - -void ClearModM(struct MusicPlayerTrack *track) -{ - track->lfoSpeedC = 0; - track->modM = 0; - - if (track->modT == 0) - track->flags |= MPT_FLG_PITCHG; - else - track->flags |= MPT_FLG_VOLCHG; -} - -void m4aMPlayModDepthSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 modDepth) -{ - s32 i; - u32 bit; - struct MusicPlayerTrack *track; - - if (mplayInfo->ident != ID_NUMBER) - return; - - mplayInfo->ident++; - - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - bit = 1; - - while (i > 0) - { - if (trackBits & bit) - { - if (track->flags & MPT_FLG_EXIST) - { - track->mod = modDepth; - - if (!track->mod) - ClearModM(track); - } - } - - i--; - track++; - bit <<= 1; - } - - mplayInfo->ident = ID_NUMBER; -} - -void m4aMPlayLFOSpeedSet(struct MusicPlayerInfo *mplayInfo, u16 trackBits, u8 lfoSpeed) -{ - s32 i; - u32 bit; - struct MusicPlayerTrack *track; - - if (mplayInfo->ident != ID_NUMBER) - return; - - mplayInfo->ident++; - - i = mplayInfo->trackCount; - track = mplayInfo->tracks; - bit = 1; - - while (i > 0) - { - if (trackBits & bit) - { - if (track->flags & MPT_FLG_EXIST) - { - track->lfoSpeed = lfoSpeed; - - if (!track->lfoSpeed) - ClearModM(track); - } - } - - i--; - track++; - bit <<= 1; - } - - mplayInfo->ident = ID_NUMBER; -} - -#define MEMACC_COND_JUMP(cond) \ -if (cond) \ - goto cond_true; \ -else \ - goto cond_false; \ - -void ply_memacc(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - u32 op; - u8 *addr; - u8 data; - - op = *track->cmdPtr; - track->cmdPtr++; - - addr = mplayInfo->memAccArea + *track->cmdPtr; - track->cmdPtr++; - - data = *track->cmdPtr; - track->cmdPtr++; - - switch (op) - { - case 0: - *addr = data; - return; - case 1: - *addr += data; - return; - case 2: - *addr -= data; - return; - case 3: - *addr = mplayInfo->memAccArea[data]; - return; - case 4: - *addr += mplayInfo->memAccArea[data]; - return; - case 5: - *addr -= mplayInfo->memAccArea[data]; - return; - case 6: - MEMACC_COND_JUMP(*addr == data) - return; - case 7: - MEMACC_COND_JUMP(*addr != data) - return; - case 8: - MEMACC_COND_JUMP(*addr > data) - return; - case 9: - MEMACC_COND_JUMP(*addr >= data) - return; - case 10: - MEMACC_COND_JUMP(*addr <= data) - return; - case 11: - MEMACC_COND_JUMP(*addr < data) - return; - case 12: - MEMACC_COND_JUMP(*addr == mplayInfo->memAccArea[data]) - return; - case 13: - MEMACC_COND_JUMP(*addr != mplayInfo->memAccArea[data]) - return; - case 14: - MEMACC_COND_JUMP(*addr > mplayInfo->memAccArea[data]) - return; - case 15: - MEMACC_COND_JUMP(*addr >= mplayInfo->memAccArea[data]) - return; - case 16: - MEMACC_COND_JUMP(*addr <= mplayInfo->memAccArea[data]) - return; - case 17: - MEMACC_COND_JUMP(*addr < mplayInfo->memAccArea[data]) - return; - default: - return; - } - -cond_true: - { - void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[1]); - func(mplayInfo, track); - return; - } - -cond_false: - track->cmdPtr += 4; -} - -void ply_xcmd(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - u32 n = *track->cmdPtr; - track->cmdPtr++; - - gXcmdTable[n](mplayInfo, track); -} - -void ply_xxx(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - void (*func)(struct MusicPlayerInfo *, struct MusicPlayerTrack *) = *(&gMPlayJumpTable[0]); - func(mplayInfo, track); -} - -#define READ_XCMD_BYTE(var, n) \ -{ \ - u32 byte = track->cmdPtr[(n)]; \ - byte <<= n * 8; \ - (var) &= ~(0xFF << (n * 8)); \ - (var) |= byte; \ -} - -void ply_xwave(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - u32 wav; - - READ_XCMD_BYTE(wav, 0) // UB: uninitialized variable - READ_XCMD_BYTE(wav, 1) - READ_XCMD_BYTE(wav, 2) - READ_XCMD_BYTE(wav, 3) - - track->tone.wav = (struct WaveData *)wav; - track->cmdPtr += 4; -} - -void ply_xtype(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.type = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xatta(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.attack = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xdeca(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.decay = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xsust(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.sustain = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xrele(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.release = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xiecv(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->echoVolume = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xiecl(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->echoLength = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xleng(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.length = *track->cmdPtr; - track->cmdPtr++; -} - -void ply_xswee(struct MusicPlayerInfo *mplayInfo, struct MusicPlayerTrack *track) -{ - track->tone.pan_sweep = *track->cmdPtr; - track->cmdPtr++; -} - -void DummyFunc() -{ - ; -} @@ -1,6 +1,7 @@ #include "global.h" #include "random.h" #include "flash.h" +#include "text.h" extern char ewram_start[]; @@ -34,7 +35,6 @@ extern void InitInput(void); extern void InitBGPaletteBuffer(void); extern void sub_80057E8(void); extern void InitFileSystem(void); -extern void sub_8006218(void); extern void sub_80098A0(void); extern void sub_80096E0(void); extern void sub_800B6F4(int, void *); diff --git a/src/memory.c b/src/memory.c index 05c89a2..3ac8772 100644 --- a/src/memory.c +++ b/src/memory.c @@ -143,3 +143,36 @@ void InitSubHeap(struct HeapDescriptor *parentHeap, struct HeapMemoryBlock *bloc settings.size = aligned_size; DoInitHeap(parentHeap, &settings, freeList, freeListMax); } + +u8 xxx_memory_attr_related(u32 r0) +{ + u32 temp; + u32 return_var; + if(r0 == 0) + { + return 0; + } + if((r0 & 8) != 0) + { + return 4; + } + + temp = r0 & 7; + if(temp == 7) + { + return_var = 1;; + } + else if(temp == 1) + { + return_var = 2; + } + else if(temp == 3) + { + return_var = 3; + } + else + { + return_var = 5; + } + return return_var; +} diff --git a/src/memory1.c b/src/memory1.c new file mode 100644 index 0000000..8efcc04 --- /dev/null +++ b/src/memory1.c @@ -0,0 +1,11 @@ +#include "global.h" + +void nullsub_141(void) +{ + +} + +void nullsub_142(void) +{ + +} diff --git a/src/music.c b/src/music.c new file mode 100644 index 0000000..8997887 --- /dev/null +++ b/src/music.c @@ -0,0 +1,215 @@ +#include "global.h" +#include "m4a.h" + +#define NUM_BG_SONGS 128 + +extern u8 sub_80023E4(u32); +extern void sub_80118C4(u16); +extern void sub_809C730(); + +extern bool8 DisableInterrupts(); +extern bool8 EnableInterrupts(); + +extern void sub_800C3F8(u16, u16); +extern void Random(); +extern void sub_800BA5C(); +extern void xxx_update_bg_sound_input(); + +extern u16 gUnknown_202D688; +extern u16 gUnknown_202D68A; +extern u16 gUnknown_202D690; +extern u8 gUnknown_202D694; +extern u32 gUnknown_203B0B8; +extern u16 gUnknown_203B0BC; + +bool8 IsBGSong(u32); +bool8 sub_800CAAC(u32); +bool8 sub_800CACC(u32); +u16 sub_800CAE0(u16); + +void sub_800C93C(void) +{ + bool8 interrupt_flag; + u16 temp; + + sub_800C3F8(0x3e5, 0x10); + sub_800C3F8(0x3e6, 0x10); + + interrupt_flag = DisableInterrupts(); + if(gUnknown_202D690 == 0) + { + if(gUnknown_202D68A != 0x3e7) + { + temp = gUnknown_202D688 - 1; + if(temp <= 1) + { + if(gUnknown_202D688 == 2) + { + gUnknown_202D694 = gUnknown_202D690; + } + else + { + if(gUnknown_202D688 == 1) + { + gUnknown_202D694 = 1; + } + } + gUnknown_202D688 = 4; + } + } + } + m4aMPlayStop(&gUnknown_20008F0); + m4aSoundVSyncOff(); + if(interrupt_flag) + { + EnableInterrupts(); + } +} + +void sub_800C9CC(void) +{ + bool8 interrupt_flag = DisableInterrupts(); + m4aSoundVSyncOn(); + if(gUnknown_202D690 == 0) + { + if(gUnknown_202D68A != 0x3e7) + { + if(gUnknown_202D688 == 4) + { + gUnknown_202D688 = 1; + if(gUnknown_202D694 != 0) + { + m4aSongNumStart(gUnknown_202D68A); + } + else + { + m4aMPlayContinue(&gUnknown_20008F0); + } + } + } + } + if(interrupt_flag) + { + EnableInterrupts(); + } + +} + +void nullsub_179(void) +{ +} + +u8 sub_800CA38(u32 songIndex) +{ + if(IsBGSong(songIndex)) + { + if(sub_800CAE0(songIndex) == 0) + { + return 1; + } + } + if(sub_800CACC(songIndex)) + { + if(sub_800CAE0(songIndex) == 1) + { + return 1; + } + } + else if(sub_800CAAC(songIndex)) + { + if(sub_800CAE0(songIndex) > 1) + { + return 1; + } + } + return 0; +} + +void nullsub_19(void) +{ +} + +bool8 IsBGSong(u32 songIndex) +{ + if(songIndex <= NUM_BG_SONGS) + { + return TRUE; + } + return FALSE; +} + +bool8 sub_800CAAC(u32 songIndex) +{ + if(songIndex - 300 <= 639) + { + return TRUE; + } + return FALSE; +} + +bool8 sub_800CACC(u32 songIndex) +{ + if(songIndex - 200 <= 19) + { + return TRUE; + } + return FALSE; +} + +u16 sub_800CAE0(u16 songIndex) +{ + return gSongTable[songIndex].ms; +} + +bool8 sub_800CAF0(u16 songIndex) +{ + // Had to cast this.. m4a_internal header has this as u32 + if((u16)gMPlayTable[songIndex].info->status == 0) + { + return 0; + } + return 1; +} + +void nullsub_20(u16 songIndex) +{ +} + +void nullsub_21(void) +{ +} + +void sub_800CB20(void) +{ + sub_800BA5C(); + gUnknown_203B0B8++; + if((gUnknown_203B0BC & 5) != 0) + { + Random(); + } + Random(); +} + +u32 sub_800CB50(void) +{ + return gUnknown_203B0B8; +} + +void nullsub_180(void) +{ +} + +void xxx_call_update_bg_sound_input(void) +{ + xxx_update_bg_sound_input(); +} + +void nullsub_181(void) +{ +} + +u32 sub_800CB70(void) +{ + return 0; +} + diff --git a/src/music_pre.c b/src/music_pre.c new file mode 100644 index 0000000..292f0a8 --- /dev/null +++ b/src/music_pre.c @@ -0,0 +1,241 @@ +#include "global.h" +#include "gba/io_reg.h" +#include "m4a.h" + +extern void nullsub_19(void); +extern void nullsub_20(u16 songIndex); +extern bool8 EnableInterrupts(void); +extern bool8 DisableInterrupts(void); +extern bool8 IsBGSong(u32); + +extern void sub_800C298(u16 r0); +extern u16 sub_800CAE0(u16); + +extern u32 gUnknown_202D5F0[]; +extern u16 gUnknown_202D688; +extern u16 gUnknown_202D68A; +extern u16 gUnknown_202D68C; +extern u16 gUnknown_202D68E; +extern u16 gUnknown_202D690; +extern u16 gUnknown_202D692; +extern u8 gUnknown_202D694; + +struct unkStruct_3000FD8 +{ + u16 unk0; + u16 unk2; + u16 unk4; + u8 unk6; + u8 padding; +}; + +extern struct unkStruct_3000FD8 gUnknown_3000FD8[8]; + +void sub_800BF80(void); + +// Some kind of initializer for music? +void sub_800BD08(void) +{ + s32 counter; + u16 zero; + u16 zero2; + + struct unkStruct_3000FD8 *preload; + + DmaStop(0); + DmaStop(1); + DmaStop(2); + DmaStop(3); + + m4aSoundInit(); + + gUnknown_202D688 = 0; + gUnknown_202D68A = 0x3e7; + gUnknown_202D68C = 0x3e7; + gUnknown_202D68E = 0x3e5; + gUnknown_202D690 = 0; + gUnknown_202D692 = 0; + gUnknown_202D694 = 0; + + // Kinda hacky but makes things match + preload = gUnknown_3000FD8; + zero = 0; + zero2 = 0; + counter = 7; + + while(counter >= 0) + { + preload->unk0 = zero2; + preload->unk2 = 0x3e5; + preload->unk4 = zero2; + preload->unk6 = zero; + counter--; + preload++; + } + nullsub_19(); +} + +void sub_800BDDC(void) +{ + sub_800BF80(); + sub_800C298(0x3e6); + sub_800C298(0x3e5); +} + + +void sub_800BDFC(u16 songIndex) +{ + bool8 interrupt_flag; + u16 temp_store; + + if(!IsBGSong(songIndex)) + return; + if(songIndex == 0x3e7) + return; + if(songIndex == gUnknown_202D68A) + { + temp_store = gUnknown_202D688 - 1; + if(temp_store <= 1) + return; + } + if(sub_800CAE0(songIndex)) + { + nullsub_20(songIndex); + return; + } + interrupt_flag = DisableInterrupts(); + gUnknown_202D68A = songIndex; + gUnknown_202D694 = 1; + + if(gUnknown_202D690 == 0) + { + gUnknown_202D688 = 1; + m4aSongNumStart(songIndex); + } + if(interrupt_flag) + EnableInterrupts(); +} + +void FadeInNewBGM(u16 SongIndex, u16 speed) +{ + bool8 interrupt_flag; + u16 temp_store; + + if(!IsBGSong(SongIndex)) + return; + if(SongIndex == 0x3e7) + return; + if(SongIndex == gUnknown_202D68A) + { + temp_store = gUnknown_202D688 - 1; + if((temp_store) <= 1) + return; + } + + if((speed > 256)) + { + speed = 16; + + } + else + { + if((speed >>= 4) == 0) + { + speed = 1; + } + } + + interrupt_flag = DisableInterrupts(); + gUnknown_202D68A = SongIndex; + gUnknown_202D694 = 1; + + if(gUnknown_202D690 == 0) + { + gUnknown_202D688 = 1; + m4aSongNumStart(SongIndex); + m4aMPlayImmInit(&gUnknown_20008F0); + m4aMPlayVolumeControl(&gUnknown_20008F0, 0xFF, 0); + m4aSongNumStop(SongIndex); + m4aMPlayFadeIn(&gUnknown_20008F0, speed); + } + if(interrupt_flag) + EnableInterrupts(); +} + +void sub_800BF48(u16 SongIndex) +{ + u16 preload = gUnknown_202D68A; + if(preload == 0x3e7) + { + sub_800BDFC(SongIndex); + gUnknown_202D68C = preload; + return; + } + gUnknown_202D68C = SongIndex; +} + +void sub_800BF80(void) +{ + bool8 interrupt_flag = DisableInterrupts(); + if(gUnknown_202D690 == 0) + { + if(gUnknown_202D68A != 0x3e7) + { + m4aMPlayStop(&gUnknown_20008F0); + } + } + gUnknown_202D68A = 0x3e7; + gUnknown_202D68C = 0x3e7; + if(interrupt_flag) + EnableInterrupts(); +} + +void sub_800BFD0(u16 speed) +{ + + u32 comparison; + bool8 interrupt_flag; + + // TODO clean this comparison up + comparison = 0x80 << 17; // 16777216 + if((speed * 65536) > comparison) + { + speed = 16; + } + else + { + if((speed >>= 4) == 0) + { + speed = 1; + } + } + interrupt_flag = DisableInterrupts(); + if(gUnknown_202D690 == 0) + { + if(gUnknown_202D68A != 0x3e7) + { + if(gUnknown_202D688 == 2) + { + gUnknown_202D688 = 3; + m4aMPlayFadeOut(&gUnknown_20008F0, speed); + } + else + { + gUnknown_202D68A = 0x3e7; + m4aMPlayStop(&gUnknown_20008F0); + } + } + } + else + { + gUnknown_202D68A = 0x3e7; + } + gUnknown_202D68C = 0x3e7; + if(interrupt_flag) + EnableInterrupts(); +} + +u16 sub_800C068(void) +{ + return gUnknown_202D68A; +} diff --git a/src/personality_test.c b/src/personality_test.c new file mode 100644 index 0000000..c0562e4 --- /dev/null +++ b/src/personality_test.c @@ -0,0 +1,55 @@ +#include "global.h" +#include "constants/species.h" + +// TODO convert this... maybe a script? +const u8 gUnknown_80F4244[32] = +{ + 0, 0, 0, 0, + 5, 0, 0, 0, + 0xC, 0, 6, 0, + 5, 0, 5, 0, + 5, 0, 0, 0, + 0, 0, 0, 0, + + 'p', 'k', 's', 'd', 'i', 'r', '0', 0 +}; + +const u16 gPartners[10] = +{ + SPECIES_CHARMANDER, + SPECIES_BULBASAUR, + SPECIES_SQUIRTLE, + SPECIES_PIKACHU, + SPECIES_CHIKORITA, + SPECIES_TOTODILE, + SPECIES_CYNDAQUIL, + SPECIES_TORCHIC, + SPECIES_TREECKO, + SPECIES_MUDKIP +}; + +extern u8 gUnknown_80F42D0[]; +extern u8 gUnknown_80F42F0[]; +extern u8 gUnknown_203B408; + +u8 sub_803D0D8() +{ + return gUnknown_203B408; +} + +void sub_803D0E4(u8 r0) +{ + gUnknown_203B408 = r0; +} + +u8 sub_803D0F0(u8 r0) +{ + return gUnknown_80F42F0[r0]; +} + +u8 sub_803D100(u8 r0) +{ + return gUnknown_80F42D0[r0]; +} + + diff --git a/src/pokemon.c b/src/pokemon.c new file mode 100644 index 0000000..454751e --- /dev/null +++ b/src/pokemon.c @@ -0,0 +1,43 @@ +#include "global.h" +#include "pokemon.h" +#include "file_system.h" + +extern u32 *gUnknown_203B45C; +extern u32 gUnknown_202F400; +extern struct FileArchive gUnknown_8300500; +extern const char gUnknown_81075F4; +extern struct OpenedFile *gMonsterParametersFile; +extern u16 gUnknown_20384E8; +extern struct gPokemon gMonsterParameters; + +extern u64 gUnknown_8107544[]; +extern u32 gUnknown_810697C; +extern void sub_8086448(); +extern void sub_80866C4(u32 *r0); + +void sub_808CD9C(u8 r0) +{ + sub_8086448(); + sub_80866C4(&gUnknown_810697C); +} + +u64 *sub_808CDB0(u8 r0) +{ + return &gUnknown_8107544[r0]; +} + +void LoadMonsterParameters(void) +{ + gUnknown_203B45C = &gUnknown_202F400; + gMonsterParametersFile = OpenFileAndGetFileDataPtr(&gUnknown_81075F4, &gUnknown_8300500); + // TODO verify this... other parts imply this is an array + gMonsterParameters.species = gMonsterParametersFile->data; + gUnknown_20384E8 = 0; +} + +u32 *sub_808CE00(void) +{ + return &gUnknown_202F400; + +} + diff --git a/src/pokemon_1.c b/src/pokemon_1.c new file mode 100644 index 0000000..ebb24d7 --- /dev/null +++ b/src/pokemon_1.c @@ -0,0 +1,74 @@ +#include "global.h" +#include "pokemon.h" +#include "file_system.h" + +extern int sprintf(char *, const char *, ...); + +extern struct gPokemon *gMonsterParameters; +extern struct FileArchive gUnknown_8510000; +extern const char gUnknown_8107684[]; + +struct unkEvolve +{ + /* 0x0 */ struct EvolveStruct1 conditions; + /* 0x4 */ struct EvolveNeeds needs; +}; + +s16 sub_808DD48(s16 r0, struct unkEvolve *r1) +{ + struct EvolveStruct1 temp2; + struct EvolveNeeds temp1; + temp1 = gMonsterParameters[r0].need; + temp2 = gMonsterParameters[r0].pre; + r1->conditions = temp2; + r1->needs = temp1; + // The return value is not used anywhere, but necessary for the function to match. + return r0; +} + +u8 sub_808DD68(s16 r0, u32 r1) +{ + // Had to have this cast to match + u32 temp; + temp = r0; + if (r1 != 0) + { + return 0xA; + } + else + { + return gMonsterParameters[temp].overworld_sprite; + } +} + +struct OpenedFile *sub_808DD90(s16 r0) +{ + // Looks like this loads the dialogue sprite for the pokemon + + char buffer[0xC]; + if(gMonsterParameters[r0].dialogue_sprites == 0) + { + return NULL; + } + sprintf(buffer, gUnknown_8107684, r0); // "kao%03d" + return OpenFile(buffer, &gUnknown_8510000); +} + +struct OpenedFile *sub_808DDD0(s16 r0) +{ + // Looks like this loads the dialogue sprite for the pokemon + + char buffer[0xC]; + if(gMonsterParameters[r0].dialogue_sprites == 0) + { + return NULL; + } + sprintf(buffer, gUnknown_8107684, r0); // "kao%03d" + return OpenFileAndGetFileDataPtr(buffer, &gUnknown_8510000); +} + +bool8 sub_808DE10(s16 r0, s32 r1) +{ + // checking to see if dialogue sprite is available?? + return (gMonsterParameters[r0].dialogue_sprites >> r1) & 1; +} diff --git a/src/pokemon_mid.c b/src/pokemon_mid.c new file mode 100644 index 0000000..e348784 --- /dev/null +++ b/src/pokemon_mid.c @@ -0,0 +1,85 @@ +#include "global.h" +#include "pokemon.h" + +extern struct gPokemon *gMonsterParameters; + +u8 *GetCategoryString(s16 r0) +{ + return gMonsterParameters[r0].category; +} + +u8 GetPokemonSize(s16 r0) +{ + return gMonsterParameters[r0].size; +} + +u8 GetShadowSize(s16 r0) +{ + return gMonsterParameters[r0].shadow_size; +} + +s32 GetMoveSpeed(s16 r0) +{ + return gMonsterParameters[r0].move_speed; +} + +u8 GetWalkableTiles(s16 r0) +{ + return gMonsterParameters[r0].walkable_tiles; +} + +u8 GetUnk1B(s16 r0) +{ + return ((u8)(gMonsterParameters[r0].unk1B) << 25) >> 24; +} + +bool8 GetIsMoving(s16 r0) +{ + return gMonsterParameters[r0].isMoving; +} + +u8 GetUnk1D(s16 r0) +{ + return gMonsterParameters[r0].unk1D; +} + +u16 GetLowKickDmg(s16 r0) +{ + return gMonsterParameters[r0].lowkick_dmg; +} + +u16 GetSizeOrbDmg(s16 r0) +{ + return gMonsterParameters[r0].sizeorb_dmg; +} + +u8 GetFriendArea(s16 r0) +{ + return gMonsterParameters[r0].friend_area; +} + +u16 GetBaseHP(s16 r0) +{ + return gMonsterParameters[r0].base_hp; +} + +bool8 GetUnk33(s16 r0) +{ + return gMonsterParameters[r0].unk33; +} + +u8 GetUnk12(s16 r0) +{ + return gMonsterParameters[r0].unk12; +} + +s16 sub_808DC0C(s16 r0) +{ + return gMonsterParameters[r0].pre.evolve_from; +} + +// TODO fix calculation to match +//u32 sub_808DC28(s16 r0, u32 r1) +//{ +// return gMonsterParameters[r0].base_att + (r1 << 1); +//} @@ -1,14 +1,7 @@ #include "global.h" #include "flash.h" #include "memory.h" - -struct UnkStruct_203B184 { - u8 fill000[0x4C]; - u8 *unk04C; - u32 unk050; - u32 unk054; - u32 unk058; -}; +#include "save.h" struct UnkStruct_sub_8011DAC { u8 fill000[0x4]; @@ -30,7 +23,20 @@ struct UnkStruct_sub_8011DAC { u8 fill448[0x538C]; }; -extern u32 gUnknown_202DE28; + +struct unk_struct +{ + u32 unk0; + u32 unk4; + u32 unk8; + u32 unkC; + u32 unk10; + u32 unk14; + u32 unk18; + u32 padding[505]; +}; + +extern s32 gUnknown_202DE28; extern u32 gUnknown_203B17C; extern u32 gUnknown_203B180; extern volatile struct UnkStruct_203B184 *gUnknown_203B184; @@ -61,12 +67,12 @@ void sub_8011C28(u32 in) gUnknown_203B17C = in; } -u32 sub_8011C34(void) +s32 sub_8011C34(void) { return gUnknown_202DE28; } -void sub_8011C40(u32 in) +void sub_8011C40(s32 in) { gUnknown_202DE28 = in; } @@ -269,3 +275,52 @@ u32 sub_8011DAC(u32 *a) MemoryFree(r5); return r7; } + +u32 sub_8011F9C(s32 *r0, u8 *r1, s32 r2) +{ + return ReadSaveSector(r0, r1, r2); +} + +u32 sub_8011FA8(void) +{ + u32 temp2; + u32 temp3; + u32 temp; + struct unk_struct *r5 = MemoryAlloc(sizeof(struct unk_struct), 5); + temp = 0x1F; + temp2 = ReadSaveSector(&temp, (u8 *)r5, sizeof(struct unk_struct)); + if( temp2 == 0) + { + if(r5->unk14 != 0x5071412) + { + temp2 = 4; + } + } + temp3 = 0xf1209; + if(temp2 == 0) + { + temp3 = r5->unk18; + } + MemoryFree(r5); + return temp3; +} + +bool8 sub_8011FF8(void) +{ + u32 temp2; + u32 temp; + bool8 r6; + struct unk_struct *r5 = MemoryAlloc(sizeof(struct unk_struct), 5); + temp = 0x1F; + r6 = FALSE; + temp2 = ReadSaveSector(&temp, (u8 *)r5, sizeof(struct unk_struct)); + if(temp2 == 0) + { + if(r5->unk14 == 0x5071412) + { + r6 = TRUE; + } + } + MemoryFree(r5); + return r6; +} diff --git a/src/save1.c b/src/save1.c index b7de6c6..a194557 100644 --- a/src/save1.c +++ b/src/save1.c @@ -1,6 +1,55 @@ #include "global.h" +#include "code_800558C.h" +#include "input.h" + + +struct UnkSaveStruct1 +{ + /* 0x0 */ u32 unk0; + /* 0x4 */ u32 unk4; + /* 0x8 */ u16 unk8; + /* 0xA */ u8 unkA; +}; + +struct UnkStruct +{ + /* 0x0 */ u8 unk0; + /* 0x1 */ u8 unk1; + /* 0x2 */ u8 unk2; + /* 0x3 */ u8 unk3; + /* 0x4 */ u8 unk4; + /* 0x5 */ u32 unk5; + /* 0x9 */ u32 unk9; + /* 0xD */ u32 unkD; + /* 0x12 */ u32 unk11; + /* 0x16 */ u32 unk15; + /* 0x1A */ u32 unk19; + /* 0x1E */ u32 unk1D; + /* 0x24 */ u32 unk24; + /* 0x28 */ u8 unk28; + /* 0x29 */ u8 unk29; + /* 0x2A */ u8 unk2A; + /* 0x2B */ u8 unk2B; + /* 0x2C */ u8 unk2C; +}; extern void MemoryFree(void *); +extern void sub_8011860(); +extern void xxx_draw_string_80144C4(); +extern void nullsub_8(u8); +extern void sub_8005180(); +extern void sub_800CB20(); +extern void CopySpritesToOam(); +extern void sub_8005304(); +extern void TransferBGPaletteBuffer(); +extern void xxx_call_update_bg_vram(); +extern void sub_8009908(); +extern void xxx_call_update_bg_sound_input(); +extern void ResetSprites(u8 r0); +extern u32 sub_8012AE8(void); +extern void nullsub_34(struct UnkStruct *r0); + +extern struct UnkSaveStruct1 *gUnknown_203B46C; extern u8 *gUnknown_203B194; @@ -11,3 +60,71 @@ void sub_80129FC() gUnknown_203B194 = NULL; } } + +void sub_8012A18() +{ + sub_8011860(); + xxx_draw_string_80144C4(); + nullsub_8(gUnknown_203B46C->unkA); + sub_8005180(); + sub_80060EC(); + sub_800CB20(); + sub_800485C(); // Input related + CopySpritesToOam(); + sub_8005304(); + TransferBGPaletteBuffer(); + xxx_call_update_bg_vram(); + sub_8009908(); + xxx_call_update_bg_sound_input(); + ResetSprites(0); +} + +u32 sub_8012A64(struct UnkStruct *r0, u32 r1) +{ + if(r0 == NULL) + { + return sub_8012AE8(); + } + if(r1 != -1) + { + nullsub_34(r0); + } + if(r0->unk1 != 0) + { + r0->unk1 = 0; + return 1; + } + if(r0->unk2 == 0) + { + return sub_8012AE8(); + } + r0->unk2 = r0->unk1; + return 2; +} + +// TODO match that one line +//u32 GetKeyPress(struct UnkStruct *r0) +//{ +// if(r0 == NULL) +// { +// return sub_8012AE8(); +// } +// // TODO it's not a struct access.. +// if(r0->unk29 != 0) +// { +// return 1; +// } +// if(r0->unk2A != 0) +// { +// return 2; +// } +// if(r0->unk2C != 0) +// { +// return 9; +// } +// if(r0->unk2B == 0) +// { +// return sub_8012AE8(); +// } +// return 0xA; +//} diff --git a/src/save_mid.c b/src/save_mid.c new file mode 100644 index 0000000..ddf6d4d --- /dev/null +++ b/src/save_mid.c @@ -0,0 +1,311 @@ +#include "global.h" +#include "save.h" + +extern struct UnkStruct_203B184 *gUnknown_203B184; +extern struct unkTimeStruct *gUnknown_203B47C; + +struct unk_203B188 +{ + u32 unk0; + u32 unk4; +}; + +struct unk_struct +{ + u32 unk0; + u32 unk4; + u32 unk8; + u32 unkC; + u32 unk10; + u32 unk14; + u32 unk18; + u32 unk1C; + u32 padding[504]; +}; + +extern struct unk_203B188 *gUnknown_203B188; + +extern u32 *gUnknown_203B45C; +extern u32 *gUnknown_203B460; +extern u32 gUnknown_203B464; +extern u8 *gUnknown_203B468; +extern u32 gUnknown_203B46C; +extern u8 *gUnknown_203B480; +extern u8 *gUnknown_203B484; +extern u32 *gUnknown_203B488; +extern u32 *gUnknown_203B48C; +extern u32 gUnknown_203B490; +extern u32 gUnknown_203B494; +extern u8 *gUnknown_203B498; +extern u32 gUnknown_80D4354; + +extern void sub_800135C(void); +extern u32 *sub_808CE00(void); +extern void sub_808CE08(void); +extern u32 *sub_80909D0(void); +extern void sub_80909D8(void); +extern u32 sub_809208C(void); +extern void sub_8092094(void); +extern u8 *sub_80923B0(void); +extern void sub_80923B8(void); +extern u32 sub_8094990(void); +extern void sub_8094998(u8 r0); +extern u8 *sub_80950F8(void); +extern u8 *sub_8095100(void); +extern u32 *sub_8095108(void); +extern u32 *sub_8095110(void); +extern void sub_8095118(void); +extern u32 sub_80958F8(void); +extern void sub_8095900(void); +extern u32 sub_8097680(void); +extern void sub_80972F4(void); +extern void sub_80974E8(void); +extern u8 *sub_8097F6C(void); +extern void sub_8097F74(void); + +extern void sub_8011C28(u32 r0); +extern void sub_8011C40(s32 r0); +extern void sub_8097748(void); + + +extern void ResetPlayTime(struct unkTimeStruct *Time); // defined in src/code_8094F88.c +extern struct unkTimeStruct *sub_8094FA0(void); + +extern void* MemoryAlloc(u32 a, u32 b); +extern void MemoryFree(void* a); +extern void MemoryFill8(u8 *dest, u8 value, s32 size); +extern void sub_8011830(void); +extern s32 WriteFlashData(s32 sector, u8 *src, s32 size); +extern void sub_8011854(void); +extern u32 *sub_809769C(void); +u32 *sub_8011C4C(void); +extern void sub_80958E4(u8 *a, u32 b); +extern s32 WriteSaveSector(s32 *a, u8 *src, s32 size); +extern u32 sub_8011DAC(u32 *a); +extern u32 sub_80144A4(u32 *a); +extern bool8 sub_8011FF8(void); +extern void sub_80141B4(u32 *r0, u32 r1, u32 r2, u16 r3); + +void sub_8012298(); +void sub_80122D0(); +void sub_80122F4(); +void sub_8012300(); +void sub_80976A8(); +void sub_80122A8(); + + +s32 sub_80121D4(s32 *a, u8 *src, s32 size) +{ + return WriteSaveSector(a, src, size); +} + +u32 sub_80121E0(u32 r0) +{ + u32 temp; + u32 *temp2; + u32 temp3; + struct unk_struct *r4 = MemoryAlloc(sizeof(struct unk_struct), 5); + temp = 0x1F; + + r4->unk18 = r0; + r4->unk1C = *sub_809769C(); + r4->unk14 = 0x5071412; + + temp2 = sub_8011C4C(); + strncpy((u8 *)r4 + 4, (u8*)temp2, 16); + sub_80958E4((u8 *)r4 + 32, 0); + temp3 = WriteSaveSector(&temp, (u8 *)r4, sizeof(struct unk_struct)); + MemoryFree(r4); + return temp3; +} + +u32 sub_8012240(void) +{ + s32 temp; + struct unk_struct *r5 = MemoryAlloc(sizeof(struct unk_struct), 5); + MemoryFill8((u8 *)r5, 0xFF, 0x4); + sub_8011830(); + temp = WriteFlashData(0x1F, (u8 *)r5, sizeof(struct unk_struct)); + sub_8011854(); + MemoryFree(r5); + if(temp != 0) + { + return 2; + } + else + { + return 0; + } +} + +void sub_8012284(void) +{ + sub_80122D0(); + sub_80122F4(); + sub_8012300(); +} + +void sub_8012298(void) +{ + sub_80976A8(); + sub_80122A8(); +} + +void sub_80122A8(void) +{ + sub_80122D0(); + sub_80122F4(); + sub_8012300(); + sub_8012240(); + +} + +void nullsub_33(void) +{ +} + +void sub_80122C4(void) +{ + sub_80122A8(); +} + +void sub_80122D0(void) +{ + sub_8011C28(0); + sub_8011C40(-1); + sub_8097748(); + ResetPlayTime(gUnknown_203B47C); +} + +void sub_80122F4(void) +{ + sub_800135C(); +} + +void sub_8012300(void) +{ + sub_80923B8(); + sub_808CE08(); + sub_80909D8(); + sub_8092094(); + sub_80972F4(); + sub_8095118(); + sub_8095900(); + sub_80974E8(); + sub_8094998(1); + sub_8097F74(); +} + + +// Unused +void nullsub_200(u32 r0) +{ +} + +// Unused +void sub_8012334(struct UnkStruct_203B184 *r0) +{ + gUnknown_203B184 = r0; + if(r0 != NULL) + { + gUnknown_203B460 = r0->unk0; + gUnknown_203B45C = r0->unk4; + gUnknown_203B480 = r0->unk8; + gUnknown_203B484 = r0->unkC; + gUnknown_203B488 = r0->unk10; + gUnknown_203B48C = r0->unk14; + gUnknown_203B490 = r0->unk18; + gUnknown_203B464 = r0->unk1C; + gUnknown_203B494 = r0->unk20; + gUnknown_203B498 = r0->unk24; + gUnknown_203B468 = r0->unk28; + gUnknown_203B46C = r0->unk2C; + gUnknown_203B47C = r0->unk30; + return; + } + gUnknown_203B460 = sub_80909D0(); + gUnknown_203B45C = sub_808CE00(); + gUnknown_203B480 = sub_80950F8(); + gUnknown_203B484 = sub_8095100(); + gUnknown_203B488 = sub_8095108(); + gUnknown_203B48C = sub_8095110(); + gUnknown_203B490 = sub_80958F8(); + gUnknown_203B464 = sub_809208C(); + gUnknown_203B494 = sub_8097680(); + gUnknown_203B498 = sub_8097F6C(); + gUnknown_203B468 = sub_80923B0(); + gUnknown_203B46C = sub_8094990(); + gUnknown_203B47C = sub_8094FA0(); + +} + +void sub_8012468(void) +{ + gUnknown_203B188 = MemoryAlloc(sizeof(struct unk_203B188), 5); + gUnknown_203B188->unk0 = 1; + +} + +u8 sub_8012484(void) +{ + u32 temp; + u32 temp2; + switch(gUnknown_203B188->unk0) + { + case 0: + gUnknown_203B188->unk0 = 1; + break; + case 1: + temp = 0; + gUnknown_203B188->unk4 = sub_8011DAC(&temp); + gUnknown_203B188->unk0 = 2; + break; + case 2: + if(gUnknown_203B188->unk4 != 0) + { + if(sub_8011FF8()) + { + sub_80141B4(&gUnknown_80D4354, 0, 0, 0x301); + gUnknown_203B188->unk0 = 3; + break; + } + else + { + gUnknown_203B188->unk0 = 4; + break; + } + } + else + { + gUnknown_203B188->unk0 = 6; + break; + } + case 3: + if(sub_80144A4(&temp2) == 0) + { + gUnknown_203B188->unk0 = 4; + break; + } + else + { + break; + } + case 4: + sub_8012298(); + gUnknown_203B188->unk0 = 6; + case 5: + break; + case 6: + return 0; + } + return 1; +} + +void sub_8012558(void) +{ + if(gUnknown_203B188 != NULL) + { + MemoryFree(gUnknown_203B188); + gUnknown_203B188 = NULL; + } +} diff --git a/src/wonder_mail.c b/src/wonder_mail.c new file mode 100644 index 0000000..c3fa39b --- /dev/null +++ b/src/wonder_mail.c @@ -0,0 +1,1444 @@ +#include "global.h" + +// Wonder Mail Related +struct WonderMailStruct_203B2C0 +{ + u32 unk0; + u32 unk4; + u8 padding2[0x38]; + u32 unk40; + u32 unk44; + u16 unk48[232]; + u8 unk218; + u8 padding7[3]; + u32 unk21C; + u8 padding[0x7C]; + u32 unk29C; + u8 padding6[0x6C]; + u32 unk30C; + u8 padding8[0x4C]; + u32 unk35C; + u8 padding5[0x5C]; + u32 unk3BC; + u8 padding4[0x60]; + u32 unk420; + u8 padding3[0x110]; + u32 unk534; + s32 unk538; // A7 << 3 + u32 unk53C; + u32 unk540; // A8 << 4 + s16 unk544; +}; + +struct unkStruct_8095228 +{ + u32 unk0; + u8 unk4; + u8 padding[0x27]; + s8 unk30; +}; + +struct unkStruct_80293F4 +{ + // size of 0x44 + u32 unk0; + u32 unk4; + u32 unk8; + u32 *unkC; + u32 unk10; + u8 unk14[0xA]; // very unsure about this one + u32 unk20; + u32 unk24; + u32 padding[7]; +}; + + +extern struct WonderMailStruct_203B2C0 *gUnknown_203B2C0; + +extern u32 sub_80144A4(s32 *r0); +extern void sub_8011C28(u32); +extern void sub_8012574(u32); +extern u8 sub_8012600(); +extern void sub_8012750(); +extern void sub_8095240(u8); + +extern void sub_809927C(u8); +extern u8 sub_8030C20(u32); +extern u32 sub_8031050(); +extern void sub_80310B4(); +extern u32 sub_8095350(); + +extern struct unkStruct_8095228 *sub_8095228(u8); +extern u8 sub_80A2824(u32); + +extern u32 gWonderMailErrorText; +extern u32 gWonderMailNumGBAsText; +extern u32 gWonderMailWrongModeText; +extern u32 gWonderMailStorageFullText; +extern u32 gWonderMailDuplicateText; +extern u32 gWonderMailNotEligibleReceiveText; +extern u32 gWonderMailNoRoomText; +extern u32 gWonderMailFriendErrorText; +extern u32 gWonderMailPasswordIncorrectText; +extern u32 gWonderMailSOSPasswordIncorrectText; +extern u32 gWonderMailDuplicateText; +extern u32 gWonderMailAOKMailReceivedText; + +extern s32 sub_8095190(void); +extern u32 sub_8095324(u32); +extern void sub_80141B4(u32 *r0, u32, u32 *r1, u32); +extern void nullsub_130(void); +extern void sub_8028348(void); +extern void sub_800641C(void *r0, u8, u8); +extern void sub_8004914(); +extern void sub_803084C(); +extern u32 sub_8030768(u32); +extern u8 sub_80307EC(); +extern void sub_8030D40(u8, u32); +extern void sub_8006518(u32 *r0); +extern u8 sub_8012FD8(u32 *r0); +extern void sub_8030810(u32); +extern void sub_8035CC0(u32 *r0, u32); +extern void sub_8035CF4(u32 *r0, u32, u32); +extern u32 sub_8030DA0(void); +extern void sub_8030DE4(void); +extern void sub_803092C(void); +extern void sub_8011C28(u32); +extern void sub_8012574(u32); +extern u8 sub_8012600(); +extern u32 sub_8012744(); +extern void sub_8012750(); + + +extern u32 sub_80154F0(); +void MemoryFill8(u8 *dest, u8 value, s32 size); +extern u32 sub_8039068(u32, u32 *r1, u8 *r0); +extern u32 gUnknown_80DDA48; +extern void sub_8014248(u32 *r0, u32, u32, u32 *r1); +extern void sub_8095274(u32); +extern void sub_80155F0(); +extern void sub_80951BC(u8 *r0); +extern void sub_8013114(u32 *r0, s32 *r1); +extern void sub_8035CC0(u32 *r0, u32); +extern void sub_8023C60(); +extern u32 sub_8023A94(u32); +extern void sub_8024458(s16, u32); +extern u16 sub_8023B44(); +extern void sub_8023B7C(u32); +extern u32 sub_80244E4(); +extern void sub_802452C(); +extern void sub_802453C(); +extern u8 sub_8024108(u32); +extern u32 sub_8031DCC(); +extern void sub_8031E10(); +extern void sub_8031E00(); + +void sub_8028B04(u32 r0) +{ + gUnknown_203B2C0->unk4 = r0; + nullsub_130(); + sub_8028348(); +} + +// Wonder Mail Linking... +void sub_8028B1C(u32 r0) +{ + switch(r0) + { + case 0: + break; + case 1: + case 2: + sub_80141B4(&gWonderMailErrorText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 3: + sub_80141B4(&gWonderMailNumGBAsText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 4: + sub_80141B4(&gWonderMailWrongModeText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 5: + sub_80141B4(&gWonderMailErrorText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 6: + sub_80141B4(&gWonderMailStorageFullText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 7: + sub_80141B4(&gWonderMailDuplicateText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 8: + break; + case 9: + sub_80141B4(&gWonderMailNotEligibleReceiveText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 10: + break; + case 11: + sub_80141B4(&gWonderMailNotEligibleReceiveText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 12: + break; + case 13: + sub_80141B4(&gWonderMailNoRoomText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 14: + sub_80141B4(&gWonderMailErrorText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + case 15: + sub_80141B4(&gWonderMailFriendErrorText, 0, &gUnknown_203B2C0->unk420, 0x10d); + break; + default: + break; + } +} + +void sub_8028BF0(void) +{ + u32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + gUnknown_203B2C0->unk40 = 8; + gUnknown_203B2C0->unk544 = 0xffff; + switch(temp) + { + case 0: + gUnknown_203B2C0->unk40 = 3; + gUnknown_203B2C0->unk538 = 0; + if(sub_8095190() != -1) + { + sub_8028B04(8); + } + else + { + sub_8028B04(9); + } + break; + case 1: + if(sub_8095324(2) != 0) + { + sub_8028B04(30); + } + else + { + sub_8028B04(26); + } + break; + case 2: + gUnknown_203B2C0->unk40 = 4; + gUnknown_203B2C0->unk538 = 2; + if(sub_8095324(4) != 0) + { + sub_8028B04(41); + } + else + { + sub_8028B04(47); + } + break; + case 3: + sub_8028B04(11); + break; + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + break; + case 10: + sub_8028B04(2); + break; + default: + break; + } +} + + +void sub_8028CE0() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(3); +} + +void sub_8028CFC() +{ + s32 temp; + u32 temp2; + + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(sub_8031050()) + { + case 2: + case 3: + temp2 = sub_8095350(); + sub_80310B4(); + if(temp2 != gUnknown_203B2C0->unk540) + { + sub_8028B04(23); + } + else + { + sub_8028B04(25); + } + break; + default: + break; + } +} + +void sub_8028D4C() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + gUnknown_203B2C0->unk538 = temp; + switch(gUnknown_203B2C0->unk538) + { + case 5: + if(sub_8030C20(2) != 0) + { + sub_8028B04(12); + } + else + { + sub_8028B04(13); + } + break; + case 6: + if(sub_8030C20(4) != 0) + { + sub_8028B04(14); + } + else + { + sub_8028B04(15); + } + break; + case 7: + if(sub_8030C20(0) != 0) + { + sub_8028B04(16); + } + else + { + sub_8028B04(17); + } + break; + case 10: + sub_8028B04(1); + break; + default: + break; + } +} + +void sub_8028DE8(u32 r0) +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(r0); +} + +void sub_8028E08() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(18); +} + +void sub_8028E24() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + sub_8028B04(19); + break; + case 10: + sub_8028B04(1); + break; + default: + break; + } +} + +void sub_8028E54() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + sub_8028B04(20); + break; + case 10: + sub_8028B04(1); + break; + default: + break; + } +} + +void sub_8028E84() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(24); + sub_8011C28(1); + sub_8012574(0); +} + +void sub_8028EAC() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + if(sub_8012600() == 0) + { + sub_8012750(); + sub_8028B04(25); + } +} + +void sub_8028ED4() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + if(temp == 8) + { + sub_8028B04(11); + } + else + { + switch(temp){ + case 8: + sub_8028B04(2); + break; + case 9: + case 10: + sub_8028B04(2); + break; + default: + break; + } + } +} + +void sub_8028F04() +{ + s32 temp; + s32 counter; + + if(sub_80144A4(&temp) != 0) + { + return; + } + for(counter = 0; counter <= 31; counter++) + { + sub_8095240(counter); + } + sub_8028B04(21); +} + +void sub_8028F30() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(22); + sub_8011C28(1); + sub_8012574(0); +} + +void sub_8028F58() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + if(sub_8012600() == 0) + { + sub_8012750(); + sub_8028B04(2); + } +} + +void sub_8028F80() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_809927C(gUnknown_203B2C0->unk218); + gUnknown_203B2C0->unk53C = 1; + sub_8028B04(3); +} + +void sub_8028FC0() +{ + s32 temp; + + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(1); +} + +void sub_8028FDC(void) +{ + s32 temp; + struct unkStruct_8095228 *return_var; + + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + return_var = sub_8095228(gUnknown_203B2C0->unk218); + if(sub_80A2824(return_var->unk4) == 0) + { + sub_8028B04(0x1C); + } + else + { + if(return_var->unk30 <= 0) + { + sub_8028B04(0x1D); + } + else + { + sub_8028B04(0x1B); + } + } + break; + case 9: + case 10: + sub_8028B04(1); + break; + default: + break; + } +} + +void sub_8029044(void) +{ + switch(sub_8030768(1)) + { + case 2: + sub_803084C(); + sub_8028B04(1); + break; + case 3: + gUnknown_203B2C0->unk218 = sub_80307EC(); + sub_8028B04(32); + break; + case 4: + gUnknown_203B2C0->unk0 = 0x1F; + gUnknown_203B2C0->unk218 = sub_80307EC(); + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8030D40(gUnknown_203B2C0->unk218, 0); + sub_8028B04(33); + break; + } +} + +void sub_80290D4(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(31); +} + +void sub_80290F0(void) +{ + s32 temp; + temp = -1; + sub_8030768(0); + if(sub_8012FD8(&(gUnknown_203B2C0->unk30C)) == 0) + { + sub_8013114(&(gUnknown_203B2C0->unk30C), &temp); + } + switch(temp) + { + case 11: + sub_803084C(); + sub_8028B04(34); + break; + case 12: + gUnknown_203B2C0->unk0 = 0x3D; + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8030D40(gUnknown_203B2C0->unk218, 0); + sub_8028B04(33); + break; + case 4: + case 10: + sub_8035CC0(&(gUnknown_203B2C0->unk35C), 2); + sub_8030810(1); + sub_8028B04(31); + break; + default: + break; + } +} + +void sub_80291AC(void) +{ + switch(sub_8030DA0()) + { + case 2: + case 3: + sub_8030DE4(); + sub_8004914(); + sub_800641C(&(gUnknown_203B2C0->unk3BC), 1, 1); + sub_803092C(); + if(gUnknown_203B2C0->unk0 == 0x3D) + { + sub_8035CF4(&(gUnknown_203B2C0->unk21C), 3, 1); + sub_8028B04(0x20); + } + else + { + sub_8028B04(gUnknown_203B2C0->unk0); + } + default: + break; + } +} + +void sub_8029208(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + + case 13: + case 14: + gUnknown_203B2C0->unk534 = 0xD; + switch(gUnknown_203B2C0->unk538) + { + case 0: + sub_8028B04(4); + break; + case 2: + sub_8028B04(0x30); + break; + default: + return; + } + break; + case 15: + gUnknown_203B2C0->unk534 = temp; + switch(gUnknown_203B2C0->unk538) + { + case 0: + sub_8028B04(0x26); + break; + case 2: + sub_8028B04(0x3A); + break; + default: + return; + } + break; + case 10: + sub_8028B04(1); + break; + } +} + +void sub_80292A4(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + switch(gUnknown_203B2C0->unk538) + { + case 0: + case 2: + sub_8028B04(5); + break; + } + break; + case 10: + sub_8028B04(1); + break; + } +} + +void sub_80292EC(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + if(gUnknown_203B2C0->unk44 == 0) + { + switch(gUnknown_203B2C0->unk538) + { + case 0: + sub_8028B04(0x23); + break; + case 2: + sub_8028B04(0x37); + break; + } + } + else + { + sub_8028B1C(gUnknown_203B2C0->unk44); + sub_8028B04(0x7); + } +} + +void sub_802933C(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(1); +} + +void sub_8029358(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(1); +} + +void sub_8029374(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x24); + sub_8011C28(1); + sub_8012574(0); +} + +void sub_802939C(void) +{ + s32 temp; + u32 return_var; + if(sub_80144A4(&temp) != 0) + { + return; + } + if(sub_8012600() == 0) + { + return_var = sub_8012744(); + sub_8012750(); + if(return_var == 0) + { + sub_8028B04(0x25); + } + else + { + sub_8028B04(0x2); + } + } +} + +void sub_80293D8(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x27); +} + +#ifndef NONMATCHING +NAKED +#endif +void sub_80293F4(void) +{ +#ifdef NONMATCHING + u32 return_var; + u32 temp_var; + struct unkStruct_80293F4 temp; + return_var = sub_80154F0(); + MemoryFill8(temp.unk14, 0, 0x30); + switch(return_var) + { + case 3: + return_var = sub_8039068(0x1C, &(gUnknown_203B2C0->unk8), temp.unk14) - 7; + if(return_var <= 0x11) + { + switch(return_var) + { + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + break; + case 10: + // TODO one register off from matching + temp.unk0 = 0; + temp.unk4 = 4; + temp.unk8 = 0; + temp.unkC = &(gUnknown_203B2C0->unk420); + temp.unk10 = 0xC; + sub_8014248(&gWonderMailPasswordIncorrectText, 0, 8, &gUnknown_80DDA48); + sub_8028B04(0x28); + break; + case 11: + sub_80141B4(&gWonderMailSOSPasswordIncorrectText, 0, &gUnknown_203B2C0->unk420, 0x10d); + sub_8028B04(7); + break; + case 0: + sub_80141B4(&gWonderMailDuplicateText, 0, &gUnknown_203B2C0->unk420, 0x10d); + sub_8028B04(7); + break; + case 12: + case 13: + case 14: + break; + case 15: + sub_8095274(temp.unk24); + // This one is iffy.. not sure + temp.unk14[0] = 2; + sub_80951BC(temp.unk14); + sub_80141B4(&gWonderMailAOKMailReceivedText, 0, &gUnknown_203B2C0->unk420, 0x101); + sub_8028B04(0x23); + break; + case 16: + case 17: + default: + break; + } + } + sub_80155F0(); + break; + case 2: + sub_80155F0(); + sub_8004914(); + sub_800641C(&(gUnknown_203B2C0->unk3BC), 1, 1); + sub_8028B04(1); + break; + default: + break; + } +#else + asm_unified("\tpush {r4,lr}\n" + "\tsub sp, 0x44\n" + "\tbl sub_80154F0\n" + "\tadds r4, r0, 0\n" + "\tadd r0, sp, 0x14\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0x30\n" + "\tbl MemoryFill8\n" + "\tcmp r4, 0x2\n" + "\tbne _0802940E\n" + "\tb _08029530\n" +"_0802940E:\n" + "\tcmp r4, 0x3\n" + "\tbeq _08029414\n" + "\tb _08029550\n" +"_08029414:\n" + "\tldr r0, _08029434\n" + "\tldr r1, [r0]\n" + "\tadds r1, 0x8\n" + "\tmovs r0, 0x1C\n" + "\tadd r2, sp, 0x14\n" + "\tbl sub_8039068\n" + "\tsubs r0, 0x7\n" + "\tcmp r0, 0x11\n" + "\tbls _0802942A\n" + "\tb _0802951C\n" +"_0802942A:\n" + "\tlsls r0, 2\n" + "\tldr r1, _08029438\n" + "\tadds r0, r1\n" + "\tldr r0, [r0]\n" + "\tmov pc, r0\n" + "\t.align 2, 0\n" +"_08029434: .4byte gUnknown_203B2C0\n" +"_08029438: .4byte _0802943C\n" + "\t.align 2, 0\n" +"_0802943C:\n" + "\t.4byte _080294C8\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _08029484\n" + "\t.4byte _080294C0\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" + "\t.4byte _080294F0\n" + "\t.4byte _0802951C\n" + "\t.4byte _0802951C\n" +"_08029484:\n" + "\tldr r0, _080294B4\n" + "\tldr r3, _080294B8\n" + "\tmovs r2, 0\n" + "\tstr r2, [sp]\n" + "\tmovs r1, 0x4\n" + "\tstr r1, [sp, 0x4]\n" + "\tstr r2, [sp, 0x8]\n" + "\tldr r1, _080294BC\n" + "\tldr r1, [r1]\n" + "\tmovs r2, 0x84\n" + "\tlsls r2, 3\n" + "\tadds r1, r2\n" + "\tstr r1, [sp, 0xC]\n" + "\tmovs r1, 0xC\n" + "\tstr r1, [sp, 0x10]\n" + "\tmovs r1, 0\n" + "\tmovs r2, 0x8\n" + "\tbl sub_8014248\n" + "\tmovs r0, 0x28\n" + "\tbl sub_8028B04\n" + "\tb _0802951C\n" + "\t.align 2, 0\n" +"_080294B4: .4byte gWonderMailPasswordIncorrectText\n" +"_080294B8: .4byte gUnknown_80DDA48\n" +"_080294BC: .4byte gUnknown_203B2C0\n" +"_080294C0:\n" + "\tldr r0, _080294C4\n" + "\tb _080294CA\n" + "\t.align 2, 0\n" +"_080294C4: .4byte gWonderMailSOSPasswordIncorrectText\n" +"_080294C8:\n" + "\tldr r0, _080294E4\n" +"_080294CA:\n" + "\tldr r1, _080294E8\n" + "\tldr r2, [r1]\n" + "\tmovs r1, 0x84\n" + "\tlsls r1, 3\n" + "\tadds r2, r1\n" + "\tldr r3, _080294EC\n" + "\tmovs r1, 0\n" + "\tbl sub_80141B4\n" + "\tmovs r0, 0x7\n" + "\tbl sub_8028B04\n" + "\tb _0802951C\n" + "\t.align 2, 0\n" +"_080294E4: .4byte gWonderMailDuplicateText\n" +"_080294E8: .4byte gUnknown_203B2C0\n" +"_080294EC: .4byte 0x0000010d\n" +"_080294F0:\n" + "\tldr r0, [sp, 0x24]\n" + "\tbl sub_8095274\n" + "\tadd r1, sp, 0x14\n" + "\tmovs r0, 0x2\n" + "\tstrb r0, [r1]\n" + "\tadds r0, r1, 0\n" + "\tbl sub_80951BC\n" + "\tldr r0, _08029524\n" + "\tldr r1, _08029528\n" + "\tldr r2, [r1]\n" + "\tmovs r1, 0x84\n" + "\tlsls r1, 3\n" + "\tadds r2, r1\n" + "\tldr r3, _0802952C\n" + "\tmovs r1, 0\n" + "\tbl sub_80141B4\n" + "\tmovs r0, 0x23\n" + "\tbl sub_8028B04\n" +"_0802951C:\n" + "\tbl sub_80155F0\n" + "\tb _08029550\n" + "\t.align 2, 0\n" +"_08029524: .4byte gWonderMailAOKMailReceivedText\n" +"_08029528: .4byte gUnknown_203B2C0\n" +"_0802952C: .4byte 0x00000101\n" +"_08029530:\n" + "\tbl sub_80155F0\n" + "\tbl sub_8004914\n" + "\tldr r0, _08029558\n" + "\tldr r0, [r0]\n" + "\tmovs r2, 0xEF\n" + "\tlsls r2, 2\n" + "\tadds r0, r2\n" + "\tmovs r1, 0x1\n" + "\tmovs r2, 0x1\n" + "\tbl sub_800641C\n" + "\tmovs r0, 0x1\n" + "\tbl sub_8028B04\n" +"_08029550:\n" + "\tadd sp, 0x44\n" + "\tpop {r4}\n" + "\tpop {r0}\n" + "\tbx r0\n" + "\t.align 2, 0\n" +"_08029558: .4byte gUnknown_203B2C0\n"); +#endif +} + +void sub_802955C(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + sub_8028B04(0x26); + break; + case 10: + sub_8028B04(1); + break; + } +} + +void sub_802958C(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(6); +} + +void sub_80295A8(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 8: + sub_8028B04(0x8); + break; + case 9: + case 10: + sub_8028B04(1); + break; + + } +} + +void sub_80295D8(void) +{ + switch(sub_8030768(1)) + { + case 2: + sub_803084C(); + sub_8028B04(1); + break; + case 3: + gUnknown_203B2C0->unk218 = sub_80307EC(); + sub_8028B04(0x2B); + break; + case 4: + gUnknown_203B2C0->unk0 = 0x2A; + gUnknown_203B2C0->unk218 = sub_80307EC(); + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8030D40(gUnknown_203B2C0->unk218, 0); + sub_8028B04(0x2C); + break; + } +} + +void sub_8029668(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x2A); +} + +void sub_8029684(void) +{ + s32 temp; + temp = -1; + sub_8030768(0); + if(sub_8012FD8(&(gUnknown_203B2C0->unk30C)) == 0) + { + sub_8013114(&(gUnknown_203B2C0->unk30C), &temp); + } + switch(temp) + { + case 0xB: + sub_803084C(); + sub_8028B04(0x2D); + break; + case 0xC: + gUnknown_203B2C0->unk0 = 0x3D; + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8030D40(gUnknown_203B2C0->unk218, 0); + sub_8028B04(0x2C); + break; + case 0x4: + case 0xA: + sub_8035CC0(&(gUnknown_203B2C0->unk35C),2); + sub_8030810(1); + sub_8028B04(0x2A); + break; + } +} + +void sub_8029740(void) +{ + switch(sub_8030DA0()) + { + case 2: + case 3: + sub_8030DE4(); + sub_8004914(); + sub_800641C(&(gUnknown_203B2C0->unk3BC), 1, 1); + sub_803092C(); + if(gUnknown_203B2C0->unk0 == 0x3D) + { + sub_8035CF4(&(gUnknown_203B2C0->unk21C), 3, 1); + sub_8028B04(0x2B); + } + else + { + sub_8028B04(gUnknown_203B2C0->unk0); + } + break; + } +} + +void sub_802979C(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(1); +} + +void sub_80297B8(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x33); +} + +void sub_80297D4(void) +{ + switch(sub_8023A94(1)) + { + case 2: + sub_8023C60(); + sub_8028B04(1); + gUnknown_203B2C0->unk544 = 0xffff; + break; + case 3: + gUnknown_203B2C0->unk544 = sub_8023B44(); + sub_8028B04(0x34); + break; + case 4: + gUnknown_203B2C0->unk0 = 0x33; + gUnknown_203B2C0->unk544 = sub_8023B44(); + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8024458(gUnknown_203B2C0->unk544, 0); + sub_8028B04(0x35); + break; + } +} + +void sub_8029884(void) +{ + s32 temp; + temp = -1; + sub_8023A94(0); + if(sub_8012FD8(&(gUnknown_203B2C0->unk30C)) == 0) + { + sub_8013114(&(gUnknown_203B2C0->unk30C), &temp); + } + switch(temp) + { + case 0xB: + sub_8023C60(); + sub_8028B04(4); + break; + case 0xC: + gUnknown_203B2C0->unk0 = 0x3D; + sub_8006518(&(gUnknown_203B2C0->unk3BC)); + sub_8004914(); + sub_800641C(0, 1, 1); + sub_8024458(gUnknown_203B2C0->unk544, 0); + sub_8028B04(0x35); + break; + case 0x4: + case 0xA: + sub_8035CC0(&(gUnknown_203B2C0->unk35C), 3); + sub_8023B7C(1); + sub_8028B04(0x33); + break; + } +} + +void sub_8029944(void) +{ + u32 temp; + temp = sub_80244E4(); + if(temp == 1) + { + sub_802452C(); + return; + } + switch(temp) + { + case 1: + break; + case 2: + case 3: + sub_802453C(); + sub_8004914(); + sub_800641C(&(gUnknown_203B2C0->unk3BC), 1, 1); + sub_8023B7C(1); + if(gUnknown_203B2C0->unk0 == 0x3D) + { + sub_8035CF4(&(gUnknown_203B2C0->unk21C), 3, 1); + sub_8028B04(0x34); + } + else + { + sub_8028B04(gUnknown_203B2C0->unk0); + } + + } +} + +void sub_80299AC(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 0x12: + sub_8028B04(4); + break; + case 0xA: + sub_8028B04(1); + break; + default: + break; + } +} + +void sub_80299D8(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + + case 8: + sub_8028B04(4); + break; + case 9: + sub_8028B04(0x32); + break; + case 0xA: + sub_8028B04(1); + break; + } +} + +void sub_8029A18(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + switch(temp) + { + case 0x11: + if(sub_8024108(3) != 0) + { + sub_8028B04(0x31); + } + else + { + sub_8028B04(0x32); + } + break; + case 0x12: + sub_8028B04(0x4); + break; + case 0xA: + sub_8028B04(1); + break; + } +} + +void sub_8029A6C(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x2E); +} + +void sub_8029A88(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + if(sub_8012600() == 0) + { + sub_8012750(); + sub_8028B04(0x39); + } +} + +void sub_8029AB0(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x38); + sub_8011C28(1); + sub_8012574(0); +} + +void sub_8029AD8(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(0x3B); +} + +void sub_8029AF4(void) +{ + switch(sub_8031DCC()) + { + + case 2: + case 3: + sub_8031E10(); + sub_8004914(); + sub_800641C(&(gUnknown_203B2C0->unk3BC), 1, 1); + sub_8028B04(0x3C); + break; + case 1: + sub_8031E00(); + break; + } +} + +void sub_8029B34(void) +{ + s32 temp; + if(sub_80144A4(&temp) != 0) + { + return; + } + sub_8028B04(3); +} |