From bba94787f73662b21703d105603da6d1f40a442c Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 31 Jul 2017 16:11:41 +0200 Subject: battle message decompiled --- src/battle_4.c | 9 - src/battle_message.c | 1064 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1064 insertions(+), 9 deletions(-) create mode 100644 src/battle_message.c (limited to 'src') diff --git a/src/battle_4.c b/src/battle_4.c index 31d6c76dc..6dd5d7df6 100644 --- a/src/battle_4.c +++ b/src/battle_4.c @@ -246,15 +246,6 @@ extern u8 gUnknown_081D95DB[]; //bs payday money give #define CMP_COMMON_BITS 0x4 #define CMP_NO_COMMON_BITS 0x5 -#define BATTLE_WON 0x1 -#define BATTLE_LOST 0x2 -#define BATTLE_DREW 0x3 -#define BATTLE_RAN 0x4 -#define BATTLE_PLAYER_TELEPORTED 0x5 -#define BATTLE_POKE_FLED 0x6 -#define BATTLE_CAUGHT 0x7 -#define BATTLE_OPPONENT_TELEPORTED 0xA - #define uBYTE0_16(value)(( (u8) (((u16)(value) & (0x000000FF)) >> 0x00))) #define uBYTE1_16(value)(( (u8) (((u16)(value) & (0x0000FF00)) >> 0x08))) diff --git a/src/battle_message.c b/src/battle_message.c new file mode 100644 index 000000000..d4b8f86c6 --- /dev/null +++ b/src/battle_message.c @@ -0,0 +1,1064 @@ +#include "global.h" +#include "battle_message.h" +#include "battle.h" +#include "item.h" +#include "items.h" +#include "pokemon.h" +#include "data2.h" +#include "text.h" +#include "string_util.h" +#include "link.h" +#include "battle_setup.h" +#include "battle_tower.h" +#include "flags.h" + +#define BATTLESTRING_TO_SUB 12 +#define BATTLESTRINGS_NO 351 +#define BATTLESTRINGS_MAX BATTLESTRINGS_NO + BATTLESTRING_TO_SUB + +extern const u8* const gBattleStringsTable[BATTLESTRINGS_NO]; + +extern u16 gLastUsedItem; +extern u8 gLastUsedAbility; +extern u8 gActiveBank; +extern u8 gBankAttacker; +extern u8 gBankTarget; +extern u8 gStringBank; +extern u8 gEffectBank; +extern u8 gAbilitiesPerBank[4]; +extern u8 gBattleTextBuff1[]; +extern u8 gBattleTextBuff2[]; +extern u8 gBattleTextBuff3[]; +extern u8 gStringVar1[]; +extern u8 gStringVar2[]; +extern u8 gStringVar3[]; +extern u16 gBattleTypeFlags; +extern u16 gTrainerBattleOpponent; +extern u8 gDisplayedStringBattle[]; +extern u8 gStringVar1[]; +extern u8 gStringVar2[]; +extern u8 gStringVar3[]; +extern u16 gBattlePartyID[4]; +extern struct BattleEnigmaBerry gEnigmaBerries[4]; +extern u8 gBattleBufferA[4][0x200]; + +extern const u8 gUnknown_084005DB[]; +extern const u8 gUnknown_084005C7[]; +extern const u8 gUnknown_084005AA[]; +extern const u8 gUnknown_08400568[]; +extern const u8 gUnknown_08400590[]; +extern const u8 gUnknown_0840057B[]; +extern const u8 gUnknown_08400555[]; +extern const u8 gUnknown_084006F1[]; +extern const u8 gUnknown_084006A4[]; +extern const u8 gUnknown_0840069C[]; +extern const u8 gUnknown_0840065C[]; +extern const u8 gUnknown_08400645[]; +extern const u8 gUnknown_08400608[]; +extern const u8 gUnknown_08400635[]; +extern const u8 gUnknown_084005F5[]; +extern const u8 gUnknown_08400709[]; +extern const u8 gUnknown_08400727[]; +extern const u8 gUnknown_08400736[]; +extern const u8 gUnknown_08400749[]; +extern const u8 gUnknown_08400781[]; +extern const u8 gUnknown_08400771[]; +extern const u8 gUnknown_0840075E[]; +extern const u8 gUnknown_084006B3[]; +extern const u8 gUnknown_084006BB[]; +extern const u8 gUnknown_084006C6[]; +extern const u8 gUnknown_084006D5[]; +extern const u8 gUnknown_0840068C[]; +extern const u8 gUnknown_0840067C[]; +extern const u8 gUnknown_08400622[]; +extern const u8 gUnknown_084007BD[]; +extern const u8 gUnknown_083FFEFC[]; +extern const u8 gUnknown_083FFFF7[]; +extern const u8 gUnknown_083FFFEA[]; +extern const u8 gUnknown_083FFF6A[]; +extern const u8 gUnknown_083FFF99[]; +extern const u8 gUnknown_083FFFCB[]; +extern const u8 gUnknown_083FFF56[]; +extern const u8 gUnknown_083FFF81[]; +extern const u8 gUnknown_083FFFB3[]; +extern const u8 gUnknown_08400A78[]; +extern const u8 gUnknown_08400A85[]; +extern const u8 gUnknown_08400797[]; +extern const u8 gUnknown_08400791[]; +extern const u8 gUnknown_084007B7[]; +extern const u8 gUnknown_084007B2[]; +extern const u8 gUnknown_0840079C[]; +extern const u8 gUnknown_084007A1[]; +extern const u8 gUnknown_084007A7[]; +extern const u8 gUnknown_084007AC[]; +extern const u8 gUnknown_084009ED[]; +extern const u8 gUnknown_084009F7[]; +extern const u8 gUnknown_084007C8[]; +extern const u8 gUnknown_084007CA[]; +extern const u8 gUnknown_084007CC[]; +extern const u8 gUnknown_084007CE[]; +extern const u8 gUnknown_084007D0[]; +extern const u8 gUnknown_08400E5E[]; +extern const u8 gUnknown_08400E62[]; + +extern const u16 gUnknown_084016BC[]; // a table of moves + +extern const u8* const gUnknown_08401674[]; // table of pointers to 'a -TYPE' strings +extern const u8* const gUnknown_08400F58[]; // table of pointers to stat strings +extern const u8* const gUnknown_08400F78[]; // table of pointers to flavour strings + +struct StatusFlagString +{ + u8* flag; + u8* ptr; +}; + +extern const struct StatusFlagString gUnknown_081FA6D4[7]; // status flag/text +extern const u8 gUnknown_084017A8[8]; // empty flags + +struct StringInfo +{ + u16 currentMove; + u16 lastMove; + u16 lastItem; + u8 lastAbility; + u8 scrActive; + u8 unk1605E; + u8 hpScale; + u8 StringBank; + u8 moveType; + u8 abilities[4]; + u8 textBuffs[3][0x10]; +}; + +extern struct StringInfo* gSelectedOrderFromParty; +#define gStringInfo gSelectedOrderFromParty + +static void sub_8121D1C(u8* textBuff); +static void sub_8121D74(u8* textBuff); +static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst); + +u8 GetBankSide(u8 bank); +s32 sub_803FC34(u16); +void get_trainer_name(u8* dst); +u8 get_trainer_class_name_index(void); +u8 sub_8135FD8(void); +u8 GetMultiplayerId(void); +u8 GetBankByPlayerAI(u8 ID); +u8 GetBankSide(u8 bank); +u8 GetBankIdentity(u8 bank); + +void BufferStringBattle(u16 stringID) +{ + int i; + const u8* stringPtr = NULL; + + gStringInfo = (struct StringInfo*)(&gBattleBufferA[gActiveBank][4]); + gLastUsedItem = gStringInfo->lastItem; + gLastUsedAbility = gStringInfo->lastAbility; + BATTLE_STRUCT->scriptingActive = gStringInfo->scrActive; + BATTLE_STRUCT->unk1605E = gStringInfo->unk1605E; + BATTLE_STRUCT->hpScale = gStringInfo->hpScale; + gStringBank = gStringInfo->StringBank; + BATTLE_STRUCT->stringMoveType = gStringInfo->moveType; + for (i = 0; i < 4; i++) + { + gAbilitiesPerBank[i] = gStringInfo->abilities[i]; + } + for (i = 0; i < 0x10; i++) + { + gBattleTextBuff1[i] = gStringInfo->textBuffs[0][i]; + gBattleTextBuff2[i] = gStringInfo->textBuffs[1][i]; + gBattleTextBuff3[i] = gStringInfo->textBuffs[2][i]; + } + switch (stringID) + { + case 0: // first battle msg + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_084005DB; + else + stringPtr = gUnknown_084005C7; + } + else + stringPtr = gUnknown_084005AA; + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_LEGENDARY) + stringPtr = gUnknown_08400568; + else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) // interesting, looks like they had something planned for wild double battles + stringPtr = gUnknown_08400590; + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) + stringPtr = gUnknown_0840057B; + else + stringPtr = gUnknown_08400555; + } + break; + case 1: // poke first send-out + if (GetBankSide(gActiveBank) == 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_084006F1; + else + stringPtr = gUnknown_084006A4; + } + else + stringPtr = gUnknown_0840069C; + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_0840065C; + else if (gBattleTypeFlags & BATTLE_TYPE_LINK) + stringPtr = gUnknown_08400645; + else + stringPtr = gUnknown_08400608; + } + else if (gBattleTypeFlags & BATTLE_TYPE_LINK) + stringPtr = gUnknown_08400635; + else + stringPtr = gUnknown_084005F5; + } + break; + case 2: // sending poke to ball msg + if (GetBankSide(gActiveBank) == 0) + { + if (BATTLE_STRUCT->hpScale == 0) + stringPtr = gUnknown_08400709; + else if (BATTLE_STRUCT->hpScale == 1 || gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + stringPtr = gUnknown_08400727; + else if (BATTLE_STRUCT->hpScale == 2) + stringPtr = gUnknown_08400736; + else + stringPtr = gUnknown_08400749; + } + else + { + if (gTrainerBattleOpponent == 0x800) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_08400781; + else + stringPtr = gUnknown_08400771; + } + else + stringPtr = gUnknown_0840075E; + } + break; + case 3: // switch-in msg + if (GetBankSide(BATTLE_STRUCT->scriptingActive) == 0) + { + if (BATTLE_STRUCT->hpScale == 0 || gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + stringPtr = gUnknown_084006B3; + else if (BATTLE_STRUCT->hpScale == 1) + stringPtr = gUnknown_084006BB; + else if (BATTLE_STRUCT->hpScale == 2) + stringPtr = gUnknown_084006C6; + else + stringPtr = gUnknown_084006D5; + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_0840068C; + else + stringPtr = gUnknown_0840067C; + } + else + stringPtr = gUnknown_08400622; + } + break; + case 4: // pokemon used a move msg + sub_8121D1C(gBattleTextBuff1); + if (gStringInfo->currentMove > 0x162) + StringCopy(gBattleTextBuff2, gUnknown_08401674[BATTLE_STRUCT->stringMoveType]); + else + StringCopy(gBattleTextBuff2, gMoveNames[gStringInfo->currentMove]); + sub_8121D74(gBattleTextBuff2); + stringPtr = gUnknown_084007BD; + break; + case 5: // battle end + if (gBattleTextBuff1[0] & 0x80) + { + gBattleTextBuff1[0] &= ~(0x80); + if (GetBankSide(gActiveBank) == 1 && gBattleTextBuff1[0] != 3) + gBattleTextBuff1[0] ^= 3; + if (gBattleTextBuff1[0] == BATTLE_LOST || gBattleTextBuff1[0] == BATTLE_DREW) + stringPtr = gUnknown_083FFEFC; + else + { + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + stringPtr = gUnknown_083FFFF7; + else + stringPtr = gUnknown_083FFFEA; + } + } + else + { + if (GetBankSide(gActiveBank) == 1 && gBattleTextBuff1[0] != 3) + gBattleTextBuff1[0] ^= 3; + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + switch (gBattleTextBuff1[0]) + { + case BATTLE_WON: + stringPtr = gUnknown_083FFF6A; + break; + case BATTLE_LOST: + stringPtr = gUnknown_083FFF99; + break; + case BATTLE_DREW: + stringPtr = gUnknown_083FFFCB; + break; + } + } + else + { + switch (gBattleTextBuff1[0]) + { + case BATTLE_WON: + stringPtr = gUnknown_083FFF56; + break; + case BATTLE_LOST: + stringPtr = gUnknown_083FFF81; + break; + case BATTLE_DREW: + stringPtr = gUnknown_083FFFB3; + break; + } + } + } + break; + default: // load a string from the table + if (stringID >= BATTLESTRINGS_MAX) + { + gDisplayedStringBattle[0] = EOS; + return; + } + else + stringPtr = gBattleStringsTable[stringID - BATTLESTRING_TO_SUB]; + break; + } + StrCpyDecodeToDisplayedStringBattle(stringPtr); +} + +u32 StrCpyDecodeToDisplayedStringBattle(const u8* src) +{ + StrCpyDecodeBattle(src, gDisplayedStringBattle); +} + +static const u8* AppendStatusString(u8* src) +{ + u32 i; + u8 status[8]; + u32 flag1, flag2; + u8* statusPtr; + + memcpy(status, gUnknown_084017A8, 8); + + statusPtr = status; + for (i = 0; i < sizeof(struct StatusFlagString); i++) + { + if (*src == EOS) + break; + *statusPtr = *src; + src++; + statusPtr++; + } + flag1 = *(u32*)(&status[0]); + flag2 = *(u32*)(&status[4]); + for (i = 0; i < 7; i++) + { + if (flag1 == *(u32*)(&gUnknown_081FA6D4[i].flag[0]) && flag2 == *(u32*)(&gUnknown_081FA6D4[i].flag[4])) + return gUnknown_081FA6D4[i].ptr; + } + return NULL; +} + +u32 StrCpyDecodeBattle(const u8* src, u8* dst) +{ + u32 dstID = 0; // if they used dstID, why not use srcID as well? + const u8* toCpy = NULL; + u8 text[12]; + u8 multiplayerID = GetMultiplayerId(); + + while (*src != EOS) + { + if (*src == 0xFD) + { + src++; + switch (*src) + { + case 0: + if (gBattleTextBuff1[0] == 0xFD) + { + StrCpyDecodeBattleTextBuff(gBattleTextBuff1, gStringVar1); + toCpy = gStringVar1; + } + else + { + toCpy = AppendStatusString(gBattleTextBuff1); + if (toCpy == 0) + toCpy = gBattleTextBuff1; + } + break; + case 1: + if (gBattleTextBuff2[0] == 0xFD) + { + StrCpyDecodeBattleTextBuff(gBattleTextBuff2, gStringVar2); + toCpy = gStringVar2; + } + else + toCpy = gBattleTextBuff2; + break; + case 42: + if (gBattleTextBuff3[0] == 0xFD) + { + StrCpyDecodeBattleTextBuff(gBattleTextBuff3, gStringVar3); + toCpy = gStringVar3; + } + else + toCpy = gBattleTextBuff3; + break; + case 2: // first player poke name + GetMonData(&gPlayerParty[gBattlePartyID[GetBankByPlayerAI(0)]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 3: // first enemy poke name + GetMonData(&gEnemyParty[gBattlePartyID[GetBankByPlayerAI(1)]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 4: // second player poke name + GetMonData(&gPlayerParty[gBattlePartyID[GetBankByPlayerAI(2)]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 5: // second enemy poke name + GetMonData(&gEnemyParty[gBattlePartyID[GetBankByPlayerAI(3)]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 6: // link first player poke name + GetMonData(&gPlayerParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 7: // link first opponent poke name + GetMonData(&gEnemyParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 1]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 8: // link second player poke name + GetMonData(&gPlayerParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 2]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 9: // link second opponent poke name + GetMonData(&gEnemyParty[gBattlePartyID[gLinkPlayers[multiplayerID].lp_field_18 ^ 3]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + toCpy = text; + break; + case 10: // attacker name with prefix, only bank 0/1 + if (GetBankSide(gBankAttacker) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1)]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1)]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 11: // attacker partner name, only bank 0/1 + if (GetBankSide(gBankAttacker) == 0) + GetMonData(&gPlayerParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1) + 2]], MON_DATA_NICKNAME, text); + else + GetMonData(&gEnemyParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1) + 2]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 12: // attacker name with prefix + if (GetBankSide(gBankAttacker) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[gBankAttacker]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 13: // target name with prefix + if (GetBankSide(gBankTarget) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[gBankTarget]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 14: // effect bank name with prefix + if (GetBankSide(gEffectBank) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[gEffectBank]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[gEffectBank]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 15: // active bank name with prefix + if (GetBankSide(gActiveBank) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 16: // scripting active bank name with prefix + if (GetBankSide(BATTLE_STRUCT->scriptingActive) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[gBattlePartyID[BATTLE_STRUCT->scriptingActive]], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[gBattlePartyID[BATTLE_STRUCT->scriptingActive]], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 17: // current move name + if (gStringInfo->currentMove > 0x162) + toCpy = (void*) &gUnknown_08401674[BATTLE_STRUCT->stringMoveType]; + else + toCpy = gMoveNames[gStringInfo->currentMove]; + break; + case 18: // last used move name + if (gStringInfo->lastMove > 0x162) + toCpy = (void*) &gUnknown_08401674[BATTLE_STRUCT->stringMoveType]; + else + toCpy = gMoveNames[gStringInfo->lastMove]; + break; + case 19: // last used item + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (gLastUsedItem == ITEM_ENIGMA_BERRY) + { + if (gLinkPlayers[BATTLE_STRUCT->linkPlayerIndex].lp_field_18 == gStringBank) + { + StringCopy(text, gEnigmaBerries[gStringBank].name); + StringAppend(text, gUnknown_08400A85); + toCpy = text; + } + else + toCpy = gUnknown_08400A78; + } + else + { + CopyItemName(gLastUsedItem, text); + toCpy = text; + } + } + else + { + CopyItemName(gLastUsedItem, text); + toCpy = text; + } + break; + case 20: // last used ability + toCpy = gAbilityNames[gLastUsedAbility]; + break; + case 21: // attacker ability + toCpy = gAbilityNames[gAbilitiesPerBank[gBankAttacker]]; + break; + case 22: // target ability + toCpy = gAbilityNames[gAbilitiesPerBank[gBankTarget]]; + break; + case 23: // scripting active ability + toCpy = gAbilityNames[gAbilitiesPerBank[BATTLE_STRUCT->scriptingActive]]; + break; + case 24: // effect bank ability + toCpy = gAbilityNames[gAbilitiesPerBank[gEffectBank]]; + break; + case 25: // trainer class name + if (gTrainerBattleOpponent == 0x400) + toCpy = gTrainerClassNames[GetSecretBaseTrainerNameIndex()]; + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + toCpy = gTrainerClassNames[get_trainer_class_name_index()]; + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + toCpy = gTrainerClassNames[sub_8135FD8()]; + else + toCpy = gTrainerClassNames[gTrainers[gTrainerBattleOpponent].trainerClass]; + break; + case 26: // trainer name + if (gTrainerBattleOpponent == 0x400) + { + memset(text, 0xFF, 8); + memcpy(text, &ewram[0x17002], 7); + toCpy = text; + } + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + { + get_trainer_name(text); + toCpy = text; + } + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + { + sub_8135FF4(text); + toCpy = text; + } + else + toCpy = gTrainers[gTrainerBattleOpponent].trainerName; + break; + case 27: // link player name? + toCpy = gLinkPlayers[multiplayerID].name; + break; + case 28: // link partner name? + toCpy = gLinkPlayers[sub_803FC34(2 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + break; + case 29: // link opponent 1 name? + toCpy = gLinkPlayers[sub_803FC34(1 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + break; + case 30: // link opponent 2 name? + toCpy = gLinkPlayers[sub_803FC34(3 ^ gLinkPlayers[multiplayerID].lp_field_18)].name; + break; + case 31: // link scripting active name + toCpy = gLinkPlayers[sub_803FC34(BATTLE_STRUCT->scriptingActive)].name; + break; + case 32: // player name + toCpy = gSaveBlock2.playerName; + break; + case 33: // ? + toCpy = sub_8082830(); + break; + case 34: // ? + if (GetBankSide(BATTLE_STRUCT->scriptingActive) != 0) + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + toCpy = gUnknown_08400797; + else + toCpy = gUnknown_08400791; + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + GetMonData(&gEnemyParty[BATTLE_STRUCT->unk1605E], MON_DATA_NICKNAME, text); + } + else + GetMonData(&gPlayerParty[BATTLE_STRUCT->unk1605E], MON_DATA_NICKNAME, text); + + StringGetEnd10(text); + toCpy = text; + break; + case 35: // lanette pc + if (FlagGet(SYS_PC_LANETTE)) + toCpy = gUnknown_084009F7; + else + toCpy = gUnknown_084009ED; + break; + case 38: + if (GetBankSide(gBankAttacker) == 0) + toCpy = gUnknown_084007AC; + else + toCpy = gUnknown_084007A7; + break; + case 39: + if (GetBankSide(gBankTarget) == 0) + toCpy = gUnknown_084007AC; + else + toCpy = gUnknown_084007A7; + break; + case 36: + if (GetBankSide(gBankAttacker) == 0) + toCpy = gUnknown_084007A1; + else + toCpy = gUnknown_0840079C; + break; + case 37: + if (GetBankSide(gBankTarget) == 0) + toCpy = gUnknown_084007A1; + else + toCpy = gUnknown_0840079C; + break; + case 40: + if (GetBankSide(gBankAttacker) == 0) + toCpy = gUnknown_084007B7; + else + toCpy = gUnknown_084007B2; + break; + case 41: + if (GetBankSide(gBankTarget) == 0) + toCpy = gUnknown_084007B7; + else + toCpy = gUnknown_084007B2; + break; + } + //if (toCpy != NULL) really GF, why did you forgot about this + while (*toCpy != EOS) + { + dst[dstID] = *toCpy; + dstID++; + toCpy++; + } + if (*src == 33) + { + dst[dstID] = 0xFC; + dstID++; + dst[dstID] = 9; + dstID++; + } + } + else + { + dst[dstID] = *src; + dstID++; + } + src++; + } + dst[dstID] = *src; + dstID++; + return dstID; +} + +#define ByteRead16(ptr) ((ptr)[0] | ((ptr)[1] << 8)) +#define ByteRead32(ptr) ((ptr)[0] | (ptr)[1] << 8 | (ptr)[2] << 16 | (ptr)[3] << 24) + +static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) +{ + u32 srcID = 1; + u32 value = 0; + u8 text[12]; + + *dst = EOS; + while (src[srcID] != EOS) + { + switch (src[srcID]) + { + case 0: // battlescript ptr + { + u16 BS_ID = ByteRead16(&src[srcID + 1]); + StringAppend(dst, gBattleStringsTable[BS_ID - BATTLESTRING_TO_SUB]); + srcID += 3; + } + break; + case 1: // int to string + switch (src[srcID + 1]) + { + case 1: + value = src[srcID + 3]; + break; + case 2: + value = ByteRead16(&src[srcID + 3]); + break; + case 4: + value = ByteRead32(&src[srcID + 3]); + break; + } + ConvertIntToDecimalStringN(dst, value, 0, src[srcID + 2]); + srcID += src[srcID + 1] + 3; + break; + case 2: // move name + StringAppend(dst, gMoveNames[ByteRead16(&src[srcID + 1])]); + srcID += 3; + break; + case 3: // type name + StringAppend(dst, gTypeNames[src[srcID + 1]]); + srcID += 2; + break; + case 4: // poke nick with prefix + if (GetBankSide(src[srcID + 1]) == 0) + { + GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + } + else + { + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + StringAppend(dst, gUnknown_08400797); + else + StringAppend(dst, gUnknown_08400791); + GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + } + StringGetEnd10(text); + StringAppend(dst, text); + srcID += 3; + break; + case 5: // stats + StringAppend(dst, gUnknown_08400F58[src[srcID + 1]]); + srcID += 2; + break; + case 6: // species name + GetSpeciesName(dst, ByteRead16(&src[srcID + 1])); + srcID += 3; + break; + case 7: // poke nick without prefix + if (GetBankSide(src[srcID + 1]) == 0) + GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + else + GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, dst); + StringGetEnd10(dst); + srcID += 3; + break; + case 8: // flavour table + StringAppend(dst, gUnknown_08400F78[src[srcID + 1]]); + srcID += 2; + break; + case 9: // ability names + StringAppend(dst, gAbilityNames[src[srcID + 1]]); + srcID += 2; + break; + case 10: // item name + { + u16 item = ByteRead16(&src[srcID + 1]); + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + if (item == ITEM_ENIGMA_BERRY) + { + if (gLinkPlayers[BATTLE_STRUCT->linkPlayerIndex].lp_field_18 == gStringBank) + { + StringCopy(dst, gEnigmaBerries[gStringBank].name); + StringAppend(dst, gUnknown_08400A85); + } + else + StringAppend(dst, gUnknown_08400A78); + } + else + CopyItemName(item, dst); + } + else + CopyItemName(item, dst); + srcID += 3; + } + break; + } + } +} + +static void sub_8121D1C(u8* textBuff) +{ + s32 counter = 0; + u32 i = 0; + + while (counter != 4) + { + if (gUnknown_084016BC[i] == 0) + counter++; + if (gUnknown_084016BC[i++] == gStringInfo->currentMove) + break; + } + + if (counter >= 0) + { + if (counter <= 2) + StringCopy(textBuff, gUnknown_08400E5E); // is + else if (counter <= 4) + StringCopy(textBuff, gUnknown_08400E62); // 's + } +} + +#ifdef NONMATCHING + +static void sub_8121D74(u8* dst) +{ + s32 counter = 0; + s32 i; + + while (*dst != EOS) + dst++; + + i = 0; + while (counter != 4) + { + if (gUnknown_084016BC[i] == 0) + counter++; + if (gUnknown_084016BC[i++] == gStringInfo->currentMove) + break; + } + switch (counter) + { + case 0: + StringCopy(dst, gUnknown_084007C8); + break; + case 1: + StringCopy(dst, gUnknown_084007CA); + break; + case 2: + StringCopy(dst, gUnknown_084007CC); + break; + case 3: + StringCopy(dst, gUnknown_084007CE); + break; + case 4: + StringCopy(dst, gUnknown_084007D0); + break; + } +} + +#else +__attribute__((naked)) +static void sub_8121D74(u8* dst) +{ + asm(".syntax unified\n\ + push {r4,r5,lr}\n\ + adds r3, r0, 0\n\ + movs r4, 0\n\ + b _08121D7E\n\ +_08121D7C:\n\ + adds r3, 0x1\n\ +_08121D7E:\n\ + ldrb r0, [r3]\n\ + cmp r0, 0xFF\n\ + bne _08121D7C\n\ + ldr r1, _08121DB4 @ =gUnknown_084016BC\n\ + ldr r5, _08121DB8 @ =gSelectedOrderFromParty\n\ + movs r0, 0\n\ + lsls r0, 1\n\ + adds r2, r0, r1\n\ +_08121D8E:\n\ + cmp r4, 0x4\n\ + beq _08121DA8\n\ + ldrh r1, [r2]\n\ + cmp r1, 0\n\ + bne _08121D9A\n\ + adds r4, 0x1\n\ +_08121D9A:\n\ + ldr r0, [r5]\n\ + adds r2, 0x2\n\ + ldrh r0, [r0]\n\ + cmp r1, r0\n\ + bne _08121D8E\n\ + cmp r4, 0x4\n\ + bhi _08121E04\n\ +_08121DA8:\n\ + lsls r0, r4, 2\n\ + ldr r1, _08121DBC @ =_08121DC0\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ +_08121DB4: .4byte gUnknown_084016BC\n\ +_08121DB8: .4byte gSelectedOrderFromParty\n\ +_08121DBC: .4byte _08121DC0\n\ + .align 2, 0\n\ +_08121DC0:\n\ + .4byte _08121DD4\n\ + .4byte _08121DDC\n\ + .4byte _08121DE4\n\ + .4byte _08121DEC\n\ + .4byte _08121DFC\n\ +_08121DD4:\n\ + ldr r1, _08121DD8 @ =gUnknown_084007C8\n\ + b _08121DEE\n\ + .align 2, 0\n\ +_08121DD8: .4byte gUnknown_084007C8\n\ +_08121DDC:\n\ + ldr r1, _08121DE0 @ =gUnknown_084007CA\n\ + b _08121DEE\n\ + .align 2, 0\n\ +_08121DE0: .4byte gUnknown_084007CA\n\ +_08121DE4:\n\ + ldr r1, _08121DE8 @ =gUnknown_084007CC\n\ + b _08121DEE\n\ + .align 2, 0\n\ +_08121DE8: .4byte gUnknown_084007CC\n\ +_08121DEC:\n\ + ldr r1, _08121DF8 @ =gUnknown_084007CE\n\ +_08121DEE:\n\ + adds r0, r3, 0\n\ + bl StringCopy\n\ + b _08121E04\n\ + .align 2, 0\n\ +_08121DF8: .4byte gUnknown_084007CE\n\ +_08121DFC:\n\ + ldr r1, _08121E0C @ =gUnknown_084007D0\n\ + adds r0, r3, 0\n\ + bl StringCopy\n\ +_08121E04:\n\ + pop {r4,r5}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_08121E0C: .4byte gUnknown_084007D0\n\ + .syntax divided"); +} + +#endif // NONMATCHING -- cgit v1.2.3 From e67214db6c4b7a655726134cdbefa4da20a0c8a9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 5 Aug 2017 21:53:51 +0200 Subject: start decompiling berry blender --- src/berry_blender.c | 903 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 903 insertions(+) create mode 100644 src/berry_blender.c (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c new file mode 100644 index 000000000..7e7f58db7 --- /dev/null +++ b/src/berry_blender.c @@ -0,0 +1,903 @@ +#include "global.h" +#include "decompress.h" +#include "palette.h" +#include "event_data.h" +#include "main.h" +#include "text_window.h" +#include "menu.h" +#include "strings2.h" +#include "sound.h" +#include "berry.h" +#include "string_util.h" +#include "link.h" +#include "task.h" + +//needed to match Blender_ControlHitPitch +struct MusicPlayerInfo +{ + struct SongHeader *songHeader; + u32 status; + u8 trackCount; + u8 priority; + u8 cmd; + u8 unk_B; + u32 clock; + u8 gap[8]; + u8 *memAccArea; + u16 tempoD; + u16 tempoU; + u16 tempoI; + u16 tempoC; + u16 fadeOI; + u16 fadeOC; + u16 fadeOV; + struct MusicPlayerTrack *tracks; + struct ToneData *tone; + u32 ident; + u32 func; + u32 intp; +}; + +// other files functions +void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch); +void sub_80A6978(void); +u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); + +#define BLENDER_MAX_PLAYERS 4 + +struct BlenderBerry +{ + u16 field_0; + u8 name[7]; + u8 spicy; + u8 dry; + u8 sweet; + u8 bitter; + u8 sour; + u8 smoothness; +}; + +struct BerryBlenderData +{ + u8 field_0; + u8 field_1; + u8 field_2; + u8 field_3; + u8 field_4; + u8 field_5; + u8 field_6; + u8 field_7; + u8 field_8; + u8 field_9; + u8 field_A; + u8 field_B; + u8 field_C; + u8 field_D; + u8 field_E; + u8 field_F; + u8 field_10; + u8 field_11; + u8 field_12; + u8 field_13; + u8 field_14; + u8 field_15; + u8 field_16; + u8 field_17; + u8 field_18; + u8 field_19; + u8 field_1A; + u8 field_1B; + u8 field_1C; + u8 field_1D; + u8 field_1E; + u8 field_1F; + u8 field_20; + u8 field_21; + u8 field_22; + u8 field_23; + u8 field_24; + u8 field_25; + u8 field_26; + u8 field_27; + u8 field_28; + u8 field_29; + u8 field_2A; + u8 field_2B; + u8 field_2C; + u8 field_2D; + u8 field_2E; + u8 field_2F; + u8 field_30; + u8 field_31; + u8 field_32; + u8 field_33; + u8 field_34; + u8 field_35; + u8 field_36; + u8 field_37; + u8 field_38; + u8 field_39; + u8 field_3A; + u8 field_3B; + u8 field_3C; + u8 field_3D; + u8 field_3E; + u8 field_3F; + u8 field_40; + u8 field_41; + u8 field_42; + u8 field_43; + u8 field_44; + u8 field_45; + u8 field_46; + u8 field_47; + u8 field_48; + u8 field_49; + u8 field_4A; + u8 field_4B; + u8 field_4C; + u8 field_4D; + u16 field_4E; + u8 field_50; + u8 field_51; + u8 field_52; + u8 field_53; + u16 field_54; + s16 hitPitch; //56 + u8 field_58; + u8 field_59; + u16 field_5A; + u8 SyncArrowSpriteID[BLENDER_MAX_PLAYERS]; + u8 field_60; + u8 field_61; + u8 field_62; + u8 field_63; + u8 field_64; + u8 field_65; + u8 field_66; + u8 field_67; + u8 field_68; + u8 field_69; + u8 field_6A; + u8 field_6B; + u8 field_6C; + u8 field_6D; + u8 field_6E; + u8 field_6F; + u16 field_70[BLENDER_MAX_PLAYERS]; + u8 field_78; + u8 field_79; + u8 field_7A; + u8 field_7B; + u16 field_7C; + u8 field_7E; + u8 field_7F; + u16 field_80[BLENDER_MAX_PLAYERS]; + u8 field_88; + u8 field_89; + u8 field_8A; + u8 field_8B; + u8 field_8C; + u8 field_8D; + u8 field_8E; + u8 field_8F; + u8 field_90; + u8 field_91; + u8 field_92; + u8 field_93; + u8 field_94; + u8 field_95; + u8 field_96; + u8 field_97; + u8 field_98; + u8 field_99; + u8 field_9A; + u8 field_9B; + u8 field_9C; + u8 field_9D; + u8 field_9E; + u8 field_9F; + u8 field_A0; + u8 field_A1; + u8 field_A2; + u8 field_A3; + u8 field_A4; + u8 field_A5; + u8 field_A6; + u8 field_A7; + u8 field_A8; + u8 field_A9; + u8 field_AA; + u8 field_AB; + u8 field_AC; + u8 field_AD; + u8 field_AE; + u8 field_AF; + u8 field_B0; + u8 field_B1; + u8 field_B2; + u8 field_B3; + u8 field_B4; + u8 field_B5; + u8 field_B6; + u8 field_B7; + u8 field_B8; + u8 field_B9; + u8 field_BA; + u8 field_BB; + u8 field_BC; + u8 field_BD; + u8 field_BE; + u8 field_BF; + u8 field_C0; + u8 field_C1; + u8 field_C2; + u8 field_C3; + u8 field_C4; + u8 field_C5; + u8 field_C6; + u8 field_C7; + u8 field_C8; + u8 field_C9; + u8 field_CA; + u8 field_CB; + u8 field_CC; + u8 field_CD; + u8 field_CE; + u8 field_CF; + u8 field_D0; + u8 field_D1; + u8 field_D2; + u8 field_D3; + u8 field_D4; + u8 field_D5; + u8 field_D6; + u8 field_D7; + u8 field_D8; + u8 field_D9; + u8 field_DA; + u8 field_DB; + u8 field_DC; + u8 field_DD; + u8 field_DE; + u8 field_DF; + u8 field_E0; + u8 field_E1; + u8 field_E2; + u8 field_E3; + u8 field_E4; + u8 field_E5; + u8 field_E6; + u8 field_E7; + u8 field_E8; + u8 field_E9; + u8 field_EA; + u8 field_EB; + u8 field_EC; + u8 field_ED; + u8 field_EE; + u8 field_EF; + u8 field_F0; + u8 field_F1; + u8 field_F2; + u8 field_F3; + u8 field_F4; + u8 field_F5; + u8 field_F6; + u8 field_F7; + u8 field_F8; + u8 field_F9; + u8 field_FA; + u8 field_FB; + u8 field_FC; + u8 field_FD; + u8 field_FE; + u8 field_FF; + u8 field_100; + u8 field_101; + u8 field_102; + u8 field_103; + u8 field_104; + u8 field_105; + u8 field_106; + u8 field_107; + u8 field_108; + u8 field_109; + u8 field_10A; + u8 field_10B; + u8 field_10C; + u8 field_10D; + u8 field_10E; + u8 field_10F; + u8 field_110; + u8 field_111; + u8 field_112; + u8 field_113; + u8 field_114; + u8 field_115; + u8 field_116; + u8 field_117; + u8 field_118; + u8 field_119; + u8 field_11A; + u8 field_11B; + u8 field_11C; + u8 field_11D; + u8 field_11E; + u8 field_11F; + u8 field_120; + u8 field_121; + u8 field_122; + u8 field_123; + u8 field_124; + u8 field_125; + u8 field_126; + u8 field_127; + u8 field_128; + u8 field_129; + u8 field_12A; + u8 field_12B; + u8 field_12C; + u8 field_12D; + u8 field_12E; + u8 field_12F; + u32 field_130; + u32 field_134; + u8 field_138; + u8 field_139; + u8 field_13A; + u8 field_13B; + u8 field_13C; + u8 field_13D; + u16 field_13E; + u16 field_140; + u16 field_142; + u16 field_144; + u16 field_146; + u8 field_148; + u8 field_149; + u8 field_14A; + u8 field_14B; + u16 field_14C[BLENDER_MAX_PLAYERS][2]; + u8 field_15C; + u8 field_15D; + u8 field_15E; + u8 field_15F; + u8 field_160; + u8 field_161; + u8 field_162; + u8 field_163; + u8 field_164; + u8 field_165; + u8 field_166; + u8 field_167; + u8 field_168; + u8 field_169; + u8 field_16A; + u8 field_16B; + u8 field_16C; + u8 field_16D; + u8 field_16E; + u8 field_16F; + u8 field_170; + u8 field_171; + u8 field_172; + u8 field_173; + u8 field_174; + u8 field_175; + u8 field_176; + u8 field_177; + u8 field_178; + u8 field_179; + u8 field_17A; + u8 field_17B; + struct BlenderBerry blendedBerries[BLENDER_MAX_PLAYERS]; +}; + +extern struct BerryBlenderData* sBerryBlenderData; + +extern struct MusicPlayerInfo gMPlay_SE2; +extern u8 ewram[]; + +// this file's functions: +void sub_80514A4(void); +void sub_80514F0(void); +void sub_804E56C(void); +void sub_804E884(u8 a0); +void sub_8051474(void); +void sub_804E9F8(void); +void sub_804F378(void); +void sub_8051414(void*); + +void Blender_ControlHitPitch(void) +{ + m4aMPlayPitchControl(&gMPlay_SE2, 0xFFFF, (sBerryBlenderData->hitPitch - 128) * 2); +} + +void VBlankCB0_BerryBlender(void) +{ + sub_80514A4(); + sub_80514F0(); + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void VBlankCB1_BerryBlender(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +extern const u8 gUnknown_08E6C100[]; +extern const u8 gUnknown_08215C2C[]; +extern const u8 gUnknown_08E6C920[]; +extern const u8 gUnknown_08E6D354[]; +extern const u16 gUnknown_08215C0C[]; +extern const u16 gUnknown_0821602C[]; +extern const struct SpriteSheet gUnknown_082163DC; +extern const struct SpriteSheet gUnknown_082164F4; +extern const struct SpriteSheet gUnknown_08216454; +extern const struct SpriteSheet gUnknown_08216540; +extern const struct SpriteSheet gUnknown_08216574; +extern const struct SpritePalette gUnknown_082163EC; +extern const struct SpritePalette gUnknown_082163E4; + +bool8 sub_804E2EC(void) +{ + switch (sBerryBlenderData->field_1) + { + case 0: + sub_800D238(gUnknown_08E6C100, &ewram[0x10000]); + sBerryBlenderData->field_1++; + break; + case 1: + { + const void* offsetRead = gUnknown_08215C2C; + void* offsetWrite = (void*)(VRAM + 0x4000); + + DmaCopy16(3, offsetRead, offsetWrite, 0x400); + LoadPalette(gUnknown_08215C0C, 0, 0x100); + sBerryBlenderData->field_1++; + } + break; + case 2: + { + void* offsetRead = &ewram[0x10000]; + void* offsetWrite = (void*)(VRAM); + u32 size = 0x2000; + while (TRUE) + { + DmaCopy16(3, offsetRead, offsetWrite, 0x1000); + offsetRead += 0x1000; + offsetWrite += 0x1000; + size -= 0x1000; + if (size <= 0x1000) + { + DmaCopy16(3, offsetRead, offsetWrite, size); + break; + } + } + sBerryBlenderData->field_1++; + } + break; + case 3: + sub_800D238(gUnknown_08E6C920, &ewram[0x10000]); + sBerryBlenderData->field_1++; + break; + case 4: + sub_800D238(gUnknown_08E6D354, &ewram[0x13000]); + sBerryBlenderData->field_1++; + break; + case 5: + { + void* offsetRead = &ewram[0x10000]; + void* offsetWrite = (void*)(VRAM + 0xE000); + + DmaCopy16(3, offsetRead, offsetWrite, 0x1000); + sBerryBlenderData->field_1++; + } + break; + case 6: + { + void* offsetRead = &ewram[0x11000]; + void* offsetWrite = (void*)(VRAM + 0xF000); + + DmaCopy16(3, offsetRead, offsetWrite, 0x1000); + sBerryBlenderData->field_1++; + } + break; + case 7: + { + u16 i; + u16* palStore = (u16*)(&ewram[0x13000]); + void* offsetRead; + void* offsetWrite; + + for (i = 0; i < 640; i++) + { + *(palStore + i) |= 0x100; + } + offsetRead = &ewram[0x13000]; + offsetWrite = (void*)(VRAM + 0x6000); + DmaCopy16(3, offsetRead, offsetWrite, 0x500); + LoadPalette(gUnknown_0821602C, 0x80, 0x20); + sBerryBlenderData->field_1++; + } + break; + case 8: + LoadSpriteSheet(&gUnknown_082163DC); + LoadSpriteSheet(&gUnknown_082164F4); + LoadSpriteSheet(&gUnknown_08216454); + sBerryBlenderData->field_1++; + break; + case 9: + LoadSpriteSheet(&gUnknown_08216540); + LoadSpriteSheet(&gUnknown_08216574); + LoadSpritePalette(&gUnknown_082163EC); + LoadSpritePalette(&gUnknown_082163E4); + sBerryBlenderData->field_1 = 0; + return 1; + } + return 0; +} + +void sub_804E4FC(void) +{ + REG_DISPCNT = 0x1341; + REG_BG2CNT = 0x4880; + REG_BG1CNT = 0xC0D; + REG_BG0HOFS = 0; + REG_BG0VOFS = 0; + REG_BG1HOFS = 0; + REG_BG1VOFS = 0; +} + +void sub_804E538(void) +{ + u8* field6F; //this temp value is needed to match + + sBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); + + field6F = &sBerryBlenderData->field_6F; + sBerryBlenderData->field_0 = 0; + *field6F = 0; + + sub_804E884(gSpecialVar_0x8004); + SetMainCallback2(sub_804E56C); +} + +extern const struct WindowConfig gWindowConfig_81E6F68; +extern const u8 sBlenderSyncArrowsPos[][2]; +extern const struct SpriteTemplate sBlenderSyncArrow_SpriteTemplate; + +void sub_804E56C(void) +{ + s32 i; + switch (sBerryBlenderData->field_0) + { + case 0: + REG_DISPCNT = 0; + ResetSpriteData(); + FreeAllSpritePalettes(); + SetVBlankCallback(NULL); + SetUpWindowConfig(&gWindowConfig_81E6F68); + InitMenuWindow(&gWindowConfig_81E6F68); + sBerryBlenderData->field_0++; + sBerryBlenderData->field_140 = 0; + sBerryBlenderData->field_13E = 0; + sBerryBlenderData->field_142 = 0x50; + sBerryBlenderData->field_144 = 0; + sBerryBlenderData->field_146 = 0; + sBerryBlenderData->field_1 = 0; + sub_8051474(); + break; + case 1: + if (sub_804E2EC()) + { + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->SyncArrowSpriteID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[i]], i + 8); + } + SetVBlankCallback(VBlankCB0_BerryBlender); + sBerryBlenderData->field_0++; + } + break; + case 2: + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + sub_8051474(); + sBerryBlenderData->field_0++; + break; + case 3: + sub_804E4FC(); + if (!gPaletteFade.active) + { + sBerryBlenderData->field_0++; + } + break; + case 4: + MenuDrawTextWindow(0, 14, 29, 19); + MenuPrintMessage(gOtherText_BlenderChooseBerry, 1, 15); + sBerryBlenderData->field_0++; + break; + case 5: + if (MenuUpdateWindowText()) + { + sBerryBlenderData->field_0++; + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + } + break; + case 6: + if (!gPaletteFade.active) + { + sub_80A6978(); + sBerryBlenderData->field_0 = 0; + } + break; + } + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_804E738(struct Sprite* sprite) +{ + sprite->data1 += sprite->data6; + sprite->data2 -= sprite->data4; + sprite->data2 += sprite->data7; + sprite->data0 += sprite->data7; + sprite->data4--; + + if (sprite->data0 < sprite->data2) + { + sprite->data3 = sprite->data4 = sprite->data3 - 1; + if (++sprite->data5 > 3) + DestroySprite(sprite); + else + PlaySE(116); + } + sprite->pos1.x = sprite->data1; + sprite->pos1.y = sprite->data2; +} + +void sub_804E794(struct Sprite* sprite, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) +{ + sprite->data0 = a3; + sprite->data1 = a2; + sprite->data2 = a3; + sprite->data3 = a4; + sprite->data4 = 10; + sprite->data5 = 0; + sprite->data6 = a5; + sprite->data7 = a6; + sprite->callback = sub_804E738; +} + +extern const s16 gUnknown_08216594[][5]; + +void sub_804E7C0(u16 a0, u8 a1) +{ + u8 spriteID = sub_80A7DEC(a0 + 123, 0, 80, a1 & 1); + sub_804E794(&gSprites[spriteID], gUnknown_08216594[a1][0], gUnknown_08216594[a1][1], gUnknown_08216594[a1][2], gUnknown_08216594[a1][3], gUnknown_08216594[a1][4]); +} + +void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) +{ + const struct Berry *berryInfo = GetBerryInfo(itemID + 124); + berry->field_0 = itemID; + StringCopy(berry->name, berryInfo->name); + berry->spicy = berryInfo->spicy; + berry->dry = berryInfo->dry; + berry->sweet = berryInfo->sweet; + berry->bitter = berryInfo->bitter; + berry->sour = berryInfo->sour; + berry->smoothness = berryInfo->smoothness; +} + +extern u8 gUnknown_03004834; +extern const u8* const gUnknown_082162B8[]; + +void sub_804E884(u8 a0) +{ + int i; + if (a0) + { + for (i = 0; i < 4; i++) + gLinkPlayers[i].language = LANGUAGE_ENGLISH; + } + switch (a0) + { + case 0: + gUnknown_03004834 = 0; + break; + case 1: + gUnknown_03004834 = 1; + sBerryBlenderData->field_88 = 2; + StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); + StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); + break; + case 2: + gUnknown_03004834 = 2; + sBerryBlenderData->field_88 = 3; + StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); + StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); + StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); + break; + case 3: + gUnknown_03004834 = 3; + sBerryBlenderData->field_88 = 4; + StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); + StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); + StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); + StringCopy(gLinkPlayers[3].name, gUnknown_082162B8[2]); + break; + } +} + +void sub_804E990(void) +{ + s32 i; + + REG_DISPCNT = 0; + sBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); + sBerryBlenderData->field_0 = 0; + sBerryBlenderData->field_134 = 0; + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->field_80[i] = 0; + } + sub_804E884(gSpecialVar_0x8004); + if (gSpecialVar_0x8004 == 0) + SetMainCallback2(sub_804E9F8); + else + SetMainCallback2(sub_804F378); +} + +extern u16 gScriptItemId; + +extern const u8 gUnknown_082162EC[3][4]; +extern const u16 gUnknown_082162F8[]; +extern const u8 gUnknown_08216300[]; + +void sub_804E9F8(void) +{ + int i, j; + switch (sBerryBlenderData->field_0) + { + case 0: + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + SetVBlankCallback(VBlankCB0_BerryBlender); + SetUpWindowConfig(&gWindowConfig_81E6F68); + InitMenuWindow(&gWindowConfig_81E6F68); + gLinkType = 0x4422; + sBerryBlenderData->field_0++; + sBerryBlenderData->field_4E = 0; + sBerryBlenderData->field_7E = 0; + sBerryBlenderData->field_144 = 0; + sBerryBlenderData->field_146 = 0; + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->field_70[i] = 0; + for (j = 0; j < 2; j++) + { + sBerryBlenderData->field_14C[i][j] = 0; + } + } + sBerryBlenderData->field_7C = 0; + sBerryBlenderData->hitPitch = 0; + sBerryBlenderData->field_54 = 0; + sBerryBlenderData->field_5A = 0; + sBerryBlenderData->field_1 = 0; + break; + case 1: + if (!sub_804E2EC()) + { + sBerryBlenderData->field_0++; + sub_8051474(); + } + break; + case 2: + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->SyncArrowSpriteID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[i]], i + 8); + } + sBerryBlenderData->field_0++; + break; + case 3: + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + sBerryBlenderData->field_0++; + break; + case 4: + sub_804E4FC(); + if (!gPaletteFade.active) + { + sBerryBlenderData->field_0++; + } + break; + case 5: + MenuDrawTextWindow(0, 14, 29, 19); + MenuPrint(gOtherText_BlenderChooseBerry, 1, 15); + sBerryBlenderData->field_0 = 8; + sBerryBlenderData->field_130 = 0; + break; + case 8: + sBerryBlenderData->field_0++; + sBerryBlenderData->field_13C = 0; + Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); + memcpy(gBlockSendBuffer, &sBerryBlenderData->blendedBerries[0], sizeof(struct BlenderBerry)); + sub_80084A4(); + sBerryBlenderData->field_130 = 0; + break; + case 9: + if (sub_8007ECC()) + { + ResetBlockReceivedFlags(); + if (GetMultiplayerId() == 0) + sub_8007E9C(4); + sBerryBlenderData->field_0++; + } + break; + case 10: + if (++sBerryBlenderData->field_130 > 20) + { + MenuZeroFillScreen(); + if (GetBlockReceivedStatus() == sub_8008198()) + { + for (i = 0; i < GetLinkPlayerCount(); i++) + { + memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][256], sizeof(struct BlenderBerry)); + sBerryBlenderData->field_80[i] = sBerryBlenderData->blendedBerries[i].field_0; + } + ResetBlockReceivedFlags(); + sBerryBlenderData->field_0++; + } + } + break; + case 11: + sBerryBlenderData->field_88 = GetLinkPlayerCount(); + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->field_88][i]) + { + sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_88], i); + break; + } + } + sBerryBlenderData->field_130 = 0; + sBerryBlenderData->field_0++; + sBerryBlenderData->field_13C++; + break; + case 12: + if (++sBerryBlenderData->field_130 > 60) + { + if (sBerryBlenderData->field_13C >= sBerryBlenderData->field_88) + { + sBerryBlenderData->field_0++; + sBerryBlenderData->field_54 = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; + } + else + sBerryBlenderData->field_0--; + sBerryBlenderData->field_130 = 0; + } + break; + case 13: + if (sub_8007ECC()) + { + sBerryBlenderData->field_0++; + sub_8051414(&sBerryBlenderData->field_168); + } + break; + case 14: + + break; + } + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} -- cgit v1.2.3 From f7c33068ff9eafaf111985dc934e83d773183ba9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 6 Aug 2017 18:16:56 +0200 Subject: fake matching troubles --- src/berry_blender.c | 594 ++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 533 insertions(+), 61 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index 7e7f58db7..47aebf513 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -11,6 +11,9 @@ #include "string_util.h" #include "link.h" #include "task.h" +#include "rom4.h" +#include "items.h" +#include "rng.h" //needed to match Blender_ControlHitPitch struct MusicPlayerInfo @@ -45,15 +48,17 @@ u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); #define BLENDER_MAX_PLAYERS 4 +#define FLAVOUR_SPICY 0 +#define FLAVOUR_DRY 1 +#define FLAVOUR_SWEET 2 +#define FLAVOUR_BITTER 3 +#define FLAVOUR_SOUR 4 + struct BlenderBerry { u16 field_0; u8 name[7]; - u8 spicy; - u8 dry; - u8 sweet; - u8 bitter; - u8 sour; + u8 flavours[5]; u8 smoothness; }; @@ -142,16 +147,13 @@ struct BerryBlenderData u8 field_51; u8 field_52; u8 field_53; - u16 field_54; + u16 arrowPos; s16 hitPitch; //56 u8 field_58; u8 field_59; u16 field_5A; u8 SyncArrowSpriteID[BLENDER_MAX_PLAYERS]; - u8 field_60; - u8 field_61; - u8 field_62; - u8 field_63; + u8 SyncArrowSprite2ID[BLENDER_MAX_PLAYERS]; u8 field_64; u8 field_65; u8 field_66; @@ -191,22 +193,8 @@ struct BerryBlenderData u8 field_97; u8 field_98; u8 field_99; - u8 field_9A; - u8 field_9B; - u8 field_9C; - u8 field_9D; - u8 field_9E; - u8 field_9F; - u8 field_A0; - u8 field_A1; - u8 field_A2; - u8 field_A3; - u8 field_A4; - u8 field_A5; - u8 field_A6; - u8 field_A7; - u8 field_A8; - u8 field_A9; + u16 field_9A[BLENDER_MAX_PLAYERS]; + u16 field_A2[BLENDER_MAX_PLAYERS]; u8 field_AA; u8 field_AB; u8 field_AC; @@ -337,11 +325,8 @@ struct BerryBlenderData u8 field_129; u8 field_12A; u8 field_12B; - u8 field_12C; - u8 field_12D; - u8 field_12E; - u8 field_12F; - u32 field_130; + u32 field_12C; + s32 field_130; u32 field_134; u8 field_138; u8 field_139; @@ -354,19 +339,9 @@ struct BerryBlenderData u16 field_142; u16 field_144; u16 field_146; - u8 field_148; - u8 field_149; - u8 field_14A; + u8 field_148[3]; u8 field_14B; - u16 field_14C[BLENDER_MAX_PLAYERS][2]; - u8 field_15C; - u8 field_15D; - u8 field_15E; - u8 field_15F; - u8 field_160; - u8 field_161; - u8 field_162; - u8 field_163; + u16 field_14C[BLENDER_MAX_PLAYERS][3]; u8 field_164; u8 field_165; u8 field_166; @@ -387,8 +362,7 @@ struct BerryBlenderData u8 field_175; u8 field_176; u8 field_177; - u8 field_178; - u8 field_179; + u16 field_178; u8 field_17A; u8 field_17B; struct BlenderBerry blendedBerries[BLENDER_MAX_PLAYERS]; @@ -408,6 +382,12 @@ void sub_8051474(void); void sub_804E9F8(void); void sub_804F378(void); void sub_8051414(void*); +void sub_804F238(void); +void sub_80501FC(void); +bool8 sub_8051B8C(void); +void sub_80516C4(u8 a0, u16 itemID); +void sub_804F2A8(void); +void sub_804F81C(void); void Blender_ControlHitPitch(void) { @@ -688,11 +668,11 @@ void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) const struct Berry *berryInfo = GetBerryInfo(itemID + 124); berry->field_0 = itemID; StringCopy(berry->name, berryInfo->name); - berry->spicy = berryInfo->spicy; - berry->dry = berryInfo->dry; - berry->sweet = berryInfo->sweet; - berry->bitter = berryInfo->bitter; - berry->sour = berryInfo->sour; + berry->flavours[FLAVOUR_SPICY] = berryInfo->spicy; + berry->flavours[FLAVOUR_DRY] = berryInfo->dry; + berry->flavours[FLAVOUR_SWEET] = berryInfo->sweet; + berry->flavours[FLAVOUR_BITTER] = berryInfo->bitter; + berry->flavours[FLAVOUR_SOUR] = berryInfo->sour; berry->smoothness = berryInfo->smoothness; } @@ -760,6 +740,7 @@ extern u16 gScriptItemId; extern const u8 gUnknown_082162EC[3][4]; extern const u16 gUnknown_082162F8[]; extern const u8 gUnknown_08216300[]; +extern const struct SpriteTemplate gSpriteTemplate_8216548; void sub_804E9F8(void) { @@ -782,19 +763,19 @@ void sub_804E9F8(void) for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { sBerryBlenderData->field_70[i] = 0; - for (j = 0; j < 2; j++) + for (j = 0; j < 3; j++) { sBerryBlenderData->field_14C[i][j] = 0; } } sBerryBlenderData->field_7C = 0; sBerryBlenderData->hitPitch = 0; - sBerryBlenderData->field_54 = 0; + sBerryBlenderData->arrowPos = 0; sBerryBlenderData->field_5A = 0; sBerryBlenderData->field_1 = 0; break; case 1: - if (!sub_804E2EC()) + if (sub_804E2EC()) { sBerryBlenderData->field_0++; sub_8051474(); @@ -803,8 +784,8 @@ void sub_804E9F8(void) case 2: for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->SyncArrowSpriteID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[i]], i + 8); + sBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); } sBerryBlenderData->field_0++; break; @@ -820,8 +801,8 @@ void sub_804E9F8(void) } break; case 5: - MenuDrawTextWindow(0, 14, 29, 19); - MenuPrint(gOtherText_BlenderChooseBerry, 1, 15); + MenuDrawTextWindow(0, 13, 29, 19); + MenuPrint(gOtherText_LinkStandby3, 1, 14); sBerryBlenderData->field_0 = 8; sBerryBlenderData->field_130 = 0; break; @@ -850,7 +831,7 @@ void sub_804E9F8(void) { for (i = 0; i < GetLinkPlayerCount(); i++) { - memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][256], sizeof(struct BlenderBerry)); + memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][0], sizeof(struct BlenderBerry)); sBerryBlenderData->field_80[i] = sBerryBlenderData->blendedBerries[i].field_0; } ResetBlockReceivedFlags(); @@ -862,9 +843,9 @@ void sub_804E9F8(void) sBerryBlenderData->field_88 = GetLinkPlayerCount(); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->field_88][i]) + if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]) { - sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_88], i); + sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_13C], i); break; } } @@ -878,7 +859,7 @@ void sub_804E9F8(void) if (sBerryBlenderData->field_13C >= sBerryBlenderData->field_88) { sBerryBlenderData->field_0++; - sBerryBlenderData->field_54 = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; } else sBerryBlenderData->field_0--; @@ -893,7 +874,329 @@ void sub_804E9F8(void) } break; case 14: + REG_DISPCNT |= 0x400; + sBerryBlenderData->arrowPos += 0x200; + sBerryBlenderData->field_142 += 4; + if (sBerryBlenderData->field_142 > 255) + { + sBerryBlenderData->field_0++; + sBerryBlenderData->field_142 = 256; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]]; + REG_BG2CNT = 0x4882; + sBerryBlenderData->field_130 = 0; + sub_804F238(); + sub_804F2A8(); + } + sub_8051414(&sBerryBlenderData->field_168); + break; + case 15: + if (sub_8051B8C()) + { + sBerryBlenderData->field_130 = 0; + sBerryBlenderData->field_0++; + } + sub_8051414(&sBerryBlenderData->field_168); + break; + case 16: + CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); + sBerryBlenderData->field_0++; + break; + case 18: + sBerryBlenderData->field_0++; + break; + case 19: + sub_80084A4(); + sBerryBlenderData->field_0++; + break; + case 20: + if (sub_8007ECC()) + { + sub_8007E24(); + sBerryBlenderData->field_0++; + } + break; + case 21: + sBerryBlenderData->hitPitch = 128; + sBerryBlenderData->field_12C = 0; + SetMainCallback2(sub_80501FC); + if (GetCurrentMapMusic() != 403) + { + sBerryBlenderData->field_178 = GetCurrentMapMusic(); + } + PlayBGM(403); + break; + case 100: + MenuDrawTextWindow(0, 13, 29, 19); + MenuPrintMessage(gOtherText_LinkNotFound, 1, 15); + sBerryBlenderData->field_0++; + break; + case 101: + if (MenuUpdateWindowText()) + sBerryBlenderData->field_0++; + break; + case 102: + if (!gPaletteFade.active) + SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); + break; + } + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_804F0F4(void) +{ + REG_DISPCNT = 0; + + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + + SetVBlankCallback(VBlankCB0_BerryBlender); + + SetUpWindowConfig(&gWindowConfig_81E6F68); + InitMenuWindow(&gWindowConfig_81E6F68); + + gLinkType = 0x4422; + + sBerryBlenderData->field_4E = 0; + sBerryBlenderData->hitPitch = 0; + sBerryBlenderData->arrowPos = 0; + sBerryBlenderData->field_5A = 0; + sBerryBlenderData->field_144 = 0; + sBerryBlenderData->field_146 = 0; + sBerryBlenderData->field_0++; +} + +extern const u8 gUnknown_08216303[]; + +u8 sub_804F16C(u16 arrowPos, u8 a1) +{ + u32 var1 = (arrowPos / 256) + 24; + u8 arrID = sBerryBlenderData->field_A2[a1]; + u32 var2 = gUnknown_08216303[arrID]; + + if (var1 >= var2 && var1 < var2 + 48) + { + if (var1 >= var2 + 20 && var1 < var2 + 28) + return 2; + else + return 1; + } + else + return 0; +} + +extern const u8 gUnknown_082165BC[][3]; + +void sub_804F1BC(u16 itemID, u8 a1, struct BlenderBerry* berry) +{ + u16 r4 = 0; + u16 i; + if (itemID == ITEM_ENIGMA_BERRY) + { + for (i = 0; i < 5; i++) + { + if (berry->flavours[r4] > berry->flavours[i]) + r4 = i; + } + r4 += 5; + } + else + { + r4 = itemID - 133; + if (r4 >= 5) + r4 = (r4 % 5) + 5; + } + for (i = 0; i < a1 - 1; i++) + { + sub_80516C4(i + 1, gUnknown_082165BC[r4][i] + 133); + } +} + +void sub_804F238(void) +{ + s32 i, j; + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->field_A2[i] = 0xFF; + sBerryBlenderData->field_9A[i] = gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]; + } + for (j = 0; j < BLENDER_MAX_PLAYERS; j++) + { + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + if (sBerryBlenderData->field_9A[i] == j) + sBerryBlenderData->field_A2[j] = i; + } + } +} + +extern const u8 gUnknown_082162C4[]; +extern const u8 gUnknown_082162D4[][2]; + +void sub_804F2A8(void) +{ + int i; + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + if (sBerryBlenderData->field_9A[i] != 0xFF) + { + u8* stringPtr = gStringVar1; + + sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[i]] = sBerryBlenderData->SyncArrowSprite2ID[i]; + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[i]]], i); + if (GetMultiplayerId() == sBerryBlenderData->field_9A[i]) + stringPtr = StringCopy(stringPtr, gUnknown_082162C4); + StringCopy(stringPtr, gLinkPlayers[sBerryBlenderData->field_9A[i]].name); + MenuPrint_PixelCoords(gStringVar1, gUnknown_082162D4[i][0] * 8 + 1, gUnknown_082162D4[i][1] * 8, 1); + } + } +} + +extern const TaskFunc gUnknown_08216308[]; + +void sub_804F378(void) +{ + s32 i, j; + switch (sBerryBlenderData->field_0) + { + case 0: + sub_804F0F4(); + sub_80516C4(0, gScriptItemId); + Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); + sub_804F1BC(gScriptItemId, sBerryBlenderData->field_88, &sBerryBlenderData->blendedBerries[0]); + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->field_70[i] = 0; + for (j = 0; j < 3; j++) + { + sBerryBlenderData->field_14C[i][j] = 0; + } + } + sBerryBlenderData->field_7C = 0; + sBerryBlenderData->field_1 = 0; + break; + case 1: + if (sub_804E2EC()) + { + sBerryBlenderData->field_0++; + sub_8051474(); + } + break; + case 2: + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + sBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); + } + sBerryBlenderData->field_0++; + break; + case 3: + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + sBerryBlenderData->field_0++; + sBerryBlenderData->field_130 = 0; + break; + case 4: + if (++sBerryBlenderData->field_130 == 2) + sub_804E4FC(); + if (!gPaletteFade.active) + sBerryBlenderData->field_0 = 8; + break; + case 8: + sBerryBlenderData->field_0 = 11; + sBerryBlenderData->field_13C = 0; + break; + case 11: + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + u32 var = gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]; + if (sBerryBlenderData->field_13C == var) + { + sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_13C], i); + break; + } + } + sBerryBlenderData->field_130 = 0; + sBerryBlenderData->field_0++; + sBerryBlenderData->field_13C++; + break; + case 12: + if (++sBerryBlenderData->field_130 > 60) + { + if (sBerryBlenderData->field_13C >= sBerryBlenderData->field_88) + { + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; + sBerryBlenderData->field_0++; + } + else + sBerryBlenderData->field_0--; + sBerryBlenderData->field_130 = 0; + } + break; + case 13: + sBerryBlenderData->field_0++; + sub_804F238(); + PlaySE(43); + sub_8051414(&sBerryBlenderData->field_168); + break; + case 14: + REG_DISPCNT |= 0x400; + sBerryBlenderData->arrowPos += 0x200; + sBerryBlenderData->field_142 += 4; + if (sBerryBlenderData->field_142 > 255) + { + sBerryBlenderData->field_0++; + sBerryBlenderData->field_142 = 256; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]]; + REG_BG2CNT = 0x4882; + sBerryBlenderData->field_130 = 0; + PlaySE(52); + sub_804F2A8(); + } + sub_8051414(&sBerryBlenderData->field_168); + break; + case 15: + if (sub_8051B8C()) + { + sBerryBlenderData->field_0++; + } + sub_8051414(&sBerryBlenderData->field_168); + break; + case 16: + CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); + sBerryBlenderData->field_0++; + break; + case 18: + sBerryBlenderData->field_0++; + break; + case 19: + sBerryBlenderData->field_0++; + break; + case 20: + sBerryBlenderData->field_0++; + break; + case 21: + sub_804F81C(); + sBerryBlenderData->hitPitch = 128; + sBerryBlenderData->field_12C = 0; + sBerryBlenderData->field_14B = 0; + sBerryBlenderData->field_7E = 0; + SetMainCallback2(sub_80501FC); + for (i = 0; i < gSpecialVar_0x8004; i++) + { + sBerryBlenderData->field_148[i] = CreateTask(gUnknown_08216308[i], 10 + i); + } + + if (GetCurrentMapMusic() != 403) + { + sBerryBlenderData->field_178 = GetCurrentMapMusic(); + } + PlayBGM(403); + PlaySE(53); + Blender_ControlHitPitch(); break; } RunTasks(); @@ -901,3 +1204,172 @@ void sub_804E9F8(void) BuildOamBuffer(); UpdatePaletteFade(); } + +void sub_804F81C(void) +{ + s32 i; + for (i = 0; i < 4; i++) + { + gSendCmd[0] = 0; + gSendCmd[2] = 0; + gRecvCmds[0][i] = 0; + gRecvCmds[2][i] = 0; + } +} + +void sub_804F844(u8 taskID) +{ + if(++gTasks[taskID].data[0] > gTasks[taskID].data[1]) + { + gRecvCmds[2][gTasks[taskID].data[2]] = 0x2345; + DestroyTask(taskID); + } +} + +void sub_804F890(u8 a0, u8 a1) +{ + u8 taskID = CreateTask(sub_804F844, 80); + gTasks[taskID].data[1] = a1; + gTasks[taskID].data[2] = a0; +} + +void sub_804F8C8(u8 taskID) +{ + if (sub_804F16C(sBerryBlenderData->arrowPos, 1) == 2) + { + if (gTasks[taskID].data[0] == 0) + { + if (sBerryBlenderData->field_14B == 0) + { + u8 rand = Random() / 655; + if (sBerryBlenderData->hitPitch < 500) + { + if (rand > 75) + gRecvCmds[2][1] = 0x4523; + else + gRecvCmds[2][1] = 0x5432; + gRecvCmds[2][1] = 0x5432; // ??? + } + else if (sBerryBlenderData->hitPitch < 1500) + { + if (rand > 80) + gRecvCmds[2][1] = 0x4523; + else + { + u8 value = rand - 21; + if (value < 60) + gRecvCmds[2][1] = 0x5432; + else if (rand < 10) + sub_804F890(1, 5); + } + } + else if (rand <= 90) + { + u8 value = rand - 71; + if (value < 20) + gRecvCmds[2][1] = 0x5432; + else if (rand < 30) + sub_804F890(1, 5); + } + else + gRecvCmds[2][1] = 0x4523; + } + else + gRecvCmds[2][1] = 0x4523; + + gTasks[taskID].data[0] = 1; + } + } + else + gTasks[taskID].data[0] = 0; +} + +void sub_804F9F4(u8 taskID) +{ + u32 var1 = (sBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; + u32 var2 = sBerryBlenderData->field_A2[2] & 0xFF; + if ((var1 >> 8) > gUnknown_08216303[var2] + 20 && (var1 >> 8) < gUnknown_08216303[var2] + 40) + { + if (gTasks[taskID].data[0] == 0) + { + if (sBerryBlenderData->field_14B == 0) + { + u8 rand = Random() / 655; + if (sBerryBlenderData->hitPitch < 500) + { + if (rand > 66) + gRecvCmds[2][2] = 0x4523; + else + gRecvCmds[2][2] = 0x5432; + } + else + { + u8 value; + if (rand > 65) + gRecvCmds[2][2] = 0x4523; + value = rand - 41; + if (value < 25) + gRecvCmds[2][2] = 0x5432; + if (rand < 10) + sub_804F890(2, 5); + } + + gTasks[taskID].data[0] = 1; + } + else + { + gRecvCmds[2][2] = 0x4523; + gTasks[taskID].data[0] = 1; + } + } + } + else + gTasks[taskID].data[0] = 0; +} + +void sub_804FB1C(u8 taskID) +{ + u32 var1, var2; + + #ifndef FAKEMATCHING + asm("":::"r6"); + #endif // FAKEMATCHING + + var1 = (sBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; + var2 = sBerryBlenderData->field_A2[3] & 0xFF; + if ((var1 >> 8) > gUnknown_08216303[var2] + 20 && (var1 >> 8) < gUnknown_08216303[var2] + 40) + { + if (gTasks[taskID].data[0] == 0) + { + if (sBerryBlenderData->field_14B == 0) + { + u8 rand = (Random() / 655); + if (sBerryBlenderData->hitPitch < 500) + { + if (rand > 88) + gRecvCmds[2][3] = 0x4523; + else + gRecvCmds[2][3] = 0x5432; + } + else + { + u8 value; + if (rand > 60) + gRecvCmds[2][3] = 0x4523; + else if ((value = rand - 56) < 5) + gRecvCmds[2][3] = 0x5432; + if (rand < 5) + sub_804F890(3, 5); + } + gTasks[taskID].data[0] = 1; + } + else + { + gRecvCmds[2][3] = 0x4523; + gTasks[taskID].data[0] = 1; + } + } + } + else + gTasks[taskID].data[0] = 0; +} -- cgit v1.2.3 From f72d61c18c8e1d476c305bee4fded8923ff1278e Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 7 Aug 2017 17:39:49 +0200 Subject: more stuff done --- src/berry_blender.c | 124 ++++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 105 insertions(+), 19 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index 47aebf513..62264f76e 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -148,7 +148,7 @@ struct BerryBlenderData u8 field_52; u8 field_53; u16 arrowPos; - s16 hitPitch; //56 + s16 field_56; u8 field_58; u8 field_59; u16 field_5A; @@ -337,8 +337,8 @@ struct BerryBlenderData u16 field_13E; u16 field_140; u16 field_142; - u16 field_144; - u16 field_146; + s16 field_144; + s16 field_146; u8 field_148[3]; u8 field_14B; u16 field_14C[BLENDER_MAX_PLAYERS][3]; @@ -388,10 +388,13 @@ bool8 sub_8051B8C(void); void sub_80516C4(u8 a0, u16 itemID); void sub_804F2A8(void); void sub_804F81C(void); +void sub_805156C(void); +void sub_8051684(struct Sprite* sprite); +void sub_8051AC8(s16* a0, u16 a1); void Blender_ControlHitPitch(void) { - m4aMPlayPitchControl(&gMPlay_SE2, 0xFFFF, (sBerryBlenderData->hitPitch - 128) * 2); + m4aMPlayPitchControl(&gMPlay_SE2, 0xFFFF, (sBerryBlenderData->field_56 - 128) * 2); } void VBlankCB0_BerryBlender(void) @@ -769,7 +772,7 @@ void sub_804E9F8(void) } } sBerryBlenderData->field_7C = 0; - sBerryBlenderData->hitPitch = 0; + sBerryBlenderData->field_56 = 0; sBerryBlenderData->arrowPos = 0; sBerryBlenderData->field_5A = 0; sBerryBlenderData->field_1 = 0; @@ -916,7 +919,7 @@ void sub_804E9F8(void) } break; case 21: - sBerryBlenderData->hitPitch = 128; + sBerryBlenderData->field_56 = 128; sBerryBlenderData->field_12C = 0; SetMainCallback2(sub_80501FC); if (GetCurrentMapMusic() != 403) @@ -961,7 +964,7 @@ void sub_804F0F4(void) gLinkType = 0x4422; sBerryBlenderData->field_4E = 0; - sBerryBlenderData->hitPitch = 0; + sBerryBlenderData->field_56 = 0; sBerryBlenderData->arrowPos = 0; sBerryBlenderData->field_5A = 0; sBerryBlenderData->field_144 = 0; @@ -1179,7 +1182,7 @@ void sub_804F378(void) break; case 21: sub_804F81C(); - sBerryBlenderData->hitPitch = 128; + sBerryBlenderData->field_56 = 128; sBerryBlenderData->field_12C = 0; sBerryBlenderData->field_14B = 0; sBerryBlenderData->field_7E = 0; @@ -1242,7 +1245,7 @@ void sub_804F8C8(u8 taskID) if (sBerryBlenderData->field_14B == 0) { u8 rand = Random() / 655; - if (sBerryBlenderData->hitPitch < 500) + if (sBerryBlenderData->field_56 < 500) { if (rand > 75) gRecvCmds[2][1] = 0x4523; @@ -1250,7 +1253,7 @@ void sub_804F8C8(u8 taskID) gRecvCmds[2][1] = 0x5432; gRecvCmds[2][1] = 0x5432; // ??? } - else if (sBerryBlenderData->hitPitch < 1500) + else if (sBerryBlenderData->field_56 < 1500) { if (rand > 80) gRecvCmds[2][1] = 0x4523; @@ -1295,7 +1298,7 @@ void sub_804F9F4(u8 taskID) if (sBerryBlenderData->field_14B == 0) { u8 rand = Random() / 655; - if (sBerryBlenderData->hitPitch < 500) + if (sBerryBlenderData->field_56 < 500) { if (rand > 66) gRecvCmds[2][2] = 0x4523; @@ -1331,10 +1334,6 @@ void sub_804FB1C(u8 taskID) { u32 var1, var2; - #ifndef FAKEMATCHING - asm("":::"r6"); - #endif // FAKEMATCHING - var1 = (sBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; var2 = sBerryBlenderData->field_A2[3] & 0xFF; if ((var1 >> 8) > gUnknown_08216303[var2] + 20 && (var1 >> 8) < gUnknown_08216303[var2] + 40) @@ -1344,7 +1343,7 @@ void sub_804FB1C(u8 taskID) if (sBerryBlenderData->field_14B == 0) { u8 rand = (Random() / 655); - if (sBerryBlenderData->hitPitch < 500) + if (sBerryBlenderData->field_56 < 500) { if (rand > 88) gRecvCmds[2][3] = 0x4523; @@ -1353,11 +1352,15 @@ void sub_804FB1C(u8 taskID) } else { - u8 value; if (rand > 60) gRecvCmds[2][3] = 0x4523; - else if ((value = rand - 56) < 5) - gRecvCmds[2][3] = 0x5432; + else + { + s8 value = rand - 56; // makes me wonder what the original code was + u8 value2 = value; + if (value2 < 5) + gRecvCmds[2][3] = 0x5432; + } if (rand < 5) sub_804F890(3, 5); } @@ -1373,3 +1376,86 @@ void sub_804FB1C(u8 taskID) else gTasks[taskID].data[0] = 0; } + +extern const s8 gUnknown_082162CC[][2]; +extern const struct SpriteTemplate gSpriteTemplate_821645C; + +void sub_804FC48(u16 a0, u8 a1) +{ + u8 spriteID; + + spriteID = CreateSprite(&gSpriteTemplate_821645C, + sBlenderSyncArrowsPos[a1][0] - (10 * gUnknown_082162CC[a1][0]), + sBlenderSyncArrowsPos[a1][1] - (10 * gUnknown_082162CC[a1][1]), + 1); + if (a0 == 0x4523) + { + StartSpriteAnim(&gSprites[spriteID], 2); + gSprites[spriteID].callback = sub_8051684; + PlaySE(40); + } + else if (a0 == 0x5432) + { + StartSpriteAnim(&gSprites[spriteID], 0); + PlaySE(31); + } + else if (a0 == 0x2345) + { + StartSpriteAnim(&gSprites[spriteID], 1); + PlaySE(32); + } + sub_805156C(); +} + +extern const u8 gUnknown_082165DA[]; + +void sub_804FD30(u16 a0) +{ + Blender_ControlHitPitch(); + switch (a0) + { + case 0x4523: + if (sBerryBlenderData->field_56 < 1500) + sBerryBlenderData->field_56 += (384 / gUnknown_082165DA[sBerryBlenderData->field_88]); + else + { + sBerryBlenderData->field_56 += (128 / gUnknown_082165DA[sBerryBlenderData->field_88]); + sub_8051AC8(&sBerryBlenderData->field_144, (sBerryBlenderData->field_56 / 100) - 10); + sub_8051AC8(&sBerryBlenderData->field_146, (sBerryBlenderData->field_56 / 100) - 10); + } + break; + case 0x5432: + if (sBerryBlenderData->field_56 < 1500) + sBerryBlenderData->field_56 += (256 / gUnknown_082165DA[sBerryBlenderData->field_88]); + break; + case 0x2345: + sBerryBlenderData->field_56 -= (256 / gUnknown_082165DA[sBerryBlenderData->field_88]); + if (sBerryBlenderData->field_56 < 128) + sBerryBlenderData->field_56 = 128; + break; + } +} + +void sub_804FE70(void) +{ + s32 i; + + if (gSpecialVar_0x8004 != 0) + { + if (gSendCmd[2] != 0) + { + gRecvCmds[2][0] = 0; + gRecvCmds[0][0] = 0x4444; + gSendCmd[2] = 0; + } + for (i = 0; i < 3; i++) + { + if (gRecvCmds[2][i] != 0) + gRecvCmds[0][i] = 0x4444; + } + } + for (i = 0; i < gUnknown_082165DA[sBerryBlenderData->field_88]; i++) + { + if (gRecvCmds[0]) + } +} -- cgit v1.2.3 From c1d160c31d1be9c756b6666b4dfc97d7b1845b0f Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 9 Aug 2017 22:45:59 +0200 Subject: more stuff, a troublesome function --- src/berry_blender.c | 351 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 344 insertions(+), 7 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index 62264f76e..ce2f3db20 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -43,6 +43,7 @@ struct MusicPlayerInfo // other files functions void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch); +void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo); void sub_80A6978(void); u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); @@ -56,7 +57,7 @@ u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); struct BlenderBerry { - u16 field_0; + u16 itemID; u8 name[7]; u8 flavours[5]; u8 smoothness; @@ -371,7 +372,9 @@ struct BerryBlenderData extern struct BerryBlenderData* sBerryBlenderData; extern struct MusicPlayerInfo gMPlay_SE2; +extern struct MusicPlayerInfo gMPlay_BGM; extern u8 ewram[]; +extern s16 gUnknown_03000520[]; // this file's functions: void sub_80514A4(void); @@ -391,6 +394,11 @@ void sub_804F81C(void); void sub_805156C(void); void sub_8051684(struct Sprite* sprite); void sub_8051AC8(s16* a0, u16 a1); +void sub_805194C(u16 a0, u16 a1); +void sub_8051A3C(u16 a0); +void sub_8051B18(void); +void sub_805123C(void); +void sub_8050954(void); void Blender_ControlHitPitch(void) { @@ -669,7 +677,7 @@ void sub_804E7C0(u16 a0, u8 a1) void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) { const struct Berry *berryInfo = GetBerryInfo(itemID + 124); - berry->field_0 = itemID; + berry->itemID = itemID; StringCopy(berry->name, berryInfo->name); berry->flavours[FLAVOUR_SPICY] = berryInfo->spicy; berry->flavours[FLAVOUR_DRY] = berryInfo->dry; @@ -835,7 +843,7 @@ void sub_804E9F8(void) for (i = 0; i < GetLinkPlayerCount(); i++) { memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][0], sizeof(struct BlenderBerry)); - sBerryBlenderData->field_80[i] = sBerryBlenderData->blendedBerries[i].field_0; + sBerryBlenderData->field_80[i] = sBerryBlenderData->blendedBerries[i].itemID; } ResetBlockReceivedFlags(); sBerryBlenderData->field_0++; @@ -1444,18 +1452,347 @@ void sub_804FE70(void) { if (gSendCmd[2] != 0) { - gRecvCmds[2][0] = 0; + gRecvCmds[2][0] = gSendCmd[2]; gRecvCmds[0][0] = 0x4444; gSendCmd[2] = 0; } - for (i = 0; i < 3; i++) + for (i = 1; i < 4; i++) { if (gRecvCmds[2][i] != 0) gRecvCmds[0][i] = 0x4444; } } - for (i = 0; i < gUnknown_082165DA[sBerryBlenderData->field_88]; i++) + for (i = 0; i < sBerryBlenderData->field_88; i++) { - if (gRecvCmds[0]) + if (gRecvCmds[0][i] == 0x4444) + { + u32 var = sBerryBlenderData->field_A2[i]; + if (gRecvCmds[2][i] == 0x4523) + { + sub_804FD30(0x4523); + sBerryBlenderData->field_13E += (sBerryBlenderData->field_56 / 55); + if (sBerryBlenderData->field_13E >= 1000) + sBerryBlenderData->field_13E = 1000; + sub_804FC48(0x4523, var); + sBerryBlenderData->field_14C[i][0]++; + } + else if (gRecvCmds[2][i] == 0x5432) + { + sub_804FD30(0x5432); + sBerryBlenderData->field_13E += (sBerryBlenderData->field_56 / 70); + sub_804FC48(0x5432, var); + sBerryBlenderData->field_14C[i][1]++; + } + else if (gRecvCmds[2][i] == 0x2345) + { + sub_804FC48(0x2345, var); + sub_804FD30(0x2345); + if (sBerryBlenderData->field_15 > 1000) + sBerryBlenderData->field_13E = 1000; + if (sBerryBlenderData->field_14C[i][2] < 999) + sBerryBlenderData->field_14C[i][2]++; + } + if (gRecvCmds[2][i] == 0x2345 || gRecvCmds[2][i] == 0x4523 || gRecvCmds[2][i] == 0x5432) + { + if (sBerryBlenderData->field_56 > 1500) + m4aMPlayTempoControl(&gMPlay_BGM, ((sBerryBlenderData->field_56 - 750) / 20) + 256); + else + m4aMPlayTempoControl(&gMPlay_BGM, 256); + } + } + } + if (gSpecialVar_0x8004 != 0) + { + for (i = 0; i < sBerryBlenderData->field_88; i++) + { + gRecvCmds[0][i] = 0; + gRecvCmds[2][i] = 0; + } + } +} + +extern u8 gUnknown_020297ED; + +void sub_80500A8(void) +{ + bool8 A_pressed = 0; + u8 var2 = sBerryBlenderData->field_A2[GetMultiplayerId()]; + if (sBerryBlenderData->field_6F == 0) + { + if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A && gMain.newKeys & A_BUTTON) + A_pressed = ((gMain.heldKeysRaw & (A_BUTTON | L_BUTTON)) != (A_BUTTON | L_BUTTON)); + else if (gMain.newKeys & A_BUTTON) + A_pressed = 1; + if (A_pressed) + { + u8 var3; + StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[var2]]], var2 + 4); + var3 = sub_804F16C(sBerryBlenderData->arrowPos, GetMultiplayerId()); + if (var3 == 2) + gSendCmd[2] = 0x4523; + else if (var3 == 1) + gSendCmd[2] = 0x5432; + else + gSendCmd[2] = 0x2345; + } + } + if (++sBerryBlenderData->field_7E > 5) + { + if (sBerryBlenderData->field_56 > 128) + sBerryBlenderData->field_56--; + sBerryBlenderData->field_7E = 0; + } + if (gUnknown_020297ED && gMain.newKeys & L_BUTTON) + sBerryBlenderData->field_14B ^= 1; +} + +void sub_80501FC(void) +{ + sub_8051474(); + if (sBerryBlenderData->field_12C < 359940) + sBerryBlenderData->field_12C++; + sub_80500A8(); + SetLinkDebugValues((u16)(sBerryBlenderData->field_56), sBerryBlenderData->field_13E); + sub_804FE70(); + sub_805194C(sBerryBlenderData->field_13E, 1000); + sub_8051A3C(sBerryBlenderData->field_56); + sub_8051B18(); + sub_805123C(); + if (sBerryBlenderData->field_6F == 0 && sBerryBlenderData->field_140 >= 1000) + { + sBerryBlenderData->field_13E = 1000; + sBerryBlenderData->field_6F = 1; + SetMainCallback2(sub_8050954); + } + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +#define ARE_FLAVOURS_SAME(flavours1, flavours2)(((*(u32*)(&flavours1[-1]) & 0xFFFFFF00) == (*(u32*)(&flavours2[-1]) & 0xFFFFFF00)&& (*(u32*)(&flavours1[3]) & 0xFFFFFF) == (*(u32*)(&flavours2[3]) & 0xFFFFFF))) + +bool8 sub_80502A4(struct BlenderBerry* berries, u8 index1, u8 index2) +{ + if (berries[index1].itemID != berries[index2].itemID + || (StringCompare(berries[index1].name, berries[index2].name) == 0 + && ARE_FLAVOURS_SAME(berries[index1].flavours, berries[index2].flavours))) + return 1; + else + return 0; +} + +#undef ARE_FLAVOURS_SAME + +u32 sub_80502F8(struct BlenderBerry* berries, s16* a1, u8 a2, u8 a3) +{ + s16 vars[5]; + s32 i; + s32 r6; + u8 r2; + + for (i = 0; i <= 5; i++) // bug, writing one index too far + vars[i] = a1[i]; + r6 = 0; + for (i = 0; i < 5; i++) + { + if (vars[i] == 0) + r6++; + } + if (r6 == 5 || a3 > 3) + return 12; + for (i = 0; i < a2; i++) + { + for (r6 = 0; r6 < a2; r6++) + { + if (berries[i].itemID == berries[r6].itemID && i != r6 + && (berries[i].itemID != ITEM_ENIGMA_BERRY || sub_80502A4(berries, i, r6))) + return 12; + } + } + r2 = 0; + for (r2 = 0, i = 0; i < 5; i++) + { + if (vars[i] > 0) + r2++; + } + if (r2 > 3) + return 13; + if (r2 == 3) + return 11; + for (i = 0; i < 5; i++) + { + if (vars[i] > 50) + return 14; + } + if (r2 == 1 && vars[0] > 0) + return 1; + if (r2 == 1 && vars[1] > 0) + return 2; + if (r2 == 1 && vars[2] > 0) + return 3; + if (r2 == 1 && vars[3] > 0) + return 4; + if (r2 == 1 && vars[4] > 0) + return 5; + if (r2 == 2) + { + s32 var = 0; + for (i = 0; i < 5; i++) + { + if (vars[i] > 0) + gUnknown_03000520[var++] = i; + } + if (vars[gUnknown_03000520[0]] >= vars[gUnknown_03000520[1]]) + { + if (gUnknown_03000520[0] == 0) + return (gUnknown_03000520[1] << 16) | 6; + if (gUnknown_03000520[0] == 1) + return (gUnknown_03000520[1] << 16) | 7; + if (gUnknown_03000520[0] == 2) + return (gUnknown_03000520[1] << 16) | 8; + if (gUnknown_03000520[0] == 3) + return (gUnknown_03000520[1] << 16) | 9; + if (gUnknown_03000520[0] == 4) + return (gUnknown_03000520[1] << 16) | 10; + } + else + { + if (gUnknown_03000520[1] == 0) + return (gUnknown_03000520[0] << 16) | 6; + if (gUnknown_03000520[1] == 1) + return (gUnknown_03000520[0] << 16) | 7; + if (gUnknown_03000520[1] == 2) + return (gUnknown_03000520[0] << 16) | 8; + if (gUnknown_03000520[1] == 3) + return (gUnknown_03000520[0] << 16) | 9; + if (gUnknown_03000520[1] == 4) + return (gUnknown_03000520[0] << 16) | 10; + } + } + return 0; +} + +extern s16 gUnknown_0300052C; +extern s16 gUnknown_0300052E; + +void sub_80504F0(s16 value) +{ + gUnknown_0300052C = value; +} + +s16 unref_sub_80504FC(void) +{ + return gUnknown_0300052C; +} + +void sub_8050508(s16 value) +{ + gUnknown_0300052E = value; +} + +s16 unref_sub_8050514(void) +{ + return gUnknown_0300052E; +} + +extern s16 gUnknown_03000510[6]; +extern s32 gUnknown_03000530[]; +extern s32 gUnknown_03000548[]; +extern u32 gUnknown_0300055C; + +extern const u8 gUnknown_082165DF[]; + +void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) +{ + s32 i, j; + + s32 var5, var6; + + for (i = 0; i < 6; i++) + gUnknown_03000510[i] = 0; + for (i = 0; i < a2; i++) + { + for (j = 0; j < 5; j++) + gUnknown_03000510[j] += berries[i].flavours[j]; + } + + var5 = gUnknown_03000510[0]; + gUnknown_03000510[0] -= gUnknown_03000510[1]; + gUnknown_03000510[1] -= gUnknown_03000510[2]; + gUnknown_03000510[2] -= gUnknown_03000510[3]; + gUnknown_03000510[3] -= gUnknown_03000510[4]; + gUnknown_03000510[4] -= var5; + + var6 = 0; + for (i = 0; i < 6; i++) + { + if (gUnknown_03000510[i] < 0) + { + gUnknown_03000510[i] = 0; + var6++; + } + } + for (i = 0; i < 6; i++) + { + if (gUnknown_03000510[i] > 0) + { + if (gUnknown_03000510[i] < var6) + gUnknown_03000510[i] = 0; + else + gUnknown_03000510[i] -= var6; + } + } + for (i = 0; i < 6; i++) + { + gUnknown_03000530[i] = gUnknown_03000510[i]; + } + + gUnknown_0300055C = ((a4 / 333) + 100); + + for (i = 0; i < 5; i++) + { + s32 var4; + s32 var3 = gUnknown_03000510[i]; + var3 = (((a4 / 333) + 100) * var3) / 10; + var4 = var3 % 10; + var3 /= 10; + if (var4 > 4) + var3++; + gUnknown_03000510[i] = var3; + } + for (i = 0; i < 5; i++) + { + gUnknown_03000548[i] = gUnknown_03000510[i]; + } + *a1 = sub_80502F8(berries, &gUnknown_03000510[0], a2, var6); + gUnknown_03000510[5] = (gUnknown_03000510[5] / a2) - a2; + if (gUnknown_03000510[5] > 0) + gUnknown_03000510[5] = 0; + if (*a1 == 12) + { + u16 rand = Random() % 10; + for (i = 0; i < 6; i++) + { + if ((gUnknown_082165DF[rand] >> i) & 1) + gUnknown_03000510[i] = 2; + else + gUnknown_03000510[i] = 0; + } + } + for (i = 0; i < 6; i++) + { + if (gUnknown_03000510[i] > 255) + gUnknown_03000510[i] = 255; + } + a1[1] = gUnknown_03000510[0]; + a1[2] = gUnknown_03000510[1]; + a1[3] = gUnknown_03000510[2]; + a1[4] = gUnknown_03000510[3]; + a1[5] = gUnknown_03000510[4]; + a1[6] = gUnknown_03000510[5]; + for (i = 0; i < 6; i++) + { + a3[i] = gUnknown_03000510[i]; } } -- cgit v1.2.3 From a50ec1ee05ff46ea8335b982ac501bc9917ec289 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Fri, 11 Aug 2017 16:06:12 -0500 Subject: decompile sub_813265C - sub_81330E8 --- src/learn_move.c | 556 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 556 insertions(+) create mode 100644 src/learn_move.c (limited to 'src') diff --git a/src/learn_move.c b/src/learn_move.c new file mode 100644 index 000000000..fe14cebf6 --- /dev/null +++ b/src/learn_move.c @@ -0,0 +1,556 @@ +#include "global.h" +#include "data2.h" +#include "field_fadetransition.h" +#include "main.h" +#include "menu.h" +#include "menu_cursor.h" +#include "palette.h" +#include "pokemon.h" +#include "rom4.h" +#include "script.h" +#include "songs.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "strings2.h" +#include "task.h" + +struct UnknownStruct1 +{ + const u8 *unk0; + u8 unk4; + u8 unk5; + u8 unk6; +}; + +extern u8 ewram[]; +extern u16 gSpecialVar_0x8004; +extern u16 gSpecialVar_0x8005; +extern u8 gTileBuffer[]; + +extern const struct WindowConfig gWindowConfig_81E6CE4; +extern const struct WindowConfig gWindowConfig_81E7240; +extern const struct UnknownStruct1 gUnknown_08402D08[]; +extern const struct SpriteSheet gUnknown_08402D80; +extern const struct SpritePalette gUnknown_08402D88; + +extern void sub_809D9F0(struct Pokemon *, u8, u8, void *, u32); + +struct Struct2017000 +{ + u8 unk0; + u8 filler1[2]; + u8 unk3; + u8 unk4; + u8 unk5[16]; + u8 filler15[3]; + u8 unk18; + u8 filler19[0x1B-0x19]; + u8 unk1B; + u8 filler1C; + u8 unk1D; + u8 unk1E; + u8 filler1F; + u16 unk20[4]; + u8 filler28[0x2C3-0x28]; + u8 unk2C3; + u8 unk2C4; + u8 unk2C5; + u8 unk2C6; +}; + +extern struct Struct2017000 *gUnknown_030007B0; + +const u16 gDexArrows_Pal[] = INCBIN_U16("graphics/pokedex/arrows.gbapal"); + +const u8 gDexArrows_Gfx[] = INCBIN_U8("graphics/pokedex/arrows.4bpp"); + +const u8 gUnknown_08402CF8[][4] = +{ + { 0, 0, 9, 13}, + {10, 0, 29, 7}, + { 2, 14, 27, 19}, + {10, 8, 29, 13}, +}; + +const struct UnknownStruct1 gUnknown_08402D08[] = +{ + {OtherText_Battle, 1, 1, 0}, + {OtherText_Power, 1, 4, 1}, + {OtherText_Accuracy, 1, 9, 2}, + {NULL, 0, 0, 0}, + {OtherText_Contest, 1, 1, 0}, + {OtherText_Appeal, 1, 4, 1}, + {OtherText_Jam, 1, 9, 2}, + {NULL, 0, 0, 0}, +}; + +void sub_813269C(u8); +void sub_81326D8(void); +void sub_8132870(void); +void sub_8132908(void); +void sub_8132FEC(void); +void sub_8133030(u8); +u8 sub_81330E8(void); +void sub_8133140(u8); +u8 sub_8133248(void); +void sub_81332A0(void); +void sub_8133358(void); +void sub_8133558(void); +void sub_813362C(void); +void sub_8133800(void); +void sub_8133AEC(); +void sub_8133CA4(void); + +void sub_813265C(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +void sub_8132670(void) +{ + ScriptContext2_Enable(); + CreateTask(sub_813269C, 10); + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); +} + +void sub_813269C(u8 taskId) +{ + if (!gPaletteFade.active) + { + SetMainCallback2(sub_81326D8); + gFieldCallback = sub_8080990; + DestroyTask(taskId); + } +} + +void sub_81326D8(void) +{ + REG_DISPCNT = 0; + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + gUnknown_030007B0 = (struct Struct2017000 *)(ewram + 0x17000); + sub_81332A0(); + gUnknown_030007B0->unk2C5 = gSpecialVar_0x8004; + sub_8133558(); + SetVBlankCallback(sub_813265C); + + SetUpWindowConfig(&gWindowConfig_81E7240); + InitMenuWindow(&gWindowConfig_81E7240); + MenuZeroFillScreen(); + + SetUpWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); + MenuZeroFillScreen(); + + REG_BG0VOFS = 0; + REG_BG0VOFS = 0; // huh? + REG_BG1HOFS = 0; + REG_BG1HOFS = 0; // huh? + + LoadSpriteSheet(&gUnknown_08402D80); + LoadSpritePalette(&gUnknown_08402D88); + sub_8133358(); + FillPalette(0, 0, 2); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); + SetMainCallback2(sub_8132870); +} + +void sub_81327A4(void) +{ + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + gUnknown_030007B0 = (struct Struct2017000 *)(ewram + 0x17000); + sub_8133558(); + gUnknown_030007B0->unk2C6 = gSpecialVar_0x8005; + SetVBlankCallback(sub_813265C); + + SetUpWindowConfig(&gWindowConfig_81E7240); + InitMenuWindow(&gWindowConfig_81E7240); + MenuZeroFillScreen(); + + SetUpWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); + MenuZeroFillScreen(); + + REG_DISPCNT = 0x1340; + REG_BG0VOFS = 0; + REG_BG0HOFS = 0; + REG_BG1HOFS = 0; + REG_BG1HOFS = 0; // huh? + + LoadSpriteSheet(&gUnknown_08402D80); + LoadSpritePalette(&gUnknown_08402D88); + sub_8133358(); + FillPalette(0, 0, 2); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); + SetMainCallback2(sub_8132870); +} + +void sub_8132870(void) +{ + sub_8132908(); + if (gUnknown_030007B0->unk1D != 0) + { + gUnknown_030007B0->unk1D = 0; + sub_814AD7C(0x58, (gUnknown_030007B0->unk18 * 2 + 1) * 8); + } + if (gUnknown_030007B0->unk1E != 0) + { + gUnknown_030007B0->unk1E = 0; + sub_8133800(); + } + if (gUnknown_030007B0->unk2C3 != 0) + { + sub_8133AEC(gUnknown_030007B0->unk2C4, 1); + gUnknown_030007B0->unk2C3 = 0; + } + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_81328E8(const u8 *a) +{ + StringExpandPlaceholders(gStringVar4, a); + MenuPrintMessage(gStringVar4, 3, 15); +} + +void sub_8132908(void) +{ + switch (gUnknown_030007B0->unk0) + { + case 0: + gUnknown_030007B0->unk0++; + sub_8132FEC(); + sub_8133030(0); + sub_8133800(); + gSprites[1].pos1.x = 0x48; + gUnknown_030007B0->unk2C3 = 1; + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); + REG_DISPCNT = 0x1340; + break; + case 1: + if (!gPaletteFade.active) + gUnknown_030007B0->unk0 = 4; + break; + case 2: + gUnknown_030007B0->unk0++; + break; + case 3: + sub_8133030(0); + sub_8133800(); + gUnknown_030007B0->unk2C3 = 1; + gUnknown_030007B0->unk0++; + gSprites[1].pos1.x = 0x48; + break; + case 4: + if (sub_81330E8() == 0) + sub_813362C(); + return; + case 5: + sub_8133140(0); + sub_8133800(); + gUnknown_030007B0->unk2C3 = 1; + gSprites[1].pos1.x = 0x48; + gUnknown_030007B0->unk0++; + break; + case 6: + if (sub_8133248() == 0) + sub_813362C(); + break; + case 8: + if (MenuUpdateWindowText()) + { + DisplayYesNoMenu(21, 7, 1); + gUnknown_030007B0->unk0++; + } + break; + case 9: + { + s8 var = ProcessMenuInputNoWrap_(); + + if (var == 0) + { + sub_8133CA4(); + if (GiveMoveToMon(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]) != 0xFFFF) + { + sub_81328E8(gOtherText_PokeLearnedMove); + gSpecialVar_0x8004 = 1; + gUnknown_030007B0->unk0 = 31; + } + else + { + gUnknown_030007B0->unk0 = 16; + } + } + else if (var == -1 || var == 1) + { + sub_8133CA4(); + if (gUnknown_030007B0->unk2C4 == 0) + gUnknown_030007B0->unk0 = 3; + if (gUnknown_030007B0->unk2C4 == 1) + gUnknown_030007B0->unk0 = 5; + } + } + break; + case 12: + if (MenuUpdateWindowText()) + { + DisplayYesNoMenu(21, 7, 1); + gUnknown_030007B0->unk0++; + } + break; + case 13: + { + s8 r4 = ProcessMenuInputNoWrap_(); + + if (r4 == 0) + { + sub_8133CA4(); + gSpecialVar_0x8004 = r4; + gUnknown_030007B0->unk0 = 14; + } + else if (r4 == -1 || r4 == 1) + { + sub_8133CA4(); + if (gUnknown_030007B0->unk2C4 == 0) + gUnknown_030007B0->unk0 = 3; + if (gUnknown_030007B0->unk2C4 == 1) + gUnknown_030007B0->unk0 = 5; + } + } + break; + case 16: + sub_81328E8(gOtherText_DeleteOlderMove); + gUnknown_030007B0->unk0++; + break; + case 17: + if (MenuUpdateWindowText()) + { + DisplayYesNoMenu(21, 7, 1); + gUnknown_030007B0->unk0 = 18; + } + break; + case 18: + { + s8 var = ProcessMenuInputNoWrap_(); + + if (var == 0) + { + sub_8133CA4(); + sub_81328E8(gOtherText_WhichMoveToForget); + gUnknown_030007B0->unk0 = 19; + } + else if (var == -1 || var == 1) + { + sub_8133CA4(); + gUnknown_030007B0->unk0 = 24; + } + } + break; + case 24: + sub_81328E8(gOtherText_StopLearningMove); + gUnknown_030007B0->unk0++; + break; + case 25: + if (MenuUpdateWindowText()) + { + gUnknown_030007B0->unk0 = 26; + DisplayYesNoMenu(21, 7, 1); + } + break; + case 26: + { + s8 var = ProcessMenuInputNoWrap_(); + + if (var == 0) + { + sub_8133CA4(); + gUnknown_030007B0->unk0 = 27; + } + else if (var == -1 || var == 1) + { + sub_8133CA4(); + + // What's the point? It gets set to 16, anyway. + if (gUnknown_030007B0->unk2C4 == 0) + gUnknown_030007B0->unk0 = 3; + if (gUnknown_030007B0->unk2C4 == 1) + gUnknown_030007B0->unk0 = 5; + gUnknown_030007B0->unk0 = 16; + } + } + break; + case 27: + if (MenuUpdateWindowText()) + { + if (gUnknown_030007B0->unk2C4 == 0) + gUnknown_030007B0->unk0 = 3; + if (gUnknown_030007B0->unk2C4 == 1) + gUnknown_030007B0->unk0 = 5; + } + break; + case 19: + if (MenuUpdateWindowText()) + { + gUnknown_030007B0->unk0 = 20; + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); + } + break; + case 20: + if (!gPaletteFade.active) + { + sub_809D9F0(gPlayerParty, gUnknown_030007B0->unk2C5, gPlayerPartyCount - 1, sub_81327A4, gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]); + gUnknown_030007B0->unk0 = 28; + } + break; + case 21: + if (MenuUpdateWindowText()) + gUnknown_030007B0->unk0 = 14; + break; + case 22: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); + break; + case 14: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); + gUnknown_030007B0->unk0++; + break; + case 15: + if (!gPaletteFade.active) + SetMainCallback2(c2_exit_to_overworld_2_switch); + break; + case 28: + BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); + gUnknown_030007B0->unk0++; + sub_8132FEC(); + sub_8133800(); + if (gUnknown_030007B0->unk2C4 == 0) + sub_8133030(1); + if (gUnknown_030007B0->unk2C4 == 1) + { + gSprites[1].pos1.x = 0x48; + sub_8133140(1); + } + sub_8133AEC(gUnknown_030007B0->unk2C4, 1); + break; + case 29: + if (!gPaletteFade.active) + { + if (gUnknown_030007B0->unk2C6 == 4) + { + gUnknown_030007B0->unk0 = 24; + } + else + { + u16 moveId = GetMonData(&gPlayerParty[gUnknown_030007B0->unk2C5], MON_DATA_MOVE1 + gUnknown_030007B0->unk2C6); + + StringCopy(gStringVar3, gMoveNames[moveId]); + RemoveMonPPBonus(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk2C6); + SetMonMoveSlot(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B], gUnknown_030007B0->unk2C6); + StringCopy(gStringVar2, gMoveNames[gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]]); + sub_81328E8(gOtherText_ForgotMove123); + gUnknown_030007B0->unk0 = 30; + gSpecialVar_0x8004 = 1; + } + } + break; + case 30: + if (MenuUpdateWindowText()) + { +#ifdef ENGLISH + sub_81328E8(gOtherText_ForgotOrDidNotLearnMove); +#else + sub_81328E8(deuOtherText_ForgotAndLearned); +#endif + gUnknown_030007B0->unk0 = 31; + PlayFanfare(BGM_FANFA1); + } + break; + case 31: + if (MenuUpdateWindowText()) + { + PlayFanfare(BGM_FANFA1); + gUnknown_030007B0->unk0 = 32; + } + break; + case 32: + if (IsFanfareTaskInactive()) + gUnknown_030007B0->unk0 = 33; + break; + case 33: + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk0 = 14; + } + break; + } +} + +void sub_8132FEC(void) +{ + u32 i; + + BasicInitMenuWindow(&gWindowConfig_81E7240); + for (i = 0; i < 4; i++) + { + MenuDrawTextWindow( + gUnknown_08402CF8[i][0], + gUnknown_08402CF8[i][1], + gUnknown_08402CF8[i][2], + gUnknown_08402CF8[i][3]); + } + BasicInitMenuWindow(&gWindowConfig_81E6CE4); +} + +void sub_8133030(bool8 a) +{ + s32 i; + + gSprites[gUnknown_030007B0->unk3].invisible = FALSE; + gSprites[gUnknown_030007B0->unk4].invisible = FALSE; + for (i = 0; i < 16; i++) + { + // Hmm... + gSprites[*((u8 *)gUnknown_030007B0 + i + 7)].invisible = TRUE; + } + for (i = 0; gUnknown_08402D08[i].unk0 != NULL; i++) + { + sub_8072C74(gTileBuffer, gUnknown_08402D08[i].unk0, 64, 2); + MenuPrint(gTileBuffer, gUnknown_08402D08[i].unk4, gUnknown_08402D08[i].unk5); + } + if (!a) + { + sub_8072AB0(gOtherText_TeachWhichMove, 24, 120, 192, 32, 1); + } +} + +u8 sub_81330E8(void) +{ + u32 r4 = ((gMain.newKeys & 0x30) != 0); + + if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_LR + && (gMain.newKeys & 0x300)) + r4++; + + if (r4 != 0) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk0 = 5; + gUnknown_030007B0->unk2C4 = 1; + } + + return r4; +} -- cgit v1.2.3 From f3b6f3c2738a9a1d7e1167b4078355c59cce8074 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 12 Aug 2017 12:39:45 -0500 Subject: finish decompiling learn_move --- src/learn_move.c | 460 ++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 437 insertions(+), 23 deletions(-) (limited to 'src') diff --git a/src/learn_move.c b/src/learn_move.c index fe14cebf6..01a37fe70 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -12,8 +12,10 @@ #include "sound.h" #include "sprite.h" #include "string_util.h" +#include "strings.h" #include "strings2.h" #include "task.h" +#include "trig.h" struct UnknownStruct1 { @@ -30,7 +32,6 @@ extern u8 gTileBuffer[]; extern const struct WindowConfig gWindowConfig_81E6CE4; extern const struct WindowConfig gWindowConfig_81E7240; -extern const struct UnknownStruct1 gUnknown_08402D08[]; extern const struct SpriteSheet gUnknown_08402D80; extern const struct SpritePalette gUnknown_08402D88; @@ -39,20 +40,27 @@ extern void sub_809D9F0(struct Pokemon *, u8, u8, void *, u32); struct Struct2017000 { u8 unk0; - u8 filler1[2]; - u8 unk3; - u8 unk4; + u8 filler1; + u8 unk2; + u8 unk3[2]; + //u8 unk4; u8 unk5[16]; u8 filler15[3]; u8 unk18; - u8 filler19[0x1B-0x19]; + u8 unk19; + u8 unk1A; u8 unk1B; - u8 filler1C; + u8 unk1C; u8 unk1D; u8 unk1E; u8 filler1F; - u16 unk20[4]; - u8 filler28[0x2C3-0x28]; + //u16 unk20[4]; + //u8 filler28[0x2C3-0x28]; + u16 unk20[20]; + u8 filler48[0x52-0x48]; + //u8 unk52[0x2C3-0x52]; + u8 unk52[6][0x19]; + u8 fillerE8[0x2C3-0xE8]; u8 unk2C3; u8 unk2C4; u8 unk2C5; @@ -73,16 +81,20 @@ const u8 gUnknown_08402CF8[][4] = {10, 8, 29, 13}, }; -const struct UnknownStruct1 gUnknown_08402D08[] = +const struct UnknownStruct1 gUnknown_08402D08[][4] = { - {OtherText_Battle, 1, 1, 0}, - {OtherText_Power, 1, 4, 1}, - {OtherText_Accuracy, 1, 9, 2}, - {NULL, 0, 0, 0}, - {OtherText_Contest, 1, 1, 0}, - {OtherText_Appeal, 1, 4, 1}, - {OtherText_Jam, 1, 9, 2}, - {NULL, 0, 0, 0}, + { + {OtherText_Battle, 1, 1, 0}, + {OtherText_Power, 1, 4, 1}, + {OtherText_Accuracy, 1, 9, 2}, + {NULL, 0, 0, 0}, + }, + { + {OtherText_Contest, 1, 1, 0}, + {OtherText_Appeal, 1, 4, 1}, + {OtherText_Jam, 1, 9, 2}, + {NULL, 0, 0, 0}, + }, }; void sub_813269C(u8); @@ -99,7 +111,7 @@ void sub_8133358(void); void sub_8133558(void); void sub_813362C(void); void sub_8133800(void); -void sub_8133AEC(); +void sub_8133AEC(u8, int); void sub_8133CA4(void); void sub_813265C(void) @@ -519,17 +531,17 @@ void sub_8133030(bool8 a) { s32 i; - gSprites[gUnknown_030007B0->unk3].invisible = FALSE; - gSprites[gUnknown_030007B0->unk4].invisible = FALSE; + gSprites[gUnknown_030007B0->unk3[0]].invisible = FALSE; + gSprites[gUnknown_030007B0->unk3[1]].invisible = FALSE; for (i = 0; i < 16; i++) { // Hmm... gSprites[*((u8 *)gUnknown_030007B0 + i + 7)].invisible = TRUE; } - for (i = 0; gUnknown_08402D08[i].unk0 != NULL; i++) + for (i = 0; gUnknown_08402D08[0][i].unk0 != NULL; i++) { - sub_8072C74(gTileBuffer, gUnknown_08402D08[i].unk0, 64, 2); - MenuPrint(gTileBuffer, gUnknown_08402D08[i].unk4, gUnknown_08402D08[i].unk5); + sub_8072C74(gTileBuffer, gUnknown_08402D08[0][i].unk0, 64, 2); + MenuPrint(gTileBuffer, gUnknown_08402D08[0][i].unk4, gUnknown_08402D08[0][i].unk5); } if (!a) { @@ -554,3 +566,405 @@ u8 sub_81330E8(void) return r4; } + +void sub_8133140(bool8 a) +{ + s32 i; + + gSprites[gUnknown_030007B0->unk3[0]].invisible = FALSE; + gSprites[gUnknown_030007B0->unk3[1]].invisible = FALSE; + for (i = 0; i < 16; i++) + { + // Hmm... + gSprites[*((u8 *)gUnknown_030007B0 + i + 7)].invisible = FALSE; + } + for (i = 0; gUnknown_08402D08[0][i].unk0 != NULL; i++) + { + sub_8072C74(gTileBuffer, gUnknown_08402D08[1][i].unk0, 64, 2); + MenuPrint(gTileBuffer, gUnknown_08402D08[1][i].unk4, gUnknown_08402D08[1][i].unk5); + if (i != 0) + { + MenuZeroFillWindowRect( + gUnknown_08402D08[1][i].unk4, + gUnknown_08402D08[1][i].unk5 + 2, + gUnknown_08402D08[1][i].unk4 + 7, + gUnknown_08402D08[1][i].unk5 + 3); + } + } + if (!a) + sub_8072AB0(gOtherText_TeachWhichMove, 24, 120, 192, 32, 1); +} + +u8 sub_8133248(void) +{ + u32 r4 = ((gMain.newKeys & 0x30) != 0); + + if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_LR + && (gMain.newKeys & 0x300)) + r4++; + + if (r4 != 0) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk0 = 3; + gUnknown_030007B0->unk2C4 = 0; + } + + return r4; +} + +void sub_81332A0(void) +{ + s32 i; + + gUnknown_030007B0->unk0 = 0; + gUnknown_030007B0->unk2 = 0; + gUnknown_030007B0->unk19 = 0; + gUnknown_030007B0->unk18 = 0; + gUnknown_030007B0->unk1C = 0; + gUnknown_030007B0->unk1A = 0; + gUnknown_030007B0->unk1B = 0; + gUnknown_030007B0->unk1D = 0; + gUnknown_030007B0->unk1E = 0; + gUnknown_030007B0->unk2C3 = 0; + gUnknown_030007B0->unk2C4 = 0; + for (i = 0; i < 20; i++) + gUnknown_030007B0->unk20[i] = 0; +} + +void sub_8133300(struct Sprite *sprite) +{ + s16 var = (sprite->data1 * 10) & 0xFF; + + switch (sprite->data0) + { + case 0: + break; + case 1: + sprite->pos2.x = Sin(var, 3) * sprite->data2; + break; + case 2: + sprite->pos2.y = Sin(var, 1) * sprite->data2; + break; + } + sprite->data1++; +} + +extern const struct SpriteTemplate gSpriteTemplate_8402D90; +extern const struct SpriteTemplate gSpriteTemplate_8402DC0; +extern const struct SpriteTemplate gSpriteTemplate_8402E08; + +void sub_8133358(void) +{ + s32 i; + + gUnknown_030007B0->unk3[0] = CreateSprite(&gSpriteTemplate_8402D90, 8, 16, 0); + gSprites[gUnknown_030007B0->unk3[0]].data0 = 1; + gSprites[gUnknown_030007B0->unk3[0]].data2 = -1; + + gUnknown_030007B0->unk3[1] = CreateSprite(&gSpriteTemplate_8402D90, 72, 16, 0); + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[1]], 1); + gSprites[gUnknown_030007B0->unk3[1]].data0 = 1; + gSprites[gUnknown_030007B0->unk3[1]].data2 = 1; + + gUnknown_030007B0->unk3[2] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 4, 0); + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[2]], 1); + gSprites[gUnknown_030007B0->unk3[2]].data0 = 2; + gSprites[gUnknown_030007B0->unk3[2]].data2 = -1; + + gUnknown_030007B0->unk3[3] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 60, 0); + gSprites[gUnknown_030007B0->unk3[3]].data0 = 2; + gSprites[gUnknown_030007B0->unk3[3]].data2 = 1; + + for (i = 0; i < 8; i++) + { + gUnknown_030007B0->unk3[i + 4] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x34, 0); + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 2); + } + + for (i = 0; i < 8; i++) + { + gUnknown_030007B0->unk3[i + 12] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x5C, 0); + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 2); + } + + for (i = 0; i < 20; i++) + gSprites[gUnknown_030007B0->unk3[i]].invisible = TRUE; + + CreateBlendedOutlineCursor(16, 0xFFFF, 12, 0x2D9F, 18); +} + +void sub_8133558(void) +{ + s32 i; + u8 nickname[POKEMON_NAME_LENGTH + 1]; + + gUnknown_030007B0->unk1A = GetMoveRelearnerMoves(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20); + for (i = 0; i < gUnknown_030007B0->unk1A; i++) + StringCopy(gUnknown_030007B0->unk52[i], gMoveNames[gUnknown_030007B0->unk20[i]]); + GetMonData(&gPlayerParty[gUnknown_030007B0->unk2C5], MON_DATA_NICKNAME, nickname); + StringCopy10(gStringVar1, nickname); + StringCopy(gUnknown_030007B0->unk52[gUnknown_030007B0->unk1A], gUnknownText_Exit); + gUnknown_030007B0->unk1A++; +} + +void sub_813360C(s8 a) +{ + gUnknown_030007B0->unk1C = gUnknown_030007B0->unk18; + gUnknown_030007B0->unk18 += a; + gUnknown_030007B0->unk1D = 1; +} + +void sub_813362C(void) +{ + if (gMain.newAndRepeatedKeys & 0x40) + { + if (gUnknown_030007B0->unk1B != 0) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk1B--; + gUnknown_030007B0->unk2C3 = 1; + if (gUnknown_030007B0->unk18 != 0) + { + sub_813360C(-1); + } + else if (gUnknown_030007B0->unk19 != 0) + { + gUnknown_030007B0->unk19--; + gUnknown_030007B0->unk1E++; + } + } + } + else if (gMain.newAndRepeatedKeys & 0x80) + { + if (gUnknown_030007B0->unk1B < gUnknown_030007B0->unk1A - 1) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk1B++; + gUnknown_030007B0->unk2C3 = 1; + if (gUnknown_030007B0->unk18 != 2) + { + sub_813360C(1); + } + else if (gUnknown_030007B0->unk19 != gUnknown_030007B0->unk1A - 3) + { + gUnknown_030007B0->unk19++; + gUnknown_030007B0->unk1E++; + } + } + } + else if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + if (gUnknown_030007B0->unk1B != gUnknown_030007B0->unk1A - 1) + { + gUnknown_030007B0->unk0 = 8; + StringCopy(gStringVar2, gUnknown_030007B0->unk52[gUnknown_030007B0->unk1B]); + StringExpandPlaceholders(gStringVar4, gOtherText_TeachSpecificMove); + MenuPrintMessage(gStringVar4, 3, 15); + } + else + { + StringExpandPlaceholders(gStringVar4, gOtherText_GiveUpTeachingMove); + MenuPrintMessage(gStringVar4, 3, 15); + gUnknown_030007B0->unk0 = 12; + } + } + else if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + gUnknown_030007B0->unk0 = 12; + StringExpandPlaceholders(gStringVar4, gOtherText_GiveUpTeachingMove); + MenuPrintMessage(gStringVar4, 3, 15); + } + if (gUnknown_030007B0->unk1A > 3) + { + gSprites[2].invisible = FALSE; + gSprites[3].invisible = FALSE; + if (gUnknown_030007B0->unk19 == 0) + gSprites[2].invisible = TRUE; + else if (gUnknown_030007B0->unk19 == gUnknown_030007B0->unk1A - 3) + gSprites[3].invisible = TRUE; + } +} + +extern const u8 *const gUnknown_083CAF70[]; + +struct ContestMove +{ + u8 effect; + u8 contestCategory:3; + u8 comboStarterId; + u8 comboMoves[4]; +}; + +extern const struct ContestMove gContestMoves[]; +extern const u8 gTypeNames[][7]; + +void sub_8133800(void) +{ + u8 r6 = gUnknown_030007B0->unk19; + u8 *str = gTileBuffer; + s32 i; + + for (i = 0; i < 3; i++) + { + if (r6 >= gUnknown_030007B0->unk1A) + { + str = sub_8072C74(str, gEmptyString_81E72B0, 0x90, 0); + } + else if (r6 == gUnknown_030007B0->unk1A - 1) + { + str = sub_8072C74(str, gUnknownText_Exit, 0x90, 0); + } + else + { + u16 moveId = gUnknown_030007B0->unk20[r6]; + + if (gUnknown_030007B0->unk2C4 != 0) + str = sub_8072C74(str, gUnknown_083CAF70[gContestMoves[moveId].contestCategory], 0x27, 0); + else + str = sub_8072C74(str, gTypeNames[gBattleMoves[moveId].type], 0x27, 0); + + str = sub_8072C74(str, gUnknown_030007B0->unk52[r6], 0x72, 0); + + str[0] = 0xCA; + str[1] = 0xCA; + str[2] = 0xBA; + str += 3; + + str = sub_8072C14(str, gBattleMoves[moveId].pp, 0x90, 0); + } + *str++ = 0xFE; + r6++; + } + *str = 0xFF; + MenuPrint(gTileBuffer, 11, 1); + sub_813360C(0); +} + +struct ContestEffect +{ + u8 effectType; + u8 appeal; + u8 jam; +}; + +extern const struct ContestEffect gContestEffects[]; + +void sub_8133940(u16 a, const u8 *b) +{ + u8 str[0x34]; + u8 numHearts; + u8 i; + + StringCopy(str, gExpandedPlaceholder_Empty); + switch (b[2]) + { + case 1: + break; + case 2: + if (gBattleMoves[a].power < 2) + sub_8072C74(str, gOtherText_ThreeDashes2, 32, 2); + else + sub_8072C14(str, gBattleMoves[a].power, 32, 2); + MenuPrint(str, b[0], b[1]); + break; + case 4: + if (gBattleMoves[a].accuracy == 0) + sub_8072C74(str, gOtherText_ThreeDashes2, 32, 2); + else + sub_8072C14(str, gBattleMoves[a].accuracy, 32, 2); + MenuPrint(str, b[0], b[1]); + break; + case 6: + MenuZeroFillWindowRect(b[0], b[1], b[0], b[1] + 1); + numHearts = gContestEffects[gContestMoves[a].effect].appeal / 10; + if (numHearts == 255) + numHearts = 0; + for (i = 0; i < 8; i++) + { + if (i < numHearts) + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 1); + else + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 0); + } + break; + case 7: + MenuZeroFillWindowRect(b[0], b[1], b[0], b[1] + 1); + numHearts = gContestEffects[gContestMoves[a].effect].jam / 10; + if (numHearts == 255) + numHearts = 0; + for (i = 0; i < 8; i++) + { + if (i < numHearts) + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 3); + else + StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 2); + } + break; + } +} + +extern const u8 gUnknown_08402E24[][3]; +extern const u8 gUnknown_08402E3D[]; +extern const u8 gUnknown_08402E39[]; + +extern const u8 *const gUnknown_083CADD4[]; +extern const u8 *const gMoveDescriptions[]; + +void sub_8133AEC(u8 a, int unused) +{ + u16 i; + + if (gUnknown_030007B0->unk1B != gUnknown_030007B0->unk1A - 1) + { + u16 r5 = gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]; + + if (a != 0) + { + for (i = 0; i < 16; i++) + gSprites[gUnknown_030007B0->unk3[i + 4]].invisible = FALSE; + for (i = 0; i < 3; i++) + sub_8133940(r5, gUnknown_08402E24[gUnknown_08402E3D[i]]); + sub_8072AB0(gUnknown_083CADD4[gContestMoves[r5].effect], 0x58, 0x48, 0x90, 32, 1); + } + //_08133BA0 + else + { + u8 var; + + for (i = 0; i < 4; i++) + sub_8133940(r5, gUnknown_08402E24[gUnknown_08402E39[i]]); + var = sub_8072A18(gMoveDescriptions[r5 - 1], 0x58, 0x48, 0x90, 1); + if (var < 2) + { + u8 r1 = var * 2 + 9; + + MenuFillWindowRectWithBlankTile(11, r1, 28, 12); + } + } + } + else + { + if (a != 0) + { + MenuZeroFillWindowRect(gUnknown_08402E24[5][0], gUnknown_08402E24[5][1], gUnknown_08402E24[5][0], gUnknown_08402E24[5][1] + 1); + MenuZeroFillWindowRect(gUnknown_08402E24[6][0], gUnknown_08402E24[6][1], gUnknown_08402E24[6][0], gUnknown_08402E24[6][1] + 1); + for (i = 0; i < 16; i++) + gSprites[gUnknown_030007B0->unk3[i + 4]].invisible = TRUE; + } + else + { + MenuZeroFillWindowRect(gUnknown_08402E24[1][0], gUnknown_08402E24[1][1], gUnknown_08402E24[1][0] + 3, gUnknown_08402E24[1][1] + 1); + MenuZeroFillWindowRect(gUnknown_08402E24[3][0], gUnknown_08402E24[3][1], gUnknown_08402E24[3][0] + 3, gUnknown_08402E24[3][1] + 1); + } + MenuZeroFillWindowRect(11, 9, 28, 12); + } +} + +void sub_8133CA4(void) +{ + MenuZeroFillWindowRect(21, 7, 27, 12); + sub_8133AEC(gUnknown_030007B0->unk2C4, 0); +} -- cgit v1.2.3 From 11f590a1e88eed99b24439d246110356142cc9eb Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 12 Aug 2017 13:20:23 -0500 Subject: move ROM data into learn_move.c --- src/learn_move.c | 133 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 129 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/learn_move.c b/src/learn_move.c index 01a37fe70..a83d7a491 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -97,6 +97,135 @@ const struct UnknownStruct1 gUnknown_08402D08[][4] = }, }; +// XXX: What are these for? +const u32 unkDataFF00FFEF = 0xFF00FFEF; +const u8 *const gTileBuffer_ = gTileBuffer; + +const struct OamData gOamData_8402D50 = {.shape = 0}; +const struct OamData gOamData_8402D58 = {.shape = 2}; +const struct OamData gOamData_8402D60 = {.shape = 1}; + +const union AnimCmd gSpriteAnim_8402D68[] = +{ + ANIMCMD_FRAME(2, 5), + ANIMCMD_END, +}; + +const union AnimCmd gSpriteAnim_8402D70[] = +{ + ANIMCMD_FRAME(0, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpriteAnimTable_8402D78[] = +{ + gSpriteAnim_8402D68, + gSpriteAnim_8402D70, +}; + +const struct SpriteSheet gUnknown_08402D80 = {gDexArrows_Gfx, sizeof(gDexArrows_Gfx), 5525}; +const struct SpritePalette gUnknown_08402D88 = {gDexArrows_Pal, 5526}; + +void sub_8133300(struct Sprite *); +const struct SpriteTemplate gSpriteTemplate_8402D90 = +{ + .tileTag = 5525, + .paletteTag = 5526, + .oam = &gOamData_8402D58, + .anims = gSpriteAnimTable_8402D78, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8133300, +}; + +const union AnimCmd gSpriteAnim_8402DA8[] = +{ + ANIMCMD_FRAME(4, 5), + ANIMCMD_END, +}; + +const union AnimCmd gSpriteAnim_8402DB0[] = +{ + ANIMCMD_FRAME(6, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpriteAnimTable_8402DB8[] = +{ + gSpriteAnim_8402DA8, + gSpriteAnim_8402DB0, +}; + +const struct SpriteTemplate gSpriteTemplate_8402DC0 = +{ + .tileTag = 5525, + .paletteTag = 5526, + .oam = &gOamData_8402D60, + .anims = gSpriteAnimTable_8402DB8, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8133300, +}; + +const union AnimCmd gSpriteAnim_8402DD8[] = +{ + ANIMCMD_FRAME(8, 5), + ANIMCMD_END, +}; + +const union AnimCmd gSpriteAnim_8402DE0[] = +{ + ANIMCMD_FRAME(9, 5), + ANIMCMD_END, +}; + +const union AnimCmd gSpriteAnim_8402DE8[] = +{ + ANIMCMD_FRAME(10, 5), + ANIMCMD_END, +}; + +const union AnimCmd gSpriteAnim_8402DF0[] = +{ + ANIMCMD_FRAME(11, 5), + ANIMCMD_END, +}; + +const union AnimCmd *const gSpriteAnimTable_8402DF8[] = +{ + gSpriteAnim_8402DD8, + gSpriteAnim_8402DE0, + gSpriteAnim_8402DE8, + gSpriteAnim_8402DF0, +}; + +const struct SpriteTemplate gSpriteTemplate_8402E08 = +{ + .tileTag = 5525, + .paletteTag = 5526, + .oam = &gOamData_8402D50, + .anims = gSpriteAnimTable_8402DF8, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8133300, +}; + +const u8 gString_AkitoMori[] = _("あきと"); // programmer Akito Mori? + +const u8 gUnknown_08402E24[7][3] = +{ + {11, 1, 1}, + { 3, 6, 2}, + {24, 1, 3}, + { 3, 11, 4}, + { 5, 4, 5}, + { 3, 6, 6}, + { 3, 11, 7}, +}; + +const u8 gUnknown_08402E39[] = {0, 1, 2, 3}; +const u8 gUnknown_08402E3D[] = {4, 5, 6}; + void sub_813269C(u8); void sub_81326D8(void); void sub_8132870(void); @@ -906,10 +1035,6 @@ void sub_8133940(u16 a, const u8 *b) } } -extern const u8 gUnknown_08402E24[][3]; -extern const u8 gUnknown_08402E3D[]; -extern const u8 gUnknown_08402E39[]; - extern const u8 *const gUnknown_083CADD4[]; extern const u8 *const gMoveDescriptions[]; -- cgit v1.2.3 From 79a04893cea2b62ce21eaf236a13998130ee2546 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 12 Aug 2017 22:35:53 +0200 Subject: almost done --- src/berry_blender.c | 1800 ++++++++++++++++++++++++++++++++++++++++++++------- src/link.c | 5 +- 2 files changed, 1586 insertions(+), 219 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index ce2f3db20..74b87b983 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -7,13 +7,19 @@ #include "menu.h" #include "strings2.h" #include "sound.h" +#include "songs.h" #include "berry.h" #include "string_util.h" #include "link.h" #include "task.h" #include "rom4.h" +#include "item.h" #include "items.h" #include "rng.h" +#include "save.h" +#include "menu_cursor.h" +#include "trig.h" +#include "pokeblock.h" //needed to match Blender_ControlHitPitch struct MusicPlayerInfo @@ -44,10 +50,20 @@ struct MusicPlayerInfo // other files functions void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch); void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo); +void m4aMPlayStop(struct MusicPlayerInfo *mplayInfo); void sub_80A6978(void); u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); +void sub_814A880(u8 a1, u8 a2); +u8 sub_814A5C0(u8 a1, u16 a2, u8 a3, u16 a4, u8 a5); +s8 sub_810CA00(void); +bool8 sub_810CA34(struct Pokeblock *pokeblock); + +#define BLENDER_SCORE_BEST 0 +#define BLENDER_SCORE_GOOD 1 +#define BLENDER_SCORE_MISS 2 #define BLENDER_MAX_PLAYERS 4 +#define BLENDER_SCORES_NO 3 #define FLAVOUR_SPICY 0 #define FLAVOUR_DRY 1 @@ -69,55 +85,7 @@ struct BerryBlenderData u8 field_1; u8 field_2; u8 field_3; - u8 field_4; - u8 field_5; - u8 field_6; - u8 field_7; - u8 field_8; - u8 field_9; - u8 field_A; - u8 field_B; - u8 field_C; - u8 field_D; - u8 field_E; - u8 field_F; - u8 field_10; - u8 field_11; - u8 field_12; - u8 field_13; - u8 field_14; - u8 field_15; - u8 field_16; - u8 field_17; - u8 field_18; - u8 field_19; - u8 field_1A; - u8 field_1B; - u8 field_1C; - u8 field_1D; - u8 field_1E; - u8 field_1F; - u8 field_20; - u8 field_21; - u8 field_22; - u8 field_23; - u8 field_24; - u8 field_25; - u8 field_26; - u8 field_27; - u8 field_28; - u8 field_29; - u8 field_2A; - u8 field_2B; - u8 field_2C; - u8 field_2D; - u8 field_2E; - u8 field_2F; - u8 field_30; - u8 field_31; - u8 field_32; - u8 field_33; - u8 field_34; + struct Window field_4; u8 field_35; u8 field_36; u8 field_37; @@ -144,15 +112,11 @@ struct BerryBlenderData u8 field_4C; u8 field_4D; u16 field_4E; - u8 field_50; - u8 field_51; - u8 field_52; - u8 field_53; + u8 scoreIconIDs[3]; u16 arrowPos; s16 field_56; - u8 field_58; - u8 field_59; - u16 field_5A; + s16 field_58; + u16 max_RPM; u8 SyncArrowSpriteID[BLENDER_MAX_PLAYERS]; u8 SyncArrowSprite2ID[BLENDER_MAX_PLAYERS]; u8 field_64; @@ -168,15 +132,13 @@ struct BerryBlenderData u8 field_6E; u8 field_6F; u16 field_70[BLENDER_MAX_PLAYERS]; - u8 field_78; - u8 field_79; - u8 field_7A; - u8 field_7B; + u16 field_78; + u16 field_7A; u16 field_7C; u8 field_7E; u8 field_7F; - u16 field_80[BLENDER_MAX_PLAYERS]; - u8 field_88; + u16 chosenItemID[BLENDER_MAX_PLAYERS]; + u8 playersNo; u8 field_89; u8 field_8A; u8 field_8B; @@ -188,8 +150,7 @@ struct BerryBlenderData u8 field_91; u8 field_92; u8 field_93; - u8 field_94; - u8 field_95; + u16 field_94; u8 field_96; u8 field_97; u8 field_98; @@ -197,67 +158,7 @@ struct BerryBlenderData u16 field_9A[BLENDER_MAX_PLAYERS]; u16 field_A2[BLENDER_MAX_PLAYERS]; u8 field_AA; - u8 field_AB; - u8 field_AC; - u8 field_AD; - u8 field_AE; - u8 field_AF; - u8 field_B0; - u8 field_B1; - u8 field_B2; - u8 field_B3; - u8 field_B4; - u8 field_B5; - u8 field_B6; - u8 field_B7; - u8 field_B8; - u8 field_B9; - u8 field_BA; - u8 field_BB; - u8 field_BC; - u8 field_BD; - u8 field_BE; - u8 field_BF; - u8 field_C0; - u8 field_C1; - u8 field_C2; - u8 field_C3; - u8 field_C4; - u8 field_C5; - u8 field_C6; - u8 field_C7; - u8 field_C8; - u8 field_C9; - u8 field_CA; - u8 field_CB; - u8 field_CC; - u8 field_CD; - u8 field_CE; - u8 field_CF; - u8 field_D0; - u8 field_D1; - u8 field_D2; - u8 field_D3; - u8 field_D4; - u8 field_D5; - u8 field_D6; - u8 field_D7; - u8 field_D8; - u8 field_D9; - u8 field_DA; - u8 field_DB; - u8 field_DC; - u8 field_DD; - u8 field_DE; - u8 field_DF; - u8 field_E0; - u8 field_E1; - u8 field_E2; - u8 field_E3; - u8 field_E4; - u8 field_E5; - u8 field_E6; - u8 field_E7; + u8 stringVar[61]; u8 field_E8; u8 field_E9; u8 field_EA; @@ -326,8 +227,8 @@ struct BerryBlenderData u8 field_129; u8 field_12A; u8 field_12B; - u32 field_12C; - s32 field_130; + u32 gameFrameTime; + s32 framesToWait; u32 field_134; u8 field_138; u8 field_139; @@ -342,31 +243,17 @@ struct BerryBlenderData s16 field_146; u8 field_148[3]; u8 field_14B; - u16 field_14C[BLENDER_MAX_PLAYERS][3]; - u8 field_164; - u8 field_165; - u8 field_166; - u8 field_167; - u8 field_168; - u8 field_169; - u8 field_16A; - u8 field_16B; - u8 field_16C; - u8 field_16D; - u8 field_16E; - u8 field_16F; - u8 field_170; - u8 field_171; - u8 field_172; - u8 field_173; - u8 field_174; - u8 field_175; - u8 field_176; - u8 field_177; + u16 scores[BLENDER_MAX_PLAYERS][3]; + u8 playerPlaces[BLENDER_MAX_PLAYERS]; + struct BgAffineDstData field_168; u16 field_178; u8 field_17A; u8 field_17B; struct BlenderBerry blendedBerries[BLENDER_MAX_PLAYERS]; + u32 field_1BC; + u16 field_1C0; + u16 field_1C2; + u32 field_1C4; }; extern struct BerryBlenderData* sBerryBlenderData; @@ -384,11 +271,11 @@ void sub_804E884(u8 a0); void sub_8051474(void); void sub_804E9F8(void); void sub_804F378(void); -void sub_8051414(void*); +void sub_8051414(struct BgAffineDstData *dest); void sub_804F238(void); void sub_80501FC(void); bool8 sub_8051B8C(void); -void sub_80516C4(u8 a0, u16 itemID); +void Blender_SetBankBerryData(u8 bank, u16 itemID); void sub_804F2A8(void); void sub_804F81C(void); void sub_805156C(void); @@ -399,6 +286,14 @@ void sub_8051A3C(u16 a0); void sub_8051B18(void); void sub_805123C(void); void sub_8050954(void); +bool8 Blender_PrintBlendingRanking(void); +bool8 Blender_PrintBlendingResults(void); +void sub_80510E8(void); +void sub_8050E30(void); +void sub_805197C(u16 a0, u16 a1); +void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst); +void sub_8052BD0(u8 taskID); +void sub_8052AF8(void); void Blender_ControlHitPitch(void) { @@ -705,20 +600,20 @@ void sub_804E884(u8 a0) break; case 1: gUnknown_03004834 = 1; - sBerryBlenderData->field_88 = 2; + sBerryBlenderData->playersNo = 2; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); break; case 2: gUnknown_03004834 = 2; - sBerryBlenderData->field_88 = 3; + sBerryBlenderData->playersNo = 3; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); break; case 3: gUnknown_03004834 = 3; - sBerryBlenderData->field_88 = 4; + sBerryBlenderData->playersNo = 4; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); @@ -737,7 +632,7 @@ void sub_804E990(void) sBerryBlenderData->field_134 = 0; for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->field_80[i] = 0; + sBerryBlenderData->chosenItemID[i] = 0; } sub_804E884(gSpecialVar_0x8004); if (gSpecialVar_0x8004 == 0) @@ -776,13 +671,13 @@ void sub_804E9F8(void) sBerryBlenderData->field_70[i] = 0; for (j = 0; j < 3; j++) { - sBerryBlenderData->field_14C[i][j] = 0; + sBerryBlenderData->scores[i][j] = 0; } } sBerryBlenderData->field_7C = 0; sBerryBlenderData->field_56 = 0; sBerryBlenderData->arrowPos = 0; - sBerryBlenderData->field_5A = 0; + sBerryBlenderData->max_RPM = 0; sBerryBlenderData->field_1 = 0; break; case 1: @@ -815,7 +710,7 @@ void sub_804E9F8(void) MenuDrawTextWindow(0, 13, 29, 19); MenuPrint(gOtherText_LinkStandby3, 1, 14); sBerryBlenderData->field_0 = 8; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; break; case 8: sBerryBlenderData->field_0++; @@ -823,7 +718,7 @@ void sub_804E9F8(void) Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); memcpy(gBlockSendBuffer, &sBerryBlenderData->blendedBerries[0], sizeof(struct BlenderBerry)); sub_80084A4(); - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; break; case 9: if (sub_8007ECC()) @@ -835,7 +730,7 @@ void sub_804E9F8(void) } break; case 10: - if (++sBerryBlenderData->field_130 > 20) + if (++sBerryBlenderData->framesToWait > 20) { MenuZeroFillScreen(); if (GetBlockReceivedStatus() == sub_8008198()) @@ -843,7 +738,7 @@ void sub_804E9F8(void) for (i = 0; i < GetLinkPlayerCount(); i++) { memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][0], sizeof(struct BlenderBerry)); - sBerryBlenderData->field_80[i] = sBerryBlenderData->blendedBerries[i].itemID; + sBerryBlenderData->chosenItemID[i] = sBerryBlenderData->blendedBerries[i].itemID; } ResetBlockReceivedFlags(); sBerryBlenderData->field_0++; @@ -851,30 +746,30 @@ void sub_804E9F8(void) } break; case 11: - sBerryBlenderData->field_88 = GetLinkPlayerCount(); + sBerryBlenderData->playersNo = GetLinkPlayerCount(); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]) + if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]) { - sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_13C], i); + sub_804E7C0(sBerryBlenderData->chosenItemID[sBerryBlenderData->field_13C], i); break; } } - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; sBerryBlenderData->field_0++; sBerryBlenderData->field_13C++; break; case 12: - if (++sBerryBlenderData->field_130 > 60) + if (++sBerryBlenderData->framesToWait > 60) { - if (sBerryBlenderData->field_13C >= sBerryBlenderData->field_88) + if (sBerryBlenderData->field_13C >= sBerryBlenderData->playersNo) { sBerryBlenderData->field_0++; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]] - 22528; } else sBerryBlenderData->field_0--; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; } break; case 13: @@ -892,9 +787,9 @@ void sub_804E9F8(void) { sBerryBlenderData->field_0++; sBerryBlenderData->field_142 = 256; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]]; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]]; REG_BG2CNT = 0x4882; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; sub_804F238(); sub_804F2A8(); } @@ -903,7 +798,7 @@ void sub_804E9F8(void) case 15: if (sub_8051B8C()) { - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; sBerryBlenderData->field_0++; } sub_8051414(&sBerryBlenderData->field_168); @@ -928,7 +823,7 @@ void sub_804E9F8(void) break; case 21: sBerryBlenderData->field_56 = 128; - sBerryBlenderData->field_12C = 0; + sBerryBlenderData->gameFrameTime = 0; SetMainCallback2(sub_80501FC); if (GetCurrentMapMusic() != 403) { @@ -974,7 +869,7 @@ void sub_804F0F4(void) sBerryBlenderData->field_4E = 0; sBerryBlenderData->field_56 = 0; sBerryBlenderData->arrowPos = 0; - sBerryBlenderData->field_5A = 0; + sBerryBlenderData->max_RPM = 0; sBerryBlenderData->field_144 = 0; sBerryBlenderData->field_146 = 0; sBerryBlenderData->field_0++; @@ -1022,7 +917,7 @@ void sub_804F1BC(u16 itemID, u8 a1, struct BlenderBerry* berry) } for (i = 0; i < a1 - 1; i++) { - sub_80516C4(i + 1, gUnknown_082165BC[r4][i] + 133); + Blender_SetBankBerryData(i + 1, gUnknown_082165BC[r4][i] + 133); } } @@ -1032,7 +927,7 @@ void sub_804F238(void) for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { sBerryBlenderData->field_A2[i] = 0xFF; - sBerryBlenderData->field_9A[i] = gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]; + sBerryBlenderData->field_9A[i] = gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]; } for (j = 0; j < BLENDER_MAX_PLAYERS; j++) { @@ -1075,15 +970,15 @@ void sub_804F378(void) { case 0: sub_804F0F4(); - sub_80516C4(0, gScriptItemId); + Blender_SetBankBerryData(0, gScriptItemId); Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); - sub_804F1BC(gScriptItemId, sBerryBlenderData->field_88, &sBerryBlenderData->blendedBerries[0]); + sub_804F1BC(gScriptItemId, sBerryBlenderData->playersNo, &sBerryBlenderData->blendedBerries[0]); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { sBerryBlenderData->field_70[i] = 0; for (j = 0; j < 3; j++) { - sBerryBlenderData->field_14C[i][j] = 0; + sBerryBlenderData->scores[i][j] = 0; } } sBerryBlenderData->field_7C = 0; @@ -1107,10 +1002,10 @@ void sub_804F378(void) case 3: BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); sBerryBlenderData->field_0++; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; break; case 4: - if (++sBerryBlenderData->field_130 == 2) + if (++sBerryBlenderData->framesToWait == 2) sub_804E4FC(); if (!gPaletteFade.active) sBerryBlenderData->field_0 = 8; @@ -1122,28 +1017,28 @@ void sub_804F378(void) case 11: for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - u32 var = gUnknown_082162EC[sBerryBlenderData->field_88 - 2][i]; + u32 var = gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]; if (sBerryBlenderData->field_13C == var) { - sub_804E7C0(sBerryBlenderData->field_80[sBerryBlenderData->field_13C], i); + sub_804E7C0(sBerryBlenderData->chosenItemID[sBerryBlenderData->field_13C], i); break; } } - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; sBerryBlenderData->field_0++; sBerryBlenderData->field_13C++; break; case 12: - if (++sBerryBlenderData->field_130 > 60) + if (++sBerryBlenderData->framesToWait > 60) { - if (sBerryBlenderData->field_13C >= sBerryBlenderData->field_88) + if (sBerryBlenderData->field_13C >= sBerryBlenderData->playersNo) { - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]] - 22528; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]] - 22528; sBerryBlenderData->field_0++; } else sBerryBlenderData->field_0--; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; } break; case 13: @@ -1160,9 +1055,9 @@ void sub_804F378(void) { sBerryBlenderData->field_0++; sBerryBlenderData->field_142 = 256; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->field_88 - 2]]; + sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]]; REG_BG2CNT = 0x4882; - sBerryBlenderData->field_130 = 0; + sBerryBlenderData->framesToWait = 0; PlaySE(52); sub_804F2A8(); } @@ -1191,7 +1086,7 @@ void sub_804F378(void) case 21: sub_804F81C(); sBerryBlenderData->field_56 = 128; - sBerryBlenderData->field_12C = 0; + sBerryBlenderData->gameFrameTime = 0; sBerryBlenderData->field_14B = 0; sBerryBlenderData->field_7E = 0; SetMainCallback2(sub_80501FC); @@ -1424,20 +1319,20 @@ void sub_804FD30(u16 a0) { case 0x4523: if (sBerryBlenderData->field_56 < 1500) - sBerryBlenderData->field_56 += (384 / gUnknown_082165DA[sBerryBlenderData->field_88]); + sBerryBlenderData->field_56 += (384 / gUnknown_082165DA[sBerryBlenderData->playersNo]); else { - sBerryBlenderData->field_56 += (128 / gUnknown_082165DA[sBerryBlenderData->field_88]); + sBerryBlenderData->field_56 += (128 / gUnknown_082165DA[sBerryBlenderData->playersNo]); sub_8051AC8(&sBerryBlenderData->field_144, (sBerryBlenderData->field_56 / 100) - 10); sub_8051AC8(&sBerryBlenderData->field_146, (sBerryBlenderData->field_56 / 100) - 10); } break; case 0x5432: if (sBerryBlenderData->field_56 < 1500) - sBerryBlenderData->field_56 += (256 / gUnknown_082165DA[sBerryBlenderData->field_88]); + sBerryBlenderData->field_56 += (256 / gUnknown_082165DA[sBerryBlenderData->playersNo]); break; case 0x2345: - sBerryBlenderData->field_56 -= (256 / gUnknown_082165DA[sBerryBlenderData->field_88]); + sBerryBlenderData->field_56 -= (256 / gUnknown_082165DA[sBerryBlenderData->playersNo]); if (sBerryBlenderData->field_56 < 128) sBerryBlenderData->field_56 = 128; break; @@ -1462,7 +1357,7 @@ void sub_804FE70(void) gRecvCmds[0][i] = 0x4444; } } - for (i = 0; i < sBerryBlenderData->field_88; i++) + for (i = 0; i < sBerryBlenderData->playersNo; i++) { if (gRecvCmds[0][i] == 0x4444) { @@ -1474,23 +1369,23 @@ void sub_804FE70(void) if (sBerryBlenderData->field_13E >= 1000) sBerryBlenderData->field_13E = 1000; sub_804FC48(0x4523, var); - sBerryBlenderData->field_14C[i][0]++; + sBerryBlenderData->scores[i][BLENDER_SCORE_BEST]++; } else if (gRecvCmds[2][i] == 0x5432) { sub_804FD30(0x5432); sBerryBlenderData->field_13E += (sBerryBlenderData->field_56 / 70); sub_804FC48(0x5432, var); - sBerryBlenderData->field_14C[i][1]++; + sBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]++; } else if (gRecvCmds[2][i] == 0x2345) { sub_804FC48(0x2345, var); sub_804FD30(0x2345); - if (sBerryBlenderData->field_15 > 1000) + if (sBerryBlenderData->field_4.win_field_F > 1000) sBerryBlenderData->field_13E = 1000; - if (sBerryBlenderData->field_14C[i][2] < 999) - sBerryBlenderData->field_14C[i][2]++; + if (sBerryBlenderData->scores[i][BLENDER_SCORE_MISS] < 999) + sBerryBlenderData->scores[i][BLENDER_SCORE_MISS]++; } if (gRecvCmds[2][i] == 0x2345 || gRecvCmds[2][i] == 0x4523 || gRecvCmds[2][i] == 0x5432) { @@ -1503,7 +1398,7 @@ void sub_804FE70(void) } if (gSpecialVar_0x8004 != 0) { - for (i = 0; i < sBerryBlenderData->field_88; i++) + for (i = 0; i < sBerryBlenderData->playersNo; i++) { gRecvCmds[0][i] = 0; gRecvCmds[2][i] = 0; @@ -1549,8 +1444,8 @@ void sub_80500A8(void) void sub_80501FC(void) { sub_8051474(); - if (sBerryBlenderData->field_12C < 359940) - sBerryBlenderData->field_12C++; + if (sBerryBlenderData->gameFrameTime < (99 * 60 * 60) + (59 * 60)) // game time can't be longer than 99 minutes and 59 seconds, can't print 3 digits + sBerryBlenderData->gameFrameTime++; sub_80500A8(); SetLinkDebugValues((u16)(sBerryBlenderData->field_56), sBerryBlenderData->field_13E); sub_804FE70(); @@ -1703,11 +1598,18 @@ extern u32 gUnknown_0300055C; extern const u8 gUnknown_082165DF[]; -void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) -{ - s32 i, j; +#ifdef NONMATCHING - s32 var5, var6; +void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +{ + s32 i; + s32 j; + s32 savedEntry; + s32 var3; + s32 var4; + s32 var6; + s32 var11; + u16 rand; for (i = 0; i < 6; i++) gUnknown_03000510[i] = 0; @@ -1717,12 +1619,12 @@ void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) gUnknown_03000510[j] += berries[i].flavours[j]; } - var5 = gUnknown_03000510[0]; + savedEntry = gUnknown_03000510[0]; gUnknown_03000510[0] -= gUnknown_03000510[1]; gUnknown_03000510[1] -= gUnknown_03000510[2]; gUnknown_03000510[2] -= gUnknown_03000510[3]; gUnknown_03000510[3] -= gUnknown_03000510[4]; - gUnknown_03000510[4] -= var5; + gUnknown_03000510[4] -= savedEntry; var6 = 0; for (i = 0; i < 6; i++) @@ -1733,7 +1635,7 @@ void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) var6++; } } - for (i = 0; i < 6; i++) + for (i = 0; i < 5; i++) { if (gUnknown_03000510[i] > 0) { @@ -1743,18 +1645,18 @@ void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) gUnknown_03000510[i] -= var6; } } - for (i = 0; i < 6; i++) + for (i = 0; i < 5; i++) { gUnknown_03000530[i] = gUnknown_03000510[i]; } - gUnknown_0300055C = ((a4 / 333) + 100); + var11 = a4 / 333 + 100; + gUnknown_0300055C = ((var11)); for (i = 0; i < 5; i++) { - s32 var4; - s32 var3 = gUnknown_03000510[i]; - var3 = (((a4 / 333) + 100) * var3) / 10; + var3 = gUnknown_03000510[i]; + var3 = ((var11) * var3) / 10; var4 = var3 % 10; var3 /= 10; if (var4 > 4) @@ -1767,11 +1669,11 @@ void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) } *a1 = sub_80502F8(berries, &gUnknown_03000510[0], a2, var6); gUnknown_03000510[5] = (gUnknown_03000510[5] / a2) - a2; - if (gUnknown_03000510[5] > 0) + if (gUnknown_03000510[5] < 0) gUnknown_03000510[5] = 0; if (*a1 == 12) { - u16 rand = Random() % 10; + rand = Random() % 10; for (i = 0; i < 6; i++) { if ((gUnknown_082165DF[rand] >> i) & 1) @@ -1796,3 +1698,1467 @@ void sub_8050520(struct BlenderBerry* berries, u8* a1, u8 a2, u8* a3, u16 a4) a3[i] = gUnknown_03000510[i]; } } + +#else +__attribute__((naked)) +void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x10\n\ + str r0, [sp]\n\ + mov r8, r1\n\ + str r3, [sp, 0x4]\n\ + ldr r0, [sp, 0x30]\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + mov r9, r2\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x8]\n\ + ldr r7, _080505DC @ =gUnknown_03000510\n\ + adds r2, r7, 0\n\ + movs r1, 0\n\ + adds r0, r7, 0\n\ + adds r0, 0xA\n\ +_0805054A:\n\ + strh r1, [r0]\n\ + subs r0, 0x2\n\ + cmp r0, r2\n\ + bge _0805054A\n\ + movs r6, 0\n\ + cmp r6, r9\n\ + bge _08050580\n\ + ldr r0, _080505DC @ =gUnknown_03000510\n\ + mov r12, r0\n\ + ldr r5, [sp]\n\ + adds r5, 0x9\n\ +_08050560:\n\ + movs r3, 0\n\ + adds r4, r5, 0\n\ + mov r2, r12\n\ +_08050566:\n\ + adds r1, r4, r3\n\ + ldrh r0, [r2]\n\ + ldrb r1, [r1]\n\ + adds r0, r1\n\ + strh r0, [r2]\n\ + adds r2, 0x2\n\ + adds r3, 0x1\n\ + cmp r3, 0x5\n\ + ble _08050566\n\ + adds r5, 0x10\n\ + adds r6, 0x1\n\ + cmp r6, r9\n\ + blt _08050560\n\ +_08050580:\n\ + movs r1, 0\n\ + ldrsh r3, [r7, r1]\n\ + ldrh r0, [r7]\n\ + ldrh r1, [r7, 0x2]\n\ + subs r0, r1\n\ + strh r0, [r7]\n\ + ldrh r0, [r7, 0x4]\n\ + subs r1, r0\n\ + strh r1, [r7, 0x2]\n\ + ldrh r1, [r7, 0x6]\n\ + subs r0, r1\n\ + strh r0, [r7, 0x4]\n\ + ldrh r0, [r7, 0x8]\n\ + subs r1, r0\n\ + strh r1, [r7, 0x6]\n\ + subs r0, r3\n\ + strh r0, [r7, 0x8]\n\ + movs r3, 0\n\ + movs r2, 0\n\ + adds r1, r7, 0\n\ + movs r6, 0x4\n\ +_080505AA:\n\ + movs r4, 0\n\ + ldrsh r0, [r1, r4]\n\ + cmp r0, 0\n\ + bge _080505B6\n\ + strh r2, [r1]\n\ + adds r3, 0x1\n\ +_080505B6:\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505AA\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r10, r0\n\ + movs r4, 0\n\ + ldr r1, _080505DC @ =gUnknown_03000510\n\ + movs r6, 0x4\n\ +_080505CA:\n\ + ldrh r2, [r1]\n\ + movs r5, 0\n\ + ldrsh r0, [r1, r5]\n\ + cmp r0, 0\n\ + ble _080505E4\n\ + cmp r0, r3\n\ + bge _080505E0\n\ + strh r4, [r1]\n\ + b _080505E4\n\ + .align 2, 0\n\ +_080505DC: .4byte gUnknown_03000510\n\ +_080505E0:\n\ + subs r0, r2, r3\n\ + strh r0, [r1]\n\ +_080505E4:\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505CA\n\ + ldr r1, _080506C4 @ =gUnknown_03000510\n\ + ldr r2, _080506C8 @ =gUnknown_03000530\n\ + movs r6, 0x4\n\ +_080505F2:\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + stm r2!, {r0}\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505F2\n\ + ldr r1, _080506CC @ =0x0000014d\n\ + ldr r0, [sp, 0x8]\n\ + bl __udivsi3\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + adds r3, r0, 0\n\ + adds r3, 0x64\n\ + ldr r4, _080506D0 @ =gUnknown_0300055C\n\ + str r3, [r4]\n\ + movs r6, 0x4\n\ +_08050616:\n\ + movs r0, 0\n\ + ldrsh r5, [r7, r0]\n\ + adds r0, r5, 0\n\ + muls r0, r3\n\ + movs r1, 0xA\n\ + str r3, [sp, 0xC]\n\ + bl __divsi3\n\ + adds r5, r0, 0\n\ + movs r1, 0xA\n\ + bl __modsi3\n\ + adds r4, r0, 0\n\ + adds r0, r5, 0\n\ + movs r1, 0xA\n\ + bl __divsi3\n\ + adds r5, r0, 0\n\ + ldr r3, [sp, 0xC]\n\ + cmp r4, 0x4\n\ + ble _08050642\n\ + adds r5, 0x1\n\ +_08050642:\n\ + strh r5, [r7]\n\ + adds r7, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _08050616\n\ + ldr r1, _080506C4 @ =gUnknown_03000510\n\ + ldr r2, _080506D4 @ =gUnknown_03000548\n\ + movs r6, 0x4\n\ +_08050652:\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + stm r2!, {r0}\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _08050652\n\ + ldr r4, _080506C4 @ =gUnknown_03000510\n\ + ldr r0, [sp]\n\ + adds r1, r4, 0\n\ + mov r2, r9\n\ + mov r3, r10\n\ + bl sub_80502F8\n\ + mov r5, r8\n\ + strb r0, [r5]\n\ + movs r1, 0xA\n\ + ldrsh r0, [r4, r1]\n\ + mov r1, r9\n\ + bl __divsi3\n\ + mov r3, r9\n\ + subs r0, r3\n\ + strh r0, [r4, 0xA]\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + bge _0805068C\n\ + movs r0, 0\n\ + strh r0, [r4, 0xA]\n\ +_0805068C:\n\ + mov r5, r8\n\ + ldrb r0, [r5]\n\ + cmp r0, 0xC\n\ + bne _080506E6\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0xA\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + lsrs r3, r0, 16\n\ + movs r6, 0\n\ + ldr r0, _080506D8 @ =gUnknown_082165DF\n\ + adds r0, r3, r0\n\ + ldrb r0, [r0]\n\ + adds r1, r4, 0\n\ + movs r4, 0x1\n\ + movs r3, 0x2\n\ +_080506B4:\n\ + adds r2, r0, 0\n\ + asrs r2, r6\n\ + ands r2, r4\n\ + cmp r2, 0\n\ + beq _080506DC\n\ + strh r3, [r1]\n\ + b _080506DE\n\ + .align 2, 0\n\ +_080506C4: .4byte gUnknown_03000510\n\ +_080506C8: .4byte gUnknown_03000530\n\ +_080506CC: .4byte 0x0000014d\n\ +_080506D0: .4byte gUnknown_0300055C\n\ +_080506D4: .4byte gUnknown_03000548\n\ +_080506D8: .4byte gUnknown_082165DF\n\ +_080506DC:\n\ + strh r2, [r1]\n\ +_080506DE:\n\ + adds r1, 0x2\n\ + adds r6, 0x1\n\ + cmp r6, 0x4\n\ + ble _080506B4\n\ +_080506E6:\n\ + ldr r7, _08050740 @ =gUnknown_03000510\n\ + movs r2, 0xFF\n\ + adds r1, r7, 0\n\ + movs r6, 0x5\n\ +_080506EE:\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + cmp r0, 0xFF\n\ + ble _080506F8\n\ + strh r2, [r1]\n\ +_080506F8:\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080506EE\n\ + ldrh r0, [r7]\n\ + mov r4, r8\n\ + strb r0, [r4, 0x1]\n\ + ldrh r0, [r7, 0x2]\n\ + strb r0, [r4, 0x2]\n\ + ldrh r0, [r7, 0x4]\n\ + strb r0, [r4, 0x3]\n\ + ldrh r0, [r7, 0x6]\n\ + strb r0, [r4, 0x4]\n\ + ldrh r0, [r7, 0x8]\n\ + strb r0, [r4, 0x5]\n\ + ldrh r0, [r7, 0xA]\n\ + strb r0, [r4, 0x6]\n\ + movs r6, 0\n\ + adds r2, r7, 0\n\ +_0805071E:\n\ + ldr r5, [sp, 0x4]\n\ + adds r1, r5, r6\n\ + ldrh r0, [r2]\n\ + strb r0, [r1]\n\ + adds r2, 0x2\n\ + adds r6, 0x1\n\ + cmp r6, 0x5\n\ + ble _0805071E\n\ + add sp, 0x10\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_08050740: .4byte gUnknown_03000510\n\ + .syntax divided"); +} + +#endif // NONMATCHING + +void sub_8050744(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +{ + sub_8050520(berries, pokeblock, a2, a3, a4); // what is the purpose of this function? +} + +void sub_8050760(void) +{ + u32 frames = (u16)(sBerryBlenderData->gameFrameTime); + u32 max_RPM = (u16)(sBerryBlenderData->max_RPM); + s16 var = 0; + + if (frames < 900) + var = 5; + else if ((u16)(frames - 900) < 600) + var = 4; + else if ((u16)(frames - 1500) < 600) + var = 3; + else if ((u16)(frames - 2100) < 900) + var = 2; + else if ((u16)(frames - 3300) < 300) + var = 1; + sub_8050508(var); + + var = 0; + if (max_RPM <= 64) + { + if ((u16)(max_RPM - 50) < 50) + var = -1; + else if ((u16)(max_RPM - 100) < 50) + var = -2; + else if ((u16)(max_RPM - 150) < 50) + var = -3; + else if ((u16)(max_RPM - 200) < 50) + var = -4; + else if ((u16)(max_RPM - 250) < 50) + var = -5; + else if ((u16)(max_RPM - 350) < 50) + var = -6; + else if ((u16)(max_RPM - 400) < 50) + var = -7; + else if ((u16)(max_RPM - 500) < 50) + var = -8; + else if ((u16)(max_RPM - 550) < 50) + var = -9; + else if (max_RPM >= 600) + var = -10; + } + sub_80504F0(var); +} + +void sub_80508D4(u8 value) +{ + sBerryBlenderData->field_AA = value; + sub_814A880(192, (sBerryBlenderData->field_AA * 16) + 72); +} + +void sub_80508FC(void) +{ + sBerryBlenderData->field_AA = 0; + MenuDrawTextWindow(23, 8, 28, 13); + sub_814A5C0(0, -1, 12, 0x2D9F, 32); + MenuPrint(gOtherText_YesNoTerminating, 24, 9); + sub_80508D4(sBerryBlenderData->field_AA); +} + +void sub_8050954(void) +{ + u8 i; + u8 multiplayerID; // unused + + sub_8051474(); + multiplayerID = GetMultiplayerId(); + switch (sBerryBlenderData->field_6F) + { + case 1: + ClearLinkCallback(); + m4aMPlayTempoControl(&gMPlay_BGM, 256); + for (i = 0; i < gSpecialVar_0x8004; i++) + { + DestroyTask(sBerryBlenderData->field_148[i]); + } + sBerryBlenderData->field_6F++; + break; + case 2: + sBerryBlenderData->field_56 -= 32; + if (sBerryBlenderData->field_56 <= 0) + { + sBerryBlenderData->field_56 = 0; + if (gReceivedRemoteLinkPlayers != 0) + sBerryBlenderData->field_6F++; + else + sBerryBlenderData->field_6F = 5; + sBerryBlenderData->field_0 = 0; + m4aMPlayStop(&gMPlay_SE2); + } + Blender_ControlHitPitch(); + break; + case 3: + if (/*multiplayerID != 0*/ GetMultiplayerId() != 0) + sBerryBlenderData->field_6F++; + else if (sub_8007ECC()) + { + sBerryBlenderData->field_1BC = sBerryBlenderData->gameFrameTime; + sBerryBlenderData->field_1C0 = sBerryBlenderData->max_RPM; + SendBlock(0, &sBerryBlenderData->field_1BC, 40); + sBerryBlenderData->field_6F++; + } + break; + case 4: + if (GetBlockReceivedStatus()) + { + u32* ptr = ((u32*)(&gBlockRecvBuffer[0][0])); + sBerryBlenderData->max_RPM = gBlockRecvBuffer[0][2]; + sBerryBlenderData->gameFrameTime = *ptr; + sBerryBlenderData->field_6F++; + ResetBlockReceivedFlags(); + } + break; + case 5: + if (Blender_PrintBlendingRanking()) + sBerryBlenderData->field_6F++; + break; + case 6: + if (Blender_PrintBlendingResults()) + { + if (gUnknown_03004834 == 0) + IncrementGameStat(34); + else + IncrementGameStat(33); + sBerryBlenderData->field_6F++; + } + break; + case 7: + sBerryBlenderData->field_6F++; + MenuDrawTextWindow(0, 14, 29, 19); + MenuPrintMessage(gOtherText_BlendAnotherBerryPrompt, 1, 15); + break; + case 8: + if (MenuUpdateWindowText()) + sBerryBlenderData->field_6F++; + break; + case 9: + sBerryBlenderData->field_AA = 0; + sub_80508FC(); + sBerryBlenderData->field_6F++; + break; + case 10: + if (gMain.newKeys & DPAD_UP) + { + if (sBerryBlenderData->field_AA != 0) + PlaySE(SE_SELECT); + sub_80508D4(0); + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (sBerryBlenderData->field_AA != 1) + PlaySE(SE_SELECT); + sub_80508D4(1); + } + else if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + sBerryBlenderData->field_6F++; + } + else if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + sBerryBlenderData->field_6F++; + sub_80508D4(1); + } + break; + case 11: + gSendCmd[0] = 0x2FFF; + if (sBerryBlenderData->field_AA == 0) + { + if (IsBagPocketNonEmpty(BAG_BERRIES) == FALSE) // is empty + { + sBerryBlenderData->field_7C = 2; + gSendCmd[1] = 0x9999; + } + else if (sub_810CA00() == -1) + { + sBerryBlenderData->field_7C = 3; + gSendCmd[1] = 0xAAAA; + } + else + { + sBerryBlenderData->field_7C = 0; + gSendCmd[1] = 0x7779; + } + sBerryBlenderData->field_6F++; + } + else + { + sBerryBlenderData->field_7C = 1; + gSendCmd[1] = 0x8888; + sBerryBlenderData->field_6F++; + } + break; + case 12: + if (gUnknown_03004834) + { + SetMainCallback2(sub_80510E8); + sBerryBlenderData->field_6F = 0; + sBerryBlenderData->field_0 = 0; + } + else + { + MenuPrintMessage(gOtherText_LinkStandby3, 1, 15); + sBerryBlenderData->field_6F++; + } + break; + case 13: + if (MenuUpdateWindowText()) + { + SetMainCallback2(sub_8050E30); + sBerryBlenderData->field_6F = 0; + sBerryBlenderData->field_0 = 0; + } + break; + } + sub_8051B18(); + sub_8051A3C(sBerryBlenderData->field_56); + sub_805123C(); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +bool8 sub_8050CE8(void) +{ + switch (sBerryBlenderData->field_1C4) + { + case 0: + sub_80084A4(); + sBerryBlenderData->field_1C4 = 1; + sBerryBlenderData->framesToWait = 0; + break; + case 1: + if (sub_8007ECC()) + { + sBerryBlenderData->field_1C4++; + gSoftResetDisabled = TRUE; + } + break; + case 2: + sub_8125E2C(); + sBerryBlenderData->field_1C4++; + sBerryBlenderData->framesToWait = 0; + break; + case 3: + if (++sBerryBlenderData->framesToWait == 10) + { + sub_80084A4(); + sBerryBlenderData->field_1C4++; + } + break; + case 4: + if (sub_8007ECC()) + { + if (sub_8125E6C()) + sBerryBlenderData->field_1C4 = 5; + else + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_1C4 = 3; + } + } + break; + case 5: + sBerryBlenderData->field_1C4++; + sBerryBlenderData->framesToWait = 0; + break; + case 6: + if (++sBerryBlenderData->framesToWait > 5) + { + gSoftResetDisabled = FALSE; + return 1; + } + break; + } + return 0; +} + +void sub_8050E30(void) +{ + switch (sBerryBlenderData->field_6F) + { + case 0: + if (sBerryBlenderData->field_70[0] == 0x2222) + sBerryBlenderData->field_6F = 5; + else if (sBerryBlenderData->field_70[0] == 0x1111) + { + if (sBerryBlenderData->field_78 == 0x9999) + sBerryBlenderData->field_6F = 2; + else if (sBerryBlenderData->field_78 == 0xAAAA) + sBerryBlenderData->field_6F = 1; + else + sBerryBlenderData->field_6F = 5; + } + break; + case 1: + sBerryBlenderData->field_6F = 3; + DestroyMenuCursor(); + MenuZeroFillWindowRect(23, 8, 28, 13); + StringCopy(gStringVar4, gLinkPlayers[sBerryBlenderData->field_7A].name); + StringAppend(gStringVar4, gOtherText_OtherCaseIsFull); + MenuPrintMessage(gStringVar4, 1, 15); + break; + case 2: + sBerryBlenderData->field_6F++; + DestroyMenuCursor(); + MenuZeroFillWindowRect(23, 8, 28, 13); + StringCopy(gStringVar4, gLinkPlayers[sBerryBlenderData->field_7A].name); + StringAppend(gStringVar4, gOtherText_NoBerriesForBlend); + MenuPrintMessage(gStringVar4, 1, 15); + break; + case 3: + if (MenuUpdateWindowText()) + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_6F++; + } + break; + case 4: + if (++sBerryBlenderData->framesToWait > 60) + sBerryBlenderData->field_6F = 5; + break; + case 5: + MenuDrawTextWindow(0, 14, 29, 19); + MenuPrint(gMultiText_Saving, 2, 15); + sub_80084A4(); + sBerryBlenderData->field_6F++; + break; + case 6: + if (sub_8007ECC()) + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_6F++; + sBerryBlenderData->field_1C4 = 0; + } + break; + case 7: + if (sub_8050CE8()) + { + PlaySE(SE_SAVE); + sBerryBlenderData->field_6F++; + } + break; + case 8: + sBerryBlenderData->field_6F++; + sub_80084A4(); + break; + case 9: + if (sub_8007ECC()) + { + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + sBerryBlenderData->field_6F++; + } + break; + case 10: + if (!gPaletteFade.active) + { + if (sBerryBlenderData->field_70[0] == 0x2222) + SetMainCallback2(sub_804E538); + else + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_6F++; + } + } + break; + case 11: + if (++sBerryBlenderData->framesToWait > 30) + { + sub_800832C(); + sBerryBlenderData->field_6F++; + } + break; + case 12: + if (gReceivedRemoteLinkPlayers == 0) + SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); + break; + } + + sub_805123C(); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_80510E8(void) +{ + switch (sBerryBlenderData->field_6F) + { + case 0: + if (sBerryBlenderData->field_7C < 2) + sBerryBlenderData->field_6F = 9; + if (sBerryBlenderData->field_7C == 2) + sBerryBlenderData->field_6F = 2; + if (sBerryBlenderData->field_7C == 3) + sBerryBlenderData->field_6F =1; + break; + case 1: + sBerryBlenderData->field_6F = 3; + DestroyMenuCursor(); + MenuZeroFillWindowRect(23, 8, 28, 13); + MenuPrintMessage(gOtherText_CaseIsFull, 1, 15); + break; + case 2: + sBerryBlenderData->field_6F++; + DestroyMenuCursor(); + MenuZeroFillWindowRect(23, 8, 28, 13); + MenuPrintMessage(gOtherText_OutOfBerries, 1, 15); + break; + case 3: + if (MenuUpdateWindowText()) + sBerryBlenderData->field_6F = 9; + break; + case 9: + BeginFastPaletteFade(3); + sBerryBlenderData->field_6F++; + break; + case 10: + if (!gPaletteFade.active) + { + if (sBerryBlenderData->field_7C == 0) + SetMainCallback2(sub_804E538); + else + SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); + } + break; + } + + sub_805123C(); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +void sub_805123C(void) +{ + if (gReceivedRemoteLinkPlayers) + { + if (gRecvCmds[0][0] == 0x2FFF) + { + if (gRecvCmds[1][0] == 0x1111) + { + switch (gRecvCmds[2][0]) + { + case 0x8888: + sBerryBlenderData->field_78 = 0x8888; + sBerryBlenderData->field_7A = gRecvCmds[3][0]; + break; + case 0x9999: + sBerryBlenderData->field_78 = 0x9999; + sBerryBlenderData->field_7A = gRecvCmds[3][0]; + break; + case 0xAAAA: + sBerryBlenderData->field_78 = 0xAAAA; + sBerryBlenderData->field_7A = gRecvCmds[3][0]; + break; + } + sBerryBlenderData->field_70[0] = 0x1111; + } + else if (gRecvCmds[1][0] == 0x2222) + sBerryBlenderData->field_70[0] = 0x2222; + } + if (GetMultiplayerId() == 0 && sBerryBlenderData->field_70[0] != 0x1111 && sBerryBlenderData->field_70[0] != 0x2222) + { + u8 i; + for (i = 0; i < GetLinkPlayerCount(); i++) + { + if (gRecvCmds[0][i] == 0x2FFF) + { + switch (gRecvCmds[1][i]) + { + case 0x8888: + sBerryBlenderData->field_70[i] = 0x8888; + break; + case 0x7779: + sBerryBlenderData->field_70[i] = 0x7779; + break; + case 0x9999: + sBerryBlenderData->field_70[i] = 0x9999; + break; + case 0xAAAA: + sBerryBlenderData->field_70[i] = 0xAAAA; + break; + } + } + } + for (i = 0; i < GetLinkPlayerCount(); i++) + { + if (sBerryBlenderData->field_70[i] == 0) + break; + } + if (i == GetLinkPlayerCount()) + { + for (i = 0; i < GetLinkPlayerCount(); i++) + { + if (sBerryBlenderData->field_70[i] != 0x7779) + break; + } + gSendCmd[0] = 0x2FFF; + if (i == GetLinkPlayerCount()) + gSendCmd[1] = 0x2222; + else + { + gSendCmd[1] = 0x1111; + gSendCmd[2] = sBerryBlenderData->field_70[i]; + gSendCmd[3] = i; + } + } + } + } +} + +void sub_8051414(struct BgAffineDstData *dest) +{ + struct BgAffineSrcData affineSrc; + affineSrc.texX = 30720; + affineSrc.texY = 20480; + affineSrc.scrX = 120 - sBerryBlenderData->field_144; + affineSrc.scrY = 80 - sBerryBlenderData->field_146; + affineSrc.sx = sBerryBlenderData->field_142; + affineSrc.sy = sBerryBlenderData->field_142; + affineSrc.alpha = sBerryBlenderData->arrowPos; + BgAffineSet(&affineSrc, dest, 1); +} + +void sub_8051474(void) +{ + sBerryBlenderData->field_58 = sBerryBlenderData->arrowPos; + sBerryBlenderData->arrowPos += sBerryBlenderData->field_56; + sub_8051414(&sBerryBlenderData->field_168); +} + +void sub_80514A4(void) +{ + REG_BG2PA = sBerryBlenderData->field_168.pa; + REG_BG2PB = sBerryBlenderData->field_168.pb; + REG_BG2PC = sBerryBlenderData->field_168.pc; + REG_BG2PD = sBerryBlenderData->field_168.pd; + REG_BG2X = sBerryBlenderData->field_168.dx; + REG_BG2Y = sBerryBlenderData->field_168.dy; +} + +void sub_80514F0(void) +{ + REG_BG1HOFS = sBerryBlenderData->field_144; + REG_BG1VOFS = sBerryBlenderData->field_146; + REG_BG0HOFS = sBerryBlenderData->field_144; + REG_BG0VOFS = sBerryBlenderData->field_146; +} + +void sub_8051524(struct Sprite* sprite) +{ + sprite->data2 += sprite->data0; + sprite->data3 += sprite->data1; + sprite->pos2.x = sprite->data2 / 8; + sprite->pos2.y = sprite->data3 / 8; + if (sprite->animEnded) + DestroySprite(sprite); +} + +extern const struct SpriteTemplate gSpriteTemplate_82164FC; + +void sub_805156C(void) +{ + s32 limit = (Random() % 2) + 1; + s32 i; + + for (i = 0; i < limit; i++) + { + u16 rand; + s32 x, y; + u8 spriteID; + + rand = sBerryBlenderData->arrowPos + (Random() % 20); + + x = gSineTable[(rand & 0xFF) + 64] / 4; + y = gSineTable[(rand & 0xFF)] / 4; + + spriteID = CreateSprite(&gSpriteTemplate_82164FC, x + 120, y + 80, 1); + gSprites[spriteID].data0 = 16 - (Random() % 32); + gSprites[spriteID].data1 = 16 - (Random() % 32); + + gSprites[spriteID].callback = sub_8051524; + } +} + +void sub_8051650(struct Sprite* sprite) +{ + sprite->data0++; + sprite->pos2.y = -(sprite->data0 / 3); + if (sprite->animEnded) + DestroySprite(sprite); +} + +void sub_8051684(struct Sprite* sprite) +{ + sprite->data0++; + sprite->pos2.y = -(sprite->data0 * 2); + if (sprite->pos2.y < -12) + sprite->pos2.y = -12; + if (sprite->animEnded) + DestroySprite(sprite); +} + +void Blender_SetBankBerryData(u8 bank, u16 itemID) +{ + sBerryBlenderData->chosenItemID[bank] = itemID; + Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[bank], itemID); +} + +extern const u8* const gUnknown_08216284[]; +extern u8 byte_3002A68; + +void unref_sub_80516F8(u8 taskID) +{ + struct Task* task = &gTasks[taskID]; + if (gReceivedRemoteLinkPlayers) + { + s32 i; + if (GetMultiplayerId() == 0) + { + if (++task->data[0] > 120) + task->data[0] = 0; + if (task->data[0] == 100) + { + ZeroFillWindowRect(&sBerryBlenderData->field_4, 0, 0, 16, 20); + MenuDrawTextWindow(4, 4, 10, 12); + for (i = 0; i < 3; i++) + { + if (gLinkPlayers[i + 1].trainerId != 0) + MenuPrint(gUnknown_08216284[i], 5, (2 * i) + 5); + MenuDrawTextWindow(0, 13, 29, 19); + MenuPrint(gOtherText_PressAToStart, 1, 15); + } + } + if (gMain.newKeys & A_BUTTON) + { + sub_8007E4C(); + DestroyTask(taskID); + } + } + else + { + if (task->data[0] == 10) + MenuPrint(gOtherText_PleaseWait, 3, 10); + if (++task->data[0] > 120) + task->data[0] = 0; + if (byte_3002A68 > 4 && gReceivedRemoteLinkPlayers == 1) + DestroyTask(taskID); + } + } +} + +extern const struct SpriteTemplate gSpriteTemplate_821657C; + +void sub_805181C(struct Sprite* sprite) +{ + switch (sprite->data0) + { + case 0: + sprite->data1 += 8; + if (sprite->data1 > 88) + { + sprite->data1 = 88; + sprite->data0++; + PlaySE(SE_KON); + } + break; + case 1: + sprite->data2 += 1; + if (sprite->data2 > 20) + { + sprite->data0++; + sprite->data2 = 0; + } + break; + case 2: + sprite->data1 += 4; + if (sprite->data1 > 176) + { + if (++sprite->data3 == 3) + { + DestroySprite(sprite); + CreateSprite(&gSpriteTemplate_821657C, 120, -20, 2); + } + else + { + sprite->data0 = 0; + sprite->data1 = -16; + StartSpriteAnim(sprite, sprite->data3); + } + } + break; + } + sprite->pos2.y = sprite->data1; +} + +void sub_80518CC(struct Sprite* sprite) +{ + switch (sprite->data0) + { + case 0: + sprite->data1 += 8; + if (sprite->data1 > 92) + { + sprite->data1 = 92; + sprite->data0++; + PlaySE(SE_PIN); + } + break; + case 1: + sprite->data2 += 1; + if (sprite->data2 > 20) + sprite->data0++; + break; + case 2: + sprite->data1 += 4; + if (sprite->data1 > 176) + { + sBerryBlenderData->field_0++; + DestroySprite(sprite); + } + break; + } + sprite->pos2.y = sprite->data1; +} + +void sub_805194C(u16 a0, u16 a1) +{ + if (sBerryBlenderData->field_140 < a0) + { + sBerryBlenderData->field_140 += 2; + sub_805197C(sBerryBlenderData->field_140, a1); + } +} + +void sub_805197C(u16 a0, u16 a1) +{ + s32 var1, var2, var3, var4; + u16* vram; + + vram = (u16*)(VRAM + 0x6000); + var1 = (a0 * 64) / a1; + var2 = var1 / 8; + for (var4 = 0; var4 < var2; var4++) + { + vram[11 + var4] = 0x81E9; + vram[43 + var4] = 0x81F9; + } + var3 = var1 % 8; + if (var3 != 0) + { + vram[11 + var4] = var3 - 32287; + vram[43 + var4] = var3 - 32271; + var4++; + } + for (; var4 < 8; var4++) + { + vram[11 + var4] = 33249; + vram[43 + var4] = 33249 + 16; + } +} + +u32 sub_8051A1C(u16 a0) +{ + return 360000 * a0 / 0x10000; +} + +void sub_8051A3C(u16 a0) +{ + u8 i; + u8 palAdders[5]; + + u32 var = sub_8051A1C(a0); + if (sBerryBlenderData->max_RPM < var) + sBerryBlenderData->max_RPM = var; + for (i = 0; i < 5; i++) + { + palAdders[i] = var % 10; + var /= 10; + } + *((u16*)(VRAM + 0x6458)) = palAdders[4] + 0x8172; + *((u16*)(VRAM + 0x645A)) = palAdders[3] + 0x8172; + *((u16*)(VRAM + 0x645C)) = palAdders[2] + 0x8172; + *((u16*)(VRAM + 0x6460)) = palAdders[1] + 0x8172; + *((u16*)(VRAM + 0x6462)) = palAdders[0] + 0x8172; +} + +void sub_8051AC8(s16* a0, u16 a1) +{ + if (*a0 == 0) + *a0 = (Random() % a1) - (a1 / 2); +} + +void sub_8051AF4(s16* a0) +{ + if (*a0 < 0 ) + (*a0)++; + if (*a0 > 0 ) + (*a0)--; +} + +void sub_8051B18(void) +{ + sub_8051AF4(&sBerryBlenderData->field_144); + sub_8051AF4(&sBerryBlenderData->field_146); +} + +void sub_8051B40(s16* a0, u16 a1) +{ + s32 var; + if (a1 < 10) + var = 16; + else + var = 8; + if (*a0 == 0) + *a0 = (Random() % var) - (var / 2); + else + { + if (*a0 < 0) + (*a0)++; + if (*a0 > 0) + (*a0)--; + } +} + +bool8 sub_8051B8C(void) +{ + if (sBerryBlenderData->framesToWait == 0) + { + sBerryBlenderData->field_144 = 0; + sBerryBlenderData->field_146 = 0; + } + sBerryBlenderData->framesToWait++; + sub_8051B40(&sBerryBlenderData->field_144, sBerryBlenderData->framesToWait); + sub_8051B40(&sBerryBlenderData->field_146, sBerryBlenderData->framesToWait); + if (sBerryBlenderData->framesToWait == 20) + { + sBerryBlenderData->field_144 = 0; + sBerryBlenderData->field_146 = 0; + return 1; + } + else + return 0; +} + +void sub_8051C04(struct Sprite* sprite) +{ + sprite->pos2.x = -(sBerryBlenderData->field_144); + sprite->pos2.y = -(sBerryBlenderData->field_146); +} + +void Blender_TrySettingRecord(void) +{ + if (gSaveBlock1.berryBlenderRecords[sBerryBlenderData->playersNo - 2] < sBerryBlenderData->max_RPM) + gSaveBlock1.berryBlenderRecords[sBerryBlenderData->playersNo - 2] = sBerryBlenderData->max_RPM; +} + +extern const u8 gUnknown_082165E9[]; +extern const u8 gUnknown_082165EE[]; + +bool8 Blender_PrintBlendingResults(void) +{ + u16 i; + + struct Pokeblock pokeblock; + u8 vars2[8]; + u8 text[2][10]; + u16 berryIDs[4]; // unused + + switch (sBerryBlenderData->field_0) + { + case 0: + sBerryBlenderData->field_0++; + sBerryBlenderData->framesToWait = 17; + break; + case 1: + sBerryBlenderData->framesToWait -= 10; + if (sBerryBlenderData->framesToWait < 0) + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + } + break; + case 2: + if (++sBerryBlenderData->framesToWait > 20) + { + for (i = 0; i < 3; i++) + DestroySprite(&gSprites[sBerryBlenderData->scoreIconIDs[i]]); + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + } + break; + case 3: + { + u8* textPtr; + u16 secondsPassed, minutes, seconds; + + MenuDrawTextWindow(4, 2, 25, 17); + sub_8072BD8(gOtherText_ResultsOfBlending, 5, 3, 160); + for (i = 0; i < sBerryBlenderData->playersNo; i++) + { + u8 place = sBerryBlenderData->playerPlaces[i]; + textPtr = text[0]; + + StringCopy(textPtr, sBerryBlenderData->blendedBerries[place].name); + ConvertInternationalString(textPtr, gLinkPlayers[place].language); + StringAppend(textPtr, gOtherText_Berry); + textPtr = sBerryBlenderData->stringVar; + textPtr = ConvertIntToDecimalString(textPtr, i + 1); + textPtr[0] = CHAR_SPACE; + textPtr[1] = CHAR_PERIOD; + textPtr[2] = CHAR_SPACE; + textPtr += 3; + textPtr = sub_8072C74(textPtr, gLinkPlayers[place].name, 88, 0); + sub_8072C74(textPtr, text[0], 157, 0); + MenuPrint(sBerryBlenderData->stringVar, 5, gUnknown_082165E9[sBerryBlenderData->playersNo] + (i * gUnknown_082165EE[sBerryBlenderData->playersNo])); + } + ConvertIntToDecimalStringN(text[0], sBerryBlenderData->max_RPM % 100, 2, 2); + textPtr = sBerryBlenderData->stringVar; + textPtr = StringCopy(textPtr, gOtherText_MaxSpeed); + textPtr = sub_8072C14(textPtr, sBerryBlenderData->max_RPM / 100, 121, 1); + + textPtr[0] = CHAR_SPACE; + textPtr[1] = CHAR_PERIOD; + textPtr[2] = CHAR_SPACE; + textPtr += 3; + + textPtr = sub_8072C74(textPtr, text[0], 142, 1); + StringCopy(textPtr, gOtherText_RPM); + MenuPrint(sBerryBlenderData->stringVar, 5, 13); + + secondsPassed = sBerryBlenderData->gameFrameTime / 60; + seconds = secondsPassed % 60; + minutes = secondsPassed / 60; + ConvertIntToDecimalStringN(text[0], minutes, 2, 2); + ConvertIntToDecimalStringN(text[1], seconds, 2, 2); + textPtr = sBerryBlenderData->stringVar; + textPtr = StringCopy(textPtr, gOtherText_RequiredTime); + + textPtr = sub_8072C74(textPtr, text[0], 102, 1); + textPtr = StringAppend(textPtr, gOtherText_Min); + + textPtr = sub_8072C74(textPtr, text[1], 136, 1); + StringCopy(textPtr, gOtherText_Sec); + + MenuPrint(sBerryBlenderData->stringVar, 5, 15); + + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + } + break; + case 4: + if (gMain.newKeys & A_BUTTON) + sBerryBlenderData->field_0++; + break; + case 5: + MenuZeroFillScreen(); + MenuDrawTextWindow(0, 14, 29, 19); + for (i = 0; i < BLENDER_MAX_PLAYERS; i++) + { + if (sBerryBlenderData->chosenItemID[i] != 0) + berryIDs[i] = sBerryBlenderData->chosenItemID[i] - 133; + } + sub_8050760(); + sub_8050520(sBerryBlenderData->blendedBerries, &pokeblock, sBerryBlenderData->playersNo, vars2, sBerryBlenderData->max_RPM); + Blender_PrintMadePokeblockString(&pokeblock, sBerryBlenderData->stringVar); + CreateTask(sub_8052BD0, 6); + MenuPrintMessage(sBerryBlenderData->stringVar, 1, 15); + RemoveBagItem(gScriptItemId, 1); + sub_810CA34(&pokeblock); + sBerryBlenderData->field_0++; + break; + case 6: + if (MenuUpdateWindowText()) + { + Blender_TrySettingRecord(); + return 1; + } + break; + } + return 0; +} + +extern const u8 gUnknown_08216249[]; +extern const u8 gUnknown_082162C8[]; +extern const u8 *const gPokeblockNames[]; + +void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst) +{ + u8 text[12]; + u8 flavourLvl, feel; + + dst[0] = EOS; + StringCopy(dst, gPokeblockNames[pokeblock->color]); + StringAppend(dst, gOtherText_PokeBlockMade); + StringAppend(dst, gUnknown_082162C8); + + flavourLvl = sub_810C9B0(pokeblock); + feel = sub_810C9E8(pokeblock); + + StringAppend(dst, gOtherText_BlockLevelIs); + ConvertIntToDecimalStringN(text, flavourLvl, 0, 3); + StringAppend(dst, text); + + StringAppend(dst, gOtherText_BlockFeelIs); + ConvertIntToDecimalStringN(text, feel, 0, 3); + StringAppend(dst, text); + + StringAppend(dst, gOtherText_Period); + StringAppend(dst, gUnknown_08216249); +} + +void Blender_SortBasedOnPoints(u8* places, u8 playersNum, u32* scores) +{ + s32 i, j; + for (i = 0; i < playersNum; i++) + { + for (j = 0; j < playersNum; j++) + { + if (scores[places[i]] > scores[places[j]]) + { + u8 temp = places[i]; + places[i] = places[j]; + places[j] = temp; + } + } + } +} + +void Blender_SortScores(void) +{ + u8 i; + u8 places[4]; + u32 points[4]; + + for (i = 0; i < sBerryBlenderData->playersNo; i++) + places[i] = i; + for (i = 0; i < sBerryBlenderData->playersNo; i++) + { + points[i] = 1000000 * sBerryBlenderData->scores[i][BLENDER_SCORE_BEST]; + points[i] += 1000 * sBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]; + points[i] += 1000 - sBerryBlenderData->scores[i][BLENDER_SCORE_MISS]; + } + Blender_SortBasedOnPoints(places, sBerryBlenderData->playersNo, points); + for (i = 0; i < sBerryBlenderData->playersNo; i++) + sBerryBlenderData->playerPlaces[i] = places[i]; +} + +extern const u8 gUnknown_082165F3[]; + +bool8 Blender_PrintBlendingRanking(void) +{ + u16 i; + switch (sBerryBlenderData->field_0) + { + case 0: + sBerryBlenderData->field_0++; + sBerryBlenderData->framesToWait = 255; + break; + case 1: + sBerryBlenderData->framesToWait -= 10; + if (sBerryBlenderData->framesToWait < 0) + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + } + break; + case 2: + if (++sBerryBlenderData->framesToWait > 20) + { + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + } + break; + case 3: + MenuDrawTextWindow(4, 2, 25, 17); + sub_8072BD8(gOtherText_Ranking, 5, 3, 160); + + sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST] = CreateSprite(&gSpriteTemplate_821645C, 140, 52, 0); + gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]].callback = SpriteCallbackDummy; + StartSpriteAnim(&gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]], 3); + + sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD] = CreateSprite(&gSpriteTemplate_821645C, 164, 52, 0); + gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD]].callback = SpriteCallbackDummy; + + sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS] = CreateSprite(&gSpriteTemplate_821645C, 188, 52, 0); + gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]].callback = SpriteCallbackDummy; + StartSpriteAnim(&gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]], 1); + + Blender_SortScores(); + + for (i = 0; i < sBerryBlenderData->playersNo; i++) + { + u8 place = sBerryBlenderData->playerPlaces[i]; + u8* txtPtr = sBerryBlenderData->stringVar; + + txtPtr[0] = EXT_CTRL_CODE_BEGIN; + txtPtr[1] = 0x13; + txtPtr[2] = 4; + txtPtr += 3; + + txtPtr = ConvertIntToDecimalString(txtPtr, i + 1); + + txtPtr[0] = CHAR_SPACE; + txtPtr[1] = CHAR_PERIOD; + txtPtr[2] = CHAR_SPACE; + txtPtr += 3; + + txtPtr = StringCopy(txtPtr, gLinkPlayers[place].name); + + txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_BEST], 108, 1); + txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_GOOD], 132, 1); + txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_MISS], 156, 1); + + MenuPrint(sBerryBlenderData->stringVar, 5, i * gUnknown_082165F3[sBerryBlenderData->playersNo] + 8); + } + sBerryBlenderData->framesToWait = 0; + sBerryBlenderData->field_0++; + break; + case 4: + if (++sBerryBlenderData->framesToWait > 20) + sBerryBlenderData->field_0++; + break; + case 5: + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + sBerryBlenderData->field_0++; + } + break; + case 6: + sBerryBlenderData->field_0 = 0; + return 1; + } + return 0; +} + +struct UnknownStruct +{ + s8 bytes[24]; + s16 hword[2]; +}; + +extern struct UnknownStruct gUnknown_03000560; + +void unref_sub_80524BC(void) +{ + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + SetVBlankCallback(VBlankCB1_BerryBlender); + SetUpWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow(&gWindowConfig_81E6CE4); + SeedRng(gMain.vblankCounter1); + REG_DISPCNT = 0x1540; + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); + gUnknown_03000560.hword[1] = 0x1F40; + gUnknown_03000560.bytes[16]++; + SetMainCallback2(sub_8052AF8); +} diff --git a/src/link.c b/src/link.c index 5858ad8bf..850201ccb 100644 --- a/src/link.c +++ b/src/link.c @@ -2,7 +2,6 @@ #include "link.h" #include "battle.h" #include "berry.h" -#include "berry_blender.h" #include "hall_of_fame.h" #include "item_use.h" #include "main.h" @@ -42,6 +41,8 @@ extern u16 gBattleTypeFlags; extern u16 word_3004858; +extern void Blender_SetBankBerryData(u8 bank, u16 itemID); + static void InitLinkTestBG(u8, u8, u8, u8); void InitLinkTestBG_Unused(u8, u8, u8, u8); void LinkTestScreen(); @@ -556,7 +557,7 @@ static void ProcessRecvCmds(u8 unusedParam) sub_8007E24(); break; case 0xAAAB: - sub_80516C4(i, gRecvCmds[1][i]); + Blender_SetBankBerryData(i, gRecvCmds[1][i]); break; case 0xCCCC: #if defined(ENGLISH) -- cgit v1.2.3 From 81274f41e1730f34d2929baa3b3f95d83145a97d Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 12 Aug 2017 18:55:06 -0500 Subject: clean up learn_move.c a bit --- src/learn_move.c | 578 +++++++++++++++++++++++++++---------------------------- 1 file changed, 280 insertions(+), 298 deletions(-) (limited to 'src') diff --git a/src/learn_move.c b/src/learn_move.c index a83d7a491..71de9910a 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -17,57 +17,63 @@ #include "task.h" #include "trig.h" -struct UnknownStruct1 -{ - const u8 *unk0; - u8 unk4; - u8 unk5; - u8 unk6; -}; - extern u8 ewram[]; extern u16 gSpecialVar_0x8004; extern u16 gSpecialVar_0x8005; extern u8 gTileBuffer[]; +struct ContestMove +{ + u8 effect; + u8 contestCategory:3; + u8 comboStarterId; + u8 comboMoves[4]; +}; + +struct ContestEffect +{ + u8 effectType; + u8 appeal; + u8 jam; +}; + +extern const struct ContestMove gContestMoves[]; +extern const struct ContestEffect gContestEffects[]; extern const struct WindowConfig gWindowConfig_81E6CE4; extern const struct WindowConfig gWindowConfig_81E7240; -extern const struct SpriteSheet gUnknown_08402D80; -extern const struct SpritePalette gUnknown_08402D88; +extern const u8 *const gUnknown_083CADD4[]; +extern const u8 *const gMoveDescriptions[]; +extern const u8 gTypeNames[][7]; +extern const u8 *const gUnknown_083CAF70[]; extern void sub_809D9F0(struct Pokemon *, u8, u8, void *, u32); -struct Struct2017000 +struct LearnMoveStruct { - u8 unk0; + u8 state; u8 filler1; u8 unk2; - u8 unk3[2]; - //u8 unk4; - u8 unk5[16]; - u8 filler15[3]; + u8 spriteIDs[20]; + u8 filler17[1]; u8 unk18; u8 unk19; - u8 unk1A; - u8 unk1B; + u8 numMenuChoices; + u8 menuSelection; u8 unk1C; - u8 unk1D; + bool8 unk1D; u8 unk1E; u8 filler1F; - //u16 unk20[4]; - //u8 filler28[0x2C3-0x28]; - u16 unk20[20]; + /*0x020*/ u16 movesToLearn[20]; u8 filler48[0x52-0x48]; - //u8 unk52[0x2C3-0x52]; - u8 unk52[6][0x19]; + u8 moveNames[6][0x19]; u8 fillerE8[0x2C3-0xE8]; - u8 unk2C3; - u8 unk2C4; - u8 unk2C5; + bool8 unk2C3; + bool8 showContestInfo; + /*0x2C5*/ u8 partyMon; u8 unk2C6; }; -extern struct Struct2017000 *gUnknown_030007B0; +static struct LearnMoveStruct *sLearnMoveStruct; const u16 gDexArrows_Pal[] = INCBIN_U16("graphics/pokedex/arrows.gbapal"); @@ -81,6 +87,14 @@ const u8 gUnknown_08402CF8[][4] = {10, 8, 29, 13}, }; +struct UnknownStruct1 +{ + const u8 *unk0; + u8 unk4; + u8 unk5; + u8 unk6; +}; + const struct UnknownStruct1 gUnknown_08402D08[][4] = { { @@ -212,38 +226,24 @@ const struct SpriteTemplate gSpriteTemplate_8402E08 = const u8 gString_AkitoMori[] = _("あきと"); // programmer Akito Mori? -const u8 gUnknown_08402E24[7][3] = -{ - {11, 1, 1}, - { 3, 6, 2}, - {24, 1, 3}, - { 3, 11, 4}, - { 5, 4, 5}, - { 3, 6, 6}, - { 3, 11, 7}, -}; - -const u8 gUnknown_08402E39[] = {0, 1, 2, 3}; -const u8 gUnknown_08402E3D[] = {4, 5, 6}; - void sub_813269C(u8); -void sub_81326D8(void); -void sub_8132870(void); -void sub_8132908(void); -void sub_8132FEC(void); -void sub_8133030(u8); +void CB2_InitLearnMove(void); +void CB2_LearnMove(void); +void LearnMoveMain(void); +void DrawLearnMoveMenuWindow(void); +void sub_8133030(bool8); u8 sub_81330E8(void); void sub_8133140(u8); u8 sub_8133248(void); -void sub_81332A0(void); +void ClearLearnMoveVars(void); void sub_8133358(void); void sub_8133558(void); void sub_813362C(void); void sub_8133800(void); -void sub_8133AEC(u8, int); +void sub_8133AEC(bool8, int); void sub_8133CA4(void); -void sub_813265C(void) +void VBlankCB_LearnMove(void) { LoadOam(); ProcessSpriteCopyRequests(); @@ -261,23 +261,23 @@ void sub_813269C(u8 taskId) { if (!gPaletteFade.active) { - SetMainCallback2(sub_81326D8); + SetMainCallback2(CB2_InitLearnMove); gFieldCallback = sub_8080990; DestroyTask(taskId); } } -void sub_81326D8(void) +void CB2_InitLearnMove(void) { REG_DISPCNT = 0; ResetSpriteData(); FreeAllSpritePalettes(); ResetTasks(); - gUnknown_030007B0 = (struct Struct2017000 *)(ewram + 0x17000); - sub_81332A0(); - gUnknown_030007B0->unk2C5 = gSpecialVar_0x8004; + sLearnMoveStruct = (struct LearnMoveStruct *)(ewram + 0x17000); + ClearLearnMoveVars(); + sLearnMoveStruct->partyMon = gSpecialVar_0x8004; sub_8133558(); - SetVBlankCallback(sub_813265C); + SetVBlankCallback(VBlankCB_LearnMove); SetUpWindowConfig(&gWindowConfig_81E7240); InitMenuWindow(&gWindowConfig_81E7240); @@ -300,7 +300,7 @@ void sub_81326D8(void) AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); - SetMainCallback2(sub_8132870); + SetMainCallback2(CB2_LearnMove); } void sub_81327A4(void) @@ -308,10 +308,10 @@ void sub_81327A4(void) ResetSpriteData(); FreeAllSpritePalettes(); ResetTasks(); - gUnknown_030007B0 = (struct Struct2017000 *)(ewram + 0x17000); + sLearnMoveStruct = (struct LearnMoveStruct *)(ewram + 0x17000); sub_8133558(); - gUnknown_030007B0->unk2C6 = gSpecialVar_0x8005; - SetVBlankCallback(sub_813265C); + sLearnMoveStruct->unk2C6 = gSpecialVar_0x8005; + SetVBlankCallback(VBlankCB_LearnMove); SetUpWindowConfig(&gWindowConfig_81E7240); InitMenuWindow(&gWindowConfig_81E7240); @@ -335,26 +335,26 @@ void sub_81327A4(void) AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); - SetMainCallback2(sub_8132870); + SetMainCallback2(CB2_LearnMove); } -void sub_8132870(void) +void CB2_LearnMove(void) { - sub_8132908(); - if (gUnknown_030007B0->unk1D != 0) + LearnMoveMain(); + if (sLearnMoveStruct->unk1D) { - gUnknown_030007B0->unk1D = 0; - sub_814AD7C(0x58, (gUnknown_030007B0->unk18 * 2 + 1) * 8); + sLearnMoveStruct->unk1D = FALSE; + sub_814AD7C(0x58, (sLearnMoveStruct->unk18 * 2 + 1) * 8); } - if (gUnknown_030007B0->unk1E != 0) + if (sLearnMoveStruct->unk1E != 0) { - gUnknown_030007B0->unk1E = 0; + sLearnMoveStruct->unk1E = 0; sub_8133800(); } - if (gUnknown_030007B0->unk2C3 != 0) + if (sLearnMoveStruct->unk2C3) { - sub_8133AEC(gUnknown_030007B0->unk2C4, 1); - gUnknown_030007B0->unk2C3 = 0; + sub_8133AEC(sLearnMoveStruct->showContestInfo, 1); + sLearnMoveStruct->unk2C3 = FALSE; } RunTasks(); AnimateSprites(); @@ -368,32 +368,32 @@ void sub_81328E8(const u8 *a) MenuPrintMessage(gStringVar4, 3, 15); } -void sub_8132908(void) +void LearnMoveMain(void) { - switch (gUnknown_030007B0->unk0) + switch (sLearnMoveStruct->state) { case 0: - gUnknown_030007B0->unk0++; - sub_8132FEC(); - sub_8133030(0); + sLearnMoveStruct->state++; + DrawLearnMoveMenuWindow(); + sub_8133030(FALSE); sub_8133800(); gSprites[1].pos1.x = 0x48; - gUnknown_030007B0->unk2C3 = 1; + sLearnMoveStruct->unk2C3 = TRUE; BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); REG_DISPCNT = 0x1340; break; case 1: if (!gPaletteFade.active) - gUnknown_030007B0->unk0 = 4; + sLearnMoveStruct->state = 4; break; case 2: - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; break; case 3: - sub_8133030(0); + sub_8133030(FALSE); sub_8133800(); - gUnknown_030007B0->unk2C3 = 1; - gUnknown_030007B0->unk0++; + sLearnMoveStruct->unk2C3 = TRUE; + sLearnMoveStruct->state++; gSprites[1].pos1.x = 0x48; break; case 4: @@ -403,9 +403,9 @@ void sub_8132908(void) case 5: sub_8133140(0); sub_8133800(); - gUnknown_030007B0->unk2C3 = 1; + sLearnMoveStruct->unk2C3 = TRUE; gSprites[1].pos1.x = 0x48; - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; break; case 6: if (sub_8133248() == 0) @@ -415,34 +415,34 @@ void sub_8132908(void) if (MenuUpdateWindowText()) { DisplayYesNoMenu(21, 7, 1); - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; } break; case 9: { - s8 var = ProcessMenuInputNoWrap_(); + s8 selection = ProcessMenuInputNoWrap_(); - if (var == 0) + if (selection == 0) { sub_8133CA4(); - if (GiveMoveToMon(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]) != 0xFFFF) + if (GiveMoveToMon(&gPlayerParty[sLearnMoveStruct->partyMon], sLearnMoveStruct->movesToLearn[sLearnMoveStruct->menuSelection]) != 0xFFFF) { sub_81328E8(gOtherText_PokeLearnedMove); gSpecialVar_0x8004 = 1; - gUnknown_030007B0->unk0 = 31; + sLearnMoveStruct->state = 31; } else { - gUnknown_030007B0->unk0 = 16; + sLearnMoveStruct->state = 16; } } - else if (var == -1 || var == 1) + else if (selection == -1 || selection == 1) { sub_8133CA4(); - if (gUnknown_030007B0->unk2C4 == 0) - gUnknown_030007B0->unk0 = 3; - if (gUnknown_030007B0->unk2C4 == 1) - gUnknown_030007B0->unk0 = 5; + if (sLearnMoveStruct->showContestInfo == FALSE) + sLearnMoveStruct->state = 3; + if (sLearnMoveStruct->showContestInfo == TRUE) + sLearnMoveStruct->state = 5; } } break; @@ -450,38 +450,38 @@ void sub_8132908(void) if (MenuUpdateWindowText()) { DisplayYesNoMenu(21, 7, 1); - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; } break; case 13: { - s8 r4 = ProcessMenuInputNoWrap_(); + s8 selection = ProcessMenuInputNoWrap_(); - if (r4 == 0) + if (selection == 0) { sub_8133CA4(); - gSpecialVar_0x8004 = r4; - gUnknown_030007B0->unk0 = 14; + gSpecialVar_0x8004 = selection; + sLearnMoveStruct->state = 14; } - else if (r4 == -1 || r4 == 1) + else if (selection == -1 || selection == 1) { sub_8133CA4(); - if (gUnknown_030007B0->unk2C4 == 0) - gUnknown_030007B0->unk0 = 3; - if (gUnknown_030007B0->unk2C4 == 1) - gUnknown_030007B0->unk0 = 5; + if (sLearnMoveStruct->showContestInfo == FALSE) + sLearnMoveStruct->state = 3; + if (sLearnMoveStruct->showContestInfo == TRUE) + sLearnMoveStruct->state = 5; } } break; case 16: sub_81328E8(gOtherText_DeleteOlderMove); - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; break; case 17: if (MenuUpdateWindowText()) { DisplayYesNoMenu(21, 7, 1); - gUnknown_030007B0->unk0 = 18; + sLearnMoveStruct->state = 18; } break; case 18: @@ -492,23 +492,23 @@ void sub_8132908(void) { sub_8133CA4(); sub_81328E8(gOtherText_WhichMoveToForget); - gUnknown_030007B0->unk0 = 19; + sLearnMoveStruct->state = 19; } else if (var == -1 || var == 1) { sub_8133CA4(); - gUnknown_030007B0->unk0 = 24; + sLearnMoveStruct->state = 24; } } break; case 24: sub_81328E8(gOtherText_StopLearningMove); - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; break; case 25: if (MenuUpdateWindowText()) { - gUnknown_030007B0->unk0 = 26; + sLearnMoveStruct->state = 26; DisplayYesNoMenu(21, 7, 1); } break; @@ -519,54 +519,54 @@ void sub_8132908(void) if (var == 0) { sub_8133CA4(); - gUnknown_030007B0->unk0 = 27; + sLearnMoveStruct->state = 27; } else if (var == -1 || var == 1) { sub_8133CA4(); // What's the point? It gets set to 16, anyway. - if (gUnknown_030007B0->unk2C4 == 0) - gUnknown_030007B0->unk0 = 3; - if (gUnknown_030007B0->unk2C4 == 1) - gUnknown_030007B0->unk0 = 5; - gUnknown_030007B0->unk0 = 16; + if (sLearnMoveStruct->showContestInfo == FALSE) + sLearnMoveStruct->state = 3; + if (sLearnMoveStruct->showContestInfo == TRUE) + sLearnMoveStruct->state = 5; + sLearnMoveStruct->state = 16; } } break; case 27: if (MenuUpdateWindowText()) { - if (gUnknown_030007B0->unk2C4 == 0) - gUnknown_030007B0->unk0 = 3; - if (gUnknown_030007B0->unk2C4 == 1) - gUnknown_030007B0->unk0 = 5; + if (sLearnMoveStruct->showContestInfo == FALSE) + sLearnMoveStruct->state = 3; + if (sLearnMoveStruct->showContestInfo == TRUE) + sLearnMoveStruct->state = 5; } break; case 19: if (MenuUpdateWindowText()) { - gUnknown_030007B0->unk0 = 20; + sLearnMoveStruct->state = 20; BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); } break; case 20: if (!gPaletteFade.active) { - sub_809D9F0(gPlayerParty, gUnknown_030007B0->unk2C5, gPlayerPartyCount - 1, sub_81327A4, gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]); - gUnknown_030007B0->unk0 = 28; + sub_809D9F0(gPlayerParty, sLearnMoveStruct->partyMon, gPlayerPartyCount - 1, sub_81327A4, sLearnMoveStruct->movesToLearn[sLearnMoveStruct->menuSelection]); + sLearnMoveStruct->state = 28; } break; case 21: if (MenuUpdateWindowText()) - gUnknown_030007B0->unk0 = 14; + sLearnMoveStruct->state = 14; break; case 22: BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); break; case 14: BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - gUnknown_030007B0->unk0++; + sLearnMoveStruct->state++; break; case 15: if (!gPaletteFade.active) @@ -574,35 +574,35 @@ void sub_8132908(void) break; case 28: BeginNormalPaletteFade(0xFFFFFFFF, 0, 16, 0, 0); - gUnknown_030007B0->unk0++; - sub_8132FEC(); + sLearnMoveStruct->state++; + DrawLearnMoveMenuWindow(); sub_8133800(); - if (gUnknown_030007B0->unk2C4 == 0) - sub_8133030(1); - if (gUnknown_030007B0->unk2C4 == 1) + if (sLearnMoveStruct->showContestInfo == FALSE) + sub_8133030(TRUE); + if (sLearnMoveStruct->showContestInfo == TRUE) { gSprites[1].pos1.x = 0x48; sub_8133140(1); } - sub_8133AEC(gUnknown_030007B0->unk2C4, 1); + sub_8133AEC(sLearnMoveStruct->showContestInfo, 1); break; case 29: if (!gPaletteFade.active) { - if (gUnknown_030007B0->unk2C6 == 4) + if (sLearnMoveStruct->unk2C6 == 4) { - gUnknown_030007B0->unk0 = 24; + sLearnMoveStruct->state = 24; } else { - u16 moveId = GetMonData(&gPlayerParty[gUnknown_030007B0->unk2C5], MON_DATA_MOVE1 + gUnknown_030007B0->unk2C6); + u16 moveId = GetMonData(&gPlayerParty[sLearnMoveStruct->partyMon], MON_DATA_MOVE1 + sLearnMoveStruct->unk2C6); StringCopy(gStringVar3, gMoveNames[moveId]); - RemoveMonPPBonus(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk2C6); - SetMonMoveSlot(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B], gUnknown_030007B0->unk2C6); - StringCopy(gStringVar2, gMoveNames[gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]]); + RemoveMonPPBonus(&gPlayerParty[sLearnMoveStruct->partyMon], sLearnMoveStruct->unk2C6); + SetMonMoveSlot(&gPlayerParty[sLearnMoveStruct->partyMon], sLearnMoveStruct->movesToLearn[sLearnMoveStruct->menuSelection], sLearnMoveStruct->unk2C6); + StringCopy(gStringVar2, gMoveNames[sLearnMoveStruct->movesToLearn[sLearnMoveStruct->menuSelection]]); sub_81328E8(gOtherText_ForgotMove123); - gUnknown_030007B0->unk0 = 30; + sLearnMoveStruct->state = 30; gSpecialVar_0x8004 = 1; } } @@ -615,7 +615,7 @@ void sub_8132908(void) #else sub_81328E8(deuOtherText_ForgotAndLearned); #endif - gUnknown_030007B0->unk0 = 31; + sLearnMoveStruct->state = 31; PlayFanfare(BGM_FANFA1); } break; @@ -623,24 +623,24 @@ void sub_8132908(void) if (MenuUpdateWindowText()) { PlayFanfare(BGM_FANFA1); - gUnknown_030007B0->unk0 = 32; + sLearnMoveStruct->state = 32; } break; case 32: if (IsFanfareTaskInactive()) - gUnknown_030007B0->unk0 = 33; + sLearnMoveStruct->state = 33; break; case 33: if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk0 = 14; + sLearnMoveStruct->state = 14; } break; } } -void sub_8132FEC(void) +void DrawLearnMoveMenuWindow(void) { u32 i; @@ -660,53 +660,50 @@ void sub_8133030(bool8 a) { s32 i; - gSprites[gUnknown_030007B0->unk3[0]].invisible = FALSE; - gSprites[gUnknown_030007B0->unk3[1]].invisible = FALSE; + gSprites[sLearnMoveStruct->spriteIDs[0]].invisible = FALSE; + gSprites[sLearnMoveStruct->spriteIDs[1]].invisible = FALSE; + for (i = 0; i < 16; i++) - { - // Hmm... - gSprites[*((u8 *)gUnknown_030007B0 + i + 7)].invisible = TRUE; - } + gSprites[sLearnMoveStruct->spriteIDs[i + 4]].invisible = TRUE; + for (i = 0; gUnknown_08402D08[0][i].unk0 != NULL; i++) { sub_8072C74(gTileBuffer, gUnknown_08402D08[0][i].unk0, 64, 2); MenuPrint(gTileBuffer, gUnknown_08402D08[0][i].unk4, gUnknown_08402D08[0][i].unk5); } + if (!a) - { sub_8072AB0(gOtherText_TeachWhichMove, 24, 120, 192, 32, 1); - } } u8 sub_81330E8(void) { - u32 r4 = ((gMain.newKeys & 0x30) != 0); + u32 result = (gMain.newKeys & DPAD_LEFT) || (gMain.newKeys & DPAD_RIGHT); if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_LR - && (gMain.newKeys & 0x300)) - r4++; + && ((gMain.newKeys & L_BUTTON) || (gMain.newKeys & R_BUTTON))) + result++; - if (r4 != 0) + if (result != 0) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk0 = 5; - gUnknown_030007B0->unk2C4 = 1; + sLearnMoveStruct->state = 5; + sLearnMoveStruct->showContestInfo = TRUE; } - return r4; + return result; } void sub_8133140(bool8 a) { s32 i; - gSprites[gUnknown_030007B0->unk3[0]].invisible = FALSE; - gSprites[gUnknown_030007B0->unk3[1]].invisible = FALSE; + gSprites[sLearnMoveStruct->spriteIDs[0]].invisible = FALSE; + gSprites[sLearnMoveStruct->spriteIDs[1]].invisible = FALSE; + for (i = 0; i < 16; i++) - { - // Hmm... - gSprites[*((u8 *)gUnknown_030007B0 + i + 7)].invisible = FALSE; - } + gSprites[sLearnMoveStruct->spriteIDs[i + 4]].invisible = FALSE; + for (i = 0; gUnknown_08402D08[0][i].unk0 != NULL; i++) { sub_8072C74(gTileBuffer, gUnknown_08402D08[1][i].unk0, 64, 2); @@ -720,45 +717,46 @@ void sub_8133140(bool8 a) gUnknown_08402D08[1][i].unk5 + 3); } } + if (!a) sub_8072AB0(gOtherText_TeachWhichMove, 24, 120, 192, 32, 1); } u8 sub_8133248(void) { - u32 r4 = ((gMain.newKeys & 0x30) != 0); + u32 result = (gMain.newKeys & DPAD_LEFT) || (gMain.newKeys & DPAD_RIGHT); if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_LR - && (gMain.newKeys & 0x300)) - r4++; + && ((gMain.newKeys & L_BUTTON) || (gMain.newKeys & R_BUTTON))) + result++; - if (r4 != 0) + if (result != 0) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk0 = 3; - gUnknown_030007B0->unk2C4 = 0; + sLearnMoveStruct->state = 3; + sLearnMoveStruct->showContestInfo = FALSE; } - return r4; + return result; } -void sub_81332A0(void) +void ClearLearnMoveVars(void) { s32 i; - gUnknown_030007B0->unk0 = 0; - gUnknown_030007B0->unk2 = 0; - gUnknown_030007B0->unk19 = 0; - gUnknown_030007B0->unk18 = 0; - gUnknown_030007B0->unk1C = 0; - gUnknown_030007B0->unk1A = 0; - gUnknown_030007B0->unk1B = 0; - gUnknown_030007B0->unk1D = 0; - gUnknown_030007B0->unk1E = 0; - gUnknown_030007B0->unk2C3 = 0; - gUnknown_030007B0->unk2C4 = 0; + sLearnMoveStruct->state = 0; + sLearnMoveStruct->unk2 = 0; + sLearnMoveStruct->unk19 = 0; + sLearnMoveStruct->unk18 = 0; + sLearnMoveStruct->unk1C = 0; + sLearnMoveStruct->numMenuChoices = 0; + sLearnMoveStruct->menuSelection = 0; + sLearnMoveStruct->unk1D = FALSE; + sLearnMoveStruct->unk1E = 0; + sLearnMoveStruct->unk2C3 = FALSE; + sLearnMoveStruct->showContestInfo = FALSE; for (i = 0; i < 20; i++) - gUnknown_030007B0->unk20[i] = 0; + sLearnMoveStruct->movesToLearn[i] = 0; } void sub_8133300(struct Sprite *sprite) @@ -779,46 +777,42 @@ void sub_8133300(struct Sprite *sprite) sprite->data1++; } -extern const struct SpriteTemplate gSpriteTemplate_8402D90; -extern const struct SpriteTemplate gSpriteTemplate_8402DC0; -extern const struct SpriteTemplate gSpriteTemplate_8402E08; - void sub_8133358(void) { s32 i; - gUnknown_030007B0->unk3[0] = CreateSprite(&gSpriteTemplate_8402D90, 8, 16, 0); - gSprites[gUnknown_030007B0->unk3[0]].data0 = 1; - gSprites[gUnknown_030007B0->unk3[0]].data2 = -1; + sLearnMoveStruct->spriteIDs[0] = CreateSprite(&gSpriteTemplate_8402D90, 8, 16, 0); + gSprites[sLearnMoveStruct->spriteIDs[0]].data0 = 1; + gSprites[sLearnMoveStruct->spriteIDs[0]].data2 = -1; - gUnknown_030007B0->unk3[1] = CreateSprite(&gSpriteTemplate_8402D90, 72, 16, 0); - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[1]], 1); - gSprites[gUnknown_030007B0->unk3[1]].data0 = 1; - gSprites[gUnknown_030007B0->unk3[1]].data2 = 1; + sLearnMoveStruct->spriteIDs[1] = CreateSprite(&gSpriteTemplate_8402D90, 72, 16, 0); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[1]], 1); + gSprites[sLearnMoveStruct->spriteIDs[1]].data0 = 1; + gSprites[sLearnMoveStruct->spriteIDs[1]].data2 = 1; - gUnknown_030007B0->unk3[2] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 4, 0); - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[2]], 1); - gSprites[gUnknown_030007B0->unk3[2]].data0 = 2; - gSprites[gUnknown_030007B0->unk3[2]].data2 = -1; + sLearnMoveStruct->spriteIDs[2] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 4, 0); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[2]], 1); + gSprites[sLearnMoveStruct->spriteIDs[2]].data0 = 2; + gSprites[sLearnMoveStruct->spriteIDs[2]].data2 = -1; - gUnknown_030007B0->unk3[3] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 60, 0); - gSprites[gUnknown_030007B0->unk3[3]].data0 = 2; - gSprites[gUnknown_030007B0->unk3[3]].data2 = 1; + sLearnMoveStruct->spriteIDs[3] = CreateSprite(&gSpriteTemplate_8402DC0, 160, 60, 0); + gSprites[sLearnMoveStruct->spriteIDs[3]].data0 = 2; + gSprites[sLearnMoveStruct->spriteIDs[3]].data2 = 1; for (i = 0; i < 8; i++) { - gUnknown_030007B0->unk3[i + 4] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x34, 0); - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 2); + sLearnMoveStruct->spriteIDs[i + 4] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x34, 0); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 4]], 2); } for (i = 0; i < 8; i++) { - gUnknown_030007B0->unk3[i + 12] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x5C, 0); - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 2); + sLearnMoveStruct->spriteIDs[i + 12] = CreateSprite(&gSpriteTemplate_8402E08, (i - (i / 4) * 4) * 8 + 0x1C, (i / 4) * 8 + 0x5C, 0); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 12]], 2); } for (i = 0; i < 20; i++) - gSprites[gUnknown_030007B0->unk3[i]].invisible = TRUE; + gSprites[sLearnMoveStruct->spriteIDs[i]].invisible = TRUE; CreateBlendedOutlineCursor(16, 0xFFFF, 12, 0x2D9F, 18); } @@ -828,67 +822,67 @@ void sub_8133558(void) s32 i; u8 nickname[POKEMON_NAME_LENGTH + 1]; - gUnknown_030007B0->unk1A = GetMoveRelearnerMoves(&gPlayerParty[gUnknown_030007B0->unk2C5], gUnknown_030007B0->unk20); - for (i = 0; i < gUnknown_030007B0->unk1A; i++) - StringCopy(gUnknown_030007B0->unk52[i], gMoveNames[gUnknown_030007B0->unk20[i]]); - GetMonData(&gPlayerParty[gUnknown_030007B0->unk2C5], MON_DATA_NICKNAME, nickname); + sLearnMoveStruct->numMenuChoices = GetMoveRelearnerMoves(&gPlayerParty[sLearnMoveStruct->partyMon], sLearnMoveStruct->movesToLearn); + for (i = 0; i < sLearnMoveStruct->numMenuChoices; i++) + StringCopy(sLearnMoveStruct->moveNames[i], gMoveNames[sLearnMoveStruct->movesToLearn[i]]); + GetMonData(&gPlayerParty[sLearnMoveStruct->partyMon], MON_DATA_NICKNAME, nickname); StringCopy10(gStringVar1, nickname); - StringCopy(gUnknown_030007B0->unk52[gUnknown_030007B0->unk1A], gUnknownText_Exit); - gUnknown_030007B0->unk1A++; + StringCopy(sLearnMoveStruct->moveNames[sLearnMoveStruct->numMenuChoices], gUnknownText_Exit); + sLearnMoveStruct->numMenuChoices++; } -void sub_813360C(s8 a) +void sub_813360C(s8 delta) { - gUnknown_030007B0->unk1C = gUnknown_030007B0->unk18; - gUnknown_030007B0->unk18 += a; - gUnknown_030007B0->unk1D = 1; + sLearnMoveStruct->unk1C = sLearnMoveStruct->unk18; + sLearnMoveStruct->unk18 += delta; + sLearnMoveStruct->unk1D = TRUE; } void sub_813362C(void) { - if (gMain.newAndRepeatedKeys & 0x40) + if (gMain.newAndRepeatedKeys & DPAD_UP) { - if (gUnknown_030007B0->unk1B != 0) + if (sLearnMoveStruct->menuSelection != 0) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk1B--; - gUnknown_030007B0->unk2C3 = 1; - if (gUnknown_030007B0->unk18 != 0) + sLearnMoveStruct->menuSelection--; + sLearnMoveStruct->unk2C3 = TRUE; + if (sLearnMoveStruct->unk18 != 0) { sub_813360C(-1); } - else if (gUnknown_030007B0->unk19 != 0) + else if (sLearnMoveStruct->unk19 != 0) { - gUnknown_030007B0->unk19--; - gUnknown_030007B0->unk1E++; + sLearnMoveStruct->unk19--; + sLearnMoveStruct->unk1E++; } } } - else if (gMain.newAndRepeatedKeys & 0x80) + else if (gMain.newAndRepeatedKeys & DPAD_DOWN) { - if (gUnknown_030007B0->unk1B < gUnknown_030007B0->unk1A - 1) + if (sLearnMoveStruct->menuSelection < sLearnMoveStruct->numMenuChoices - 1) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk1B++; - gUnknown_030007B0->unk2C3 = 1; - if (gUnknown_030007B0->unk18 != 2) + sLearnMoveStruct->menuSelection++; + sLearnMoveStruct->unk2C3 = TRUE; + if (sLearnMoveStruct->unk18 != 2) { sub_813360C(1); } - else if (gUnknown_030007B0->unk19 != gUnknown_030007B0->unk1A - 3) + else if (sLearnMoveStruct->unk19 != sLearnMoveStruct->numMenuChoices - 3) { - gUnknown_030007B0->unk19++; - gUnknown_030007B0->unk1E++; + sLearnMoveStruct->unk19++; + sLearnMoveStruct->unk1E++; } } } else if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - if (gUnknown_030007B0->unk1B != gUnknown_030007B0->unk1A - 1) + if (sLearnMoveStruct->menuSelection != sLearnMoveStruct->numMenuChoices - 1) { - gUnknown_030007B0->unk0 = 8; - StringCopy(gStringVar2, gUnknown_030007B0->unk52[gUnknown_030007B0->unk1B]); + sLearnMoveStruct->state = 8; + StringCopy(gStringVar2, sLearnMoveStruct->moveNames[sLearnMoveStruct->menuSelection]); StringExpandPlaceholders(gStringVar4, gOtherText_TeachSpecificMove); MenuPrintMessage(gStringVar4, 3, 15); } @@ -896,92 +890,84 @@ void sub_813362C(void) { StringExpandPlaceholders(gStringVar4, gOtherText_GiveUpTeachingMove); MenuPrintMessage(gStringVar4, 3, 15); - gUnknown_030007B0->unk0 = 12; + sLearnMoveStruct->state = 12; } } else if (gMain.newKeys & B_BUTTON) { PlaySE(SE_SELECT); - gUnknown_030007B0->unk0 = 12; + sLearnMoveStruct->state = 12; StringExpandPlaceholders(gStringVar4, gOtherText_GiveUpTeachingMove); MenuPrintMessage(gStringVar4, 3, 15); } - if (gUnknown_030007B0->unk1A > 3) + if (sLearnMoveStruct->numMenuChoices > 3) { gSprites[2].invisible = FALSE; gSprites[3].invisible = FALSE; - if (gUnknown_030007B0->unk19 == 0) + if (sLearnMoveStruct->unk19 == 0) gSprites[2].invisible = TRUE; - else if (gUnknown_030007B0->unk19 == gUnknown_030007B0->unk1A - 3) + else if (sLearnMoveStruct->unk19 == sLearnMoveStruct->numMenuChoices - 3) gSprites[3].invisible = TRUE; } } -extern const u8 *const gUnknown_083CAF70[]; - -struct ContestMove -{ - u8 effect; - u8 contestCategory:3; - u8 comboStarterId; - u8 comboMoves[4]; -}; - -extern const struct ContestMove gContestMoves[]; -extern const u8 gTypeNames[][7]; - void sub_8133800(void) { - u8 r6 = gUnknown_030007B0->unk19; + u8 r6 = sLearnMoveStruct->unk19; u8 *str = gTileBuffer; s32 i; for (i = 0; i < 3; i++) { - if (r6 >= gUnknown_030007B0->unk1A) + if (r6 >= sLearnMoveStruct->numMenuChoices) { str = sub_8072C74(str, gEmptyString_81E72B0, 0x90, 0); } - else if (r6 == gUnknown_030007B0->unk1A - 1) + else if (r6 == sLearnMoveStruct->numMenuChoices - 1) { str = sub_8072C74(str, gUnknownText_Exit, 0x90, 0); } else { - u16 moveId = gUnknown_030007B0->unk20[r6]; + u16 moveId = sLearnMoveStruct->movesToLearn[r6]; - if (gUnknown_030007B0->unk2C4 != 0) + if (sLearnMoveStruct->showContestInfo) str = sub_8072C74(str, gUnknown_083CAF70[gContestMoves[moveId].contestCategory], 0x27, 0); else str = sub_8072C74(str, gTypeNames[gBattleMoves[moveId].type], 0x27, 0); - str = sub_8072C74(str, gUnknown_030007B0->unk52[r6], 0x72, 0); + str = sub_8072C74(str, sLearnMoveStruct->moveNames[r6], 0x72, 0); - str[0] = 0xCA; - str[1] = 0xCA; - str[2] = 0xBA; + str[0] = CHAR_P; + str[1] = CHAR_P; + str[2] = CHAR_SLASH; str += 3; str = sub_8072C14(str, gBattleMoves[moveId].pp, 0x90, 0); } - *str++ = 0xFE; + *str++ = CHAR_NEWLINE; r6++; } - *str = 0xFF; + *str = EOS; MenuPrint(gTileBuffer, 11, 1); sub_813360C(0); } -struct ContestEffect +const u8 gUnknown_08402E24[7][3] = { - u8 effectType; - u8 appeal; - u8 jam; + {11, 1, 1}, + { 3, 6, 2}, + {24, 1, 3}, + { 3, 11, 4}, + { 5, 4, 5}, + { 3, 6, 6}, + { 3, 11, 7}, }; -extern const struct ContestEffect gContestEffects[]; +const u8 gUnknown_08402E39[] = {0, 1, 2, 3}; +const u8 gUnknown_08402E3D[] = {4, 5, 6}; -void sub_8133940(u16 a, const u8 *b) +void PrintMoveInfo(u16 moveId, const u8 *b) { u8 str[0x34]; u8 numHearts; @@ -993,75 +979,71 @@ void sub_8133940(u16 a, const u8 *b) case 1: break; case 2: - if (gBattleMoves[a].power < 2) + if (gBattleMoves[moveId].power < 2) sub_8072C74(str, gOtherText_ThreeDashes2, 32, 2); else - sub_8072C14(str, gBattleMoves[a].power, 32, 2); + sub_8072C14(str, gBattleMoves[moveId].power, 32, 2); MenuPrint(str, b[0], b[1]); break; case 4: - if (gBattleMoves[a].accuracy == 0) + if (gBattleMoves[moveId].accuracy == 0) sub_8072C74(str, gOtherText_ThreeDashes2, 32, 2); else - sub_8072C14(str, gBattleMoves[a].accuracy, 32, 2); + sub_8072C14(str, gBattleMoves[moveId].accuracy, 32, 2); MenuPrint(str, b[0], b[1]); break; case 6: MenuZeroFillWindowRect(b[0], b[1], b[0], b[1] + 1); - numHearts = gContestEffects[gContestMoves[a].effect].appeal / 10; + numHearts = gContestEffects[gContestMoves[moveId].effect].appeal / 10; if (numHearts == 255) numHearts = 0; for (i = 0; i < 8; i++) { if (i < numHearts) - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 1); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 4]], 1); else - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 4]], 0); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 4]], 0); } break; case 7: MenuZeroFillWindowRect(b[0], b[1], b[0], b[1] + 1); - numHearts = gContestEffects[gContestMoves[a].effect].jam / 10; + numHearts = gContestEffects[gContestMoves[moveId].effect].jam / 10; if (numHearts == 255) numHearts = 0; for (i = 0; i < 8; i++) { if (i < numHearts) - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 3); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 12]], 3); else - StartSpriteAnim(&gSprites[gUnknown_030007B0->unk3[i + 12]], 2); + StartSpriteAnim(&gSprites[sLearnMoveStruct->spriteIDs[i + 12]], 2); } break; } } -extern const u8 *const gUnknown_083CADD4[]; -extern const u8 *const gMoveDescriptions[]; - -void sub_8133AEC(u8 a, int unused) +void sub_8133AEC(bool8 contestInfo, int unused) { u16 i; - if (gUnknown_030007B0->unk1B != gUnknown_030007B0->unk1A - 1) + if (sLearnMoveStruct->menuSelection != sLearnMoveStruct->numMenuChoices - 1) { - u16 r5 = gUnknown_030007B0->unk20[gUnknown_030007B0->unk1B]; + u16 moveId = sLearnMoveStruct->movesToLearn[sLearnMoveStruct->menuSelection]; - if (a != 0) + if (contestInfo) { for (i = 0; i < 16; i++) - gSprites[gUnknown_030007B0->unk3[i + 4]].invisible = FALSE; + gSprites[sLearnMoveStruct->spriteIDs[i + 4]].invisible = FALSE; for (i = 0; i < 3; i++) - sub_8133940(r5, gUnknown_08402E24[gUnknown_08402E3D[i]]); - sub_8072AB0(gUnknown_083CADD4[gContestMoves[r5].effect], 0x58, 0x48, 0x90, 32, 1); + PrintMoveInfo(moveId, gUnknown_08402E24[gUnknown_08402E3D[i]]); + sub_8072AB0(gUnknown_083CADD4[gContestMoves[moveId].effect], 0x58, 0x48, 0x90, 32, 1); } - //_08133BA0 else { u8 var; for (i = 0; i < 4; i++) - sub_8133940(r5, gUnknown_08402E24[gUnknown_08402E39[i]]); - var = sub_8072A18(gMoveDescriptions[r5 - 1], 0x58, 0x48, 0x90, 1); + PrintMoveInfo(moveId, gUnknown_08402E24[gUnknown_08402E39[i]]); + var = sub_8072A18(gMoveDescriptions[moveId - 1], 0x58, 0x48, 0x90, 1); if (var < 2) { u8 r1 = var * 2 + 9; @@ -1072,12 +1054,12 @@ void sub_8133AEC(u8 a, int unused) } else { - if (a != 0) + if (contestInfo) { MenuZeroFillWindowRect(gUnknown_08402E24[5][0], gUnknown_08402E24[5][1], gUnknown_08402E24[5][0], gUnknown_08402E24[5][1] + 1); MenuZeroFillWindowRect(gUnknown_08402E24[6][0], gUnknown_08402E24[6][1], gUnknown_08402E24[6][0], gUnknown_08402E24[6][1] + 1); for (i = 0; i < 16; i++) - gSprites[gUnknown_030007B0->unk3[i + 4]].invisible = TRUE; + gSprites[sLearnMoveStruct->spriteIDs[i + 4]].invisible = TRUE; } else { @@ -1091,5 +1073,5 @@ void sub_8133AEC(u8 a, int unused) void sub_8133CA4(void) { MenuZeroFillWindowRect(21, 7, 27, 12); - sub_8133AEC(gUnknown_030007B0->unk2C4, 0); + sub_8133AEC(sLearnMoveStruct->showContestInfo, 0); } -- cgit v1.2.3 From a6c0c433c9356b51181c8f2c7cc028017a953390 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 12 Aug 2017 21:19:14 -0500 Subject: fix German build --- src/learn_move.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'src') diff --git a/src/learn_move.c b/src/learn_move.c index 71de9910a..51de68171 100644 --- a/src/learn_move.c +++ b/src/learn_move.c @@ -46,6 +46,10 @@ extern const u8 *const gMoveDescriptions[]; extern const u8 gTypeNames[][7]; extern const u8 *const gUnknown_083CAF70[]; +#ifdef GERMAN +extern const u8 deuOtherText_ForgotAndLearned[]; +#endif + extern void sub_809D9F0(struct Pokemon *, u8, u8, void *, u32); struct LearnMoveStruct -- cgit v1.2.3 From bf0f2e4a0ba447abf50340586045f3567ab7a9b8 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 13 Aug 2017 23:52:47 +0200 Subject: berry blender is decompiled --- src/berry_blender.c | 1658 ++++++++++++++++++++++++++++----------------------- 1 file changed, 927 insertions(+), 731 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index 74b87b983..cbf50fdb3 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -47,17 +47,6 @@ struct MusicPlayerInfo u32 intp; }; -// other files functions -void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch); -void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo); -void m4aMPlayStop(struct MusicPlayerInfo *mplayInfo); -void sub_80A6978(void); -u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); -void sub_814A880(u8 a1, u8 a2); -u8 sub_814A5C0(u8 a1, u16 a2, u8 a3, u16 a4, u8 a5); -s8 sub_810CA00(void); -bool8 sub_810CA34(struct Pokeblock *pokeblock); - #define BLENDER_SCORE_BEST 0 #define BLENDER_SCORE_GOOD 1 #define BLENDER_SCORE_MISS 2 @@ -83,8 +72,6 @@ struct BerryBlenderData { u8 field_0; u8 field_1; - u8 field_2; - u8 field_3; struct Window field_4; u8 field_35; u8 field_36; @@ -158,75 +145,7 @@ struct BerryBlenderData u16 field_9A[BLENDER_MAX_PLAYERS]; u16 field_A2[BLENDER_MAX_PLAYERS]; u8 field_AA; - u8 stringVar[61]; - u8 field_E8; - u8 field_E9; - u8 field_EA; - u8 field_EB; - u8 field_EC; - u8 field_ED; - u8 field_EE; - u8 field_EF; - u8 field_F0; - u8 field_F1; - u8 field_F2; - u8 field_F3; - u8 field_F4; - u8 field_F5; - u8 field_F6; - u8 field_F7; - u8 field_F8; - u8 field_F9; - u8 field_FA; - u8 field_FB; - u8 field_FC; - u8 field_FD; - u8 field_FE; - u8 field_FF; - u8 field_100; - u8 field_101; - u8 field_102; - u8 field_103; - u8 field_104; - u8 field_105; - u8 field_106; - u8 field_107; - u8 field_108; - u8 field_109; - u8 field_10A; - u8 field_10B; - u8 field_10C; - u8 field_10D; - u8 field_10E; - u8 field_10F; - u8 field_110; - u8 field_111; - u8 field_112; - u8 field_113; - u8 field_114; - u8 field_115; - u8 field_116; - u8 field_117; - u8 field_118; - u8 field_119; - u8 field_11A; - u8 field_11B; - u8 field_11C; - u8 field_11D; - u8 field_11E; - u8 field_11F; - u8 field_120; - u8 field_121; - u8 field_122; - u8 field_123; - u8 field_124; - u8 field_125; - u8 field_126; - u8 field_127; - u8 field_128; - u8 field_129; - u8 field_12A; - u8 field_12B; + u8 stringVar[129]; u32 gameFrameTime; s32 framesToWait; u32 field_134; @@ -247,8 +166,6 @@ struct BerryBlenderData u8 playerPlaces[BLENDER_MAX_PLAYERS]; struct BgAffineDstData field_168; u16 field_178; - u8 field_17A; - u8 field_17B; struct BlenderBerry blendedBerries[BLENDER_MAX_PLAYERS]; u32 field_1BC; u16 field_1C0; @@ -256,51 +173,150 @@ struct BerryBlenderData u32 field_1C4; }; -extern struct BerryBlenderData* sBerryBlenderData; +struct BlenderDebug +{ + s8 cursorPos; + s8 berries[4]; + struct Pokeblock pokeblock; + u8 field_10; + u8 spicy; + u8 dry; + u8 sweet; + u8 bitter; + u8 sour; + u8 feel; + s8 field_17; + s8 field_18; + s8 field_19; + s16 BPM; +}; + +// other files functions +void m4aMPlayPitchControl(struct MusicPlayerInfo *mplayInfo, u16 trackBits, s16 pitch); +void m4aMPlayTempoControl(struct MusicPlayerInfo *mplayInfo, u16 tempo); +void m4aMPlayStop(struct MusicPlayerInfo *mplayInfo); +void sub_80A6978(void); +u8 sub_80A7DEC(u8 berryId, u8 x, u8 y, bool8 animate); +void sub_814A880(u8 a1, u8 a2); +u8 sub_814A5C0(u8 a1, u16 a2, u8 a3, u16 a4, u8 a5); +s8 sub_810CA00(void); +bool8 sub_810CA34(struct Pokeblock *pokeblock); extern struct MusicPlayerInfo gMPlay_SE2; extern struct MusicPlayerInfo gMPlay_BGM; extern u8 ewram[]; -extern s16 gUnknown_03000520[]; - -// this file's functions: -void sub_80514A4(void); -void sub_80514F0(void); -void sub_804E56C(void); -void sub_804E884(u8 a0); -void sub_8051474(void); -void sub_804E9F8(void); -void sub_804F378(void); -void sub_8051414(struct BgAffineDstData *dest); -void sub_804F238(void); -void sub_80501FC(void); -bool8 sub_8051B8C(void); +extern u16 gScriptItemId; +extern u8 gUnknown_020297ED; +extern u8 byte_3002A68; + +// rom data to do + +extern const u8 gUnknown_08E6C100[]; +extern const u8 gUnknown_08215C2C[]; +extern const u8 gUnknown_08E6C920[]; +extern const u8 gUnknown_08E6D354[]; +extern const u16 gUnknown_08215C0C[]; +extern const u16 gUnknown_0821602C[]; +extern const struct SpriteSheet gUnknown_082163DC; +extern const struct SpriteSheet gUnknown_082164F4; +extern const struct SpriteSheet gUnknown_08216454; +extern const struct SpriteSheet gUnknown_08216540; +extern const struct SpriteSheet gUnknown_08216574; +extern const struct SpritePalette gUnknown_082163EC; +extern const struct SpritePalette gUnknown_082163E4; +extern const struct WindowConfig gWindowConfig_81E6F68; +extern const u8 sBlenderSyncArrowsPos[][2]; +extern const struct SpriteTemplate sBlenderSyncArrow_SpriteTemplate; +extern const s16 gUnknown_08216594[][5]; +extern const u8* const gUnknown_082162B8[]; +extern const u8 gUnknown_082162EC[3][4]; +extern const u16 gUnknown_082162F8[]; +extern const u8 gUnknown_08216300[]; +extern const struct SpriteTemplate gSpriteTemplate_8216548; +extern const u8 gUnknown_08216303[]; +extern const u8 gUnknown_082165BC[][3]; +extern const u8 gUnknown_082162C4[]; +extern const u8 gUnknown_082162D4[][2]; +extern const TaskFunc gUnknown_08216308[]; +extern const s8 gUnknown_082162CC[][2]; +extern const struct SpriteTemplate gSpriteTemplate_821645C; +extern const u8 gUnknown_082165DA[]; +extern const u8 gUnknown_082165DF[]; +extern const struct SpriteTemplate gSpriteTemplate_82164FC; +extern const u8* const gUnknown_08216284[]; +extern const struct SpriteTemplate gSpriteTemplate_821657C; +extern const u8 gUnknown_082165E9[]; +extern const u8 gUnknown_082165EE[]; +extern const u8 gUnknown_08216249[]; +extern const u8 gUnknown_082162C8[]; +extern const u8 *const gPokeblockNames[]; +extern const u8 gUnknown_082165F3[]; +extern const u8 gOtherText_BPMAndDash[]; +extern const u8 gUnknown_082165F8[]; +extern const u8 gUnknown_08216600[]; +extern const struct Berry gBerries[]; + +// ewram +static EWRAM_DATA u8 gUnknown_020297DC = 0; +static EWRAM_DATA u32 gUnknown_020297E0 = 0; +static EWRAM_DATA u32 gUnknown_020297E4 = 0; +static EWRAM_DATA u8 gUnknown_020297E8 = 0; + +// iwram common +u16 gUnknown_03004830; +u8 gUnknown_03004834; +u16 gUnknown_03004840[10]; +struct BerryBlenderData* gBerryBlenderData; + +// iwram bss +IWRAM_DATA s16 gUnknown_03000510[8]; +IWRAM_DATA s16 gUnknown_03000520[6]; +IWRAM_DATA s16 gUnknown_0300052C; +IWRAM_DATA s16 gUnknown_0300052E; +IWRAM_DATA s32 gUnknown_03000530[6]; +IWRAM_DATA s32 gUnknown_03000548[5]; +IWRAM_DATA u32 gUnknown_0300055C; +IWRAM_DATA struct BlenderDebug sBlenderDebug; + +// this file's functions void Blender_SetBankBerryData(u8 bank, u16 itemID); -void sub_804F2A8(void); -void sub_804F81C(void); -void sub_805156C(void); + +static void sub_80514A4(void); +static void sub_80514F0(void); +static void sub_804E56C(void); +static void sub_804E884(u8 a0); +static void sub_8051474(void); +static void sub_804E9F8(void); +static void sub_804F378(void); +static void sub_8051414(struct BgAffineDstData *dest); +static void sub_804F238(void); +static void sub_80501FC(void); +static bool8 sub_8051B8C(void); +static void sub_804F2A8(void); +static void sub_804F81C(void); +static void sub_805156C(void); void sub_8051684(struct Sprite* sprite); -void sub_8051AC8(s16* a0, u16 a1); -void sub_805194C(u16 a0, u16 a1); -void sub_8051A3C(u16 a0); -void sub_8051B18(void); -void sub_805123C(void); -void sub_8050954(void); -bool8 Blender_PrintBlendingRanking(void); -bool8 Blender_PrintBlendingResults(void); -void sub_80510E8(void); -void sub_8050E30(void); -void sub_805197C(u16 a0, u16 a1); -void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst); -void sub_8052BD0(u8 taskID); -void sub_8052AF8(void); +static void sub_8051AC8(s16* a0, u16 a1); +static void sub_805194C(u16 a0, u16 a1); +static void sub_8051A3C(u16 a0); +static void sub_8051B18(void); +static void sub_805123C(void); +static void sub_8050954(void); +static bool8 Blender_PrintBlendingRanking(void); +static bool8 Blender_PrintBlendingResults(void); +static void sub_80510E8(void); +static void sub_8050E30(void); +static void sub_805197C(u16 a0, u16 a1); +static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst); +static void sub_8052BD0(u8 taskID); +static void sub_8052AF8(void); -void Blender_ControlHitPitch(void) +static void Blender_ControlHitPitch(void) { - m4aMPlayPitchControl(&gMPlay_SE2, 0xFFFF, (sBerryBlenderData->field_56 - 128) * 2); + m4aMPlayPitchControl(&gMPlay_SE2, 0xFFFF, (gBerryBlenderData->field_56 - 128) * 2); } -void VBlankCB0_BerryBlender(void) +static void VBlankCB0_BerryBlender(void) { sub_80514A4(); sub_80514F0(); @@ -309,34 +325,20 @@ void VBlankCB0_BerryBlender(void) TransferPlttBuffer(); } -void VBlankCB1_BerryBlender(void) +static void VBlankCB1_BerryBlender(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -extern const u8 gUnknown_08E6C100[]; -extern const u8 gUnknown_08215C2C[]; -extern const u8 gUnknown_08E6C920[]; -extern const u8 gUnknown_08E6D354[]; -extern const u16 gUnknown_08215C0C[]; -extern const u16 gUnknown_0821602C[]; -extern const struct SpriteSheet gUnknown_082163DC; -extern const struct SpriteSheet gUnknown_082164F4; -extern const struct SpriteSheet gUnknown_08216454; -extern const struct SpriteSheet gUnknown_08216540; -extern const struct SpriteSheet gUnknown_08216574; -extern const struct SpritePalette gUnknown_082163EC; -extern const struct SpritePalette gUnknown_082163E4; - -bool8 sub_804E2EC(void) +static bool8 sub_804E2EC(void) { - switch (sBerryBlenderData->field_1) + switch (gBerryBlenderData->field_1) { case 0: sub_800D238(gUnknown_08E6C100, &ewram[0x10000]); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; break; case 1: { @@ -345,7 +347,7 @@ bool8 sub_804E2EC(void) DmaCopy16(3, offsetRead, offsetWrite, 0x400); LoadPalette(gUnknown_08215C0C, 0, 0x100); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; } break; case 2: @@ -365,16 +367,16 @@ bool8 sub_804E2EC(void) break; } } - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; } break; case 3: sub_800D238(gUnknown_08E6C920, &ewram[0x10000]); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; break; case 4: sub_800D238(gUnknown_08E6D354, &ewram[0x13000]); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; break; case 5: { @@ -382,7 +384,7 @@ bool8 sub_804E2EC(void) void* offsetWrite = (void*)(VRAM + 0xE000); DmaCopy16(3, offsetRead, offsetWrite, 0x1000); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; } break; case 6: @@ -391,7 +393,7 @@ bool8 sub_804E2EC(void) void* offsetWrite = (void*)(VRAM + 0xF000); DmaCopy16(3, offsetRead, offsetWrite, 0x1000); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; } break; case 7: @@ -409,27 +411,27 @@ bool8 sub_804E2EC(void) offsetWrite = (void*)(VRAM + 0x6000); DmaCopy16(3, offsetRead, offsetWrite, 0x500); LoadPalette(gUnknown_0821602C, 0x80, 0x20); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; } break; case 8: LoadSpriteSheet(&gUnknown_082163DC); LoadSpriteSheet(&gUnknown_082164F4); LoadSpriteSheet(&gUnknown_08216454); - sBerryBlenderData->field_1++; + gBerryBlenderData->field_1++; break; case 9: LoadSpriteSheet(&gUnknown_08216540); LoadSpriteSheet(&gUnknown_08216574); LoadSpritePalette(&gUnknown_082163EC); LoadSpritePalette(&gUnknown_082163E4); - sBerryBlenderData->field_1 = 0; + gBerryBlenderData->field_1 = 0; return 1; } return 0; } -void sub_804E4FC(void) +static void sub_804E4FC(void) { REG_DISPCNT = 0x1341; REG_BG2CNT = 0x4880; @@ -444,24 +446,20 @@ void sub_804E538(void) { u8* field6F; //this temp value is needed to match - sBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); + gBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); - field6F = &sBerryBlenderData->field_6F; - sBerryBlenderData->field_0 = 0; + field6F = &gBerryBlenderData->field_6F; + gBerryBlenderData->field_0 = 0; *field6F = 0; sub_804E884(gSpecialVar_0x8004); SetMainCallback2(sub_804E56C); } -extern const struct WindowConfig gWindowConfig_81E6F68; -extern const u8 sBlenderSyncArrowsPos[][2]; -extern const struct SpriteTemplate sBlenderSyncArrow_SpriteTemplate; - -void sub_804E56C(void) +static void sub_804E56C(void) { s32 i; - switch (sBerryBlenderData->field_0) + switch (gBerryBlenderData->field_0) { case 0: REG_DISPCNT = 0; @@ -470,13 +468,13 @@ void sub_804E56C(void) SetVBlankCallback(NULL); SetUpWindowConfig(&gWindowConfig_81E6F68); InitMenuWindow(&gWindowConfig_81E6F68); - sBerryBlenderData->field_0++; - sBerryBlenderData->field_140 = 0; - sBerryBlenderData->field_13E = 0; - sBerryBlenderData->field_142 = 0x50; - sBerryBlenderData->field_144 = 0; - sBerryBlenderData->field_146 = 0; - sBerryBlenderData->field_1 = 0; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_140 = 0; + gBerryBlenderData->field_13E = 0; + gBerryBlenderData->field_142 = 0x50; + gBerryBlenderData->field_144 = 0; + gBerryBlenderData->field_146 = 0; + gBerryBlenderData->field_1 = 0; sub_8051474(); break; case 1: @@ -484,34 +482,34 @@ void sub_804E56C(void) { for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->SyncArrowSpriteID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[i]], i + 8); + gBerryBlenderData->SyncArrowSpriteID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSpriteID[i]], i + 8); } SetVBlankCallback(VBlankCB0_BerryBlender); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 2: BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); sub_8051474(); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 3: sub_804E4FC(); if (!gPaletteFade.active) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 4: MenuDrawTextWindow(0, 14, 29, 19); MenuPrintMessage(gOtherText_BlenderChooseBerry, 1, 15); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 5: if (MenuUpdateWindowText()) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); } break; @@ -519,7 +517,7 @@ void sub_804E56C(void) if (!gPaletteFade.active) { sub_80A6978(); - sBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_0 = 0; } break; } @@ -561,15 +559,13 @@ void sub_804E794(struct Sprite* sprite, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) sprite->callback = sub_804E738; } -extern const s16 gUnknown_08216594[][5]; - -void sub_804E7C0(u16 a0, u8 a1) +static void sub_804E7C0(u16 a0, u8 a1) { u8 spriteID = sub_80A7DEC(a0 + 123, 0, 80, a1 & 1); sub_804E794(&gSprites[spriteID], gUnknown_08216594[a1][0], gUnknown_08216594[a1][1], gUnknown_08216594[a1][2], gUnknown_08216594[a1][3], gUnknown_08216594[a1][4]); } -void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) +static void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) { const struct Berry *berryInfo = GetBerryInfo(itemID + 124); berry->itemID = itemID; @@ -582,10 +578,7 @@ void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) berry->smoothness = berryInfo->smoothness; } -extern u8 gUnknown_03004834; -extern const u8* const gUnknown_082162B8[]; - -void sub_804E884(u8 a0) +static void sub_804E884(u8 a0) { int i; if (a0) @@ -600,20 +593,20 @@ void sub_804E884(u8 a0) break; case 1: gUnknown_03004834 = 1; - sBerryBlenderData->playersNo = 2; + gBerryBlenderData->playersNo = 2; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); break; case 2: gUnknown_03004834 = 2; - sBerryBlenderData->playersNo = 3; + gBerryBlenderData->playersNo = 3; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); break; case 3: gUnknown_03004834 = 3; - sBerryBlenderData->playersNo = 4; + gBerryBlenderData->playersNo = 4; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); @@ -627,12 +620,12 @@ void sub_804E990(void) s32 i; REG_DISPCNT = 0; - sBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); - sBerryBlenderData->field_0 = 0; - sBerryBlenderData->field_134 = 0; + gBerryBlenderData = (struct BerryBlenderData*)(&ewram[0x18000]); + gBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_134 = 0; for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->chosenItemID[i] = 0; + gBerryBlenderData->chosenItemID[i] = 0; } sub_804E884(gSpecialVar_0x8004); if (gSpecialVar_0x8004 == 0) @@ -641,17 +634,10 @@ void sub_804E990(void) SetMainCallback2(sub_804F378); } -extern u16 gScriptItemId; - -extern const u8 gUnknown_082162EC[3][4]; -extern const u16 gUnknown_082162F8[]; -extern const u8 gUnknown_08216300[]; -extern const struct SpriteTemplate gSpriteTemplate_8216548; - -void sub_804E9F8(void) +static void sub_804E9F8(void) { int i, j; - switch (sBerryBlenderData->field_0) + switch (gBerryBlenderData->field_0) { case 0: ResetSpriteData(); @@ -661,64 +647,64 @@ void sub_804E9F8(void) SetUpWindowConfig(&gWindowConfig_81E6F68); InitMenuWindow(&gWindowConfig_81E6F68); gLinkType = 0x4422; - sBerryBlenderData->field_0++; - sBerryBlenderData->field_4E = 0; - sBerryBlenderData->field_7E = 0; - sBerryBlenderData->field_144 = 0; - sBerryBlenderData->field_146 = 0; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_4E = 0; + gBerryBlenderData->field_7E = 0; + gBerryBlenderData->field_144 = 0; + gBerryBlenderData->field_146 = 0; for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->field_70[i] = 0; + gBerryBlenderData->field_70[i] = 0; for (j = 0; j < 3; j++) { - sBerryBlenderData->scores[i][j] = 0; + gBerryBlenderData->scores[i][j] = 0; } } - sBerryBlenderData->field_7C = 0; - sBerryBlenderData->field_56 = 0; - sBerryBlenderData->arrowPos = 0; - sBerryBlenderData->max_RPM = 0; - sBerryBlenderData->field_1 = 0; + gBerryBlenderData->field_7C = 0; + gBerryBlenderData->field_56 = 0; + gBerryBlenderData->arrowPos = 0; + gBerryBlenderData->max_RPM = 0; + gBerryBlenderData->field_1 = 0; break; case 1: if (sub_804E2EC()) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; sub_8051474(); } break; case 2: for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); + gBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); } - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 3: BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 4: sub_804E4FC(); if (!gPaletteFade.active) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 5: MenuDrawTextWindow(0, 13, 29, 19); MenuPrint(gOtherText_LinkStandby3, 1, 14); - sBerryBlenderData->field_0 = 8; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0 = 8; + gBerryBlenderData->framesToWait = 0; break; case 8: - sBerryBlenderData->field_0++; - sBerryBlenderData->field_13C = 0; - Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); - memcpy(gBlockSendBuffer, &sBerryBlenderData->blendedBerries[0], sizeof(struct BlenderBerry)); + gBerryBlenderData->field_0++; + gBerryBlenderData->field_13C = 0; + Blender_CopyBerryData(&gBerryBlenderData->blendedBerries[0], gScriptItemId); + memcpy(gBlockSendBuffer, &gBerryBlenderData->blendedBerries[0], sizeof(struct BlenderBerry)); sub_80084A4(); - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->framesToWait = 0; break; case 9: if (sub_8007ECC()) @@ -726,119 +712,119 @@ void sub_804E9F8(void) ResetBlockReceivedFlags(); if (GetMultiplayerId() == 0) sub_8007E9C(4); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 10: - if (++sBerryBlenderData->framesToWait > 20) + if (++gBerryBlenderData->framesToWait > 20) { MenuZeroFillScreen(); if (GetBlockReceivedStatus() == sub_8008198()) { for (i = 0; i < GetLinkPlayerCount(); i++) { - memcpy(&sBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][0], sizeof(struct BlenderBerry)); - sBerryBlenderData->chosenItemID[i] = sBerryBlenderData->blendedBerries[i].itemID; + memcpy(&gBerryBlenderData->blendedBerries[i], &gBlockRecvBuffer[i][0], sizeof(struct BlenderBerry)); + gBerryBlenderData->chosenItemID[i] = gBerryBlenderData->blendedBerries[i].itemID; } ResetBlockReceivedFlags(); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } } break; case 11: - sBerryBlenderData->playersNo = GetLinkPlayerCount(); + gBerryBlenderData->playersNo = GetLinkPlayerCount(); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->field_13C == gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]) + if (gBerryBlenderData->field_13C == gUnknown_082162EC[gBerryBlenderData->playersNo - 2][i]) { - sub_804E7C0(sBerryBlenderData->chosenItemID[sBerryBlenderData->field_13C], i); + sub_804E7C0(gBerryBlenderData->chosenItemID[gBerryBlenderData->field_13C], i); break; } } - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; - sBerryBlenderData->field_13C++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_13C++; break; case 12: - if (++sBerryBlenderData->framesToWait > 60) + if (++gBerryBlenderData->framesToWait > 60) { - if (sBerryBlenderData->field_13C >= sBerryBlenderData->playersNo) + if (gBerryBlenderData->field_13C >= gBerryBlenderData->playersNo) { - sBerryBlenderData->field_0++; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]] - 22528; + gBerryBlenderData->field_0++; + gBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[gBerryBlenderData->playersNo - 2]] - 22528; } else - sBerryBlenderData->field_0--; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0--; + gBerryBlenderData->framesToWait = 0; } break; case 13: if (sub_8007ECC()) { - sBerryBlenderData->field_0++; - sub_8051414(&sBerryBlenderData->field_168); + gBerryBlenderData->field_0++; + sub_8051414(&gBerryBlenderData->field_168); } break; case 14: REG_DISPCNT |= 0x400; - sBerryBlenderData->arrowPos += 0x200; - sBerryBlenderData->field_142 += 4; - if (sBerryBlenderData->field_142 > 255) + gBerryBlenderData->arrowPos += 0x200; + gBerryBlenderData->field_142 += 4; + if (gBerryBlenderData->field_142 > 255) { - sBerryBlenderData->field_0++; - sBerryBlenderData->field_142 = 256; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]]; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_142 = 256; + gBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[gBerryBlenderData->playersNo - 2]]; REG_BG2CNT = 0x4882; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->framesToWait = 0; sub_804F238(); sub_804F2A8(); } - sub_8051414(&sBerryBlenderData->field_168); + sub_8051414(&gBerryBlenderData->field_168); break; case 15: if (sub_8051B8C()) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } - sub_8051414(&sBerryBlenderData->field_168); + sub_8051414(&gBerryBlenderData->field_168); break; case 16: CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 18: - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 19: sub_80084A4(); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 20: if (sub_8007ECC()) { sub_8007E24(); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 21: - sBerryBlenderData->field_56 = 128; - sBerryBlenderData->gameFrameTime = 0; + gBerryBlenderData->field_56 = 128; + gBerryBlenderData->gameFrameTime = 0; SetMainCallback2(sub_80501FC); if (GetCurrentMapMusic() != 403) { - sBerryBlenderData->field_178 = GetCurrentMapMusic(); + gBerryBlenderData->field_178 = GetCurrentMapMusic(); } PlayBGM(403); break; case 100: MenuDrawTextWindow(0, 13, 29, 19); MenuPrintMessage(gOtherText_LinkNotFound, 1, 15); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 101: if (MenuUpdateWindowText()) - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 102: if (!gPaletteFade.active) @@ -851,7 +837,7 @@ void sub_804E9F8(void) UpdatePaletteFade(); } -void sub_804F0F4(void) +static void sub_804F0F4(void) { REG_DISPCNT = 0; @@ -866,21 +852,19 @@ void sub_804F0F4(void) gLinkType = 0x4422; - sBerryBlenderData->field_4E = 0; - sBerryBlenderData->field_56 = 0; - sBerryBlenderData->arrowPos = 0; - sBerryBlenderData->max_RPM = 0; - sBerryBlenderData->field_144 = 0; - sBerryBlenderData->field_146 = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->field_4E = 0; + gBerryBlenderData->field_56 = 0; + gBerryBlenderData->arrowPos = 0; + gBerryBlenderData->max_RPM = 0; + gBerryBlenderData->field_144 = 0; + gBerryBlenderData->field_146 = 0; + gBerryBlenderData->field_0++; } -extern const u8 gUnknown_08216303[]; - -u8 sub_804F16C(u16 arrowPos, u8 a1) +static u8 sub_804F16C(u16 arrowPos, u8 a1) { u32 var1 = (arrowPos / 256) + 24; - u8 arrID = sBerryBlenderData->field_A2[a1]; + u8 arrID = gBerryBlenderData->field_A2[a1]; u32 var2 = gUnknown_08216303[arrID]; if (var1 >= var2 && var1 < var2 + 48) @@ -894,9 +878,7 @@ u8 sub_804F16C(u16 arrowPos, u8 a1) return 0; } -extern const u8 gUnknown_082165BC[][3]; - -void sub_804F1BC(u16 itemID, u8 a1, struct BlenderBerry* berry) +static void sub_804F1BC(u16 itemID, u8 a1, struct BlenderBerry* berry) { u16 r4 = 0; u16 i; @@ -921,184 +903,179 @@ void sub_804F1BC(u16 itemID, u8 a1, struct BlenderBerry* berry) } } -void sub_804F238(void) +static void sub_804F238(void) { s32 i, j; for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->field_A2[i] = 0xFF; - sBerryBlenderData->field_9A[i] = gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]; + gBerryBlenderData->field_A2[i] = 0xFF; + gBerryBlenderData->field_9A[i] = gUnknown_082162EC[gBerryBlenderData->playersNo - 2][i]; } for (j = 0; j < BLENDER_MAX_PLAYERS; j++) { for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->field_9A[i] == j) - sBerryBlenderData->field_A2[j] = i; + if (gBerryBlenderData->field_9A[i] == j) + gBerryBlenderData->field_A2[j] = i; } } } -extern const u8 gUnknown_082162C4[]; -extern const u8 gUnknown_082162D4[][2]; - -void sub_804F2A8(void) +static void sub_804F2A8(void) { int i; for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->field_9A[i] != 0xFF) + if (gBerryBlenderData->field_9A[i] != 0xFF) { u8* stringPtr = gStringVar1; - sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[i]] = sBerryBlenderData->SyncArrowSprite2ID[i]; - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[i]]], i); - if (GetMultiplayerId() == sBerryBlenderData->field_9A[i]) + gBerryBlenderData->SyncArrowSpriteID[gBerryBlenderData->field_9A[i]] = gBerryBlenderData->SyncArrowSprite2ID[i]; + StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSpriteID[gBerryBlenderData->field_9A[i]]], i); + if (GetMultiplayerId() == gBerryBlenderData->field_9A[i]) stringPtr = StringCopy(stringPtr, gUnknown_082162C4); - StringCopy(stringPtr, gLinkPlayers[sBerryBlenderData->field_9A[i]].name); + StringCopy(stringPtr, gLinkPlayers[gBerryBlenderData->field_9A[i]].name); MenuPrint_PixelCoords(gStringVar1, gUnknown_082162D4[i][0] * 8 + 1, gUnknown_082162D4[i][1] * 8, 1); } } } -extern const TaskFunc gUnknown_08216308[]; - -void sub_804F378(void) +static void sub_804F378(void) { s32 i, j; - switch (sBerryBlenderData->field_0) + switch (gBerryBlenderData->field_0) { case 0: sub_804F0F4(); Blender_SetBankBerryData(0, gScriptItemId); - Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[0], gScriptItemId); - sub_804F1BC(gScriptItemId, sBerryBlenderData->playersNo, &sBerryBlenderData->blendedBerries[0]); + Blender_CopyBerryData(&gBerryBlenderData->blendedBerries[0], gScriptItemId); + sub_804F1BC(gScriptItemId, gBerryBlenderData->playersNo, &gBerryBlenderData->blendedBerries[0]); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->field_70[i] = 0; + gBerryBlenderData->field_70[i] = 0; for (j = 0; j < 3; j++) { - sBerryBlenderData->scores[i][j] = 0; + gBerryBlenderData->scores[i][j] = 0; } } - sBerryBlenderData->field_7C = 0; - sBerryBlenderData->field_1 = 0; + gBerryBlenderData->field_7C = 0; + gBerryBlenderData->field_1 = 0; break; case 1: if (sub_804E2EC()) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; sub_8051474(); } break; case 2: for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - sBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); + gBerryBlenderData->SyncArrowSprite2ID[i] = CreateSprite(&sBlenderSyncArrow_SpriteTemplate, sBlenderSyncArrowsPos[i][0], sBlenderSyncArrowsPos[i][1], 1); + StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSprite2ID[i]], i + 8); } - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 3: BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); - sBerryBlenderData->field_0++; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; break; case 4: - if (++sBerryBlenderData->framesToWait == 2) + if (++gBerryBlenderData->framesToWait == 2) sub_804E4FC(); if (!gPaletteFade.active) - sBerryBlenderData->field_0 = 8; + gBerryBlenderData->field_0 = 8; break; case 8: - sBerryBlenderData->field_0 = 11; - sBerryBlenderData->field_13C = 0; + gBerryBlenderData->field_0 = 11; + gBerryBlenderData->field_13C = 0; break; case 11: for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - u32 var = gUnknown_082162EC[sBerryBlenderData->playersNo - 2][i]; - if (sBerryBlenderData->field_13C == var) + u32 var = gUnknown_082162EC[gBerryBlenderData->playersNo - 2][i]; + if (gBerryBlenderData->field_13C == var) { - sub_804E7C0(sBerryBlenderData->chosenItemID[sBerryBlenderData->field_13C], i); + sub_804E7C0(gBerryBlenderData->chosenItemID[gBerryBlenderData->field_13C], i); break; } } - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; - sBerryBlenderData->field_13C++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_13C++; break; case 12: - if (++sBerryBlenderData->framesToWait > 60) + if (++gBerryBlenderData->framesToWait > 60) { - if (sBerryBlenderData->field_13C >= sBerryBlenderData->playersNo) + if (gBerryBlenderData->field_13C >= gBerryBlenderData->playersNo) { - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]] - 22528; - sBerryBlenderData->field_0++; + gBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[gBerryBlenderData->playersNo - 2]] - 22528; + gBerryBlenderData->field_0++; } else - sBerryBlenderData->field_0--; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0--; + gBerryBlenderData->framesToWait = 0; } break; case 13: - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; sub_804F238(); PlaySE(43); - sub_8051414(&sBerryBlenderData->field_168); + sub_8051414(&gBerryBlenderData->field_168); break; case 14: REG_DISPCNT |= 0x400; - sBerryBlenderData->arrowPos += 0x200; - sBerryBlenderData->field_142 += 4; - if (sBerryBlenderData->field_142 > 255) + gBerryBlenderData->arrowPos += 0x200; + gBerryBlenderData->field_142 += 4; + if (gBerryBlenderData->field_142 > 255) { - sBerryBlenderData->field_0++; - sBerryBlenderData->field_142 = 256; - sBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[sBerryBlenderData->playersNo - 2]]; + gBerryBlenderData->field_0++; + gBerryBlenderData->field_142 = 256; + gBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[gBerryBlenderData->playersNo - 2]]; REG_BG2CNT = 0x4882; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->framesToWait = 0; PlaySE(52); sub_804F2A8(); } - sub_8051414(&sBerryBlenderData->field_168); + sub_8051414(&gBerryBlenderData->field_168); break; case 15: if (sub_8051B8C()) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } - sub_8051414(&sBerryBlenderData->field_168); + sub_8051414(&gBerryBlenderData->field_168); break; case 16: CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 18: - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 19: - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 20: - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 21: sub_804F81C(); - sBerryBlenderData->field_56 = 128; - sBerryBlenderData->gameFrameTime = 0; - sBerryBlenderData->field_14B = 0; - sBerryBlenderData->field_7E = 0; + gBerryBlenderData->field_56 = 128; + gBerryBlenderData->gameFrameTime = 0; + gBerryBlenderData->field_14B = 0; + gBerryBlenderData->field_7E = 0; SetMainCallback2(sub_80501FC); for (i = 0; i < gSpecialVar_0x8004; i++) { - sBerryBlenderData->field_148[i] = CreateTask(gUnknown_08216308[i], 10 + i); + gBerryBlenderData->field_148[i] = CreateTask(gUnknown_08216308[i], 10 + i); } if (GetCurrentMapMusic() != 403) { - sBerryBlenderData->field_178 = GetCurrentMapMusic(); + gBerryBlenderData->field_178 = GetCurrentMapMusic(); } PlayBGM(403); PlaySE(53); @@ -1111,7 +1088,7 @@ void sub_804F378(void) UpdatePaletteFade(); } -void sub_804F81C(void) +static void sub_804F81C(void) { s32 i; for (i = 0; i < 4; i++) @@ -1123,7 +1100,7 @@ void sub_804F81C(void) } } -void sub_804F844(u8 taskID) +static void sub_804F844(u8 taskID) { if(++gTasks[taskID].data[0] > gTasks[taskID].data[1]) { @@ -1132,7 +1109,7 @@ void sub_804F844(u8 taskID) } } -void sub_804F890(u8 a0, u8 a1) +static void sub_804F890(u8 a0, u8 a1) { u8 taskID = CreateTask(sub_804F844, 80); gTasks[taskID].data[1] = a1; @@ -1141,14 +1118,14 @@ void sub_804F890(u8 a0, u8 a1) void sub_804F8C8(u8 taskID) { - if (sub_804F16C(sBerryBlenderData->arrowPos, 1) == 2) + if (sub_804F16C(gBerryBlenderData->arrowPos, 1) == 2) { if (gTasks[taskID].data[0] == 0) { - if (sBerryBlenderData->field_14B == 0) + if (gBerryBlenderData->field_14B == 0) { u8 rand = Random() / 655; - if (sBerryBlenderData->field_56 < 500) + if (gBerryBlenderData->field_56 < 500) { if (rand > 75) gRecvCmds[2][1] = 0x4523; @@ -1156,7 +1133,7 @@ void sub_804F8C8(u8 taskID) gRecvCmds[2][1] = 0x5432; gRecvCmds[2][1] = 0x5432; // ??? } - else if (sBerryBlenderData->field_56 < 1500) + else if (gBerryBlenderData->field_56 < 1500) { if (rand > 80) gRecvCmds[2][1] = 0x4523; @@ -1192,16 +1169,16 @@ void sub_804F8C8(u8 taskID) void sub_804F9F4(u8 taskID) { - u32 var1 = (sBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; - u32 var2 = sBerryBlenderData->field_A2[2] & 0xFF; + u32 var1 = (gBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; + u32 var2 = gBerryBlenderData->field_A2[2] & 0xFF; if ((var1 >> 8) > gUnknown_08216303[var2] + 20 && (var1 >> 8) < gUnknown_08216303[var2] + 40) { if (gTasks[taskID].data[0] == 0) { - if (sBerryBlenderData->field_14B == 0) + if (gBerryBlenderData->field_14B == 0) { u8 rand = Random() / 655; - if (sBerryBlenderData->field_56 < 500) + if (gBerryBlenderData->field_56 < 500) { if (rand > 66) gRecvCmds[2][2] = 0x4523; @@ -1237,16 +1214,16 @@ void sub_804FB1C(u8 taskID) { u32 var1, var2; - var1 = (sBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; - var2 = sBerryBlenderData->field_A2[3] & 0xFF; + var1 = (gBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; + var2 = gBerryBlenderData->field_A2[3] & 0xFF; if ((var1 >> 8) > gUnknown_08216303[var2] + 20 && (var1 >> 8) < gUnknown_08216303[var2] + 40) { if (gTasks[taskID].data[0] == 0) { - if (sBerryBlenderData->field_14B == 0) + if (gBerryBlenderData->field_14B == 0) { u8 rand = (Random() / 655); - if (sBerryBlenderData->field_56 < 500) + if (gBerryBlenderData->field_56 < 500) { if (rand > 88) gRecvCmds[2][3] = 0x4523; @@ -1280,10 +1257,7 @@ void sub_804FB1C(u8 taskID) gTasks[taskID].data[0] = 0; } -extern const s8 gUnknown_082162CC[][2]; -extern const struct SpriteTemplate gSpriteTemplate_821645C; - -void sub_804FC48(u16 a0, u8 a1) +static void sub_804FC48(u16 a0, u8 a1) { u8 spriteID; @@ -1310,36 +1284,34 @@ void sub_804FC48(u16 a0, u8 a1) sub_805156C(); } -extern const u8 gUnknown_082165DA[]; - -void sub_804FD30(u16 a0) +static void sub_804FD30(u16 a0) { Blender_ControlHitPitch(); switch (a0) { case 0x4523: - if (sBerryBlenderData->field_56 < 1500) - sBerryBlenderData->field_56 += (384 / gUnknown_082165DA[sBerryBlenderData->playersNo]); + if (gBerryBlenderData->field_56 < 1500) + gBerryBlenderData->field_56 += (384 / gUnknown_082165DA[gBerryBlenderData->playersNo]); else { - sBerryBlenderData->field_56 += (128 / gUnknown_082165DA[sBerryBlenderData->playersNo]); - sub_8051AC8(&sBerryBlenderData->field_144, (sBerryBlenderData->field_56 / 100) - 10); - sub_8051AC8(&sBerryBlenderData->field_146, (sBerryBlenderData->field_56 / 100) - 10); + gBerryBlenderData->field_56 += (128 / gUnknown_082165DA[gBerryBlenderData->playersNo]); + sub_8051AC8(&gBerryBlenderData->field_144, (gBerryBlenderData->field_56 / 100) - 10); + sub_8051AC8(&gBerryBlenderData->field_146, (gBerryBlenderData->field_56 / 100) - 10); } break; case 0x5432: - if (sBerryBlenderData->field_56 < 1500) - sBerryBlenderData->field_56 += (256 / gUnknown_082165DA[sBerryBlenderData->playersNo]); + if (gBerryBlenderData->field_56 < 1500) + gBerryBlenderData->field_56 += (256 / gUnknown_082165DA[gBerryBlenderData->playersNo]); break; case 0x2345: - sBerryBlenderData->field_56 -= (256 / gUnknown_082165DA[sBerryBlenderData->playersNo]); - if (sBerryBlenderData->field_56 < 128) - sBerryBlenderData->field_56 = 128; + gBerryBlenderData->field_56 -= (256 / gUnknown_082165DA[gBerryBlenderData->playersNo]); + if (gBerryBlenderData->field_56 < 128) + gBerryBlenderData->field_56 = 128; break; } } -void sub_804FE70(void) +static void sub_804FE70(void) { s32 i; @@ -1357,40 +1329,40 @@ void sub_804FE70(void) gRecvCmds[0][i] = 0x4444; } } - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) { if (gRecvCmds[0][i] == 0x4444) { - u32 var = sBerryBlenderData->field_A2[i]; + u32 var = gBerryBlenderData->field_A2[i]; if (gRecvCmds[2][i] == 0x4523) { sub_804FD30(0x4523); - sBerryBlenderData->field_13E += (sBerryBlenderData->field_56 / 55); - if (sBerryBlenderData->field_13E >= 1000) - sBerryBlenderData->field_13E = 1000; + gBerryBlenderData->field_13E += (gBerryBlenderData->field_56 / 55); + if (gBerryBlenderData->field_13E >= 1000) + gBerryBlenderData->field_13E = 1000; sub_804FC48(0x4523, var); - sBerryBlenderData->scores[i][BLENDER_SCORE_BEST]++; + gBerryBlenderData->scores[i][BLENDER_SCORE_BEST]++; } else if (gRecvCmds[2][i] == 0x5432) { sub_804FD30(0x5432); - sBerryBlenderData->field_13E += (sBerryBlenderData->field_56 / 70); + gBerryBlenderData->field_13E += (gBerryBlenderData->field_56 / 70); sub_804FC48(0x5432, var); - sBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]++; + gBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]++; } else if (gRecvCmds[2][i] == 0x2345) { sub_804FC48(0x2345, var); sub_804FD30(0x2345); - if (sBerryBlenderData->field_4.win_field_F > 1000) - sBerryBlenderData->field_13E = 1000; - if (sBerryBlenderData->scores[i][BLENDER_SCORE_MISS] < 999) - sBerryBlenderData->scores[i][BLENDER_SCORE_MISS]++; + if (gBerryBlenderData->field_4.win_field_F > 1000) + gBerryBlenderData->field_13E = 1000; + if (gBerryBlenderData->scores[i][BLENDER_SCORE_MISS] < 999) + gBerryBlenderData->scores[i][BLENDER_SCORE_MISS]++; } if (gRecvCmds[2][i] == 0x2345 || gRecvCmds[2][i] == 0x4523 || gRecvCmds[2][i] == 0x5432) { - if (sBerryBlenderData->field_56 > 1500) - m4aMPlayTempoControl(&gMPlay_BGM, ((sBerryBlenderData->field_56 - 750) / 20) + 256); + if (gBerryBlenderData->field_56 > 1500) + m4aMPlayTempoControl(&gMPlay_BGM, ((gBerryBlenderData->field_56 - 750) / 20) + 256); else m4aMPlayTempoControl(&gMPlay_BGM, 256); } @@ -1398,7 +1370,7 @@ void sub_804FE70(void) } if (gSpecialVar_0x8004 != 0) { - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) { gRecvCmds[0][i] = 0; gRecvCmds[2][i] = 0; @@ -1406,13 +1378,11 @@ void sub_804FE70(void) } } -extern u8 gUnknown_020297ED; - -void sub_80500A8(void) +static void sub_80500A8(void) { bool8 A_pressed = 0; - u8 var2 = sBerryBlenderData->field_A2[GetMultiplayerId()]; - if (sBerryBlenderData->field_6F == 0) + u8 var2 = gBerryBlenderData->field_A2[GetMultiplayerId()]; + if (gBerryBlenderData->field_6F == 0) { if (gSaveBlock2.optionsButtonMode == OPTIONS_BUTTON_MODE_L_EQUALS_A && gMain.newKeys & A_BUTTON) A_pressed = ((gMain.heldKeysRaw & (A_BUTTON | L_BUTTON)) != (A_BUTTON | L_BUTTON)); @@ -1421,8 +1391,8 @@ void sub_80500A8(void) if (A_pressed) { u8 var3; - StartSpriteAnim(&gSprites[sBerryBlenderData->SyncArrowSpriteID[sBerryBlenderData->field_9A[var2]]], var2 + 4); - var3 = sub_804F16C(sBerryBlenderData->arrowPos, GetMultiplayerId()); + StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSpriteID[gBerryBlenderData->field_9A[var2]]], var2 + 4); + var3 = sub_804F16C(gBerryBlenderData->arrowPos, GetMultiplayerId()); if (var3 == 2) gSendCmd[2] = 0x4523; else if (var3 == 1) @@ -1431,32 +1401,32 @@ void sub_80500A8(void) gSendCmd[2] = 0x2345; } } - if (++sBerryBlenderData->field_7E > 5) + if (++gBerryBlenderData->field_7E > 5) { - if (sBerryBlenderData->field_56 > 128) - sBerryBlenderData->field_56--; - sBerryBlenderData->field_7E = 0; + if (gBerryBlenderData->field_56 > 128) + gBerryBlenderData->field_56--; + gBerryBlenderData->field_7E = 0; } if (gUnknown_020297ED && gMain.newKeys & L_BUTTON) - sBerryBlenderData->field_14B ^= 1; + gBerryBlenderData->field_14B ^= 1; } -void sub_80501FC(void) +static void sub_80501FC(void) { sub_8051474(); - if (sBerryBlenderData->gameFrameTime < (99 * 60 * 60) + (59 * 60)) // game time can't be longer than 99 minutes and 59 seconds, can't print 3 digits - sBerryBlenderData->gameFrameTime++; + if (gBerryBlenderData->gameFrameTime < (99 * 60 * 60) + (59 * 60)) // game time can't be longer than 99 minutes and 59 seconds, can't print 3 digits + gBerryBlenderData->gameFrameTime++; sub_80500A8(); - SetLinkDebugValues((u16)(sBerryBlenderData->field_56), sBerryBlenderData->field_13E); + SetLinkDebugValues((u16)(gBerryBlenderData->field_56), gBerryBlenderData->field_13E); sub_804FE70(); - sub_805194C(sBerryBlenderData->field_13E, 1000); - sub_8051A3C(sBerryBlenderData->field_56); + sub_805194C(gBerryBlenderData->field_13E, 1000); + sub_8051A3C(gBerryBlenderData->field_56); sub_8051B18(); sub_805123C(); - if (sBerryBlenderData->field_6F == 0 && sBerryBlenderData->field_140 >= 1000) + if (gBerryBlenderData->field_6F == 0 && gBerryBlenderData->field_140 >= 1000) { - sBerryBlenderData->field_13E = 1000; - sBerryBlenderData->field_6F = 1; + gBerryBlenderData->field_13E = 1000; + gBerryBlenderData->field_6F = 1; SetMainCallback2(sub_8050954); } RunTasks(); @@ -1467,7 +1437,7 @@ void sub_80501FC(void) #define ARE_FLAVOURS_SAME(flavours1, flavours2)(((*(u32*)(&flavours1[-1]) & 0xFFFFFF00) == (*(u32*)(&flavours2[-1]) & 0xFFFFFF00)&& (*(u32*)(&flavours1[3]) & 0xFFFFFF) == (*(u32*)(&flavours2[3]) & 0xFFFFFF))) -bool8 sub_80502A4(struct BlenderBerry* berries, u8 index1, u8 index2) +static bool8 sub_80502A4(struct BlenderBerry* berries, u8 index1, u8 index2) { if (berries[index1].itemID != berries[index2].itemID || (StringCompare(berries[index1].name, berries[index2].name) == 0 @@ -1479,7 +1449,7 @@ bool8 sub_80502A4(struct BlenderBerry* berries, u8 index1, u8 index2) #undef ARE_FLAVOURS_SAME -u32 sub_80502F8(struct BlenderBerry* berries, s16* a1, u8 a2, u8 a3) +u32 Blender_GetPokeblockColor(struct BlenderBerry* berries, s16* a1, u8 playersNo, u8 a3) { s16 vars[5]; s32 i; @@ -1496,9 +1466,9 @@ u32 sub_80502F8(struct BlenderBerry* berries, s16* a1, u8 a2, u8 a3) } if (r6 == 5 || a3 > 3) return 12; - for (i = 0; i < a2; i++) + for (i = 0; i < playersNo; i++) { - for (r6 = 0; r6 < a2; r6++) + for (r6 = 0; r6 < playersNo; r6++) { if (berries[i].itemID == berries[r6].itemID && i != r6 && (berries[i].itemID != ITEM_ENIGMA_BERRY || sub_80502A4(berries, i, r6))) @@ -1568,10 +1538,7 @@ u32 sub_80502F8(struct BlenderBerry* berries, s16* a1, u8 a2, u8 a3) return 0; } -extern s16 gUnknown_0300052C; -extern s16 gUnknown_0300052E; - -void sub_80504F0(s16 value) +static void sub_80504F0(s16 value) { gUnknown_0300052C = value; } @@ -1581,7 +1548,7 @@ s16 unref_sub_80504FC(void) return gUnknown_0300052C; } -void sub_8050508(s16 value) +static void sub_8050508(s16 value) { gUnknown_0300052E = value; } @@ -1591,29 +1558,22 @@ s16 unref_sub_8050514(void) return gUnknown_0300052E; } -extern s16 gUnknown_03000510[6]; -extern s32 gUnknown_03000530[]; -extern s32 gUnknown_03000548[]; -extern u32 gUnknown_0300055C; - -extern const u8 gUnknown_082165DF[]; - #ifdef NONMATCHING -void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +static void Blender_CalculatePokeblock(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 playersNo, u8* flavours, u16 maxRPM) { s32 i; s32 j; s32 savedEntry; s32 var3; s32 var4; - s32 var6; + u32 var6; s32 var11; u16 rand; for (i = 0; i < 6; i++) gUnknown_03000510[i] = 0; - for (i = 0; i < a2; i++) + for (i = 0; i < playersNo; i++) { for (j = 0; j < 5; j++) gUnknown_03000510[j] += berries[i].flavours[j]; @@ -1650,7 +1610,7 @@ void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a gUnknown_03000530[i] = gUnknown_03000510[i]; } - var11 = a4 / 333 + 100; + var11 = maxRPM / 333 + 100; gUnknown_0300055C = ((var11)); for (i = 0; i < 5; i++) @@ -1667,11 +1627,11 @@ void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a { gUnknown_03000548[i] = gUnknown_03000510[i]; } - *a1 = sub_80502F8(berries, &gUnknown_03000510[0], a2, var6); - gUnknown_03000510[5] = (gUnknown_03000510[5] / a2) - a2; + pokeblock->color = Blender_GetPokeblockColor(berries, &gUnknown_03000510[0], playersNo, var6); + gUnknown_03000510[5] = (gUnknown_03000510[5] / playersNo) - playersNo; if (gUnknown_03000510[5] < 0) gUnknown_03000510[5] = 0; - if (*a1 == 12) + if (pokeblock->color == 12) { rand = Random() % 10; for (i = 0; i < 6; i++) @@ -1687,21 +1647,21 @@ void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a if (gUnknown_03000510[i] > 255) gUnknown_03000510[i] = 255; } - a1[1] = gUnknown_03000510[0]; - a1[2] = gUnknown_03000510[1]; - a1[3] = gUnknown_03000510[2]; - a1[4] = gUnknown_03000510[3]; - a1[5] = gUnknown_03000510[4]; - a1[6] = gUnknown_03000510[5]; + pokeblock->spicy = gUnknown_03000510[0]; + pokeblock->dry = gUnknown_03000510[1]; + pokeblock->sweet = gUnknown_03000510[2]; + pokeblock->bitter = gUnknown_03000510[3]; + pokeblock->sour = gUnknown_03000510[4]; + pokeblock->feel = gUnknown_03000510[5]; for (i = 0; i < 6; i++) { - a3[i] = gUnknown_03000510[i]; + flavours[i] = gUnknown_03000510[i]; } } #else __attribute__((naked)) -void sub_8050520(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +static void Blender_CalculatePokeblock(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* flavours, u16 a4) { asm(".syntax unified\n\ push {r4-r7,lr}\n\ @@ -1878,7 +1838,7 @@ _08050652:\n\ adds r1, r4, 0\n\ mov r2, r9\n\ mov r3, r10\n\ - bl sub_80502F8\n\ + bl Blender_GetPokeblockColor\n\ mov r5, r8\n\ strb r0, [r5]\n\ movs r1, 0xA\n\ @@ -1989,15 +1949,15 @@ _08050740: .4byte gUnknown_03000510\n\ #endif // NONMATCHING -void sub_8050744(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* a3, u16 a4) +static void BlenderDebug_CalculatePokeblock(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 playersNo, u8* flavours, u16 a4) { - sub_8050520(berries, pokeblock, a2, a3, a4); // what is the purpose of this function? + Blender_CalculatePokeblock(berries, pokeblock, playersNo, flavours, a4); } -void sub_8050760(void) +static void sub_8050760(void) { - u32 frames = (u16)(sBerryBlenderData->gameFrameTime); - u32 max_RPM = (u16)(sBerryBlenderData->max_RPM); + u32 frames = (u16)(gBerryBlenderData->gameFrameTime); + u32 max_RPM = (u16)(gBerryBlenderData->max_RPM); s16 var = 0; if (frames < 900) @@ -2039,77 +1999,77 @@ void sub_8050760(void) sub_80504F0(var); } -void sub_80508D4(u8 value) +static void sub_80508D4(u8 value) { - sBerryBlenderData->field_AA = value; - sub_814A880(192, (sBerryBlenderData->field_AA * 16) + 72); + gBerryBlenderData->field_AA = value; + sub_814A880(192, (gBerryBlenderData->field_AA * 16) + 72); } -void sub_80508FC(void) +static void sub_80508FC(void) { - sBerryBlenderData->field_AA = 0; + gBerryBlenderData->field_AA = 0; MenuDrawTextWindow(23, 8, 28, 13); sub_814A5C0(0, -1, 12, 0x2D9F, 32); MenuPrint(gOtherText_YesNoTerminating, 24, 9); - sub_80508D4(sBerryBlenderData->field_AA); + sub_80508D4(gBerryBlenderData->field_AA); } -void sub_8050954(void) +static void sub_8050954(void) { u8 i; u8 multiplayerID; // unused sub_8051474(); multiplayerID = GetMultiplayerId(); - switch (sBerryBlenderData->field_6F) + switch (gBerryBlenderData->field_6F) { case 1: ClearLinkCallback(); m4aMPlayTempoControl(&gMPlay_BGM, 256); for (i = 0; i < gSpecialVar_0x8004; i++) { - DestroyTask(sBerryBlenderData->field_148[i]); + DestroyTask(gBerryBlenderData->field_148[i]); } - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 2: - sBerryBlenderData->field_56 -= 32; - if (sBerryBlenderData->field_56 <= 0) + gBerryBlenderData->field_56 -= 32; + if (gBerryBlenderData->field_56 <= 0) { - sBerryBlenderData->field_56 = 0; + gBerryBlenderData->field_56 = 0; if (gReceivedRemoteLinkPlayers != 0) - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; else - sBerryBlenderData->field_6F = 5; - sBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_6F = 5; + gBerryBlenderData->field_0 = 0; m4aMPlayStop(&gMPlay_SE2); } Blender_ControlHitPitch(); break; case 3: if (/*multiplayerID != 0*/ GetMultiplayerId() != 0) - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; else if (sub_8007ECC()) { - sBerryBlenderData->field_1BC = sBerryBlenderData->gameFrameTime; - sBerryBlenderData->field_1C0 = sBerryBlenderData->max_RPM; - SendBlock(0, &sBerryBlenderData->field_1BC, 40); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_1BC = gBerryBlenderData->gameFrameTime; + gBerryBlenderData->field_1C0 = gBerryBlenderData->max_RPM; + SendBlock(0, &gBerryBlenderData->field_1BC, 40); + gBerryBlenderData->field_6F++; } break; case 4: if (GetBlockReceivedStatus()) { u32* ptr = ((u32*)(&gBlockRecvBuffer[0][0])); - sBerryBlenderData->max_RPM = gBlockRecvBuffer[0][2]; - sBerryBlenderData->gameFrameTime = *ptr; - sBerryBlenderData->field_6F++; + gBerryBlenderData->max_RPM = gBlockRecvBuffer[0][2]; + gBerryBlenderData->gameFrameTime = *ptr; + gBerryBlenderData->field_6F++; ResetBlockReceivedFlags(); } break; case 5: if (Blender_PrintBlendingRanking()) - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 6: if (Blender_PrintBlendingResults()) @@ -2118,100 +2078,100 @@ void sub_8050954(void) IncrementGameStat(34); else IncrementGameStat(33); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 7: - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; MenuDrawTextWindow(0, 14, 29, 19); MenuPrintMessage(gOtherText_BlendAnotherBerryPrompt, 1, 15); break; case 8: if (MenuUpdateWindowText()) - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 9: - sBerryBlenderData->field_AA = 0; + gBerryBlenderData->field_AA = 0; sub_80508FC(); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 10: if (gMain.newKeys & DPAD_UP) { - if (sBerryBlenderData->field_AA != 0) + if (gBerryBlenderData->field_AA != 0) PlaySE(SE_SELECT); sub_80508D4(0); } else if (gMain.newKeys & DPAD_DOWN) { - if (sBerryBlenderData->field_AA != 1) + if (gBerryBlenderData->field_AA != 1) PlaySE(SE_SELECT); sub_80508D4(1); } else if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } else if (gMain.newKeys & B_BUTTON) { PlaySE(SE_SELECT); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; sub_80508D4(1); } break; case 11: gSendCmd[0] = 0x2FFF; - if (sBerryBlenderData->field_AA == 0) + if (gBerryBlenderData->field_AA == 0) { if (IsBagPocketNonEmpty(BAG_BERRIES) == FALSE) // is empty { - sBerryBlenderData->field_7C = 2; + gBerryBlenderData->field_7C = 2; gSendCmd[1] = 0x9999; } else if (sub_810CA00() == -1) { - sBerryBlenderData->field_7C = 3; + gBerryBlenderData->field_7C = 3; gSendCmd[1] = 0xAAAA; } else { - sBerryBlenderData->field_7C = 0; + gBerryBlenderData->field_7C = 0; gSendCmd[1] = 0x7779; } - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } else { - sBerryBlenderData->field_7C = 1; + gBerryBlenderData->field_7C = 1; gSendCmd[1] = 0x8888; - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 12: if (gUnknown_03004834) { SetMainCallback2(sub_80510E8); - sBerryBlenderData->field_6F = 0; - sBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_6F = 0; + gBerryBlenderData->field_0 = 0; } else { MenuPrintMessage(gOtherText_LinkStandby3, 1, 15); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 13: if (MenuUpdateWindowText()) { SetMainCallback2(sub_8050E30); - sBerryBlenderData->field_6F = 0; - sBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_6F = 0; + gBerryBlenderData->field_0 = 0; } break; } sub_8051B18(); - sub_8051A3C(sBerryBlenderData->field_56); + sub_8051A3C(gBerryBlenderData->field_56); sub_805123C(); RunTasks(); AnimateSprites(); @@ -2219,52 +2179,52 @@ void sub_8050954(void) UpdatePaletteFade(); } -bool8 sub_8050CE8(void) +static bool8 sub_8050CE8(void) { - switch (sBerryBlenderData->field_1C4) + switch (gBerryBlenderData->field_1C4) { case 0: sub_80084A4(); - sBerryBlenderData->field_1C4 = 1; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_1C4 = 1; + gBerryBlenderData->framesToWait = 0; break; case 1: if (sub_8007ECC()) { - sBerryBlenderData->field_1C4++; + gBerryBlenderData->field_1C4++; gSoftResetDisabled = TRUE; } break; case 2: sub_8125E2C(); - sBerryBlenderData->field_1C4++; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_1C4++; + gBerryBlenderData->framesToWait = 0; break; case 3: - if (++sBerryBlenderData->framesToWait == 10) + if (++gBerryBlenderData->framesToWait == 10) { sub_80084A4(); - sBerryBlenderData->field_1C4++; + gBerryBlenderData->field_1C4++; } break; case 4: if (sub_8007ECC()) { if (sub_8125E6C()) - sBerryBlenderData->field_1C4 = 5; + gBerryBlenderData->field_1C4 = 5; else { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_1C4 = 3; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_1C4 = 3; } } break; case 5: - sBerryBlenderData->field_1C4++; - sBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_1C4++; + gBerryBlenderData->framesToWait = 0; break; case 6: - if (++sBerryBlenderData->framesToWait > 5) + if (++gBerryBlenderData->framesToWait > 5) { gSoftResetDisabled = FALSE; return 1; @@ -2274,99 +2234,99 @@ bool8 sub_8050CE8(void) return 0; } -void sub_8050E30(void) +static void sub_8050E30(void) { - switch (sBerryBlenderData->field_6F) + switch (gBerryBlenderData->field_6F) { case 0: - if (sBerryBlenderData->field_70[0] == 0x2222) - sBerryBlenderData->field_6F = 5; - else if (sBerryBlenderData->field_70[0] == 0x1111) - { - if (sBerryBlenderData->field_78 == 0x9999) - sBerryBlenderData->field_6F = 2; - else if (sBerryBlenderData->field_78 == 0xAAAA) - sBerryBlenderData->field_6F = 1; + if (gBerryBlenderData->field_70[0] == 0x2222) + gBerryBlenderData->field_6F = 5; + else if (gBerryBlenderData->field_70[0] == 0x1111) + { + if (gBerryBlenderData->field_78 == 0x9999) + gBerryBlenderData->field_6F = 2; + else if (gBerryBlenderData->field_78 == 0xAAAA) + gBerryBlenderData->field_6F = 1; else - sBerryBlenderData->field_6F = 5; + gBerryBlenderData->field_6F = 5; } break; case 1: - sBerryBlenderData->field_6F = 3; + gBerryBlenderData->field_6F = 3; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); - StringCopy(gStringVar4, gLinkPlayers[sBerryBlenderData->field_7A].name); + StringCopy(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); StringAppend(gStringVar4, gOtherText_OtherCaseIsFull); MenuPrintMessage(gStringVar4, 1, 15); break; case 2: - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); - StringCopy(gStringVar4, gLinkPlayers[sBerryBlenderData->field_7A].name); + StringCopy(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); StringAppend(gStringVar4, gOtherText_NoBerriesForBlend); MenuPrintMessage(gStringVar4, 1, 15); break; case 3: if (MenuUpdateWindowText()) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_6F++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_6F++; } break; case 4: - if (++sBerryBlenderData->framesToWait > 60) - sBerryBlenderData->field_6F = 5; + if (++gBerryBlenderData->framesToWait > 60) + gBerryBlenderData->field_6F = 5; break; case 5: MenuDrawTextWindow(0, 14, 29, 19); MenuPrint(gMultiText_Saving, 2, 15); sub_80084A4(); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 6: if (sub_8007ECC()) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_6F++; - sBerryBlenderData->field_1C4 = 0; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_6F++; + gBerryBlenderData->field_1C4 = 0; } break; case 7: if (sub_8050CE8()) { PlaySE(SE_SAVE); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 8: - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; sub_80084A4(); break; case 9: if (sub_8007ECC()) { BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 10: if (!gPaletteFade.active) { - if (sBerryBlenderData->field_70[0] == 0x2222) + if (gBerryBlenderData->field_70[0] == 0x2222) SetMainCallback2(sub_804E538); else { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_6F++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_6F++; } } break; case 11: - if (++sBerryBlenderData->framesToWait > 30) + if (++gBerryBlenderData->framesToWait > 30) { sub_800832C(); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; } break; case 12: @@ -2382,42 +2342,42 @@ void sub_8050E30(void) UpdatePaletteFade(); } -void sub_80510E8(void) +static void sub_80510E8(void) { - switch (sBerryBlenderData->field_6F) + switch (gBerryBlenderData->field_6F) { case 0: - if (sBerryBlenderData->field_7C < 2) - sBerryBlenderData->field_6F = 9; - if (sBerryBlenderData->field_7C == 2) - sBerryBlenderData->field_6F = 2; - if (sBerryBlenderData->field_7C == 3) - sBerryBlenderData->field_6F =1; + if (gBerryBlenderData->field_7C < 2) + gBerryBlenderData->field_6F = 9; + if (gBerryBlenderData->field_7C == 2) + gBerryBlenderData->field_6F = 2; + if (gBerryBlenderData->field_7C == 3) + gBerryBlenderData->field_6F =1; break; case 1: - sBerryBlenderData->field_6F = 3; + gBerryBlenderData->field_6F = 3; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); MenuPrintMessage(gOtherText_CaseIsFull, 1, 15); break; case 2: - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); MenuPrintMessage(gOtherText_OutOfBerries, 1, 15); break; case 3: if (MenuUpdateWindowText()) - sBerryBlenderData->field_6F = 9; + gBerryBlenderData->field_6F = 9; break; case 9: BeginFastPaletteFade(3); - sBerryBlenderData->field_6F++; + gBerryBlenderData->field_6F++; break; case 10: if (!gPaletteFade.active) { - if (sBerryBlenderData->field_7C == 0) + if (gBerryBlenderData->field_7C == 0) SetMainCallback2(sub_804E538); else SetMainCallback2(c2_exit_to_overworld_1_continue_scripts_restart_music); @@ -2432,7 +2392,7 @@ void sub_80510E8(void) UpdatePaletteFade(); } -void sub_805123C(void) +static void sub_805123C(void) { if (gReceivedRemoteLinkPlayers) { @@ -2443,24 +2403,24 @@ void sub_805123C(void) switch (gRecvCmds[2][0]) { case 0x8888: - sBerryBlenderData->field_78 = 0x8888; - sBerryBlenderData->field_7A = gRecvCmds[3][0]; + gBerryBlenderData->field_78 = 0x8888; + gBerryBlenderData->field_7A = gRecvCmds[3][0]; break; case 0x9999: - sBerryBlenderData->field_78 = 0x9999; - sBerryBlenderData->field_7A = gRecvCmds[3][0]; + gBerryBlenderData->field_78 = 0x9999; + gBerryBlenderData->field_7A = gRecvCmds[3][0]; break; case 0xAAAA: - sBerryBlenderData->field_78 = 0xAAAA; - sBerryBlenderData->field_7A = gRecvCmds[3][0]; + gBerryBlenderData->field_78 = 0xAAAA; + gBerryBlenderData->field_7A = gRecvCmds[3][0]; break; } - sBerryBlenderData->field_70[0] = 0x1111; + gBerryBlenderData->field_70[0] = 0x1111; } else if (gRecvCmds[1][0] == 0x2222) - sBerryBlenderData->field_70[0] = 0x2222; + gBerryBlenderData->field_70[0] = 0x2222; } - if (GetMultiplayerId() == 0 && sBerryBlenderData->field_70[0] != 0x1111 && sBerryBlenderData->field_70[0] != 0x2222) + if (GetMultiplayerId() == 0 && gBerryBlenderData->field_70[0] != 0x1111 && gBerryBlenderData->field_70[0] != 0x2222) { u8 i; for (i = 0; i < GetLinkPlayerCount(); i++) @@ -2470,30 +2430,30 @@ void sub_805123C(void) switch (gRecvCmds[1][i]) { case 0x8888: - sBerryBlenderData->field_70[i] = 0x8888; + gBerryBlenderData->field_70[i] = 0x8888; break; case 0x7779: - sBerryBlenderData->field_70[i] = 0x7779; + gBerryBlenderData->field_70[i] = 0x7779; break; case 0x9999: - sBerryBlenderData->field_70[i] = 0x9999; + gBerryBlenderData->field_70[i] = 0x9999; break; case 0xAAAA: - sBerryBlenderData->field_70[i] = 0xAAAA; + gBerryBlenderData->field_70[i] = 0xAAAA; break; } } } for (i = 0; i < GetLinkPlayerCount(); i++) { - if (sBerryBlenderData->field_70[i] == 0) + if (gBerryBlenderData->field_70[i] == 0) break; } if (i == GetLinkPlayerCount()) { for (i = 0; i < GetLinkPlayerCount(); i++) { - if (sBerryBlenderData->field_70[i] != 0x7779) + if (gBerryBlenderData->field_70[i] != 0x7779) break; } gSendCmd[0] = 0x2FFF; @@ -2502,7 +2462,7 @@ void sub_805123C(void) else { gSendCmd[1] = 0x1111; - gSendCmd[2] = sBerryBlenderData->field_70[i]; + gSendCmd[2] = gBerryBlenderData->field_70[i]; gSendCmd[3] = i; } } @@ -2510,42 +2470,42 @@ void sub_805123C(void) } } -void sub_8051414(struct BgAffineDstData *dest) +static void sub_8051414(struct BgAffineDstData *dest) { struct BgAffineSrcData affineSrc; affineSrc.texX = 30720; affineSrc.texY = 20480; - affineSrc.scrX = 120 - sBerryBlenderData->field_144; - affineSrc.scrY = 80 - sBerryBlenderData->field_146; - affineSrc.sx = sBerryBlenderData->field_142; - affineSrc.sy = sBerryBlenderData->field_142; - affineSrc.alpha = sBerryBlenderData->arrowPos; + affineSrc.scrX = 120 - gBerryBlenderData->field_144; + affineSrc.scrY = 80 - gBerryBlenderData->field_146; + affineSrc.sx = gBerryBlenderData->field_142; + affineSrc.sy = gBerryBlenderData->field_142; + affineSrc.alpha = gBerryBlenderData->arrowPos; BgAffineSet(&affineSrc, dest, 1); } -void sub_8051474(void) +static void sub_8051474(void) { - sBerryBlenderData->field_58 = sBerryBlenderData->arrowPos; - sBerryBlenderData->arrowPos += sBerryBlenderData->field_56; - sub_8051414(&sBerryBlenderData->field_168); + gBerryBlenderData->field_58 = gBerryBlenderData->arrowPos; + gBerryBlenderData->arrowPos += gBerryBlenderData->field_56; + sub_8051414(&gBerryBlenderData->field_168); } -void sub_80514A4(void) +static void sub_80514A4(void) { - REG_BG2PA = sBerryBlenderData->field_168.pa; - REG_BG2PB = sBerryBlenderData->field_168.pb; - REG_BG2PC = sBerryBlenderData->field_168.pc; - REG_BG2PD = sBerryBlenderData->field_168.pd; - REG_BG2X = sBerryBlenderData->field_168.dx; - REG_BG2Y = sBerryBlenderData->field_168.dy; + REG_BG2PA = gBerryBlenderData->field_168.pa; + REG_BG2PB = gBerryBlenderData->field_168.pb; + REG_BG2PC = gBerryBlenderData->field_168.pc; + REG_BG2PD = gBerryBlenderData->field_168.pd; + REG_BG2X = gBerryBlenderData->field_168.dx; + REG_BG2Y = gBerryBlenderData->field_168.dy; } -void sub_80514F0(void) +static void sub_80514F0(void) { - REG_BG1HOFS = sBerryBlenderData->field_144; - REG_BG1VOFS = sBerryBlenderData->field_146; - REG_BG0HOFS = sBerryBlenderData->field_144; - REG_BG0VOFS = sBerryBlenderData->field_146; + REG_BG1HOFS = gBerryBlenderData->field_144; + REG_BG1VOFS = gBerryBlenderData->field_146; + REG_BG0HOFS = gBerryBlenderData->field_144; + REG_BG0VOFS = gBerryBlenderData->field_146; } void sub_8051524(struct Sprite* sprite) @@ -2558,9 +2518,7 @@ void sub_8051524(struct Sprite* sprite) DestroySprite(sprite); } -extern const struct SpriteTemplate gSpriteTemplate_82164FC; - -void sub_805156C(void) +static void sub_805156C(void) { s32 limit = (Random() % 2) + 1; s32 i; @@ -2571,7 +2529,7 @@ void sub_805156C(void) s32 x, y; u8 spriteID; - rand = sBerryBlenderData->arrowPos + (Random() % 20); + rand = gBerryBlenderData->arrowPos + (Random() % 20); x = gSineTable[(rand & 0xFF) + 64] / 4; y = gSineTable[(rand & 0xFF)] / 4; @@ -2604,13 +2562,10 @@ void sub_8051684(struct Sprite* sprite) void Blender_SetBankBerryData(u8 bank, u16 itemID) { - sBerryBlenderData->chosenItemID[bank] = itemID; - Blender_CopyBerryData(&sBerryBlenderData->blendedBerries[bank], itemID); + gBerryBlenderData->chosenItemID[bank] = itemID; + Blender_CopyBerryData(&gBerryBlenderData->blendedBerries[bank], itemID); } -extern const u8* const gUnknown_08216284[]; -extern u8 byte_3002A68; - void unref_sub_80516F8(u8 taskID) { struct Task* task = &gTasks[taskID]; @@ -2623,7 +2578,7 @@ void unref_sub_80516F8(u8 taskID) task->data[0] = 0; if (task->data[0] == 100) { - ZeroFillWindowRect(&sBerryBlenderData->field_4, 0, 0, 16, 20); + ZeroFillWindowRect(&gBerryBlenderData->field_4, 0, 0, 16, 20); MenuDrawTextWindow(4, 4, 10, 12); for (i = 0; i < 3; i++) { @@ -2651,8 +2606,6 @@ void unref_sub_80516F8(u8 taskID) } } -extern const struct SpriteTemplate gSpriteTemplate_821657C; - void sub_805181C(struct Sprite* sprite) { switch (sprite->data0) @@ -2717,7 +2670,7 @@ void sub_80518CC(struct Sprite* sprite) sprite->data1 += 4; if (sprite->data1 > 176) { - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; DestroySprite(sprite); } break; @@ -2725,16 +2678,16 @@ void sub_80518CC(struct Sprite* sprite) sprite->pos2.y = sprite->data1; } -void sub_805194C(u16 a0, u16 a1) +static void sub_805194C(u16 a0, u16 a1) { - if (sBerryBlenderData->field_140 < a0) + if (gBerryBlenderData->field_140 < a0) { - sBerryBlenderData->field_140 += 2; - sub_805197C(sBerryBlenderData->field_140, a1); + gBerryBlenderData->field_140 += 2; + sub_805197C(gBerryBlenderData->field_140, a1); } } -void sub_805197C(u16 a0, u16 a1) +static void sub_805197C(u16 a0, u16 a1) { s32 var1, var2, var3, var4; u16* vram; @@ -2761,19 +2714,19 @@ void sub_805197C(u16 a0, u16 a1) } } -u32 sub_8051A1C(u16 a0) +static u32 sub_8051A1C(u16 a0) { return 360000 * a0 / 0x10000; } -void sub_8051A3C(u16 a0) +static void sub_8051A3C(u16 a0) { u8 i; u8 palAdders[5]; u32 var = sub_8051A1C(a0); - if (sBerryBlenderData->max_RPM < var) - sBerryBlenderData->max_RPM = var; + if (gBerryBlenderData->max_RPM < var) + gBerryBlenderData->max_RPM = var; for (i = 0; i < 5; i++) { palAdders[i] = var % 10; @@ -2786,13 +2739,13 @@ void sub_8051A3C(u16 a0) *((u16*)(VRAM + 0x6462)) = palAdders[0] + 0x8172; } -void sub_8051AC8(s16* a0, u16 a1) +static void sub_8051AC8(s16* a0, u16 a1) { if (*a0 == 0) *a0 = (Random() % a1) - (a1 / 2); } -void sub_8051AF4(s16* a0) +static void sub_8051AF4(s16* a0) { if (*a0 < 0 ) (*a0)++; @@ -2800,13 +2753,13 @@ void sub_8051AF4(s16* a0) (*a0)--; } -void sub_8051B18(void) +static void sub_8051B18(void) { - sub_8051AF4(&sBerryBlenderData->field_144); - sub_8051AF4(&sBerryBlenderData->field_146); + sub_8051AF4(&gBerryBlenderData->field_144); + sub_8051AF4(&gBerryBlenderData->field_146); } -void sub_8051B40(s16* a0, u16 a1) +static void sub_8051B40(s16* a0, u16 a1) { s32 var; if (a1 < 10) @@ -2824,20 +2777,20 @@ void sub_8051B40(s16* a0, u16 a1) } } -bool8 sub_8051B8C(void) +static bool8 sub_8051B8C(void) { - if (sBerryBlenderData->framesToWait == 0) + if (gBerryBlenderData->framesToWait == 0) { - sBerryBlenderData->field_144 = 0; - sBerryBlenderData->field_146 = 0; + gBerryBlenderData->field_144 = 0; + gBerryBlenderData->field_146 = 0; } - sBerryBlenderData->framesToWait++; - sub_8051B40(&sBerryBlenderData->field_144, sBerryBlenderData->framesToWait); - sub_8051B40(&sBerryBlenderData->field_146, sBerryBlenderData->framesToWait); - if (sBerryBlenderData->framesToWait == 20) + gBerryBlenderData->framesToWait++; + sub_8051B40(&gBerryBlenderData->field_144, gBerryBlenderData->framesToWait); + sub_8051B40(&gBerryBlenderData->field_146, gBerryBlenderData->framesToWait); + if (gBerryBlenderData->framesToWait == 20) { - sBerryBlenderData->field_144 = 0; - sBerryBlenderData->field_146 = 0; + gBerryBlenderData->field_144 = 0; + gBerryBlenderData->field_146 = 0; return 1; } else @@ -2846,49 +2799,46 @@ bool8 sub_8051B8C(void) void sub_8051C04(struct Sprite* sprite) { - sprite->pos2.x = -(sBerryBlenderData->field_144); - sprite->pos2.y = -(sBerryBlenderData->field_146); + sprite->pos2.x = -(gBerryBlenderData->field_144); + sprite->pos2.y = -(gBerryBlenderData->field_146); } -void Blender_TrySettingRecord(void) +static void Blender_TrySettingRecord(void) { - if (gSaveBlock1.berryBlenderRecords[sBerryBlenderData->playersNo - 2] < sBerryBlenderData->max_RPM) - gSaveBlock1.berryBlenderRecords[sBerryBlenderData->playersNo - 2] = sBerryBlenderData->max_RPM; + if (gSaveBlock1.berryBlenderRecords[gBerryBlenderData->playersNo - 2] < gBerryBlenderData->max_RPM) + gSaveBlock1.berryBlenderRecords[gBerryBlenderData->playersNo - 2] = gBerryBlenderData->max_RPM; } -extern const u8 gUnknown_082165E9[]; -extern const u8 gUnknown_082165EE[]; - -bool8 Blender_PrintBlendingResults(void) +static bool8 Blender_PrintBlendingResults(void) { u16 i; struct Pokeblock pokeblock; - u8 vars2[8]; + u8 flavours[6]; u8 text[2][10]; u16 berryIDs[4]; // unused - switch (sBerryBlenderData->field_0) + switch (gBerryBlenderData->field_0) { case 0: - sBerryBlenderData->field_0++; - sBerryBlenderData->framesToWait = 17; + gBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 17; break; case 1: - sBerryBlenderData->framesToWait -= 10; - if (sBerryBlenderData->framesToWait < 0) + gBerryBlenderData->framesToWait -= 10; + if (gBerryBlenderData->framesToWait < 0) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } break; case 2: - if (++sBerryBlenderData->framesToWait > 20) + if (++gBerryBlenderData->framesToWait > 20) { for (i = 0; i < 3; i++) - DestroySprite(&gSprites[sBerryBlenderData->scoreIconIDs[i]]); - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + DestroySprite(&gSprites[gBerryBlenderData->scoreIconIDs[i]]); + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } break; case 3: @@ -2898,15 +2848,15 @@ bool8 Blender_PrintBlendingResults(void) MenuDrawTextWindow(4, 2, 25, 17); sub_8072BD8(gOtherText_ResultsOfBlending, 5, 3, 160); - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) { - u8 place = sBerryBlenderData->playerPlaces[i]; + u8 place = gBerryBlenderData->playerPlaces[i]; textPtr = text[0]; - StringCopy(textPtr, sBerryBlenderData->blendedBerries[place].name); + StringCopy(textPtr, gBerryBlenderData->blendedBerries[place].name); ConvertInternationalString(textPtr, gLinkPlayers[place].language); StringAppend(textPtr, gOtherText_Berry); - textPtr = sBerryBlenderData->stringVar; + textPtr = gBerryBlenderData->stringVar; textPtr = ConvertIntToDecimalString(textPtr, i + 1); textPtr[0] = CHAR_SPACE; textPtr[1] = CHAR_PERIOD; @@ -2914,12 +2864,12 @@ bool8 Blender_PrintBlendingResults(void) textPtr += 3; textPtr = sub_8072C74(textPtr, gLinkPlayers[place].name, 88, 0); sub_8072C74(textPtr, text[0], 157, 0); - MenuPrint(sBerryBlenderData->stringVar, 5, gUnknown_082165E9[sBerryBlenderData->playersNo] + (i * gUnknown_082165EE[sBerryBlenderData->playersNo])); + MenuPrint(gBerryBlenderData->stringVar, 5, gUnknown_082165E9[gBerryBlenderData->playersNo] + (i * gUnknown_082165EE[gBerryBlenderData->playersNo])); } - ConvertIntToDecimalStringN(text[0], sBerryBlenderData->max_RPM % 100, 2, 2); - textPtr = sBerryBlenderData->stringVar; + ConvertIntToDecimalStringN(text[0], gBerryBlenderData->max_RPM % 100, 2, 2); + textPtr = gBerryBlenderData->stringVar; textPtr = StringCopy(textPtr, gOtherText_MaxSpeed); - textPtr = sub_8072C14(textPtr, sBerryBlenderData->max_RPM / 100, 121, 1); + textPtr = sub_8072C14(textPtr, gBerryBlenderData->max_RPM / 100, 121, 1); textPtr[0] = CHAR_SPACE; textPtr[1] = CHAR_PERIOD; @@ -2928,14 +2878,14 @@ bool8 Blender_PrintBlendingResults(void) textPtr = sub_8072C74(textPtr, text[0], 142, 1); StringCopy(textPtr, gOtherText_RPM); - MenuPrint(sBerryBlenderData->stringVar, 5, 13); + MenuPrint(gBerryBlenderData->stringVar, 5, 13); - secondsPassed = sBerryBlenderData->gameFrameTime / 60; + secondsPassed = gBerryBlenderData->gameFrameTime / 60; seconds = secondsPassed % 60; minutes = secondsPassed / 60; ConvertIntToDecimalStringN(text[0], minutes, 2, 2); ConvertIntToDecimalStringN(text[1], seconds, 2, 2); - textPtr = sBerryBlenderData->stringVar; + textPtr = gBerryBlenderData->stringVar; textPtr = StringCopy(textPtr, gOtherText_RequiredTime); textPtr = sub_8072C74(textPtr, text[0], 102, 1); @@ -2944,32 +2894,32 @@ bool8 Blender_PrintBlendingResults(void) textPtr = sub_8072C74(textPtr, text[1], 136, 1); StringCopy(textPtr, gOtherText_Sec); - MenuPrint(sBerryBlenderData->stringVar, 5, 15); + MenuPrint(gBerryBlenderData->stringVar, 5, 15); - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } break; case 4: if (gMain.newKeys & A_BUTTON) - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 5: MenuZeroFillScreen(); MenuDrawTextWindow(0, 14, 29, 19); for (i = 0; i < BLENDER_MAX_PLAYERS; i++) { - if (sBerryBlenderData->chosenItemID[i] != 0) - berryIDs[i] = sBerryBlenderData->chosenItemID[i] - 133; + if (gBerryBlenderData->chosenItemID[i] != 0) + berryIDs[i] = gBerryBlenderData->chosenItemID[i] - 133; } sub_8050760(); - sub_8050520(sBerryBlenderData->blendedBerries, &pokeblock, sBerryBlenderData->playersNo, vars2, sBerryBlenderData->max_RPM); - Blender_PrintMadePokeblockString(&pokeblock, sBerryBlenderData->stringVar); + Blender_CalculatePokeblock(gBerryBlenderData->blendedBerries, &pokeblock, gBerryBlenderData->playersNo, flavours, gBerryBlenderData->max_RPM); + Blender_PrintMadePokeblockString(&pokeblock, gBerryBlenderData->stringVar); CreateTask(sub_8052BD0, 6); - MenuPrintMessage(sBerryBlenderData->stringVar, 1, 15); + MenuPrintMessage(gBerryBlenderData->stringVar, 1, 15); RemoveBagItem(gScriptItemId, 1); sub_810CA34(&pokeblock); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; break; case 6: if (MenuUpdateWindowText()) @@ -2982,11 +2932,7 @@ bool8 Blender_PrintBlendingResults(void) return 0; } -extern const u8 gUnknown_08216249[]; -extern const u8 gUnknown_082162C8[]; -extern const u8 *const gPokeblockNames[]; - -void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst) +static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst) { u8 text[12]; u8 flavourLvl, feel; @@ -3011,7 +2957,7 @@ void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst) StringAppend(dst, gUnknown_08216249); } -void Blender_SortBasedOnPoints(u8* places, u8 playersNum, u32* scores) +static void Blender_SortBasedOnPoints(u8* places, u8 playersNum, u32* scores) { s32 i, j; for (i = 0; i < playersNum; i++) @@ -3028,72 +2974,70 @@ void Blender_SortBasedOnPoints(u8* places, u8 playersNum, u32* scores) } } -void Blender_SortScores(void) +static void Blender_SortScores(void) { u8 i; u8 places[4]; u32 points[4]; - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) places[i] = i; - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) { - points[i] = 1000000 * sBerryBlenderData->scores[i][BLENDER_SCORE_BEST]; - points[i] += 1000 * sBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]; - points[i] += 1000 - sBerryBlenderData->scores[i][BLENDER_SCORE_MISS]; + points[i] = 1000000 * gBerryBlenderData->scores[i][BLENDER_SCORE_BEST]; + points[i] += 1000 * gBerryBlenderData->scores[i][BLENDER_SCORE_GOOD]; + points[i] += 1000 - gBerryBlenderData->scores[i][BLENDER_SCORE_MISS]; } - Blender_SortBasedOnPoints(places, sBerryBlenderData->playersNo, points); - for (i = 0; i < sBerryBlenderData->playersNo; i++) - sBerryBlenderData->playerPlaces[i] = places[i]; + Blender_SortBasedOnPoints(places, gBerryBlenderData->playersNo, points); + for (i = 0; i < gBerryBlenderData->playersNo; i++) + gBerryBlenderData->playerPlaces[i] = places[i]; } -extern const u8 gUnknown_082165F3[]; - -bool8 Blender_PrintBlendingRanking(void) +static bool8 Blender_PrintBlendingRanking(void) { u16 i; - switch (sBerryBlenderData->field_0) + switch (gBerryBlenderData->field_0) { case 0: - sBerryBlenderData->field_0++; - sBerryBlenderData->framesToWait = 255; + gBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 255; break; case 1: - sBerryBlenderData->framesToWait -= 10; - if (sBerryBlenderData->framesToWait < 0) + gBerryBlenderData->framesToWait -= 10; + if (gBerryBlenderData->framesToWait < 0) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } break; case 2: - if (++sBerryBlenderData->framesToWait > 20) + if (++gBerryBlenderData->framesToWait > 20) { - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; } break; case 3: MenuDrawTextWindow(4, 2, 25, 17); sub_8072BD8(gOtherText_Ranking, 5, 3, 160); - sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST] = CreateSprite(&gSpriteTemplate_821645C, 140, 52, 0); - gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]].callback = SpriteCallbackDummy; - StartSpriteAnim(&gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]], 3); + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST] = CreateSprite(&gSpriteTemplate_821645C, 140, 52, 0); + gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]].callback = SpriteCallbackDummy; + StartSpriteAnim(&gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]], 3); - sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD] = CreateSprite(&gSpriteTemplate_821645C, 164, 52, 0); - gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD]].callback = SpriteCallbackDummy; + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD] = CreateSprite(&gSpriteTemplate_821645C, 164, 52, 0); + gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD]].callback = SpriteCallbackDummy; - sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS] = CreateSprite(&gSpriteTemplate_821645C, 188, 52, 0); - gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]].callback = SpriteCallbackDummy; - StartSpriteAnim(&gSprites[sBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]], 1); + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS] = CreateSprite(&gSpriteTemplate_821645C, 188, 52, 0); + gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]].callback = SpriteCallbackDummy; + StartSpriteAnim(&gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]], 1); Blender_SortScores(); - for (i = 0; i < sBerryBlenderData->playersNo; i++) + for (i = 0; i < gBerryBlenderData->playersNo; i++) { - u8 place = sBerryBlenderData->playerPlaces[i]; - u8* txtPtr = sBerryBlenderData->stringVar; + u8 place = gBerryBlenderData->playerPlaces[i]; + u8* txtPtr = gBerryBlenderData->stringVar; txtPtr[0] = EXT_CTRL_CODE_BEGIN; txtPtr[1] = 0x13; @@ -3109,40 +3053,34 @@ bool8 Blender_PrintBlendingRanking(void) txtPtr = StringCopy(txtPtr, gLinkPlayers[place].name); - txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_BEST], 108, 1); - txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_GOOD], 132, 1); - txtPtr = sub_8072C14(txtPtr, sBerryBlenderData->scores[place][BLENDER_SCORE_MISS], 156, 1); + txtPtr = sub_8072C14(txtPtr, gBerryBlenderData->scores[place][BLENDER_SCORE_BEST], 108, 1); + txtPtr = sub_8072C14(txtPtr, gBerryBlenderData->scores[place][BLENDER_SCORE_GOOD], 132, 1); + txtPtr = sub_8072C14(txtPtr, gBerryBlenderData->scores[place][BLENDER_SCORE_MISS], 156, 1); - MenuPrint(sBerryBlenderData->stringVar, 5, i * gUnknown_082165F3[sBerryBlenderData->playersNo] + 8); + MenuPrint(gBerryBlenderData->stringVar, 5, i * gUnknown_082165F3[gBerryBlenderData->playersNo] + 8); } - sBerryBlenderData->framesToWait = 0; - sBerryBlenderData->field_0++; + gBerryBlenderData->framesToWait = 0; + gBerryBlenderData->field_0++; break; case 4: - if (++sBerryBlenderData->framesToWait > 20) - sBerryBlenderData->field_0++; + if (++gBerryBlenderData->framesToWait > 20) + gBerryBlenderData->field_0++; break; case 5: if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - sBerryBlenderData->field_0++; + gBerryBlenderData->field_0++; } break; case 6: - sBerryBlenderData->field_0 = 0; + gBerryBlenderData->field_0 = 0; return 1; } return 0; } -struct UnknownStruct -{ - s8 bytes[24]; - s16 hword[2]; -}; - -extern struct UnknownStruct gUnknown_03000560; +// debug menu goes here void unref_sub_80524BC(void) { @@ -3158,7 +3096,265 @@ void unref_sub_80524BC(void) AnimateSprites(); BuildOamBuffer(); UpdatePaletteFade(); - gUnknown_03000560.hword[1] = 0x1F40; - gUnknown_03000560.bytes[16]++; + sBlenderDebug.BPM = 8000; + sBlenderDebug.field_10++; SetMainCallback2(sub_8052AF8); } + +static void BlenderDebug_PrintBerryData(void) +{ + u8 text[128]; + u8 i; + + StringCopy(text, gOtherText_BPMAndDash); + MenuPrint(text, 2, 0); + + ConvertIntToDecimalStringN(text, sBlenderDebug.BPM / 100, 2, 3); + MenuPrint(text, 6, 0); + + for (i = 0; i < 4; i++) + { + u8 var; + + if (sBlenderDebug.cursorPos == i) + { + text[0] = 0xEF; + CopyItemName(sBlenderDebug.berries[i] + 133, &text[1]); + } + else + { + CopyItemName(sBlenderDebug.berries[i] + 133, &text[0]); + text[6] = CHAR_SPACE; + text[7] = EOS; + } + var = (i * 3) + 3; + MenuPrint(text, 2, var); + + ConvertIntToDecimalStringN(&text[0], gBerries[sBlenderDebug.berries[i]].spicy, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToDecimalStringN(&text[3], gBerries[sBlenderDebug.berries[i]].dry, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToDecimalStringN(&text[6], gBerries[sBlenderDebug.berries[i]].sweet, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToDecimalStringN(&text[9], gBerries[sBlenderDebug.berries[i]].bitter, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToDecimalStringN(&text[12], gBerries[sBlenderDebug.berries[i]].sour, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToDecimalStringN(&text[15], gBerries[sBlenderDebug.berries[i]].smoothness, 2, 2); + + text[17] = EOS; + MenuPrint(text, 7, var); + } + if (sBlenderDebug.pokeblock.color != 0) + { + StringCopy(text, gPokeblockNames[sBlenderDebug.pokeblock.color]); + MenuPrint(text, 2, 15); + + ConvertIntToHexStringN(&text[0], sBlenderDebug.spicy, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(&text[3], sBlenderDebug.dry, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(&text[6], sBlenderDebug.sweet, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(&text[9], sBlenderDebug.bitter, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(&text[12], sBlenderDebug.sour, 2, 2); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(&text[15], sBlenderDebug.feel, 2, 2); + + text[17] = EOS; + MenuPrint(text, 7, 17); + } +} + +static void sub_80527BC(void) +{ + u8 text[70]; + u8 buffer[10]; + u16 i; + + if (gUnknown_020297DC == 1) + { + u16 j; + for (j = 0; j < 10; j++) + gUnknown_03004840[j] = 0; + gUnknown_03004830 = Random(); + gUnknown_020297E0 = 0; + gUnknown_020297DC = 2; + for (i = 0; i < 200; i++) + ewram[i] = 0; + gUnknown_020297E8 = 0; + } + for (i = 0; i < 100; i++) + { + if (((Random() >> 15) & 1) == gUnknown_020297E8) + gUnknown_020297E0++; + else + { + u16* ewramPtr = ((u16*)(ewram)); + ewramPtr[gUnknown_020297E4] = gUnknown_020297E0; + gUnknown_020297E4++; + gUnknown_020297E0 = 0; + gUnknown_020297E8 ^= 1; + } + } + text[0] = EOS; + + ConvertIntToHexStringN(buffer, gUnknown_03004830, 2, 8); + StringAppend(text, buffer); + StringAppend(text, gUnknown_082165F8); + + ConvertIntToHexStringN(buffer, gUnknown_020297E0, 2, 8); + StringAppend(text, buffer); + StringAppend(text, gUnknown_08216600); + + if (gUnknown_020297DC == 3) + { + ConvertIntToHexStringN(buffer, gUnknown_020297E4, 2, 16); + StringAppend(text, buffer); + gUnknown_020297DC = 0; + } + + MenuPrint(text, 2, 15); +} + +static void sub_8052918(void) +{ + if (gMain.newKeys & R_BUTTON) + { + sBlenderDebug.BPM += 1000; + if (sBlenderDebug.BPM > 30000) + sBlenderDebug.BPM = 1000; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & L_BUTTON) + { + sBlenderDebug.BPM -= 1000; + if (sBlenderDebug.BPM < 0) + sBlenderDebug.BPM = 30000; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & DPAD_UP) + { + sBlenderDebug.cursorPos -= 1; + if (sBlenderDebug.cursorPos < 0) + sBlenderDebug.cursorPos = 3; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & DPAD_DOWN) + { + sBlenderDebug.cursorPos += 1; + if (sBlenderDebug.cursorPos > 3) + sBlenderDebug.cursorPos = 0; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & DPAD_LEFT) + { + if (--sBlenderDebug.berries[sBlenderDebug.cursorPos] < 0) + sBlenderDebug.berries[sBlenderDebug.cursorPos] = 42; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & DPAD_RIGHT) + { + if (++sBlenderDebug.berries[sBlenderDebug.cursorPos] > 42) + sBlenderDebug.berries[sBlenderDebug.cursorPos] = 0; + sBlenderDebug.field_10++; + } + if (gMain.newKeys & A_BUTTON) + { + u16 berryIDs[4]; + struct BlenderBerry berries[4]; + + u16 i, notEnigma = 0; + for (i = 0; i < 4; i++) + { + if (sBlenderDebug.berries[i] != 42) + { + notEnigma++; + berryIDs[i] = sBlenderDebug.berries[i]; + Blender_CopyBerryData(&berries[i], sBlenderDebug.berries[i] + 133); + } + else + break; + } + if (notEnigma > 1) + { + BlenderDebug_CalculatePokeblock(berries, &sBlenderDebug.pokeblock, notEnigma, &sBlenderDebug.spicy, sBlenderDebug.BPM); + sBlenderDebug.field_10++; + } + else + sBlenderDebug.pokeblock.color = 0xFF; + } + if (sBlenderDebug.field_10) + { + BlenderDebug_PrintBerryData(); + sBlenderDebug.field_10 = 0; + } + if (gMain.newKeys & SELECT_BUTTON && gUnknown_020297DC == 0) + { + gUnknown_020297DC++; + gUnknown_020297E0 = 0; + SeedRng(gMain.vblankCounter1); + } + if (gUnknown_020297DC != 0) + sub_80527BC(); +} + +static void sub_8052AF8(void) +{ + sub_8052918(); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +// debug menu ends +// blender record window begins + +void ShowBerryBlenderRecordWindow(void) +{ + u8 text[30]; + s32 i; + + MenuDrawTextWindow(6, 3, 23, 16); + MenuPrint(gMultiText_BerryBlenderMaxSpeedRecord, 8, 4); + MenuPrint(gMultiText_2P3P4P, 8, 9); + + for (i = 0; i < 3; i++) + { + u32 record = gSaveBlock1.berryBlenderRecords[i]; + u8* txtPtr = sub_8072C14(text, record / 100, 18, 1); + txtPtr[0] = CHAR_SPACE; + txtPtr[1] = CHAR_PERIOD; + txtPtr[2] = CHAR_SPACE; + txtPtr += 3; + txtPtr = ConvertIntToDecimalStringN(txtPtr, record % 100, 2, 2); + StringAppend(txtPtr, gOtherText_RPM); + MenuPrint(text, 15, i * 2 + 9); + } +} + +static void sub_8052BD0(u8 taskID) +{ + if (gTasks[taskID].data[0] == 0) + { + PlayFanfare(BGM_FANFA1); + gTasks[taskID].data[0]++; + } + if (IsFanfareTaskInactive()) + { + PlayBGM(gBerryBlenderData->field_178); + DestroyTask(taskID); + } +} -- cgit v1.2.3 From 04110a7040ae2a93505812fbb215bc52fdaf0e95 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sun, 13 Aug 2017 17:55:25 -0500 Subject: decompile nullsub_91 - sub_802C2EC --- src/battle_5.c | 433 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 433 insertions(+) create mode 100644 src/battle_5.c (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c new file mode 100644 index 000000000..485a67bd4 --- /dev/null +++ b/src/battle_5.c @@ -0,0 +1,433 @@ +#include "global.h" +#include "battle.h" +#include "battle_interface.h" +#include "item.h" +#include "link.h" +#include "main.h" +#include "menu_cursor.h" +#include "pokemon.h" +#include "rom3.h" +#include "songs.h" +#include "sound.h" +#include "util.h" + +extern u8 gActiveBank; +extern void (*gBattleBankFunc[])(void); +extern bool8 gDoingBattleAnim; +extern u16 gBattleTypeFlags; +extern u32 gBattleExecBuffer; +extern u8 gBattleBufferA[][0x200]; +extern u8 gObjectBankIDs[]; +extern u8 gActionSelectionCursor[]; +extern u8 gMoveSelectionCursor[]; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_03004344; +extern u8 gNoOfAllBanks; +extern u16 gBattlePartyID[]; +extern const struct BattleMove gBattleMoves[]; + +extern void dp11b_obj_instanciate(u8, u8, s8, s8); +extern u8 GetBankIdentity(u8); +extern u8 GetBankByPlayerAI(u8); +extern void dp11b_obj_free(u8, u8); +extern void sub_8010520(struct Sprite *); +extern void sub_8010574(struct Sprite *); + +void PlayerHandleGetAttributes(void); +void sub_802ECF0(void); +void PlayerHandleSetAttributes(void); +void sub_802F7CC(void); +void PlayerHandleLoadPokeSprite(void); +void PlayerHandleSendOutPoke(void); +void PlayerHandleReturnPokeToBall(void); +void PlayerHandleTrainerThrow(void); +void PlayerHandleTrainerSlide(void); +void PlayerHandleTrainerSlideBack(void); +void sub_802FE7C(void); +void sub_802FF60(void); +void sub_802FF80(void); +void PlayerHandleBallThrow(void); +void PlayerHandlePuase(void); +void PlayerHandleMoveAnimation(void); +void PlayerHandlePrintString(void); +void PlayerHandlePrintStringPlayerOnly(void); +void sub_803037C(void); +void nullsub_42(void); +void sub_8030468(void); +void PlayerHandleOpenBag(void); +void sub_8030594(void); +void sub_8030674(void); +void PlayerHandleHealthBarUpdate(void); +void PlayerHandleExpBarUpdate(void); +void PlayerHandleStatusIconUpdate(void); +void PlayerHandleStatusAnimation(void); +void PlayerHandleStatusXor(void); +void sub_803097C(void); +void PlayerHandleDMATransfer(void); +void sub_8030A3C(void); +void sub_8030A6C(void); +void sub_8030A78(void); +void sub_8030A8C(void); +void sub_8030AA0(void); +void sub_8030AB4(void); +void sub_8030AC8(void); +void sub_8030AE4(void); +void sub_8030B1C(void); +void sub_8030B34(void); +void PlayerHandleHitAnimation(void); +void sub_8030BCC(void); +void PlayerHandleEffectivenessSound(void); +void sub_8030C1C(void); +void PlayerHandleFaintingCry(void); +void PlayerHandleIntroSlide(void); +void PlayerHandleTrainerBallThrow(void); +void sub_8030FAC(void); +void sub_80310A4(void); +void sub_80310F0(void); +void PlayerHandleSpriteInvisibility(void); +void PlayerHandleBattleAnimation(void); +void PlayerHandleLinkStandbyMsg(void); +void PlayerHandleResetActionMoveSelection(void); +void sub_80312A0(void); +void nullsub_43(void); + +const u8 gString_TurnJP[] = _("ターン"); + +void (*const gPlayerBufferCommands[])(void) = +{ + PlayerHandleGetAttributes, + sub_802ECF0, + PlayerHandleSetAttributes, + sub_802F7CC, + PlayerHandleLoadPokeSprite, + PlayerHandleSendOutPoke, + PlayerHandleReturnPokeToBall, + PlayerHandleTrainerThrow, + PlayerHandleTrainerSlide, + PlayerHandleTrainerSlideBack, + sub_802FE7C, + sub_802FF60, + sub_802FF80, + PlayerHandleBallThrow, + PlayerHandlePuase, + PlayerHandleMoveAnimation, + PlayerHandlePrintString, + PlayerHandlePrintStringPlayerOnly, + sub_803037C, + nullsub_42, + sub_8030468, + PlayerHandleOpenBag, + sub_8030594, + sub_8030674, + PlayerHandleHealthBarUpdate, + PlayerHandleExpBarUpdate, + PlayerHandleStatusIconUpdate, + PlayerHandleStatusAnimation, + PlayerHandleStatusXor, + sub_803097C, + PlayerHandleDMATransfer, + sub_8030A3C, + sub_8030A6C, + sub_8030A78, + sub_8030A8C, + sub_8030AA0, + sub_8030AB4, + sub_8030AC8, + sub_8030AE4, + sub_8030B1C, + sub_8030B34, + PlayerHandleHitAnimation, + sub_8030BCC, + PlayerHandleEffectivenessSound, + sub_8030C1C, + PlayerHandleFaintingCry, + PlayerHandleIntroSlide, + PlayerHandleTrainerBallThrow, + sub_8030FAC, + sub_80310A4, + sub_80310F0, + PlayerHandleSpriteInvisibility, + PlayerHandleBattleAnimation, + PlayerHandleLinkStandbyMsg, + PlayerHandleResetActionMoveSelection, + sub_80312A0, + nullsub_43, +}; + +void PlayerBufferRunCommand(void); +void sub_802C2EC(void); +void sub_802C68C(void); + +void nullsub_91(void) +{ +} + +void SetBankFuncToPlayerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + gDoingBattleAnim = FALSE; +} + +void PlayerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + dp01_prepare_buffer_wireless_probably(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = 0x38; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void PlayerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < 0x39) + gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + PlayerBufferExecCompleted(); + } +} + +void bx_0802E404(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) + PlayerBufferExecCompleted(); +} + +void sub_802C098(void) +{ + u16 r5 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + DestroyMenuCursor(); + + // Useless switch statement. + switch (gActionSelectionCursor[gActiveBank]) + { + case 0: + dp01_build_cmdbuf_x21_a_bb(1, 0, 0); + break; + case 1: + dp01_build_cmdbuf_x21_a_bb(1, 1, 0); + break; + case 2: + dp01_build_cmdbuf_x21_a_bb(1, 2, 0); + break; + case 3: + dp01_build_cmdbuf_x21_a_bb(1, 3, 0); + break; + } + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & 0x20) + { + if (gActionSelectionCursor[gActiveBank] & 1) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & 0x10) + { + if (!(gActionSelectionCursor[gActiveBank] & 1)) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & 0x40) + { + if (gActionSelectionCursor[gActiveBank] & 2) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & 0x80) + { + if (!(gActionSelectionCursor[gActiveBank] & 2)) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & B_BUTTON) + { + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && GetBankIdentity(gActiveBank) == 2 + && !(gAbsentBankFlags & gBitTable[GetBankByPlayerAI(0)]) + && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if (gBattleBufferA[gActiveBank][1] == 1) + { + if (r5 > 12) + return; + AddBagItem(r5, 1); + } + PlaySE(SE_SELECT); + dp01_build_cmdbuf_x21_a_bb(1, 12, 0); + PlayerBufferExecCompleted(); + DestroyMenuCursor(); + } + } + else if (gMain.newKeys & 8) + { + sub_804454C(); + } +} + +void unref_sub_802C2B8(void) +{ + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + gBattleBankFunc[gActiveBank] = sub_802C2EC; +} + +// TODO: fix this function +void sub_802C2EC(void) +{ + u8 arr[4] = {0, 2, 3, 1}; + s32 i; + + dp11b_obj_instanciate(gUnknown_03004344, 1, 15, 1); + i = 0; + if (gNoOfAllBanks != 0) + { + do + { + if (i != gUnknown_03004344) + dp11b_obj_free(i, 1); + i++; + } while (i < gNoOfAllBanks); + } + if (gMain.newKeys & A_BUTTON) + { + DestroyMenuCursor(); + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + dp01_build_cmdbuf_x21_a_bb(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); + dp11b_obj_free(gUnknown_03004344, 1); + PlayerBufferExecCompleted(); + } + //_0802C3A8 + else if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + gBattleBankFunc[gActiveBank] = sub_802C68C; + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + dp11b_obj_free(gUnknown_03004344, 1); + } + else if (gMain.newKeys & 0x60) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + do + { + u8 var = GetBankIdentity(gUnknown_03004344); + + for (i = 0; i < 4; i++) + { + if (var == arr[i]) + break; + } + do + { + i--; + if (i < 0) + i = 3; + gUnknown_03004344 = GetBankByPlayerAI(arr[i]); + } while(gUnknown_03004344 == gNoOfAllBanks); + i = 0; + switch (GetBankIdentity(gUnknown_03004344)) + { + case 0: + case 2: + if (gActiveBank == gUnknown_03004344) + { + u32 moveId; + + asm("":::"memory"); + moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); + if (!(gBattleMoves[moveId].target & 2)) + break; + } + i++; + break; + case 1: + case 3: + i++; + } + //_0802C500 + if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) + i = 0; + } while (i == 0); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } + //_0802C540 + else if (gMain.newKeys & 0x90) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + do + { + u8 var = GetBankIdentity(gUnknown_03004344); + + for (i = 0; i < 4; i++) + { + if (var == arr[i]) + break; + } + do + { + i++; + if (i > 3) + i = 0; + gUnknown_03004344 = GetBankByPlayerAI(arr[i]); + } while (gUnknown_03004344 == gNoOfAllBanks); + i = 0; + switch (GetBankIdentity(gUnknown_03004344)) + { + case 0: + case 2: + if (gActiveBank == gUnknown_03004344) + { + u32 moveId; + + asm("":::"memory"); + moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); + if (!(gBattleMoves[moveId].target & 2)) + break; + } + i++; + break; + case 1: + case 3: + i++; + } + if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) + i = 0; + } while (i == 0); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } +} -- cgit v1.2.3 From 067a71db77f6df5d53764c0c8d00cb914886fdeb Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 14 Aug 2017 12:54:01 +0200 Subject: start cute sketch --- src/cute_sketch.c | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 src/cute_sketch.c (limited to 'src') diff --git a/src/cute_sketch.c b/src/cute_sketch.c new file mode 100644 index 000000000..5317bc334 --- /dev/null +++ b/src/cute_sketch.c @@ -0,0 +1,164 @@ +#include "global.h" +#include "cute_sketch.h" +#include "contest_painting.h" + +extern u16 (*gUnknown_03005DEC)[][32]; +extern u8 gUnknown_03005E00; +extern u8 gUnknown_03005DFC; +extern u8 gUnknown_03005DF8; +extern u8 gUnknown_03005DF0; +extern u8 gUnknown_03005E04; +extern u8 gUnknown_03005DF4; + +extern u8 gUnknown_03005DE8; + +// this file's functions +void sub_80FCAA4(void); +void sub_80FCB5C(void); +void sub_80FCD54(void); +void sub_80FCEA4(void); +void sub_80FCCBC(void); +void sub_80FD06C(void); +void sub_80FD114(void); +void sub_80FCF3C(void); +void sub_80FCAC4(void); +void sub_80FCC18(u8); +void sub_80FC92C(u8); +void sub_80FC9E4(u8); +void sub_80FD1C8(u16); +u16 sub_80FD39C(u16*); +u16 sub_80FD68C(u16*, u16*, u16*); + +void sub_80FC7A0(struct Unk03005E20* info) +{ + gUnknown_03005DEC = info->var_4; + gUnknown_03005E00 = info->var_1F; + gUnknown_03005DE8 = info->var_19; + gUnknown_03005DFC = info->var_1A; + gUnknown_03005DF8 = info->var_1B; + gUnknown_03005DF0 = info->var_1C; + gUnknown_03005E04 = info->var_1D; + gUnknown_03005DF4 = info->var_1E; + switch (info->var_0) + { + case 2: + sub_80FCAA4(); + break; + case 8: + sub_80FCB5C(); + break; + case 9: + sub_80FCD54(); + sub_80FCC18(gUnknown_03005E00); + break; + case 10: + sub_80FCD54(); + sub_80FCEA4(); + sub_80FCCBC(); + case 31: + sub_80FCEA4(); + break; + case 11: + sub_80FCD54(); + sub_80FD06C(); + sub_80FD06C(); + sub_80FD114(); + sub_80FCCBC(); + break; + case 13: + sub_80FCF3C(); + break; + case 30: + sub_80FCD54(); + break; + case 32: + sub_80FD06C(); + break; + case 33: + sub_80FD114(); + break; + case 6: + sub_80FCAC4(); + sub_80FC92C(3); + break; + case 36: + sub_80FCD54(); + sub_80FD06C(); + sub_80FD114(); + sub_80FCCBC(); + sub_80FCB5C(); + sub_80FCB5C(); + sub_80FC92C(2); + sub_80FC9E4(4); + break; + } +} + +#define RGB2(r, g, b) (((b) << 10) | ((g) << 5) | (r)) + +void sub_80FC92C(u8 a0) // it changes palette someway somehow... .__. +{ + u8 i, j; + for (i = 0; i < gUnknown_03005DF0; i++) + { + u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04]; + u16* pal = &var2[gUnknown_03005DE8]; + for (j = 0; j < gUnknown_03005DF8; j++, pal++) + { + if (!(0x8000 & *pal)) + { + u8 val = (31 & *pal); + val += a0; + if (val > 31) + val = 31; + + *pal = RGB2(val, val, val); + } + } + } +} + +void sub_80FC9E4(u8 a0) +{ + u8 i, j; + for (i = 0; i < gUnknown_03005DF0; i++) + { + u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04]; + u16* pal = &var2[gUnknown_03005DE8]; + for (j = 0; j < gUnknown_03005DF8; j++, pal++) + { + if (!(0x8000 & *pal)) + { + u8 val = (31 & *pal); + if (val > 31 - a0) + val = 31 - (a0 >> 1); + + *pal = RGB2(val, val, val); + } + } + } +} + +void sub_80FCAA4(void) +{ + u32 i; + for (i = 0; i < 3200; i++) + sub_80FD1C8(i); +} + +void sub_80FCAC4(void) +{ + u8 i, j; + for (i = 0; i < gUnknown_03005DF0; i++) + { + u16* var2 = &(*gUnknown_03005DEC)[0][(gUnknown_03005DFC + i) * gUnknown_03005E04]; + u16* pal = &var2[gUnknown_03005DE8]; + for (j = 0; j < gUnknown_03005DF8; j++, pal++) + { + if (!(0x8000 & *pal)) + { + *pal = sub_80FD39C(pal); + } + } + } +} -- cgit v1.2.3 From b57c52c1b311c1902b921a9bcb216ebd9b714ad8 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Mon, 14 Aug 2017 10:20:58 -0500 Subject: decompile sub_802C68C --- src/battle_5.c | 158 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 158 insertions(+) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index 485a67bd4..71939ba0d 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -9,6 +9,7 @@ #include "rom3.h" #include "songs.h" #include "sound.h" +#include "text.h" #include "util.h" extern u8 gActiveBank; @@ -25,6 +26,11 @@ extern u8 gUnknown_03004344; extern u8 gNoOfAllBanks; extern u16 gBattlePartyID[]; extern const struct BattleMove gBattleMoves[]; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern struct Window gUnknown_03004210; +extern const u8 gUnknown_08400D89[]; +extern u8 gUnknown_03004348; extern void dp11b_obj_instanciate(u8, u8, s8, s8); extern u8 GetBankIdentity(u8); @@ -32,6 +38,11 @@ extern u8 GetBankByPlayerAI(u8); extern void dp11b_obj_free(u8, u8); extern void sub_8010520(struct Sprite *); extern void sub_8010574(struct Sprite *); +extern void nullsub_7(u8); +extern void sub_802E3B4(); +extern void sub_802E220(); +extern void sub_802E2D4(); +extern void sub_802E12C(); void PlayerHandleGetAttributes(void); void sub_802ECF0(void); @@ -154,9 +165,12 @@ void (*const gPlayerBufferCommands[])(void) = nullsub_43, }; +extern const u8 gUnknown_081FAE80[]; + void PlayerBufferRunCommand(void); void sub_802C2EC(void); void sub_802C68C(void); +void sub_802CA60(void); void nullsub_91(void) { @@ -431,3 +445,147 @@ void sub_802C2EC(void) gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; } } + +struct UnknownStruct1 +{ + u16 unk0[4]; + u8 unk8[4]; + u8 fillerC[0x12-0xC]; + u8 unk12; + u8 unk13; +}; + +void sub_802C68C(void) +{ + u32 r8 = 0; + struct UnknownStruct1 *r6 = (struct UnknownStruct1 *)(gBattleBufferA[gActiveBank] + 4); + + if (gMain.newKeys & A_BUTTON) + { + u32 r4; + + PlaySE(SE_SELECT); + + if (r6->unk0[gMoveSelectionCursor[gActiveBank]] == 0xAE) + r4 = (r6->unk12 != 7 && (r6->unk13 ^ 7)) ? 0x10 : 0; + else + r4 = gBattleMoves[r6->unk0[gMoveSelectionCursor[gActiveBank]]].target; + + if (r4 & 0x10) + gUnknown_03004344 = gActiveBank; + else + gUnknown_03004344 = GetBankByPlayerAI((GetBankIdentity(gActiveBank) & 1) ^ 1); + + if (gBattleBufferA[gActiveBank][1] == 0) + { + if ((r4 & 2) && gBattleBufferA[gActiveBank][2] == 0) + r8++; + } + else + { + if (!(r4 & 0x7D)) + r8++; + if (r6->unk8[gMoveSelectionCursor[gActiveBank]] == 0) + { + r8 = 0; + } + else if (!(r4 & 0x12) && CountAliveMons(0) <= 1) + { + gUnknown_03004344 = sub_803C434(gActiveBank); + r8 = 0; + } + } + if (r8 == 0) + { + DestroyMenuCursor(); + dp01_build_cmdbuf_x21_a_bb(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); + PlayerBufferExecCompleted(); + } + else + { + gBattleBankFunc[gActiveBank] = sub_802C2EC; + if (r4 & 0x12) + gUnknown_03004344 = gActiveBank; + else if (gAbsentBankFlags & gBitTable[GetBankByPlayerAI(1)]) + gUnknown_03004344 = GetBankByPlayerAI(3); + else + gUnknown_03004344 = GetBankByPlayerAI(1); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } + } + else if (gMain.newKeys & B_BUTTON) + { + DestroyMenuCursor(); + PlaySE(SE_SELECT); + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 320; + dp01_build_cmdbuf_x21_a_bb(1, 10, 0xFFFF); + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gMoveSelectionCursor[gActiveBank] & 1) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gMoveSelectionCursor[gActiveBank] & 1) + && (gMoveSelectionCursor[gActiveBank] ^ 1) < gUnknown_03004348) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gMoveSelectionCursor[gActiveBank] & 2) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gMoveSelectionCursor[gActiveBank] & 2) + && (gMoveSelectionCursor[gActiveBank] ^ 2) < gUnknown_03004348) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & SELECT_BUTTON) + { + if (gUnknown_03004348 > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) + { + sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_081FAE80); + if (gMoveSelectionCursor[gActiveBank] != 0) + gUnknown_03004344 = 0; + else + gUnknown_03004344 = gMoveSelectionCursor[gActiveBank] + 1; + sub_802E3B4(gUnknown_03004344, 27); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D89, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + gBattleBankFunc[gActiveBank] = sub_802CA60; + } + } +} -- cgit v1.2.3 From 1e2dc716025614209e58c672afd73d4c86d7c2c7 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 14 Aug 2017 22:11:32 +0200 Subject: pokeblock feed is on the way --- src/mori_debug_menu.c | 2 +- src/pokeblock.c | 44 ++-- src/pokeblock_feed.c | 577 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/use_pokeblock.c | 18 +- src/wild_encounter.c | 2 +- 5 files changed, 610 insertions(+), 33 deletions(-) create mode 100644 src/pokeblock_feed.c (limited to 'src') diff --git a/src/mori_debug_menu.c b/src/mori_debug_menu.c index 273191192..4eadaa78b 100644 --- a/src/mori_debug_menu.c +++ b/src/mori_debug_menu.c @@ -134,7 +134,7 @@ s8 MoriDebugMenu_PokeblockCase(void) s32 loopCounter; for (loopCounter = 0; loopCounter <= 39; loopCounter++) - sub_810CA6C(loopCounter); + PokeblockClearIfExists(loopCounter); CloseMenu(); return 1; diff --git a/src/pokeblock.c b/src/pokeblock.c index 775280f6e..2fb544fea 100644 --- a/src/pokeblock.c +++ b/src/pokeblock.c @@ -582,7 +582,7 @@ static void sub_810BDAC(bool8 flag) v0 = ((i % 3) << 6) + 0x1a1 + (i / 3) * 6; if (gUnknown_02039248.unk0 + gUnknown_02039248.unk1 != gUnknown_02039248.unk2) { - if (sub_810CA9C(&gSaveBlock1.pokeblocks[gUnknown_02039248.unk0 + gUnknown_02039248.unk1], i + 1) > 0) + if (GetPokeblockData(&gSaveBlock1.pokeblocks[gUnknown_02039248.unk0 + gUnknown_02039248.unk1], i + 1) > 0) { gBGTilemapBuffers[2][v0] = (i << 12) + 23; gBGTilemapBuffers[2][v0 + 32] = (i << 12) + 24; @@ -894,7 +894,7 @@ static void sub_810C5EC(u8 taskId) static void sub_810C610(u8 taskId) { MenuZeroFillWindowRect(7, 6, 13, 11); - sub_810CA6C((gUnknown_02039248.unk0 + gUnknown_02039248.unk1)); + PokeblockClearIfExists((gUnknown_02039248.unk0 + gUnknown_02039248.unk1)); StringExpandPlaceholders(gStringVar4, gContestStatsText_WasThrownAway); DisplayItemMessageOnField(taskId, gStringVar4, sub_810C704, 0); sub_810BC98(); @@ -942,9 +942,9 @@ static void sub_810C748(u8 taskId) static void sub_810C788(u8 taskId) { - s16 v0 = sub_810CAE4(GetNature(&gEnemyParty[0]), &gSaveBlock1.pokeblocks[gScriptItemId]); + s16 v0 = PokeblockGetGain(GetNature(&gEnemyParty[0]), &gSaveBlock1.pokeblocks[gScriptItemId]); StringCopy(gBattleTextBuff1, gPokeblockNames[gSaveBlock1.pokeblocks[gScriptItemId].color]); - sub_810CA6C(gScriptItemId); + PokeblockClearIfExists(gScriptItemId); gScriptItemId = gSaveBlock1.pokeblocks[gScriptItemId].color << 8; if (v0 == 0) { @@ -967,7 +967,7 @@ static void sub_810C854(u8 taskId) SafariZoneActivatePokeblockFeeder(gScriptItemId); StringCopy(gStringVar1, gPokeblockNames[gSaveBlock1.pokeblocks[gScriptItemId].color]); gScriptResult = gScriptItemId; - sub_810CA6C(gScriptItemId); + PokeblockClearIfExists(gScriptItemId); BeginNormalPaletteFade(-1, 0, 0, 16, 0); gTasks[taskId].func = sub_810C2C8; } @@ -1024,10 +1024,10 @@ u8 sub_810C9B0(struct Pokeblock *pokeblock) { u8 contestStat; u8 maxRating; - u8 rating = sub_810CA9C(pokeblock, 1); + u8 rating = GetPokeblockData(pokeblock, 1); for (contestStat=1; contestStat<5; contestStat++) { - maxRating = sub_810CA9C(pokeblock, contestStat + 1); + maxRating = GetPokeblockData(pokeblock, contestStat + 1); if (rating < maxRating) { rating = maxRating; @@ -1038,7 +1038,7 @@ u8 sub_810C9B0(struct Pokeblock *pokeblock) u8 sub_810C9E8(struct Pokeblock *pokeblock) { - u8 feel = sub_810CA9C(pokeblock, 6); + u8 feel = GetPokeblockData(pokeblock, 6); if (feel > 99) feel = 99; return feel; @@ -1068,7 +1068,7 @@ bool8 sub_810CA34(struct Pokeblock *pokeblock) return TRUE; } -bool8 sub_810CA6C(u8 pokeblockIdx) +bool8 PokeblockClearIfExists(u8 pokeblockIdx) { if (gSaveBlock1.pokeblocks[pokeblockIdx].color == 0) { @@ -1078,33 +1078,33 @@ bool8 sub_810CA6C(u8 pokeblockIdx) return TRUE; } -s16 sub_810CA9C(const struct Pokeblock *pokeblock, u8 field) +s16 GetPokeblockData(const struct Pokeblock *pokeblock, u8 field) { - if (field == 0) + if (field == PBLOCK_COLOR) return pokeblock->color; - if (field == 1) + if (field == PBLOCK_SPICY) return pokeblock->spicy; - if (field == 2) + if (field == PBLOCK_DRY) return pokeblock->dry; - if (field == 3) + if (field == PBLOCK_SWEET) return pokeblock->sweet; - if (field == 4) + if (field == PBLOCK_BITTER) return pokeblock->bitter; - if (field == 5) + if (field == PBLOCK_SOUR) return pokeblock->sour; - if (field == 6) + if (field == PBLOCK_FEEL) return pokeblock->feel; return 0; } -s16 sub_810CAE4(u8 nature, const struct Pokeblock *pokeblock) +s16 PokeblockGetGain(u8 nature, const struct Pokeblock *pokeblock) { u8 flavor; s16 curGain; s16 totalGain = 0; for (flavor=0; flavor<5; flavor++) { - curGain = sub_810CA9C(pokeblock, flavor + 1); + curGain = GetPokeblockData(pokeblock, flavor + 1); if (curGain > 0) { totalGain += curGain * gPokeblockFlavorCompatibilityTable[5 * nature + flavor]; @@ -1113,9 +1113,9 @@ s16 sub_810CAE4(u8 nature, const struct Pokeblock *pokeblock) return totalGain; } -void sub_810CB44(struct Pokeblock *pokeblock, u8 *dest) +void PokeblockCopyName(struct Pokeblock *pokeblock, u8 *dest) { - u8 color = sub_810CA9C(pokeblock, 0); + u8 color = GetPokeblockData(pokeblock, PBLOCK_COLOR); StringCopy(dest, gPokeblockNames[color]); } @@ -1124,7 +1124,7 @@ bool8 sub_810CB68(u8 nature, u8 *dest) u8 flavor; for (flavor=0; flavor<5; flavor++) { - if (sub_810CAE4(nature, &gUnknown_083F7F9C[flavor]) > 0) + if (PokeblockGetGain(nature, &gUnknown_083F7F9C[flavor]) > 0) { StringCopy(dest, gPokeblockNames[flavor + 1]); return TRUE; diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c new file mode 100644 index 000000000..f99eca690 --- /dev/null +++ b/src/pokeblock_feed.c @@ -0,0 +1,577 @@ +#include "global.h" +#include "task.h" +#include "palette.h" +#include "main.h" +#include "menu_helpers.h" +#include "text.h" +#include "text_window.h" +#include "menu.h" +#include "rom4.h" +#include "decompress.h" +#include "data2.h" +#include "sprite.h" +#include "item_use.h" +#include "pokeblock.h" +#include "party_menu.h" +#include "strings.h" +#include "string_util.h" +#include "m4a.h" +#include "field_effect.h" +#include "sound.h" +#include "trig.h" + +extern u8 ewram[]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u8 gPokeblockMonID; +extern s16 gPokeblockGain; +extern struct CompressedSpritePalette sPokeblockFeedSpritePal; + +void sub_8147F4C(u8 taskID); +bool8 sub_8040A3C(u16 species); + +// IWRAM common + +extern const struct CompressedSpriteSheet gUnknown_083F7F74; +extern const struct CompressedSpriteSheet gUnknown_084121DC; +extern const struct CompressedSpritePalette gUnknown_083F7F7C; +extern const u8 gBattleTerrainTiles_Building[]; +extern const u8 gUnknown_08E782FC[]; +extern const u8 gBattleTerrainPalette_BattleTower[]; +extern const u8* const gUnknown_084120A4[]; +extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84120EC[]; +extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A0[]; +extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A4[]; +extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A8[]; +extern const union AffineAnimCmd* const gSpriteAffineAnimTable_8412050[]; +extern const struct SpriteTemplate gSpriteTemplate_84121E4; +extern const u8 gNatureToMonPokeblockAnim[][2]; +extern const s16 gMonPokeblockAnims[][10]; + +// this file's functions +void sub_8147B04(void); +void sub_81481DC(void); +void sub_814825C(void); +u8 sub_81480B4(void); +u8 sub_814817C(void); +u8 sub_8147F84(struct Pokemon* mon); +bool8 sub_8147B20(struct Pokemon* mon); +void sub_8147DDC(u8); +void sub_8148044(u8); +void sub_8148078(struct Sprite* sprite); +void Task_PrintAtePokeblockText(u8 taskID); +void SetPokeblockFeedSpritePal(u8); +void sub_8148108(u8, bool8); +bool8 sub_8148540(void); +bool8 sub_81485CC(void); +static bool8 FreePokeSpriteMatrix(void); +void sub_8148710(void); +void sub_814862C(void); + +void sub_8147890(void) +{ + AnimateSprites(); + BuildOamBuffer(); + RunTasks(); + UpdatePaletteFade(); +} + +void sub_81478A8(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +bool8 sub_81478BC(void) +{ + switch (gMain.state) + { + case 0: + sub_80F9438(); + sub_80F9368(); + sub_8147B04(); + gMain.state++; + break; + case 1: + ResetPaletteFade(); + gPaletteFade.bufferTransferDisabled = 1; + gMain.state++; + break; + case 2: + ResetSpriteData(); + gMain.state++; + break; + case 3: + FreeAllSpritePalettes(); + gMain.state++; + break; + case 4: + SetUpWindowConfig(&gWindowConfig_81E6E50); + gMain.state++; + break; + case 5: + MultistepInitMenuWindowBegin(&gWindowConfig_81E6E50); + gMain.state++; + break; + case 6: + if (MultistepInitMenuWindowContinue()) + { + ewram[0x1FFFF] = 0; + gMain.state++; + } + break; + case 7: + if (sub_8147B20(&gPlayerParty[gPokeblockMonID])) + { + gMain.state++; + } + break; + case 8: + ewram[0x1FFFD] = sub_81480B4(); + gMain.state++; + break; + case 9: + ewram[0x1FFFE] = sub_8147F84(&gPlayerParty[gPokeblockMonID]); + gMain.state++; + break; + case 10: + MenuDrawTextWindow(0, 14, 29, 19); + gMain.state++; + break; + case 11: + if (sub_8055870() != 1) + { + gMain.state++; + } + break; + case 12: + { + u16 savedIME = REG_IME; + REG_IME = 0; + REG_IE |= 1; + REG_IME = savedIME; + REG_DISPSTAT |= 8; + SetVBlankCallback(sub_81478A8); + gMain.state++; + } + case 13: + BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); + gPaletteFade.bufferTransferDisabled = 0; + SetMainCallback2(sub_8147890); + return 1; + } + return 0; +} + +void sub_8147ADC(void) +{ + while (1) + { + if (sub_81478BC() == 1) + { + sub_8147DDC(1); + break; + } + if (sub_80F9344() == 1) + break; + } +} + +void sub_8147B04(void) +{ + REG_BG1CNT = 0x1D02l; + REG_DISPCNT = 0x1340; +} + +bool8 sub_8147B20(struct Pokemon* mon) +{ + u16 species; + u32 PiD, TiD; + switch (ewram[0x1FFFF]) + { + case 0: + species = GetMonData(mon, MON_DATA_SPECIES2); + PiD = GetMonData(mon, MON_DATA_PERSONALITY); + HandleLoadSpecialPokePic(&gMonFrontPicTable[species], gMonFrontPicCoords[species].coords, gMonFrontPicCoords[species].y_offset, 0x2000000, gUnknown_081FAF4C[1], species, PiD); + ewram[0x1FFFF]++; + break; + case 1: + { + const struct CompressedSpritePalette* palette; + + species = GetMonData(mon, MON_DATA_SPECIES2); + PiD = GetMonData(mon, MON_DATA_PERSONALITY); + TiD = GetMonData(mon, MON_DATA_OT_ID); + palette = sub_80409C8(species, TiD, PiD); + LoadCompressedObjectPalette(palette); + GetMonSpriteTemplate_803C56C(palette->tag, 1); + ewram[0x1FFFF]++; + } + break; + case 2: + LoadCompressedObjectPic(&gUnknown_083F7F74); + ewram[0x1FFFF]++; + break; + case 3: + LoadCompressedObjectPalette(&gUnknown_083F7F7C); + ewram[0x1FFFF]++; + break; + case 4: + LoadCompressedObjectPic(&gUnknown_084121DC); + ewram[0x1FFFF]++; + break; + case 5: + SetPokeblockFeedSpritePal(gScriptItemId); + LoadCompressedObjectPalette(&sPokeblockFeedSpritePal); + ewram[0x1FFFF]++; + break; + case 6: + LZDecompressVram(gBattleTerrainTiles_Building, (void*)(VRAM)); + ewram[0x1FFFF]++; + break; + case 7: + LZDecompressVram(gUnknown_08E782FC, (void*)(VRAM + 0xE800)); + ewram[0x1FFFF]++; + break; + case 8: + LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60); + ewram[0x1FFFF] = 0; + return 1; + } + return 0; +} + +void SetPokeblockFeedSpritePal(u8 pkbID) +{ + u8 color = GetPokeblockData(&gSaveBlock1.pokeblocks[pkbID], PBLOCK_COLOR); + sPokeblockFeedSpritePal.data = gUnknown_084120A4[color - 1]; + sPokeblockFeedSpritePal.tag = 0x39E2; +} + +extern u16 gUnknown_03005F94; +extern u16 gUnknown_03005F34; +extern u8 gUnknown_03005F3C; + +void sub_8147CC8(u8 taskID) +{ + if (!gPaletteFade.active) + { + switch (gTasks[taskID].data[0]) + { + case 0: + gUnknown_03005F3C = 0; + gUnknown_03005F94 = 0; + sub_81481DC(); + break; + case 255: + sub_8148108(ewram[0x1FFFD], gTasks[taskID].data[1]); + break; + case 269: + ewram[0x1FFFC] = sub_814817C(); + break; + case 281: + sub_8148044(ewram[0x1FFFE]); + break; + case 297: + gTasks[taskID].func = Task_PrintAtePokeblockText; + return; + } + if (gUnknown_03005F94 < gUnknown_03005F34) + sub_814825C(); + else if (gUnknown_03005F94 == gUnknown_03005F34) + gTasks[taskID].data[0] = 254; + + gUnknown_03005F94++; + gTasks[taskID].data[0]++; + } +} + +void sub_8147DDC(u8 a0) +{ + u8 taskID = CreateTask(sub_8147CC8, 0); + gTasks[taskID].data[0] = 0; + gTasks[taskID].data[1] = a0; +} + +void sub_8147E10(u8 taskID) +{ + if (MenuUpdateWindowText() == 1) + gTasks[taskID].func = sub_8147F4C; +} + +void Task_PrintAtePokeblockText(u8 taskID) +{ + struct Pokemon* mon = &gPlayerParty[gPokeblockMonID]; + struct Pokeblock* pokeblock = &gSaveBlock1.pokeblocks[gScriptItemId]; + + gPokeblockGain = PokeblockGetGain(GetNature(mon), pokeblock); + GetMonNickname(mon, gStringVar1); + PokeblockCopyName(pokeblock, gStringVar2); + + if (gPokeblockGain == 0) + StringExpandPlaceholders(gStringVar4, gContestStatsText_NormallyAte); + else if (gPokeblockGain > 0) + StringExpandPlaceholders(gStringVar4, gContestStatsText_HappilyAte); + else + StringExpandPlaceholders(gStringVar4, gContestStatsText_DisdainfullyAte); + + MenuPrintMessage(gStringVar4, 1, 15); + gTasks[taskID].func = sub_8147E10; +} + +void sub_8147F08(u8 taskID) +{ + if (!gPaletteFade.active) + { + m4aMPlayVolumeControl(&gMPlay_BGM, -1, 256); + SetMainCallback2(gMain.savedCallback); + DestroyTask(taskID); + } +} + +void sub_8147F4C(u8 taskID) +{ + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gTasks[taskID].func = sub_8147F08; +} + +extern u16 gPokeblockFeedMonSpecies; +extern u8 gPokeblockFeedMonSpriteID; +extern u8 gPokeblockFeedMonNature; +extern bool8 gPokeblockMonNotFlipped; + +u8 sub_8147F84(struct Pokemon* mon) +{ + u16 species = GetMonData(mon, MON_DATA_SPECIES2); + u8 spriteID = CreateSprite(&gUnknown_02024E8C, 48, 80, 2); + + gPokeblockFeedMonSpecies = species; + gPokeblockFeedMonSpriteID = spriteID; + gPokeblockFeedMonNature = GetNature(mon); + gSprites[spriteID].data2 = species; + gSprites[spriteID].callback = SpriteCallbackDummy; + gPokeblockMonNotFlipped = 1; + if (!sub_8040A3C(species)) + { + gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84120EC; + gSprites[spriteID].oam.affineMode = 3; + CalcCenterToCornerVec(&gSprites[spriteID], gSprites[spriteID].oam.shape, gSprites[spriteID].oam.size, gSprites[spriteID].oam.affineMode); + gPokeblockMonNotFlipped = 0; + } + return spriteID; +} + +void sub_8148044(u8 spriteID) +{ + gSprites[spriteID].pos1.x = 48; + gSprites[spriteID].pos1.y = 80; + gSprites[spriteID].data0 = -8; + gSprites[spriteID].data1 = 1; + gSprites[spriteID].callback = sub_8148078; +} + +void sub_8148078(struct Sprite* sprite) +{ + sprite->pos1.x += 4; + sprite->pos1.y += sprite->data0; + sprite->data0 += sprite->data1; + if (sprite->data0 == 0) + PlayCry1(sprite->data2, 0); + if (sprite->data0 == 9) + sprite->callback = SpriteCallbackDummy; +} + +u8 sub_81480B4(void) +{ + u8 spriteID = sub_810BA50(188, 100, 2); + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A0; + gSprites[spriteID].callback = SpriteCallbackDummy; + InitSpriteAffineAnim(&gSprites[spriteID]); + return spriteID; +} + +void sub_8148108(u8 spriteID, bool8 a1) +{ + FreeOamMatrix(gSprites[spriteID].oam.matrixNum); + gSprites[spriteID].oam.affineMode = 3; + if (!a1) + gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A4; + else + gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A8; + InitSpriteAffineAnim(&gSprites[spriteID]); +} + +u8 sub_814817C(void) +{ + u8 spriteID = CreateSprite(&gSpriteTemplate_84121E4, 174, 84, 1); + gSprites[spriteID].data0 = -12; + gSprites[spriteID].data1 = 1; + return spriteID; +} + +void sub_81481B0(struct Sprite* sprite) +{ + sprite->pos1.x -= 4; + sprite->pos1.y += sprite->data0; + sprite->data0 += sprite->data1; + if (sprite->data0 == 10) + DestroySprite(sprite); +} + +void sub_81481DC(void) +{ + u8 animID, i; + + gUnknown_03005F34 = 1; + animID = gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; + for (i = 0; i < 8; i++, animID++) + { + gUnknown_03005F34 += gMonPokeblockAnims[animID][4]; + if (gMonPokeblockAnims[animID][9] == 1) + break; + } +} + +extern struct Sprite gPokeblockFeedPokeSpriteCopy; +extern struct Sprite* gPokeblockFeedPokeSprite; +extern u8 gUnknown_03005F40; +extern s16 gUnknown_03005FA0[]; + +void sub_814825C(void) +{ + switch (gUnknown_03005F3C) + { + case 0: + gUnknown_03005F40 = gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; + gPokeblockFeedPokeSprite = &gSprites[gPokeblockFeedMonSpriteID]; + gPokeblockFeedPokeSpriteCopy = *gPokeblockFeedPokeSprite; + gUnknown_03005F3C = 10; + break; + case 1 ... 9: + break; + case 10: + sub_8148540(); + if (gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) + { + gPokeblockFeedPokeSprite->oam.affineMode = 3; + gPokeblockFeedPokeSprite->oam.matrixNum = 0; + gPokeblockFeedPokeSprite->affineAnims = gSpriteAffineAnimTable_8412050; + InitSpriteAffineAnim(gPokeblockFeedPokeSprite); + } + gUnknown_03005F3C = 50; + case 50: + if (gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) + { + if (gPokeblockMonNotFlipped == 0) + StartSpriteAffineAnim(gPokeblockFeedPokeSprite, gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] + 10); + else + StartSpriteAffineAnim(gPokeblockFeedPokeSprite, gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1]); + } + gUnknown_03005F3C = 60; + break; + case 60: + if (sub_81485CC() == 1) + { + if (gUnknown_03005FA0[9] == 0) + { + gUnknown_03005F40++; + sub_8148540(); + gUnknown_03005F3C = 60; + } + else + { + FreeOamMatrix(gPokeblockFeedPokeSprite->oam.matrixNum); + gUnknown_03005F3C = 70; + } + } + break; + case 70: + FreePokeSpriteMatrix(); + gUnknown_03005F40 = 0; + gUnknown_03005F3C = 0; + break; + case 71 ... 90: + break; + } +} + +bool8 sub_8148540(void) +{ + u8 i; + for (i = 0; i < 10; i++) + gUnknown_03005FA0[i] = gMonPokeblockAnims[gUnknown_03005F40][i]; + if (gUnknown_03005FA0[4] == 0) + return 1; + else + { + gUnknown_03005FA0[10] = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2]); + gUnknown_03005FA0[11] = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3]); + gUnknown_03005FA0[12] = gUnknown_03005FA0[4]; + gUnknown_03005FA0[13] = gPokeblockFeedPokeSprite->pos2.x; + gUnknown_03005FA0[14] = gPokeblockFeedPokeSprite->pos2.y; + sub_8148710(); + gUnknown_03005FA0[4] = gUnknown_03005FA0[12]; + sub_814862C(); + gUnknown_03005FA0[4] = gUnknown_03005FA0[12]; + return 0; + } +} + +bool8 sub_81485CC(void) +{ + u16 var = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; + + gPokeblockFeedPokeSprite->pos2.x = (u16)(*((u16*)(&ewram[0x1D000]) + var)); + gPokeblockFeedPokeSprite->pos2.y = (u16)(*((u16*)(&ewram[0x1D400]) + var)); + + if (--gUnknown_03005FA0[4] == 0) + return 1; + else + return 0; +} + +static bool8 FreePokeSpriteMatrix(void) +{ + FreeSpriteOamMatrix(gPokeblockFeedPokeSprite); + return 0; +} + +void sub_814862C(void) +{ + u16 i; + u16 r8 = gUnknown_03005FA0[8]; + u16 r7 = gUnknown_03005FA0[12] - r8; + s16 var3 = gUnknown_03005FA0[13] + gUnknown_03005FA0[6]; + s16 r9 = gUnknown_03005FA0[14] + gUnknown_03005FA0[7]; + + for (i = 0; i < r7 - 1; i++) + { + s16* r3 = (((u16*)(&ewram[0x1D000]) + (r8 + i))); + s16 r1 = *r3 - (var3); + + s16* r5 = (((u16*)(&ewram[0x1D400]) + (r8 + i))); + s16 r4 = *r5 - r9; + + *r3 -= r1 * (i + 1) / r7; + *r5 -= r4 * (i + 1) / r7; + } + + *((u16*)(&ewram[0x1CFFE]) + (r8 + r7)) = var3; + *((u16*)(&ewram[0x1D3FE]) + (r8 + r7)) = r9; +} + +/* +void sub_8148710(void) +{ + bool8 var_24 = 0; + s16 r8 = gUnknown_03005FA0[13] - gUnknown_03005FA0[10]; + s16 r7 = gUnknown_03005FA0[14] - gUnknown_03005FA0[11]; + s16 r5; + if (gUnknown_03005FA0[10] < 0) + r5 = -(gUnknown_03005FA0[10]) - gUnknown_03005FA0[3]; + else + r5 = (gUnknown_03005FA0[10]) - gUnknown_03005FA0[3]; + if (gUnknown_03005FA0) +} +*/ diff --git a/src/use_pokeblock.c b/src/use_pokeblock.c index 3aa2f1fa5..19d2e4399 100644 --- a/src/use_pokeblock.c +++ b/src/use_pokeblock.c @@ -105,8 +105,8 @@ asm(".text\n" static EWRAM_DATA struct UnkPokenavStruct_Sub1 *gUnknown_02039304 = NULL; static EWRAM_DATA MainCallback gUnknown_02039308 = NULL; static EWRAM_DATA struct Pokeblock *gUnknown_0203930C = NULL; -EWRAM_DATA u8 gUnknown_02039310 = 0; -EWRAM_DATA s16 gUnknown_02039312 = 0; +EWRAM_DATA u8 gPokeblockMonID = 0; +EWRAM_DATA s16 gPokeblockGain = 0; extern u16 gKeyRepeatStartDelay; extern u16 gScriptItemId; // FIXME: remove after merge of #349 Pokeblock @@ -155,8 +155,8 @@ void sub_8136174(void) { gUnknown_02039304->pokeblock = gUnknown_0203930C; gUnknown_02039304->callback = gUnknown_02039308; - gUnknown_02039310 = sub_81370E4(gUnknown_02039310); - gUnknown_02039304->unk56 = gUnknown_02039310 < 4 ? 0 : 1; + gPokeblockMonID = sub_81370E4(gPokeblockMonID); + gUnknown_02039304->unk56 = gPokeblockMonID < 4 ? 0 : 1; gUnknown_083DFEC4->unkD162[0] = 2; launch_c3_walk_stairs_and_run_once(sub_8136294); SetMainCallback2(sub_81361E4); @@ -469,7 +469,7 @@ void sub_8136808(void) switch (gUnknown_02039304->unk50) { case 0: - gUnknown_02039310 = sub_81370A4(gUnknown_083DFEC4->unk87DC); + gPokeblockMonID = sub_81370A4(gUnknown_083DFEC4->unk87DC); gUnknown_02039308 = gUnknown_02039304->callback; gUnknown_0203930C = gUnknown_02039304->pokeblock; BeginNormalPaletteFade(-1, 0, 0, 16, 0); @@ -490,7 +490,7 @@ void sub_81368A4(void) switch (gUnknown_02039304->unk50) { case 0: - if (gUnknown_083DFEC4->unk87DC != gUnknown_02039310) + if (gUnknown_083DFEC4->unk87DC != gPokeblockMonID) { sub_80F5060(gUnknown_02039304->unk56); gUnknown_02039304->unk50++; @@ -578,7 +578,7 @@ void sub_81369CC(void) case 5: if (gMain.newKeys & (A_BUTTON | B_BUTTON) && !sub_8136D00()) { - sub_810CA6C((u8)gScriptItemId); + PokeblockClearIfExists((u8)gScriptItemId); launch_c3_walk_stairs_and_run_once(sub_8136B44); } break; @@ -864,9 +864,9 @@ void sub_8136F74(struct Pokeblock *pokeblock, struct Pokemon *pokemon) gUnknown_02039304->unk66[2] = pokeblock->bitter; gUnknown_02039304->unk66[3] = pokeblock->sweet; gUnknown_02039304->unk66[4] = pokeblock->dry; - if (gUnknown_02039312 > 0) + if (gPokeblockGain > 0) direction = 1; - else if (gUnknown_02039312 < 0) + else if (gPokeblockGain < 0) direction = -1; else return; diff --git a/src/wild_encounter.c b/src/wild_encounter.c index 96f47c067..7001c2eaa 100644 --- a/src/wild_encounter.c +++ b/src/wild_encounter.c @@ -3161,7 +3161,7 @@ static u8 PickWildMonNature(void) } for (i = 0; i < 25; i++) { - if (sub_810CAE4(natures[i], safariPokeblock) > 0) + if (PokeblockGetGain(natures[i], safariPokeblock) > 0) return natures[i]; } } -- cgit v1.2.3 From be40e2196a84f0e6c3a5fb47829f52a88bd55937 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 14 Aug 2017 23:39:08 +0200 Subject: all data moved from asm to c --- src/pokeblock_feed.c | 566 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 489 insertions(+), 77 deletions(-) (limited to 'src') diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index f99eca690..18808e8af 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -24,50 +24,476 @@ extern u8 ewram[]; extern struct MusicPlayerInfo gMPlay_BGM; extern u8 gPokeblockMonID; extern s16 gPokeblockGain; -extern struct CompressedSpritePalette sPokeblockFeedSpritePal; + +extern const u8 gPokeblockRed_Pal[]; +extern const u8 gPokeblockBlue_Pal[]; +extern const u8 gPokeblockPink_Pal[]; +extern const u8 gPokeblockGreen_Pal[]; +extern const u8 gPokeblockYellow_Pal[]; +extern const u8 gPokeblockPurple_Pal[]; +extern const u8 gPokeblockIndigo_Pal[]; +extern const u8 gPokeblockBrown_Pal[]; +extern const u8 gPokeblockLiteBlue_Pal[]; +extern const u8 gPokeblockOlive_Pal[]; +extern const u8 gPokeblockGray_Pal[]; +extern const u8 gPokeblockBlack_Pal[]; +extern const u8 gPokeblockWhite_Pal[]; +extern const u8 gPokeblockGold_Pal[]; + +extern const u8 gPokeblock_Gfx[]; void sub_8147F4C(u8 taskID); bool8 sub_8040A3C(u16 species); +// this file's functions +static void sub_8147B04(void); +static void sub_81481DC(void); +static void sub_814825C(void); +static u8 sub_81480B4(void); +static u8 sub_814817C(void); +static u8 sub_8147F84(struct Pokemon* mon); +static bool8 sub_8147B20(struct Pokemon* mon); +static void sub_8147DDC(u8); +static void sub_8148044(u8); +static void sub_8148078(struct Sprite* sprite); +static void Task_PrintAtePokeblockText(u8 taskID); +static void SetPokeblockFeedSpritePal(u8); +static void sub_8148108(u8, bool8); +static bool8 sub_8148540(void); +static bool8 sub_81485CC(void); +static bool8 FreePokeSpriteMatrix(void); +void sub_8148710(void); +static void sub_81481B0(struct Sprite* sprite); +static void sub_814862C(void); + +// EWRAM +EWRAM_DATA static struct CompressedSpritePalette sPokeblockFeedSpritePal = {0}; + // IWRAM common +struct Sprite* gPokeblockFeedPokeSprite; +u16 gPokeblockFeedMonSpecies; +bool8 gPokeblockMonNotFlipped; +u8 gPokeblockFeedMonSpriteID; +u8 gPokeblockFeedMonNature; +u16 gUnknown_03005F34; +u8 gPokeblockFeedUnused0; +u8 gUnknown_03005F3C; +u8 gUnknown_03005F40; +struct Sprite gPokeblockFeedPokeSpriteCopy; +u16 gUnknown_03005F94; +s16 gUnknown_03005FA0[24]; + +// rodata + +static const u8 sNatureToMonPokeblockAnim[][2] = +{ + { 0, 0 }, // HARDY + { 3, 0 }, // LONELY + { 4, 1 }, // BRAVE + { 5, 0 }, // ADAMANT + { 10, 0 }, // NAUGHTY + { 13, 0 }, // BOLD + { 15, 0 }, // DOCILE + { 16, 2 }, // RELAXED + { 18, 0 }, // IMPISH + { 19, 0 }, // LAX + { 20, 0 }, // TIMID + { 25, 0 }, // HASTY + { 27, 3 }, // SERIOUS + { 28, 0 }, // JOLLY + { 29, 0 }, // NAIVE + { 33, 4 }, // MODEST + { 36, 0 }, // MILD + { 37, 0 }, // QUIET + { 39, 0 }, // BASHFUL + { 42, 0 }, // RASH + { 45, 0 }, // CALM + { 46, 5 }, // GENTLE + { 47, 6 }, // SASSY + { 48, 0 }, // CAREFUL + { 53, 0 }, // QUIRKY +}; + +static const s16 sMonPokeblockAnims[][10] = +{ + // HARDY + { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, + { 0, 4, 0, 16, 24, 0, 0, 0, 12, 0}, + { 0, 4, 0, 32, 32, 0, 0, 0, 16, 1}, + + // LONELY + { 0, 3, 6, 0, 48, 0, 0, 0, 24, 1}, + + // BRAVE + { 64, 16, -24, 0, 32, 0, 0, 0, 0, 1}, + + // ADAMANT + { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, + { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, + { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, + { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, + { 0, 4, -16, 0, 4, 0, 16, 0, 0, 1}, + + // NAUGHTY + { 0, 3, 6, 0, 12, 0, 0, 0, 6, 0}, + { 0, 3, -6, 0, 12, 0, 0, 0, 6, 0}, + { 0, 16, 16, 0, 45, 1, 0, 0, 0, 1}, + + // BOLD + { 0, 16, 0, 24, 32, 0, 0, 0, 16, 0}, + { 0, 16, 0, 23, 32, 0, 0, 0, 16, 1}, + + // DOCILE + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 1}, + + // RELAXED + { 0, 2, 8, 0, 32, 0, 0, 0, 0, 0}, + { 0, 2, -8, 0, 32, 0, 0, 0, 0, 1}, + + // IMPISH + { 0, 32, 2, 1, 48, 1, 0, 0, 24, 1}, + + // LAX + { 0, 2, 16, 16, 128, 0, 0, 0, 0, 1}, + + // TIMID + { 0, 2, -8, 0, 48, 0, -24, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 64, 32, 2, 0, 36, 0, 0, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 0, 2, 8, 0, 48, 0, 24, 0, 0, 1}, + + // HASTY + { 64, 24, 16, 0, 32, 0, 0, 0, 0, 0}, + { 0, 28, 2, 1, 32, 1, 0, 0, 16, 1}, + + // SERIOUS + { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, + + // JOLLY + { 64, 16, -16, 2, 48, 0, 0, 0, 32, 1}, + + // NAIVE + { 0, 12, -8, 4, 24, 0, 8, 0, 12, 0}, + { 0, 12, 8, 8, 24, 0, -16, 0, 12, 0}, + { 0, 12, -8, 16, 24, 0, 16, 0, 12, 0}, + { 0, 12, 8, 28, 24, 0, -8, 0, 12, 1}, + + // MODEST + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 64, 16, -4, 0, 32, 0, 0, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 1}, + + // MILD + { 128, 4, 0, 8, 64, 0, 0, 0, 0, 1}, + + // QUIET + { 0, 2, 16, 0, 48, 0, 0, 0, 0, 0}, + { 128, 2, 16, 0, 48, 0, 0, 0, 0, 1}, + + // BASHFUL + { 0, 2, -4, 0, 48, 0, -48, 0, 0, 0}, + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, + { 0, 2, 8, 0, 24, 0, 48, 0, 0, 1}, + + // RASH + { 64, 4, 64, 58, 52, 0, -88, 0, 0, 0}, + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, + { 0, 24, 80, 0, 32, 0, 88, 0, 0, 1}, + + // CALM + { 0, 2, 16, 4, 64, 0, 0, 0, 0, 1}, + + // GENTLE + { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, + + // SASSY + { 0, 0, 0, 0, 42, 0, 0, 0, 0, 1}, + + // CAREFUL + { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, + { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, + { 0, 4, 0, 12, 24, 0, 0, 0, 12, 0}, + { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, + { 0, 4, 0, 4, 24, 0, 0, 0, 12, 1}, + + // QUIRKY + { 0, 4, 16, 12, 64, 0, 0, 0, 0, 0}, + { 0, -4, 16, 12, 64, 0, 0, 0, 0, 1}, +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411E90[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411EA0[] = +{ + AFFINEANIMCMD_FRAME(0, 0, 12, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 30), + AFFINEANIMCMD_FRAME(0, 0, -12, 1), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411EC0[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0, 0, 12, 1), + AFFINEANIMCMD_FRAME(0, 0, 0, 28), + AFFINEANIMCMD_FRAME(0, 0, -4, 3), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411EE8[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411F08[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411F30[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411F50[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411F78[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411F98[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411FC0[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8411FE0[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8412008[] = +{ + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8412028[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_8412050[] = +{ + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411EA0, + gSpriteAffineAnim_8411EE8, + gSpriteAffineAnim_8411F30, + gSpriteAffineAnim_8411F78, + gSpriteAffineAnim_8411FC0, + gSpriteAffineAnim_8412008, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411EC0, + gSpriteAffineAnim_8411F08, + gSpriteAffineAnim_8411F50, + gSpriteAffineAnim_8411F98, + gSpriteAffineAnim_8411FE0, + gSpriteAffineAnim_8412028, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, + gSpriteAffineAnim_8411E90, +}; + +static const u8* const sPokeblocksPals[] = +{ + gPokeblockRed_Pal, + gPokeblockBlue_Pal, + gPokeblockPink_Pal, + gPokeblockGreen_Pal, + gPokeblockYellow_Pal, + gPokeblockPurple_Pal, + gPokeblockIndigo_Pal, + gPokeblockBrown_Pal, + gPokeblockLiteBlue_Pal, + gPokeblockOlive_Pal, + gPokeblockGray_Pal, + gPokeblockBlack_Pal, + gPokeblockWhite_Pal, + gPokeblockGold_Pal +}; + +static const union AffineAnimCmd gSpriteAffineAnim_84120DC[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_84120EC[] = +{ + gSpriteAffineAnim_84120DC +}; + +static const union AffineAnimCmd gSpriteAffineAnim_84120F0[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd gSpriteAffineAnim_8412148[] = +{ + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_END +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A0[] = +{ + gSpriteAffineAnim_84120DC +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A4[] = +{ + gSpriteAffineAnim_84120F0 +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A8[] = +{ + gSpriteAffineAnim_8412148 +}; + +static const struct OamData gOamData_84121AC = +{ + .y = 0, + .affineMode = 3, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 0, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd gSpriteAnim_84121B4[] = +{ + ANIMCMD_FRAME(0, 0), + ANIMCMD_END +}; + +static const union AnimCmd *const gSpriteAnimTable_84121BC[] = +{ + gSpriteAnim_84121B4, +}; + +static const union AffineAnimCmd gSpriteAffineAnim_84121C0[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0xFFF8, 0xFFF8, 0, 1), + AFFINEANIMCMD_JUMP(1) +}; + +static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121D8[] = +{ + gSpriteAffineAnim_84121C0 +}; + +static const struct CompressedSpriteSheet gUnknown_084121DC = +{ + gPokeblock_Gfx, 0x20, 14818 +}; + +static const struct SpriteTemplate gSpriteTemplate_84121E4 = +{ + .tileTag = 14818, + .paletteTag = 14818, + .oam = &gOamData_84121AC, + .anims = gSpriteAnimTable_84121BC, + .images = NULL, + .affineAnims = gSpriteAffineAnimTable_84121D8, + .callback = sub_81481B0 +}; extern const struct CompressedSpriteSheet gUnknown_083F7F74; -extern const struct CompressedSpriteSheet gUnknown_084121DC; extern const struct CompressedSpritePalette gUnknown_083F7F7C; extern const u8 gBattleTerrainTiles_Building[]; extern const u8 gUnknown_08E782FC[]; extern const u8 gBattleTerrainPalette_BattleTower[]; -extern const u8* const gUnknown_084120A4[]; -extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84120EC[]; -extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A0[]; -extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A4[]; -extern const union AffineAnimCmd* const gSpriteAffineAnimTable_84121A8[]; -extern const union AffineAnimCmd* const gSpriteAffineAnimTable_8412050[]; -extern const struct SpriteTemplate gSpriteTemplate_84121E4; -extern const u8 gNatureToMonPokeblockAnim[][2]; -extern const s16 gMonPokeblockAnims[][10]; -// this file's functions -void sub_8147B04(void); -void sub_81481DC(void); -void sub_814825C(void); -u8 sub_81480B4(void); -u8 sub_814817C(void); -u8 sub_8147F84(struct Pokemon* mon); -bool8 sub_8147B20(struct Pokemon* mon); -void sub_8147DDC(u8); -void sub_8148044(u8); -void sub_8148078(struct Sprite* sprite); -void Task_PrintAtePokeblockText(u8 taskID); -void SetPokeblockFeedSpritePal(u8); -void sub_8148108(u8, bool8); -bool8 sub_8148540(void); -bool8 sub_81485CC(void); -static bool8 FreePokeSpriteMatrix(void); -void sub_8148710(void); -void sub_814862C(void); +// code -void sub_8147890(void) +static void sub_8147890(void) { AnimateSprites(); BuildOamBuffer(); @@ -75,14 +501,14 @@ void sub_8147890(void) UpdatePaletteFade(); } -void sub_81478A8(void) +static void sub_81478A8(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -bool8 sub_81478BC(void) +static bool8 sub_81478BC(void) { switch (gMain.state) { @@ -177,13 +603,13 @@ void sub_8147ADC(void) } } -void sub_8147B04(void) +static void sub_8147B04(void) { REG_BG1CNT = 0x1D02l; REG_DISPCNT = 0x1340; } -bool8 sub_8147B20(struct Pokemon* mon) +static bool8 sub_8147B20(struct Pokemon* mon) { u16 species; u32 PiD, TiD; @@ -241,18 +667,14 @@ bool8 sub_8147B20(struct Pokemon* mon) return 0; } -void SetPokeblockFeedSpritePal(u8 pkbID) +static void SetPokeblockFeedSpritePal(u8 pkbID) { u8 color = GetPokeblockData(&gSaveBlock1.pokeblocks[pkbID], PBLOCK_COLOR); - sPokeblockFeedSpritePal.data = gUnknown_084120A4[color - 1]; + sPokeblockFeedSpritePal.data = sPokeblocksPals[color - 1]; sPokeblockFeedSpritePal.tag = 0x39E2; } -extern u16 gUnknown_03005F94; -extern u16 gUnknown_03005F34; -extern u8 gUnknown_03005F3C; - -void sub_8147CC8(u8 taskID) +static void sub_8147CC8(u8 taskID) { if (!gPaletteFade.active) { @@ -286,20 +708,20 @@ void sub_8147CC8(u8 taskID) } } -void sub_8147DDC(u8 a0) +static void sub_8147DDC(u8 a0) { u8 taskID = CreateTask(sub_8147CC8, 0); gTasks[taskID].data[0] = 0; gTasks[taskID].data[1] = a0; } -void sub_8147E10(u8 taskID) +static void sub_8147E10(u8 taskID) { if (MenuUpdateWindowText() == 1) gTasks[taskID].func = sub_8147F4C; } -void Task_PrintAtePokeblockText(u8 taskID) +static void Task_PrintAtePokeblockText(u8 taskID) { struct Pokemon* mon = &gPlayerParty[gPokeblockMonID]; struct Pokeblock* pokeblock = &gSaveBlock1.pokeblocks[gScriptItemId]; @@ -319,7 +741,7 @@ void Task_PrintAtePokeblockText(u8 taskID) gTasks[taskID].func = sub_8147E10; } -void sub_8147F08(u8 taskID) +static void sub_8147F08(u8 taskID) { if (!gPaletteFade.active) { @@ -335,12 +757,7 @@ void sub_8147F4C(u8 taskID) gTasks[taskID].func = sub_8147F08; } -extern u16 gPokeblockFeedMonSpecies; -extern u8 gPokeblockFeedMonSpriteID; -extern u8 gPokeblockFeedMonNature; -extern bool8 gPokeblockMonNotFlipped; - -u8 sub_8147F84(struct Pokemon* mon) +static u8 sub_8147F84(struct Pokemon* mon) { u16 species = GetMonData(mon, MON_DATA_SPECIES2); u8 spriteID = CreateSprite(&gUnknown_02024E8C, 48, 80, 2); @@ -361,7 +778,7 @@ u8 sub_8147F84(struct Pokemon* mon) return spriteID; } -void sub_8148044(u8 spriteID) +static void sub_8148044(u8 spriteID) { gSprites[spriteID].pos1.x = 48; gSprites[spriteID].pos1.y = 80; @@ -370,7 +787,7 @@ void sub_8148044(u8 spriteID) gSprites[spriteID].callback = sub_8148078; } -void sub_8148078(struct Sprite* sprite) +static void sub_8148078(struct Sprite* sprite) { sprite->pos1.x += 4; sprite->pos1.y += sprite->data0; @@ -381,7 +798,7 @@ void sub_8148078(struct Sprite* sprite) sprite->callback = SpriteCallbackDummy; } -u8 sub_81480B4(void) +static u8 sub_81480B4(void) { u8 spriteID = sub_810BA50(188, 100, 2); gSprites[spriteID].oam.affineMode = 1; @@ -391,7 +808,7 @@ u8 sub_81480B4(void) return spriteID; } -void sub_8148108(u8 spriteID, bool8 a1) +static void sub_8148108(u8 spriteID, bool8 a1) { FreeOamMatrix(gSprites[spriteID].oam.matrixNum); gSprites[spriteID].oam.affineMode = 3; @@ -402,7 +819,7 @@ void sub_8148108(u8 spriteID, bool8 a1) InitSpriteAffineAnim(&gSprites[spriteID]); } -u8 sub_814817C(void) +static u8 sub_814817C(void) { u8 spriteID = CreateSprite(&gSpriteTemplate_84121E4, 174, 84, 1); gSprites[spriteID].data0 = -12; @@ -410,7 +827,7 @@ u8 sub_814817C(void) return spriteID; } -void sub_81481B0(struct Sprite* sprite) +static void sub_81481B0(struct Sprite* sprite) { sprite->pos1.x -= 4; sprite->pos1.y += sprite->data0; @@ -419,31 +836,26 @@ void sub_81481B0(struct Sprite* sprite) DestroySprite(sprite); } -void sub_81481DC(void) +static void sub_81481DC(void) { u8 animID, i; gUnknown_03005F34 = 1; - animID = gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; + animID = sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; for (i = 0; i < 8; i++, animID++) { - gUnknown_03005F34 += gMonPokeblockAnims[animID][4]; - if (gMonPokeblockAnims[animID][9] == 1) + gUnknown_03005F34 += sMonPokeblockAnims[animID][4]; + if (sMonPokeblockAnims[animID][9] == 1) break; } } -extern struct Sprite gPokeblockFeedPokeSpriteCopy; -extern struct Sprite* gPokeblockFeedPokeSprite; -extern u8 gUnknown_03005F40; -extern s16 gUnknown_03005FA0[]; - -void sub_814825C(void) +static void sub_814825C(void) { switch (gUnknown_03005F3C) { case 0: - gUnknown_03005F40 = gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; + gUnknown_03005F40 = sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][0]; gPokeblockFeedPokeSprite = &gSprites[gPokeblockFeedMonSpriteID]; gPokeblockFeedPokeSpriteCopy = *gPokeblockFeedPokeSprite; gUnknown_03005F3C = 10; @@ -452,7 +864,7 @@ void sub_814825C(void) break; case 10: sub_8148540(); - if (gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) + if (sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) { gPokeblockFeedPokeSprite->oam.affineMode = 3; gPokeblockFeedPokeSprite->oam.matrixNum = 0; @@ -461,12 +873,12 @@ void sub_814825C(void) } gUnknown_03005F3C = 50; case 50: - if (gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) + if (sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] != 0) { if (gPokeblockMonNotFlipped == 0) - StartSpriteAffineAnim(gPokeblockFeedPokeSprite, gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] + 10); + StartSpriteAffineAnim(gPokeblockFeedPokeSprite, sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1] + 10); else - StartSpriteAffineAnim(gPokeblockFeedPokeSprite, gNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1]); + StartSpriteAffineAnim(gPokeblockFeedPokeSprite, sNatureToMonPokeblockAnim[gPokeblockFeedMonNature][1]); } gUnknown_03005F3C = 60; break; @@ -496,11 +908,11 @@ void sub_814825C(void) } } -bool8 sub_8148540(void) +static bool8 sub_8148540(void) { u8 i; for (i = 0; i < 10; i++) - gUnknown_03005FA0[i] = gMonPokeblockAnims[gUnknown_03005F40][i]; + gUnknown_03005FA0[i] = sMonPokeblockAnims[gUnknown_03005F40][i]; if (gUnknown_03005FA0[4] == 0) return 1; else @@ -518,7 +930,7 @@ bool8 sub_8148540(void) } } -bool8 sub_81485CC(void) +static bool8 sub_81485CC(void) { u16 var = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; @@ -537,7 +949,7 @@ static bool8 FreePokeSpriteMatrix(void) return 0; } -void sub_814862C(void) +static void sub_814862C(void) { u16 i; u16 r8 = gUnknown_03005FA0[8]; -- cgit v1.2.3 From dc72c86f3cd6e5f89eb3305891c451664e747296 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 15 Aug 2017 00:18:36 +0200 Subject: give better names to functions --- src/pokeblock_feed.c | 182 +++++++++++++++++++++++++-------------------------- 1 file changed, 90 insertions(+), 92 deletions(-) (limited to 'src') diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 18808e8af..300464474 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -39,10 +39,13 @@ extern const u8 gPokeblockGray_Pal[]; extern const u8 gPokeblockBlack_Pal[]; extern const u8 gPokeblockWhite_Pal[]; extern const u8 gPokeblockGold_Pal[]; - extern const u8 gPokeblock_Gfx[]; +extern const u8 gBattleTerrainTiles_Building[]; +extern const u8 gUnknown_08E782FC[]; +extern const u8 gBattleTerrainPalette_BattleTower[]; +extern const struct CompressedSpriteSheet gUnknown_083F7F74; +extern const struct CompressedSpritePalette gUnknown_083F7F7C; -void sub_8147F4C(u8 taskID); bool8 sub_8040A3C(u16 species); // this file's functions @@ -51,12 +54,13 @@ static void sub_81481DC(void); static void sub_814825C(void); static u8 sub_81480B4(void); static u8 sub_814817C(void); -static u8 sub_8147F84(struct Pokemon* mon); +static u8 PokeblockFeed_CreatePokeSprite(struct Pokemon* mon); static bool8 sub_8147B20(struct Pokemon* mon); -static void sub_8147DDC(u8); +static void LaunchPokeblockFeedTask(u8); static void sub_8148044(u8); static void sub_8148078(struct Sprite* sprite); static void Task_PrintAtePokeblockText(u8 taskID); +static void Task_PaletteFadeToReturn(u8 taskID); static void SetPokeblockFeedSpritePal(u8); static void sub_8148108(u8, bool8); static bool8 sub_8148540(void); @@ -222,13 +226,13 @@ static const s16 sMonPokeblockAnims[][10] = { 0, -4, 16, 12, 64, 0, 0, 0, 0, 1}, }; -static const union AffineAnimCmd gSpriteAffineAnim_8411E90[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411E90[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411EA0[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411EA0[] = { AFFINEANIMCMD_FRAME(0, 0, 12, 1), AFFINEANIMCMD_FRAME(0, 0, 0, 30), @@ -236,7 +240,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411EA0[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411EC0[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411EC0[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 12, 1), @@ -245,7 +249,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411EC0[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411EE8[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411EE8[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), @@ -253,7 +257,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411EE8[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411F08[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411F08[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), @@ -262,7 +266,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411F08[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411F30[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411F30[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), @@ -270,7 +274,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411F30[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411F50[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411F50[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), @@ -279,7 +283,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411F50[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411F78[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411F78[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), @@ -287,7 +291,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411F78[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411F98[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411F98[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), @@ -296,7 +300,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411F98[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411FC0[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411FC0[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), @@ -304,7 +308,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411FC0[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8411FE0[] = +static const union AffineAnimCmd sSpriteAffineAnim_8411FE0[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), @@ -313,7 +317,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8411FE0[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8412008[] = +static const union AffineAnimCmd sSpriteAffineAnim_8412008[] = { AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), @@ -321,7 +325,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_8412008[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8412028[] = +static const union AffineAnimCmd sSpriteAffineAnim_8412028[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), @@ -330,29 +334,29 @@ static const union AffineAnimCmd gSpriteAffineAnim_8412028[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_8412050[] = -{ - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411EA0, - gSpriteAffineAnim_8411EE8, - gSpriteAffineAnim_8411F30, - gSpriteAffineAnim_8411F78, - gSpriteAffineAnim_8411FC0, - gSpriteAffineAnim_8412008, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411EC0, - gSpriteAffineAnim_8411F08, - gSpriteAffineAnim_8411F50, - gSpriteAffineAnim_8411F98, - gSpriteAffineAnim_8411FE0, - gSpriteAffineAnim_8412028, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, - gSpriteAffineAnim_8411E90, +static const union AffineAnimCmd *const sSpriteAffineAnimTable_8412050[] = +{ + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411EA0, + sSpriteAffineAnim_8411EE8, + sSpriteAffineAnim_8411F30, + sSpriteAffineAnim_8411F78, + sSpriteAffineAnim_8411FC0, + sSpriteAffineAnim_8412008, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411EC0, + sSpriteAffineAnim_8411F08, + sSpriteAffineAnim_8411F50, + sSpriteAffineAnim_8411F98, + sSpriteAffineAnim_8411FE0, + sSpriteAffineAnim_8412028, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, }; static const u8* const sPokeblocksPals[] = @@ -373,18 +377,18 @@ static const u8* const sPokeblocksPals[] = gPokeblockGold_Pal }; -static const union AffineAnimCmd gSpriteAffineAnim_84120DC[] = +static const union AffineAnimCmd sSpriteAffineAnim_84120DC[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_END }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_84120EC[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_84120EC[] = { - gSpriteAffineAnim_84120DC + sSpriteAffineAnim_84120DC }; -static const union AffineAnimCmd gSpriteAffineAnim_84120F0[] = +static const union AffineAnimCmd sSpriteAffineAnim_84120F0[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), @@ -399,7 +403,7 @@ static const union AffineAnimCmd gSpriteAffineAnim_84120F0[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd gSpriteAffineAnim_8412148[] = +static const union AffineAnimCmd sSpriteAffineAnim_8412148[] = { AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), @@ -414,22 +418,22 @@ static const union AffineAnimCmd gSpriteAffineAnim_8412148[] = AFFINEANIMCMD_END }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A0[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121A0[] = { - gSpriteAffineAnim_84120DC + sSpriteAffineAnim_84120DC }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A4[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121A4[] = { - gSpriteAffineAnim_84120F0 + sSpriteAffineAnim_84120F0 }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121A8[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121A8[] = { - gSpriteAffineAnim_8412148 + sSpriteAffineAnim_8412148 }; -static const struct OamData gOamData_84121AC = +static const struct OamData sOamData_84121AC = { .y = 0, .affineMode = 3, @@ -446,54 +450,48 @@ static const struct OamData gOamData_84121AC = .affineParam = 0, }; -static const union AnimCmd gSpriteAnim_84121B4[] = +static const union AnimCmd sSpriteAnim_84121B4[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -static const union AnimCmd *const gSpriteAnimTable_84121BC[] = +static const union AnimCmd *const sSpriteAnimTable_84121BC[] = { - gSpriteAnim_84121B4, + sSpriteAnim_84121B4, }; -static const union AffineAnimCmd gSpriteAffineAnim_84121C0[] = +static const union AffineAnimCmd sSpriteAffineAnim_84121C0[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0xFFF8, 0xFFF8, 0, 1), AFFINEANIMCMD_JUMP(1) }; -static const union AffineAnimCmd *const gSpriteAffineAnimTable_84121D8[] = +static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121D8[] = { - gSpriteAffineAnim_84121C0 + sSpriteAffineAnim_84121C0 }; -static const struct CompressedSpriteSheet gUnknown_084121DC = +static const struct CompressedSpriteSheet sUnknown_084121DC = { gPokeblock_Gfx, 0x20, 14818 }; -static const struct SpriteTemplate gSpriteTemplate_84121E4 = +static const struct SpriteTemplate sSpriteTemplate_84121E4 = { .tileTag = 14818, .paletteTag = 14818, - .oam = &gOamData_84121AC, - .anims = gSpriteAnimTable_84121BC, + .oam = &sOamData_84121AC, + .anims = sSpriteAnimTable_84121BC, .images = NULL, - .affineAnims = gSpriteAffineAnimTable_84121D8, + .affineAnims = sSpriteAffineAnimTable_84121D8, .callback = sub_81481B0 }; -extern const struct CompressedSpriteSheet gUnknown_083F7F74; -extern const struct CompressedSpritePalette gUnknown_083F7F7C; -extern const u8 gBattleTerrainTiles_Building[]; -extern const u8 gUnknown_08E782FC[]; -extern const u8 gBattleTerrainPalette_BattleTower[]; - // code -static void sub_8147890(void) +static void CB2_PokeblockFeed(void) { AnimateSprites(); BuildOamBuffer(); @@ -501,14 +499,14 @@ static void sub_8147890(void) UpdatePaletteFade(); } -static void sub_81478A8(void) +static void VBlankCB_PokeblockFeed(void) { LoadOam(); ProcessSpriteCopyRequests(); TransferPlttBuffer(); } -static bool8 sub_81478BC(void) +static bool8 TransitionToPokeblockFeedScene(void) { switch (gMain.state) { @@ -557,7 +555,7 @@ static bool8 sub_81478BC(void) gMain.state++; break; case 9: - ewram[0x1FFFE] = sub_8147F84(&gPlayerParty[gPokeblockMonID]); + ewram[0x1FFFE] = PokeblockFeed_CreatePokeSprite(&gPlayerParty[gPokeblockMonID]); gMain.state++; break; case 10: @@ -577,13 +575,13 @@ static bool8 sub_81478BC(void) REG_IE |= 1; REG_IME = savedIME; REG_DISPSTAT |= 8; - SetVBlankCallback(sub_81478A8); + SetVBlankCallback(VBlankCB_PokeblockFeed); gMain.state++; } case 13: BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); gPaletteFade.bufferTransferDisabled = 0; - SetMainCallback2(sub_8147890); + SetMainCallback2(CB2_PokeblockFeed); return 1; } return 0; @@ -593,9 +591,9 @@ void sub_8147ADC(void) { while (1) { - if (sub_81478BC() == 1) + if (TransitionToPokeblockFeedScene() == 1) { - sub_8147DDC(1); + LaunchPokeblockFeedTask(1); break; } if (sub_80F9344() == 1) @@ -643,7 +641,7 @@ static bool8 sub_8147B20(struct Pokemon* mon) ewram[0x1FFFF]++; break; case 4: - LoadCompressedObjectPic(&gUnknown_084121DC); + LoadCompressedObjectPic(&sUnknown_084121DC); ewram[0x1FFFF]++; break; case 5: @@ -708,17 +706,17 @@ static void sub_8147CC8(u8 taskID) } } -static void sub_8147DDC(u8 a0) +static void LaunchPokeblockFeedTask(u8 a0) { u8 taskID = CreateTask(sub_8147CC8, 0); gTasks[taskID].data[0] = 0; gTasks[taskID].data[1] = a0; } -static void sub_8147E10(u8 taskID) +static void Task_WaitForAtePokeblockText(u8 taskID) { if (MenuUpdateWindowText() == 1) - gTasks[taskID].func = sub_8147F4C; + gTasks[taskID].func = Task_PaletteFadeToReturn; } static void Task_PrintAtePokeblockText(u8 taskID) @@ -738,10 +736,10 @@ static void Task_PrintAtePokeblockText(u8 taskID) StringExpandPlaceholders(gStringVar4, gContestStatsText_DisdainfullyAte); MenuPrintMessage(gStringVar4, 1, 15); - gTasks[taskID].func = sub_8147E10; + gTasks[taskID].func = Task_WaitForAtePokeblockText; } -static void sub_8147F08(u8 taskID) +static void Task_ReturnAfterPaletteFade(u8 taskID) { if (!gPaletteFade.active) { @@ -751,13 +749,13 @@ static void sub_8147F08(u8 taskID) } } -void sub_8147F4C(u8 taskID) +static void Task_PaletteFadeToReturn(u8 taskID) { BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); - gTasks[taskID].func = sub_8147F08; + gTasks[taskID].func = Task_ReturnAfterPaletteFade; } -static u8 sub_8147F84(struct Pokemon* mon) +static u8 PokeblockFeed_CreatePokeSprite(struct Pokemon* mon) { u16 species = GetMonData(mon, MON_DATA_SPECIES2); u8 spriteID = CreateSprite(&gUnknown_02024E8C, 48, 80, 2); @@ -770,7 +768,7 @@ static u8 sub_8147F84(struct Pokemon* mon) gPokeblockMonNotFlipped = 1; if (!sub_8040A3C(species)) { - gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84120EC; + gSprites[spriteID].affineAnims = sSpriteAffineAnimTable_84120EC; gSprites[spriteID].oam.affineMode = 3; CalcCenterToCornerVec(&gSprites[spriteID], gSprites[spriteID].oam.shape, gSprites[spriteID].oam.size, gSprites[spriteID].oam.affineMode); gPokeblockMonNotFlipped = 0; @@ -802,7 +800,7 @@ static u8 sub_81480B4(void) { u8 spriteID = sub_810BA50(188, 100, 2); gSprites[spriteID].oam.affineMode = 1; - gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A0; + gSprites[spriteID].affineAnims = sSpriteAffineAnimTable_84121A0; gSprites[spriteID].callback = SpriteCallbackDummy; InitSpriteAffineAnim(&gSprites[spriteID]); return spriteID; @@ -813,15 +811,15 @@ static void sub_8148108(u8 spriteID, bool8 a1) FreeOamMatrix(gSprites[spriteID].oam.matrixNum); gSprites[spriteID].oam.affineMode = 3; if (!a1) - gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A4; + gSprites[spriteID].affineAnims = sSpriteAffineAnimTable_84121A4; else - gSprites[spriteID].affineAnims = gSpriteAffineAnimTable_84121A8; + gSprites[spriteID].affineAnims = sSpriteAffineAnimTable_84121A8; InitSpriteAffineAnim(&gSprites[spriteID]); } static u8 sub_814817C(void) { - u8 spriteID = CreateSprite(&gSpriteTemplate_84121E4, 174, 84, 1); + u8 spriteID = CreateSprite(&sSpriteTemplate_84121E4, 174, 84, 1); gSprites[spriteID].data0 = -12; gSprites[spriteID].data1 = 1; return spriteID; @@ -868,7 +866,7 @@ static void sub_814825C(void) { gPokeblockFeedPokeSprite->oam.affineMode = 3; gPokeblockFeedPokeSprite->oam.matrixNum = 0; - gPokeblockFeedPokeSprite->affineAnims = gSpriteAffineAnimTable_8412050; + gPokeblockFeedPokeSprite->affineAnims = sSpriteAffineAnimTable_8412050; InitSpriteAffineAnim(gPokeblockFeedPokeSprite); } gUnknown_03005F3C = 50; -- cgit v1.2.3 From 2730d1c42254c7098d135ff2ff9e62944cff5b6b Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Mon, 14 Aug 2017 19:59:15 -0500 Subject: decompile sub_802CA60 --- src/battle_5.c | 190 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 184 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index 71939ba0d..2ab1a2189 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -31,6 +31,7 @@ extern u16 gUnknown_030042A4; extern struct Window gUnknown_03004210; extern const u8 gUnknown_08400D89[]; extern u8 gUnknown_03004348; +extern struct BattlePokemon gBattleMons[]; extern void dp11b_obj_instanciate(u8, u8, s8, s8); extern u8 GetBankIdentity(u8); @@ -43,6 +44,7 @@ extern void sub_802E3B4(); extern void sub_802E220(); extern void sub_802E2D4(); extern void sub_802E12C(); +extern void sub_802E1B0(void); void PlayerHandleGetAttributes(void); void sub_802ECF0(void); @@ -448,11 +450,12 @@ void sub_802C2EC(void) struct UnknownStruct1 { - u16 unk0[4]; - u8 unk8[4]; - u8 fillerC[0x12-0xC]; + u16 moves[4]; + u8 pp[4]; + u8 unkC[0x12-0xC]; u8 unk12; u8 unk13; + u8 filler14[0x20-0x14]; }; void sub_802C68C(void) @@ -466,10 +469,10 @@ void sub_802C68C(void) PlaySE(SE_SELECT); - if (r6->unk0[gMoveSelectionCursor[gActiveBank]] == 0xAE) + if (r6->moves[gMoveSelectionCursor[gActiveBank]] == 0xAE) r4 = (r6->unk12 != 7 && (r6->unk13 ^ 7)) ? 0x10 : 0; else - r4 = gBattleMoves[r6->unk0[gMoveSelectionCursor[gActiveBank]]].target; + r4 = gBattleMoves[r6->moves[gMoveSelectionCursor[gActiveBank]]].target; if (r4 & 0x10) gUnknown_03004344 = gActiveBank; @@ -485,7 +488,7 @@ void sub_802C68C(void) { if (!(r4 & 0x7D)) r8++; - if (r6->unk8[gMoveSelectionCursor[gActiveBank]] == 0) + if (r6->pp[gMoveSelectionCursor[gActiveBank]] == 0) { r8 = 0; } @@ -589,3 +592,178 @@ void sub_802C68C(void) } } } + +extern const u8 gUnknown_08400D49[]; +extern const u8 gUnknown_08400D38[]; + +void sub_802CA60(void) +{ + u8 perMovePPBonuses[4]; + struct + { + u16 moves[4]; + u8 pp[4]; + u8 filler18[8]; // what is this? + } sp0; + //struct UnknownStruct1 sp0; + u8 totalPPBonuses; + + if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + if (gMoveSelectionCursor[gActiveBank] != gUnknown_03004344) + { + struct UnknownStruct1 *r9 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + s32 i; + + i = r9->moves[gMoveSelectionCursor[gActiveBank]]; + r9->moves[gMoveSelectionCursor[gActiveBank]] = r9->moves[gUnknown_03004344]; + r9->moves[gUnknown_03004344] = i; + + i = r9->pp[gMoveSelectionCursor[gActiveBank]]; + r9->pp[gMoveSelectionCursor[gActiveBank]] = r9->pp[gUnknown_03004344]; + r9->pp[gUnknown_03004344] = i; + + i = r9->unkC[gMoveSelectionCursor[gActiveBank]]; + r9->unkC[gMoveSelectionCursor[gActiveBank]] = r9->unkC[gUnknown_03004344]; + r9->unkC[gUnknown_03004344] = i; + + if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) + { + gDisableStructs[gActiveBank].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBank]]; + gDisableStructs[gActiveBank].unk18_b |= gBitTable[gUnknown_03004344]; + } + + sub_802E1B0(); + + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; + + for (i = 0; i < 4; i++) + { + gBattleMons[gActiveBank].moves[i] = r9->moves[i]; + gBattleMons[gActiveBank].pp[i] = r9->pp[i]; + } + if (!(gBattleMons[gActiveBank].status2 & 0x200000)) + { + for (i = 0; i < 4; i++) + { + sp0.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); + sp0.pp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); + } + + totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); + + i = sp0.moves[gMoveSelectionCursor[gActiveBank]]; + sp0.moves[gMoveSelectionCursor[gActiveBank]] = sp0.moves[gUnknown_03004344]; + sp0.moves[gUnknown_03004344] = i; + + i = sp0.pp[gMoveSelectionCursor[gActiveBank]]; + sp0.pp[gMoveSelectionCursor[gActiveBank]] = sp0.pp[gUnknown_03004344]; + sp0.pp[gUnknown_03004344] = i; + + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, (u8 *)&sp0.moves[i]); + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &sp0.pp[i]); + } + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); + } + } + else + { + sub_802E12C(gUnknown_03004344, gUnknown_08400D49); + } + gBattleBankFunc[gActiveBank] = sub_802C68C; + gMoveSelectionCursor[gActiveBank] = gUnknown_03004344; + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + nullsub_7(gUnknown_03004344); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_08400D49); + gBattleBankFunc[gActiveBank] = sub_802C68C; + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if ((gMain.newKeys & DPAD_LEFT) && (gUnknown_03004344 & 1)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_RIGHT) && !(gUnknown_03004344 & 1) && (gUnknown_03004344 ^ 1) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_UP) && (gUnknown_03004344 & 2)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_DOWN) && !(gUnknown_03004344 & 2) && (gUnknown_03004344 ^ 2) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } +} -- cgit v1.2.3 From 403e49189bf3f79327629d2c2245d19ece047c94 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 15 Aug 2017 10:20:19 +0200 Subject: pokeblock feed is done --- src/pokeblock_feed.c | 77 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 51 insertions(+), 26 deletions(-) (limited to 'src') diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 300464474..9cef681b0 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -53,7 +53,7 @@ static void sub_8147B04(void); static void sub_81481DC(void); static void sub_814825C(void); static u8 sub_81480B4(void); -static u8 sub_814817C(void); +static u8 CreatePokeblockSprite(void); static u8 PokeblockFeed_CreatePokeSprite(struct Pokemon* mon); static bool8 sub_8147B20(struct Pokemon* mon); static void LaunchPokeblockFeedTask(u8); @@ -67,7 +67,7 @@ static bool8 sub_8148540(void); static bool8 sub_81485CC(void); static bool8 FreePokeSpriteMatrix(void); void sub_8148710(void); -static void sub_81481B0(struct Sprite* sprite); +static void SpriteCB_ThrownPokeblock(struct Sprite* sprite); static void sub_814862C(void); // EWRAM @@ -433,7 +433,7 @@ static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121A8[] = sSpriteAffineAnim_8412148 }; -static const struct OamData sOamData_84121AC = +static const struct OamData sThrownPokeblockOamData = { .y = 0, .affineMode = 3, @@ -450,15 +450,15 @@ static const struct OamData sOamData_84121AC = .affineParam = 0, }; -static const union AnimCmd sSpriteAnim_84121B4[] = +static const union AnimCmd sThrownPokeblockSpriteAnim[] = { ANIMCMD_FRAME(0, 0), ANIMCMD_END }; -static const union AnimCmd *const sSpriteAnimTable_84121BC[] = +static const union AnimCmd *const sThrownPokeblockAnimTable[] = { - sSpriteAnim_84121B4, + sThrownPokeblockSpriteAnim, }; static const union AffineAnimCmd sSpriteAffineAnim_84121C0[] = @@ -468,7 +468,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_84121C0[] = AFFINEANIMCMD_JUMP(1) }; -static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121D8[] = +static const union AffineAnimCmd *const sThrownPokeblockAffineAnimTable[] = { sSpriteAffineAnim_84121C0 }; @@ -478,15 +478,15 @@ static const struct CompressedSpriteSheet sUnknown_084121DC = gPokeblock_Gfx, 0x20, 14818 }; -static const struct SpriteTemplate sSpriteTemplate_84121E4 = +static const struct SpriteTemplate sThrownPokeblockSpriteTemplate = { .tileTag = 14818, .paletteTag = 14818, - .oam = &sOamData_84121AC, - .anims = sSpriteAnimTable_84121BC, + .oam = &sThrownPokeblockOamData, + .anims = sThrownPokeblockAnimTable, .images = NULL, - .affineAnims = sSpriteAffineAnimTable_84121D8, - .callback = sub_81481B0 + .affineAnims = sThrownPokeblockAffineAnimTable, + .callback = SpriteCB_ThrownPokeblock }; // code @@ -687,7 +687,7 @@ static void sub_8147CC8(u8 taskID) sub_8148108(ewram[0x1FFFD], gTasks[taskID].data[1]); break; case 269: - ewram[0x1FFFC] = sub_814817C(); + ewram[0x1FFFC] = CreatePokeblockSprite(); break; case 281: sub_8148044(ewram[0x1FFFE]); @@ -817,15 +817,15 @@ static void sub_8148108(u8 spriteID, bool8 a1) InitSpriteAffineAnim(&gSprites[spriteID]); } -static u8 sub_814817C(void) +static u8 CreatePokeblockSprite(void) { - u8 spriteID = CreateSprite(&sSpriteTemplate_84121E4, 174, 84, 1); + u8 spriteID = CreateSprite(&sThrownPokeblockSpriteTemplate, 174, 84, 1); gSprites[spriteID].data0 = -12; gSprites[spriteID].data1 = 1; return spriteID; } -static void sub_81481B0(struct Sprite* sprite) +static void SpriteCB_ThrownPokeblock(struct Sprite* sprite) { sprite->pos1.x -= 4; sprite->pos1.y += sprite->data0; @@ -932,8 +932,8 @@ static bool8 sub_81485CC(void) { u16 var = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; - gPokeblockFeedPokeSprite->pos2.x = (u16)(*((u16*)(&ewram[0x1D000]) + var)); - gPokeblockFeedPokeSprite->pos2.y = (u16)(*((u16*)(&ewram[0x1D400]) + var)); + gPokeblockFeedPokeSprite->pos2.x = (*((u16*)(&ewram[0x1D000]) + var)); + gPokeblockFeedPokeSprite->pos2.y = (*((u16*)(&ewram[0x1D400]) + var)); if (--gUnknown_03005FA0[4] == 0) return 1; @@ -971,17 +971,42 @@ static void sub_814862C(void) *((u16*)(&ewram[0x1D3FE]) + (r8 + r7)) = r9; } -/* void sub_8148710(void) { bool8 var_24 = 0; s16 r8 = gUnknown_03005FA0[13] - gUnknown_03005FA0[10]; s16 r7 = gUnknown_03005FA0[14] - gUnknown_03005FA0[11]; - s16 r5; - if (gUnknown_03005FA0[10] < 0) - r5 = -(gUnknown_03005FA0[10]) - gUnknown_03005FA0[3]; - else - r5 = (gUnknown_03005FA0[10]) - gUnknown_03005FA0[3]; - if (gUnknown_03005FA0) + while (1) + { + u16 r5; + u16 r4; + u16 var; + + var = abs(gUnknown_03005FA0[5]); + r5 = var + gUnknown_03005FA0[3]; + gUnknown_03005FA0[3] = r5; + + if (gUnknown_03005FA0[2] < 0) + var_24 = 1; + + r4 = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; + + if (gUnknown_03005FA0[4] == 0) + break; + + if (var_24 == 0) + { + *((u16*)(&ewram[0x1D000]) + r4) = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] + r5 / 256) + r8; + *((u16*)(&ewram[0x1D400]) + r4) = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] + r5 / 256) + r7; + } + else + { + *((u16*)(&ewram[0x1D000]) + r4) = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] - r5 / 256) + r8; + *((u16*)(&ewram[0x1D400]) + r4) = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] - r5 / 256) + r7; + } + + gUnknown_03005FA0[0] += gUnknown_03005FA0[1]; + gUnknown_03005FA0[0] &= 0xFF; + gUnknown_03005FA0[4]--; + } } -*/ -- cgit v1.2.3 From 49aebd08cc11b02c3f6ab5ad48eb9c520528ac8a Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 15 Aug 2017 12:17:14 +0200 Subject: cleaning up other pokeblock files --- src/pokeblock.c | 1 - src/pokeblock_feed.c | 2 +- src/use_pokeblock.c | 238 +++++++++++++++++++-------------------------------- 3 files changed, 90 insertions(+), 151 deletions(-) (limited to 'src') diff --git a/src/pokeblock.c b/src/pokeblock.c index 2fb544fea..029bb066f 100644 --- a/src/pokeblock.c +++ b/src/pokeblock.c @@ -25,7 +25,6 @@ #include "sound.h" #include "songs.h" #include "safari_zone.h" -#include "use_pokeblock.h" #include "event_data.h" #include "pokeblock.h" diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 9cef681b0..69917bf5d 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -587,7 +587,7 @@ static bool8 TransitionToPokeblockFeedScene(void) return 0; } -void sub_8147ADC(void) +void CB2_PreparePokeblockFeedScene(void) { while (1) { diff --git a/src/use_pokeblock.c b/src/use_pokeblock.c index 19d2e4399..371c25c97 100644 --- a/src/use_pokeblock.c +++ b/src/use_pokeblock.c @@ -1,5 +1,6 @@ // // Created by Scott Norton on 5/31/17. +// Modified by Dizzy Egg on 8/15/17. // #include "global.h" @@ -16,8 +17,6 @@ #include "sound.h" #include "songs.h" #include "pokeblock.h" -#include "pokeblock_feed.h" -#include "use_pokeblock.h" #define GFX_TAG_CONDITIONUPDOWN 0 @@ -29,7 +28,7 @@ const u16 ConditionUpDownPalette[] = INCBIN_U16("graphics/misc/condition_up_down const u32 ConditionUpDownTiles[] = INCBIN_U32("graphics/misc/condition_up_down.4bpp"); #endif -const u32 gUnknown_08406118[] = { +static const u32 gUnknown_08406118[] = { MON_DATA_COOL, MON_DATA_TOUGH, MON_DATA_SMART, @@ -37,11 +36,11 @@ const u32 gUnknown_08406118[] = { MON_DATA_BEAUTY }; -const u8 gUnknown_0840612C[] = { +static const u8 gUnknown_0840612C[] = { 0, 4, 3, 2, 1 }; -const u8 *const gUnknown_08406134[] = { +static const u8 *const sContextStatNames[] = { OtherText_Coolness, OtherText_Toughness, OtherText_Smartness, @@ -49,18 +48,18 @@ const u8 *const gUnknown_08406134[] = { OtherText_Beauty }; -const struct SpriteSheet gSpriteSheet_ConditionUpDown = { +static const struct SpriteSheet gSpriteSheet_ConditionUpDown = { (u8 *)ConditionUpDownTiles, sizeof ConditionUpDownTiles, GFX_TAG_CONDITIONUPDOWN }; -const struct SpritePalette gSpritePalette_ConditionUpDown = { +static const struct SpritePalette gSpritePalette_ConditionUpDown = { ConditionUpDownPalette, GFX_TAG_CONDITIONUPDOWN }; -const s16 gUnknown_08406158[][2] = { +static const s16 gUnknown_08406158[][2] = { {0x9c, 0x1e}, {0x75, 0x35}, {0x75, 0x70}, @@ -68,28 +67,28 @@ const s16 gUnknown_08406158[][2] = { {0xc5, 0x35} }; -const struct OamData gOamData_840616C = { +static const struct OamData gOamData_840616C = { .shape = 1, .size = 2, .priority = 1 }; -const union AnimCmd gSpriteAnim_8406174[] = { +static const union AnimCmd gSpriteAnim_8406174[] = { ANIMCMD_FRAME(0, 5), ANIMCMD_END }; -const union AnimCmd gSpriteAnim_840617C[] = { +static const union AnimCmd gSpriteAnim_840617C[] = { ANIMCMD_FRAME(8, 5), ANIMCMD_END }; -const union AnimCmd *const gSpriteAnimTable_8406184[] = { +static const union AnimCmd *const gSpriteAnimTable_8406184[] = { gSpriteAnim_8406174, gSpriteAnim_840617C }; -const struct SpriteTemplate gSpriteTemplate_840618C = { +static const struct SpriteTemplate gSpriteTemplate_840618C = { GFX_TAG_CONDITIONUPDOWN, GFX_TAG_CONDITIONUPDOWN, &gOamData_840616C, @@ -99,9 +98,6 @@ const struct SpriteTemplate gSpriteTemplate_840618C = { SpriteCallbackDummy }; -asm(".text\n" - ".include \"constants/gba_constants.inc\""); - static EWRAM_DATA struct UnkPokenavStruct_Sub1 *gUnknown_02039304 = NULL; static EWRAM_DATA MainCallback gUnknown_02039308 = NULL; static EWRAM_DATA struct Pokeblock *gUnknown_0203930C = NULL; @@ -111,35 +107,35 @@ EWRAM_DATA s16 gPokeblockGain = 0; extern u16 gKeyRepeatStartDelay; extern u16 gScriptItemId; // FIXME: remove after merge of #349 Pokeblock -void launch_c3_walk_stairs_and_run_once(void (*const)(void)); -void sub_81361E4(void); -void sub_813622C(void); -void sub_8136244(void); -void sub_8136264(void); -void sub_8136294(void); -void sub_81365A0(void); -void sub_81365C8(void); -void sub_8136638(void); -void sub_81368A4(void); +static void launch_c3_walk_stairs_and_run_once(void (*const)(void)); +static void sub_81361E4(void); +static void sub_813622C(void); +static void sub_8136244(void); +static void sub_8136264(void); +static void sub_8136294(void); +static void sub_81365A0(void); +static void sub_81365C8(void); +static void sub_8136638(void); +static void sub_81368A4(void); void sub_8089668(void); -void sub_8136B44(void); -u8 sub_81370E4(u8); -void sub_8136BB8(void); -s8 sub_8136C40(void); -bool8 sub_8137058(void); -void sub_8136D60(void); -void sub_8136808(void); -void sub_8136D8C(void); -u8 sub_81370A4(u8); -void sub_81369CC(void); -void sub_8136EF0(void); -void sub_8137138(void); -void sub_8136C6C(void); -bool8 sub_8136D00(void); -void sub_8136DC0(u8 *, u8, s16); -void sub_8136DA0(const u8 *); -void sub_8136F74(struct Pokeblock *, struct Pokemon *); -void sub_81371DC(struct Sprite *); +static void sub_8136B44(void); +static u8 sub_81370E4(u8); +static void sub_8136BB8(void); +static s8 sub_8136C40(void); +static bool8 sub_8137058(void); +static void sub_8136D60(void); +static void sub_8136808(void); +static void sub_8136D8C(void); +static u8 sub_81370A4(u8); +static void sub_81369CC(void); +static void sub_8136EF0(void); +static void sub_8137138(void); +static void sub_8136C6C(void); +static bool8 sub_8136D00(void); +static void Pokeblock_BufferEnhancedStatText(u8 *, u8, s16); +static void Pokeblock_MenuWindowTextPrint(const u8 *); +static void sub_8136F74(struct Pokeblock *, struct Pokemon *); +static void sub_81371DC(struct Sprite *); void sub_8136130(struct Pokeblock *pokeblock, MainCallback callback) { @@ -151,7 +147,7 @@ void sub_8136130(struct Pokeblock *pokeblock, MainCallback callback) SetMainCallback2(sub_8136244); } -void sub_8136174(void) +static void sub_8136174(void) { gUnknown_02039304->pokeblock = gUnknown_0203930C; gUnknown_02039304->callback = gUnknown_02039308; @@ -162,7 +158,7 @@ void sub_8136174(void) SetMainCallback2(sub_81361E4); } -void sub_81361E4(void) +static void sub_81361E4(void) { gUnknown_02039304->unk0(); AnimateSprites(); @@ -176,7 +172,7 @@ void sub_81361E4(void) } } -void sub_813622C(void) +static void sub_813622C(void) { sub_81368A4(); AnimateSprites(); @@ -184,7 +180,7 @@ void sub_813622C(void) UpdatePaletteFade(); } -void sub_8136244(void) +static void sub_8136244(void) { gUnknown_02039304->unk0(); AnimateSprites(); @@ -192,7 +188,7 @@ void sub_8136244(void) UpdatePaletteFade(); } -void sub_8136264(void) +static void sub_8136264(void) { LoadOam(); ProcessSpriteCopyRequests(); @@ -201,13 +197,13 @@ void sub_8136264(void) sub_8089668(); } -void launch_c3_walk_stairs_and_run_once(void (*const func)(void)) +static void launch_c3_walk_stairs_and_run_once(void (*const func)(void)) { gUnknown_02039304->unk0 = func; gUnknown_02039304->unk50 = 0; } -void sub_8136294(void) +static void sub_8136294(void) { bool32 c1LinkRelatedActive; switch (gUnknown_02039304->unk50) @@ -346,7 +342,7 @@ void sub_8136294(void) } } -void sub_81365A0(void) +static void sub_81365A0(void) { while (!gUnknown_02039304->unk55) { @@ -354,7 +350,7 @@ void sub_81365A0(void) } } -void sub_81365C8(void) +static void sub_81365C8(void) { switch (gUnknown_02039304->unk50) { @@ -374,7 +370,7 @@ void sub_81365C8(void) } } -void sub_8136638(void) +static void sub_8136638(void) { switch (gUnknown_02039304->unk50) { @@ -464,7 +460,7 @@ void sub_8136638(void) } } -void sub_8136808(void) +static void sub_8136808(void) { switch (gUnknown_02039304->unk50) { @@ -479,13 +475,13 @@ void sub_8136808(void) if (!gPaletteFade.active) { gMain.savedCallback = sub_8136174; - SetMainCallback2(sub_8147ADC); + SetMainCallback2(CB2_PreparePokeblockFeedScene); } break; } } -void sub_81368A4(void) +static void sub_81368A4(void) { switch (gUnknown_02039304->unk50) { @@ -538,7 +534,7 @@ void sub_81368A4(void) } } -void sub_81369CC(void) +static void sub_81369CC(void) { switch (gUnknown_02039304->unk50) { @@ -585,7 +581,7 @@ void sub_81369CC(void) } } -void sub_8136B44(void) +static void sub_8136B44(void) { switch (gUnknown_02039304->unk50) { @@ -609,7 +605,7 @@ void sub_8136B44(void) } } -void sub_8136BB8(void) +static void sub_8136BB8(void) { GetMonData(&gPlayerParty[sub_81370A4(gUnknown_083DFEC4->unk87DC)], MON_DATA_NICKNAME, gUnknown_02039304->stringBuffer); StringGetEnd10(gUnknown_02039304->stringBuffer); @@ -621,7 +617,7 @@ void sub_8136BB8(void) MoveMenuCursor(0); } -s8 sub_8136C40(void) +static s8 sub_8136C40(void) { s8 retval = ProcessMenuInputNoWrap(); if ((u8)(retval + 1) < 3) @@ -632,124 +628,68 @@ s8 sub_8136C40(void) return retval; } -void sub_8136C6C(void) +static void sub_8136C6C(void) { BasicInitMenuWindow(&gWindowConfig_81E709C); MenuDrawTextWindow(0, 16, 29, 19); for (gUnknown_02039304->unk53 = 0; gUnknown_02039304->unk53 < 5 && gUnknown_02039304->unk61[gUnknown_02039304->unk53] == 0; gUnknown_02039304->unk53++); if (gUnknown_02039304->unk53 < 5) { - sub_8136DC0(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, gUnknown_02039304->unk61[gUnknown_02039304->unk53]); + Pokeblock_BufferEnhancedStatText(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, gUnknown_02039304->unk61[gUnknown_02039304->unk53]); } else { - sub_8136DC0(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, 0); + Pokeblock_BufferEnhancedStatText(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, 0); } - sub_8136DA0(gUnknown_02039304->stringBuffer); + Pokeblock_MenuWindowTextPrint(gUnknown_02039304->stringBuffer); } -#ifdef NONMATCHING -bool8 sub_8136D00(void) +static bool8 sub_8136D00(void) { while (1) { - if (++gUnknown_02039304->unk53 >= 5) + gUnknown_02039304->unk53++; + if (gUnknown_02039304->unk53 < 5) { - break; + if (gUnknown_02039304->unk61[gUnknown_02039304->unk53] != 0) + break; } - if (gUnknown_02039304->unk61[gUnknown_02039304->unk53] != 0) + else { - sub_8136DC0(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, gUnknown_02039304->unk61[gUnknown_02039304->unk53]); - sub_8136DA0(gUnknown_02039304->stringBuffer); - return TRUE; + gUnknown_02039304->unk53 = 5; + return FALSE; } } - gUnknown_02039304->unk53 = 5; - return FALSE; + Pokeblock_BufferEnhancedStatText(gUnknown_02039304->stringBuffer, gUnknown_02039304->unk53, gUnknown_02039304->unk61[gUnknown_02039304->unk53]); + Pokeblock_MenuWindowTextPrint(gUnknown_02039304->stringBuffer); + return TRUE; } -#else -__attribute__((naked)) -bool8 sub_8136D00(void) -{ - asm_unified("\tpush {r4,r5,lr}\n" - "\tldr r4, _08136D30 @ =gUnknown_02039304\n" - "\tadds r3, r4, 0\n" - "\tmovs r5, 0x5\n" - "_08136D08:\n" - "\tldr r0, [r3]\n" - "\tadds r0, 0x53\n" - "\tldrb r1, [r0]\n" - "\tadds r1, 0x1\n" - "\tstrb r1, [r0]\n" - "\tldr r2, [r3]\n" - "\tadds r1, r2, 0\n" - "\tadds r1, 0x53\n" - "\tldrb r0, [r1]\n" - "\tcmp r0, 0x4\n" - "\tbhi _08136D34\n" - "\tadds r0, r2, 0\n" - "\tadds r0, 0x61\n" - "\tldrb r1, [r1]\n" - "\tadds r0, r1\n" - "\tldrb r0, [r0]\n" - "\tcmp r0, 0\n" - "\tbne _08136D3A\n" - "\tb _08136D08\n" - "\t.align 2, 0\n" - "_08136D30: .4byte gUnknown_02039304\n" - "_08136D34:\n" - "\tstrb r5, [r1]\n" - "\tmovs r0, 0\n" - "\tb _08136D5A\n" - "_08136D3A:\n" - "\tldr r2, [r4]\n" - "\tadds r0, r2, 0\n" - "\tadds r0, 0x10\n" - "\tadds r1, r2, 0\n" - "\tadds r1, 0x53\n" - "\tldrb r1, [r1]\n" - "\tadds r2, 0x61\n" - "\tadds r2, r1\n" - "\tldrb r2, [r2]\n" - "\tbl sub_8136DC0\n" - "\tldr r0, [r4]\n" - "\tadds r0, 0x10\n" - "\tbl sub_8136DA0\n" - "\tmovs r0, 0x1\n" - "_08136D5A:\n" - "\tpop {r4,r5}\n" - "\tpop {r1}\n" - "\tbx r1"); -} -#endif -void sub_8136D60(void) +static void sub_8136D60(void) { BasicInitMenuWindow(&gWindowConfig_81E709C); MenuDrawTextWindow(0, 16, 29, 19); MenuPrint(gOtherText_WontEat, 1, 17); } -void sub_8136D8C(void) +static void sub_8136D8C(void) { MenuZeroFillScreen(); BasicInitMenuWindow(&gWindowConfig_81E7080); } -void sub_8136DA0(const u8 *message) +static void Pokeblock_MenuWindowTextPrint(const u8 *message) { MenuDrawTextWindow(0, 16, 29, 19); MenuPrint(message, 1, 17); } #ifdef NONMATCHING -void sub_8136DC0(u8 *dest, u8 a1, s16 a2) +static void Pokeblock_BufferEnhancedStatText(u8 *dest, u8 statID, s16 a2) { - u16 v0 = a2; if (a2 != 0) { - if ((v0 = max(a2, 0)) == 0); - StringCopy(dest, gUnknown_08406134[a1]); + StringCopy(dest, sContextStatNames[statID]); StringAppend(dest, gOtherText_WasEnhanced); } else @@ -759,7 +699,7 @@ void sub_8136DC0(u8 *dest, u8 a1, s16 a2) } #else __attribute__((naked)) -void sub_8136DC0(u8 *dest, u8 a1, s16 a2) +static void Pokeblock_BufferEnhancedStatText(u8 *dest, u8 a1, s16 a2) { asm_unified("\tpush {r4,lr}\n" "\tadds r4, r0, 0\n" @@ -775,7 +715,7 @@ void sub_8136DC0(u8 *dest, u8 a1, s16 a2) "\tmovs r0, 0\n" "_08136DD8:\n" "\tlsls r0, 16\n" - "\tldr r1, _08136DF4 @ =gUnknown_08406134\n" + "\tldr r1, _08136DF4 @ =sContextStatNames\n" "\tlsls r0, r3, 2\n" "\tadds r0, r1\n" "\tldr r1, [r0]\n" @@ -786,7 +726,7 @@ void sub_8136DC0(u8 *dest, u8 a1, s16 a2) "\tbl StringAppend\n" "\tb _08136E04\n" "\t.align 2, 0\n" - "_08136DF4: .4byte gUnknown_08406134\n" + "_08136DF4: .4byte sContextStatNames\n" "_08136DF8: .4byte gOtherText_WasEnhanced\n" "_08136DFC:\n" "\tldr r1, _08136E0C @ =gOtherText_NothingChanged\n" @@ -801,7 +741,7 @@ void sub_8136DC0(u8 *dest, u8 a1, s16 a2) } #endif -void sub_8136E10(struct Pokemon *pokemon, u8 *data) +static void sub_8136E10(struct Pokemon *pokemon, u8 *data) { u16 i; for (i=0; i<5; i++) @@ -810,7 +750,7 @@ void sub_8136E10(struct Pokemon *pokemon, u8 *data) } } -void sub_8136E40(struct Pokeblock *pokeblock, struct Pokemon *pokemon) +static void sub_8136E40(struct Pokeblock *pokeblock, struct Pokemon *pokemon) { u16 i; s16 cstat; @@ -838,7 +778,7 @@ void sub_8136E40(struct Pokeblock *pokeblock, struct Pokemon *pokemon) } } -void sub_8136EF0(void) +static void sub_8136EF0(void) { u16 i; struct Pokemon *pokemon = gPlayerParty; @@ -852,7 +792,7 @@ void sub_8136EF0(void) } } -void sub_8136F74(struct Pokeblock *pokeblock, struct Pokemon *pokemon) +static void sub_8136F74(struct Pokeblock *pokeblock, struct Pokemon *pokemon) { s8 direction; s8 i; @@ -884,7 +824,7 @@ void sub_8136F74(struct Pokeblock *pokeblock, struct Pokemon *pokemon) } } -bool8 sub_8137058(void) +static bool8 sub_8137058(void) { struct Pokemon *pokemon = gPlayerParty; pokemon += gUnknown_083DFEC4->unk893c[gUnknown_083DFEC4->unk87DC].partyIdx; @@ -893,7 +833,7 @@ bool8 sub_8137058(void) return FALSE; } -u8 sub_81370A4(u8 a0) +static u8 sub_81370A4(u8 a0) { u8 i; for (i=0; idata0 <= 5) sprite->pos2.y -= 2; -- cgit v1.2.3 From 296534003f07e6f240b11bb60fec87df42e864f4 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 15 Aug 2017 12:40:10 +0200 Subject: more cleaning, make it compile --- src/use_pokeblock.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'src') diff --git a/src/use_pokeblock.c b/src/use_pokeblock.c index 371c25c97..0c8f59959 100644 --- a/src/use_pokeblock.c +++ b/src/use_pokeblock.c @@ -28,7 +28,7 @@ const u16 ConditionUpDownPalette[] = INCBIN_U16("graphics/misc/condition_up_down const u32 ConditionUpDownTiles[] = INCBIN_U32("graphics/misc/condition_up_down.4bpp"); #endif -static const u32 gUnknown_08406118[] = { +static const u32 sContestStatsMonData[] = { MON_DATA_COOL, MON_DATA_TOUGH, MON_DATA_SMART, @@ -741,12 +741,12 @@ static void Pokeblock_BufferEnhancedStatText(u8 *dest, u8 a1, s16 a2) } #endif -static void sub_8136E10(struct Pokemon *pokemon, u8 *data) +static void Pokeblock_GetMonContestStats(struct Pokemon *pokemon, u8 *data) { u16 i; for (i=0; i<5; i++) { - data[i] = GetMonData(pokemon, gUnknown_08406118[i]); + data[i] = GetMonData(pokemon, sContestStatsMonData[i]); } } @@ -760,14 +760,14 @@ static void sub_8136E40(struct Pokeblock *pokeblock, struct Pokemon *pokemon) sub_8136F74(pokeblock, pokemon); for (i=0; i<5; i++) { - data = GetMonData(pokemon, gUnknown_08406118[i]); + data = GetMonData(pokemon, sContestStatsMonData[i]); cstat = data + gUnknown_02039304->unk66[i]; if (cstat < 0) cstat = 0; if (cstat > 255) cstat = 255; data = cstat; - SetMonData(pokemon, gUnknown_08406118[i], &data); + SetMonData(pokemon, sContestStatsMonData[i], &data); } cstat = (u8)GetMonData(pokemon, MON_DATA_SHEEN); cstat = cstat + pokeblock->feel; @@ -783,9 +783,9 @@ static void sub_8136EF0(void) u16 i; struct Pokemon *pokemon = gPlayerParty; pokemon += gUnknown_083DFEC4->unk893c[gUnknown_083DFEC4->unk87DC].partyIdx; - sub_8136E10(pokemon, gUnknown_02039304->unk57); + Pokeblock_GetMonContestStats(pokemon, gUnknown_02039304->unk57); sub_8136E40(gUnknown_02039304->pokeblock, pokemon); - sub_8136E10(pokemon, gUnknown_02039304->unk5c); + Pokeblock_GetMonContestStats(pokemon, gUnknown_02039304->unk5c); for (i=0; i<5; i++) { gUnknown_02039304->unk61[i] = gUnknown_02039304->unk5c[i] - gUnknown_02039304->unk57[i]; -- cgit v1.2.3 From d26c990f055595c92d2a40f566e87d9708de8a51 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Tue, 15 Aug 2017 19:42:54 -0500 Subject: decompile sub_802D148 - sub_802DA9C --- src/battle_5.c | 682 +++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 513 insertions(+), 169 deletions(-) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index 2ab1a2189..25c8ddc42 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -3,12 +3,15 @@ #include "battle_interface.h" #include "item.h" #include "link.h" +#include "m4a.h" #include "main.h" #include "menu_cursor.h" +#include "palette.h" #include "pokemon.h" #include "rom3.h" #include "songs.h" #include "sound.h" +#include "task.h" #include "text.h" #include "util.h" @@ -32,6 +35,10 @@ extern struct Window gUnknown_03004210; extern const u8 gUnknown_08400D89[]; extern u8 gUnknown_03004348; extern struct BattlePokemon gBattleMons[]; +extern MainCallback gPreBattleCallback1; +extern u8 gHealthboxIDs[]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u8 gUnknown_0300434C[]; extern void dp11b_obj_instanciate(u8, u8, s8, s8); extern u8 GetBankIdentity(u8); @@ -45,6 +52,9 @@ extern void sub_802E220(); extern void sub_802E2D4(); extern void sub_802E12C(); extern void sub_802E1B0(void); +extern bool8 IsDoubleBattle(); +extern void sub_804777C(); +extern void sub_8141828(); void PlayerHandleGetAttributes(void); void sub_802ECF0(void); @@ -173,6 +183,11 @@ void PlayerBufferRunCommand(void); void sub_802C2EC(void); void sub_802C68C(void); void sub_802CA60(void); +void sub_802D730(void); +void sub_802DA9C(u8); +void sub_802DB6C(u8); +void sub_802DCB0(u8); +void sub_802DDC4(u8); void nullsub_91(void) { @@ -455,7 +470,7 @@ struct UnknownStruct1 u8 unkC[0x12-0xC]; u8 unk12; u8 unk13; - u8 filler14[0x20-0x14]; + u8 filler14[0x20-0x14]; }; void sub_802C68C(void) @@ -598,172 +613,501 @@ extern const u8 gUnknown_08400D38[]; void sub_802CA60(void) { - u8 perMovePPBonuses[4]; - struct - { - u16 moves[4]; - u8 pp[4]; - u8 filler18[8]; // what is this? - } sp0; - //struct UnknownStruct1 sp0; - u8 totalPPBonuses; - - if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) - { - PlaySE(SE_SELECT); - if (gMoveSelectionCursor[gActiveBank] != gUnknown_03004344) - { - struct UnknownStruct1 *r9 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - s32 i; - - i = r9->moves[gMoveSelectionCursor[gActiveBank]]; - r9->moves[gMoveSelectionCursor[gActiveBank]] = r9->moves[gUnknown_03004344]; - r9->moves[gUnknown_03004344] = i; - - i = r9->pp[gMoveSelectionCursor[gActiveBank]]; - r9->pp[gMoveSelectionCursor[gActiveBank]] = r9->pp[gUnknown_03004344]; - r9->pp[gUnknown_03004344] = i; - - i = r9->unkC[gMoveSelectionCursor[gActiveBank]]; - r9->unkC[gMoveSelectionCursor[gActiveBank]] = r9->unkC[gUnknown_03004344]; - r9->unkC[gUnknown_03004344] = i; - - if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) - { - gDisableStructs[gActiveBank].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBank]]; - gDisableStructs[gActiveBank].unk18_b |= gBitTable[gUnknown_03004344]; - } - - sub_802E1B0(); - - for (i = 0; i < 4; i++) - perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; - perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; - - totalPPBonuses = 0; - for (i = 0; i < 4; i++) - totalPPBonuses |= perMovePPBonuses[i] << (i * 2); - gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; - - for (i = 0; i < 4; i++) - { - gBattleMons[gActiveBank].moves[i] = r9->moves[i]; - gBattleMons[gActiveBank].pp[i] = r9->pp[i]; - } - if (!(gBattleMons[gActiveBank].status2 & 0x200000)) - { - for (i = 0; i < 4; i++) - { - sp0.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); - sp0.pp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); - } - - totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); - for (i = 0; i < 4; i++) - perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); - - i = sp0.moves[gMoveSelectionCursor[gActiveBank]]; - sp0.moves[gMoveSelectionCursor[gActiveBank]] = sp0.moves[gUnknown_03004344]; - sp0.moves[gUnknown_03004344] = i; - - i = sp0.pp[gMoveSelectionCursor[gActiveBank]]; - sp0.pp[gMoveSelectionCursor[gActiveBank]] = sp0.pp[gUnknown_03004344]; - sp0.pp[gUnknown_03004344] = i; - - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; - perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; - - totalPPBonuses = 0; - for (i = 0; i < 4; i++) - totalPPBonuses |= perMovePPBonuses[i] << (i * 2); - - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, (u8 *)&sp0.moves[i]); - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &sp0.pp[i]); - } - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); - } - } - else - { - sub_802E12C(gUnknown_03004344, gUnknown_08400D49); - } - gBattleBankFunc[gActiveBank] = sub_802C68C; - gMoveSelectionCursor[gActiveBank] = gUnknown_03004344; - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); - sub_8002F44(&gUnknown_03004210); - sub_802E220(); - sub_802E2D4(); - } - if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) - { - PlaySE(SE_SELECT); - nullsub_7(gUnknown_03004344); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_08400D49); - gBattleBankFunc[gActiveBank] = sub_802C68C; - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); - sub_8002F44(&gUnknown_03004210); - sub_802E220(); - sub_802E2D4(); - } - if ((gMain.newKeys & DPAD_LEFT) && (gUnknown_03004344 & 1)) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 1; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_RIGHT) && !(gUnknown_03004344 & 1) && (gUnknown_03004344 ^ 1) < gUnknown_03004348) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 1; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_UP) && (gUnknown_03004344 & 2)) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 2; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_DOWN) && !(gUnknown_03004344 & 2) && (gUnknown_03004344 ^ 2) < gUnknown_03004348) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 2; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } + u8 perMovePPBonuses[4]; + struct + { + u16 moves[4]; + u8 pp[4]; + u8 filler18[8]; // what is this? + } sp0; + //struct UnknownStruct1 sp0; + u8 totalPPBonuses; + + if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + if (gMoveSelectionCursor[gActiveBank] != gUnknown_03004344) + { + struct UnknownStruct1 *r9 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + s32 i; + + i = r9->moves[gMoveSelectionCursor[gActiveBank]]; + r9->moves[gMoveSelectionCursor[gActiveBank]] = r9->moves[gUnknown_03004344]; + r9->moves[gUnknown_03004344] = i; + + i = r9->pp[gMoveSelectionCursor[gActiveBank]]; + r9->pp[gMoveSelectionCursor[gActiveBank]] = r9->pp[gUnknown_03004344]; + r9->pp[gUnknown_03004344] = i; + + i = r9->unkC[gMoveSelectionCursor[gActiveBank]]; + r9->unkC[gMoveSelectionCursor[gActiveBank]] = r9->unkC[gUnknown_03004344]; + r9->unkC[gUnknown_03004344] = i; + + if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) + { + gDisableStructs[gActiveBank].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBank]]; + gDisableStructs[gActiveBank].unk18_b |= gBitTable[gUnknown_03004344]; + } + + sub_802E1B0(); + + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; + + for (i = 0; i < 4; i++) + { + gBattleMons[gActiveBank].moves[i] = r9->moves[i]; + gBattleMons[gActiveBank].pp[i] = r9->pp[i]; + } + if (!(gBattleMons[gActiveBank].status2 & 0x200000)) + { + for (i = 0; i < 4; i++) + { + sp0.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); + sp0.pp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); + } + + totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); + + i = sp0.moves[gMoveSelectionCursor[gActiveBank]]; + sp0.moves[gMoveSelectionCursor[gActiveBank]] = sp0.moves[gUnknown_03004344]; + sp0.moves[gUnknown_03004344] = i; + + i = sp0.pp[gMoveSelectionCursor[gActiveBank]]; + sp0.pp[gMoveSelectionCursor[gActiveBank]] = sp0.pp[gUnknown_03004344]; + sp0.pp[gUnknown_03004344] = i; + + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, (u8 *)&sp0.moves[i]); + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &sp0.pp[i]); + } + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); + } + } + else + { + sub_802E12C(gUnknown_03004344, gUnknown_08400D49); + } + gBattleBankFunc[gActiveBank] = sub_802C68C; + gMoveSelectionCursor[gActiveBank] = gUnknown_03004344; + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + nullsub_7(gUnknown_03004344); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_08400D49); + gBattleBankFunc[gActiveBank] = sub_802C68C; + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if ((gMain.newKeys & DPAD_LEFT) && (gUnknown_03004344 & 1)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_RIGHT) && !(gUnknown_03004344 & 1) && (gUnknown_03004344 ^ 1) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_UP) && (gUnknown_03004344 & 2)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_DOWN) && !(gUnknown_03004344 & 2) && (gUnknown_03004344 ^ 2) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } +} + +void sub_802D148(void) +{ + if (gReceivedRemoteLinkPlayers == 0) + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(c2_8011A1C); + } +} + +void sub_802D18C(void) +{ + if (!gPaletteFade.active) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + sub_800832C(); + gBattleBankFunc[gActiveBank] = sub_802D148; + } + else + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + } +} + +void sub_802D204(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +// duplicate of sub_802D204 +void sub_802D23C(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +void sub_802D274(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_10(gSaveBlock2.playerGender); + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + PlayerBufferExecCompleted(); + } +} + +void sub_802D2E0(void) +{ + if (--ewram17810[gActiveBank].unk9 == 0xFF) + { + ewram17810[gActiveBank].unk9 = 0; + PlayerBufferExecCompleted(); + } +} + +void sub_802D31C(void) +{ + bool8 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + ewram17810[gActiveBank ^ 2].unk0_7 = 0; + ewram17810[gActiveBank ^ 2].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + m4aMPlayContinue(&gMPlay_BGM); + else + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + if (IsDoubleBattle()) + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], gActiveBank ^ 2); + ewram17810[gActiveBank].unk9 = 3; + gBattleBankFunc[gActiveBank] = sub_802D2E0; + } +} + +void sub_802D500(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) + sub_8141828(gActiveBank ^ 2, &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]]); + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank ^ 2], + &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], + 0); + sub_804777C(gActiveBank ^ 2); + sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); + } + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank], + &gPlayerParty[gBattlePartyID[gActiveBank]], + 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + ewram17840.unk9_0 = 0; + gBattleBankFunc[gActiveBank] = sub_802D31C; + } +} + +void sub_802D680(void) +{ + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && ewram17810[gActiveBank].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + gBattleBankFunc[gActiveBank] = sub_802D730; + } +} + +void sub_802D730(void) +{ + if (!ewram17810[gActiveBank].unk0_6 && !IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void sub_802D798(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy + && !ewram17810[gActiveBank].unk0_3) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + sub_8031F88(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_802D680; + } +} + +void c3_0802FDF4(u8 taskId) +{ + if (!IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + DestroyTask(taskId); + } +} + +void bx_t1_healthbar_update(void) +{ + s16 r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); + + sub_8043DFC(gHealthboxIDs[gActiveBank]); + if (r4 != -1) + { + sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); + } + else + { + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void sub_802D90C(void) +{ + if (gUnknown_03004210.state == 0) + PlayerBufferExecCompleted(); +} + +// Rare Candy usage, maybe? +void sub_802D924(u8 taskId) +{ + u32 pkmnIndex = (u8)gTasks[taskId].data[0]; + u8 bank = gTasks[taskId].data[2]; + s16 gainedExp = gTasks[taskId].data[1]; + + if (IsDoubleBattle() == TRUE || pkmnIndex != gBattlePartyID[bank]) + { + struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; + u16 species = GetMonData(pkmn, MON_DATA_SPECIES); + u8 level = GetMonData(pkmn, MON_DATA_LEVEL); + u32 currExp = GetMonData(pkmn, MON_DATA_EXP); + u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= nextLvlExp) + { + u8 savedActiveBank; + + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&nextLvlExp); + CalculateMonStats(pkmn); + gainedExp -= nextLvlExp - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + dp01_build_cmdbuf_x21_a_bb(1, 11, gainedExp); + gActiveBank = savedActiveBank; + + if (IsDoubleBattle() == TRUE + && ((u16)pkmnIndex == gBattlePartyID[bank] || (u16)pkmnIndex == gBattlePartyID[bank ^ 2])) + gTasks[taskId].func = sub_802DCB0; + else + gTasks[taskId].func = sub_802DDC4; + } + else + { + currExp += gainedExp; + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&currExp); + gBattleBankFunc[bank] = sub_802D90C; + DestroyTask(taskId); + } + } + else + { + gTasks[taskId].func = sub_802DA9C; + } +} + +void sub_802DA9C(u8 taskId) +{ + u8 pkmnIndex = gTasks[taskId].data[0]; + s32 r9 = gTasks[taskId].data[1]; + u8 bank = gTasks[taskId].data[2]; + struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; + u8 level = GetMonData(pkmn, MON_DATA_LEVEL); + u16 species = GetMonData(pkmn, MON_DATA_SPECIES); + u32 exp = GetMonData(pkmn, MON_DATA_EXP); + u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level]; + u32 expToNextLvl; + + exp -= currLvlExp; + expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp; + sub_8043D84(bank, gHealthboxIDs[bank], expToNextLvl, exp, -r9); + PlaySE(SE_EXP); + gTasks[taskId].func = sub_802DB6C; +} + +/* +void sub_802DB6C(u8 taskId) +{ + if (gTasks[taskId].data[10] < 13) + { + gTasks[taskId].data[10]++; + } + else + { + u8 r9 = gTasks[taskId].data[0]; + s32 r10 = gTasks[taskId].data[1]; //s16? + u8 r7 = gTasks[taskId].data[2]; + s16 r4; + + r4 = sub_8045C78(r7, gHealthboxIDs[r7], 1, 0); + sub_8043DFC(gHealthboxIDs[r7]); + if (r4 == -1) + { + struct Pokemon *pkmn; + u8 r4; + u32 sp4; + u16 r0; + u32 sp0; + + m4aSongNumStop(SE_EXP); + pkmn = &gPlayerParty[r9]; + r4 = GetMonData(pkmn, MON_DATA_LEVEL); + sp4 = GetMonData(pkmn, MON_DATA_EXP); + r0 = GetMonData(pkmn, MON_DATA_SPECIES); + sp0 = gExperienceTables[gBaseStats[r0].growthRate][r4 + 1]; + if (sp4 + r10 >= sp0) + { + u8 r5; + u32 asdf; + + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp0); + CalculateMonStats(pkmn); + //r10 -= sp0 - sp4; + asdf = sp0 - sp4; + //asdf = r10 - (sp0 - sp4); + r10 -= asdf; + r5 = gActiveBank; + gActiveBank = r7; + dp01_build_cmdbuf_x21_a_bb(1, 11, r10); + gActiveBank = r5; + gTasks[taskId].func = sub_802DCB0; + } + else + { + //u32 asdf = sp4 + r10; + sp4 += r10; + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp4); + gBattleBankFunc[r7] = sub_802D90C; + DestroyTask(taskId); + } + } + } } +*/ -- cgit v1.2.3 From 2f736ac868f0db520052915c64323423f15143ec Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Wed, 16 Aug 2017 19:42:14 -0500 Subject: decompile sub_802DCB0 - sub_802E1B0 --- src/battle_5.c | 349 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 345 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index 25c8ddc42..f7dff5e70 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -1,4 +1,5 @@ #include "global.h" +#include "data2.h" #include "battle.h" #include "battle_interface.h" #include "item.h" @@ -11,6 +12,7 @@ #include "rom3.h" #include "songs.h" #include "sound.h" +#include "string_util.h" #include "task.h" #include "text.h" #include "util.h" @@ -28,7 +30,7 @@ extern u8 gAbsentBankFlags; extern u8 gUnknown_03004344; extern u8 gNoOfAllBanks; extern u16 gBattlePartyID[]; -extern const struct BattleMove gBattleMoves[]; +//extern const struct BattleMove gBattleMoves[]; extern u16 gUnknown_030042A0; extern u16 gUnknown_030042A4; extern struct Window gUnknown_03004210; @@ -39,6 +41,11 @@ extern MainCallback gPreBattleCallback1; extern u8 gHealthboxIDs[]; extern struct MusicPlayerInfo gMPlay_BGM; extern u8 gUnknown_0300434C[]; +extern u8 gUnknown_0202E8F4; +extern u8 gUnknown_0202E8F5; +extern u8 gUnknown_02038470[]; +extern u16 gScriptItemId; +extern u8 gDisplayedStringBattle[]; extern void dp11b_obj_instanciate(u8, u8, s8, s8); extern u8 GetBankIdentity(u8); @@ -50,11 +57,15 @@ extern void nullsub_7(u8); extern void sub_802E3B4(); extern void sub_802E220(); extern void sub_802E2D4(); -extern void sub_802E12C(); +extern void sub_802E12C(s32, const u8 *); extern void sub_802E1B0(void); extern bool8 IsDoubleBattle(); extern void sub_804777C(); extern void sub_8141828(); +extern void sub_8094E20(u8); +extern void b_link_standby_message(void); +extern void nullsub_14(void); +extern void sub_80A6DCC(void); void PlayerHandleGetAttributes(void); void sub_802ECF0(void); @@ -187,7 +198,10 @@ void sub_802D730(void); void sub_802DA9C(u8); void sub_802DB6C(u8); void sub_802DCB0(u8); +void sub_802DD10(u8); void sub_802DDC4(u8); +void sub_802DF88(void); +void sub_802E03C(void); void nullsub_91(void) { @@ -1052,7 +1066,7 @@ void sub_802DA9C(u8 taskId) gTasks[taskId].func = sub_802DB6C; } -/* +#ifdef NONMATCHING void sub_802DB6C(u8 taskId) { if (gTasks[taskId].data[10] < 13) @@ -1110,4 +1124,331 @@ void sub_802DB6C(u8 taskId) } } } -*/ +#else +__attribute__((naked)) +void sub_802DB6C(u8 taskId) +{ + asm_unified("push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x8\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r8, r0\n\ + ldr r1, _0802DB98 @ =gTasks\n\ + lsls r0, 2\n\ + add r0, r8\n\ + lsls r0, 3\n\ + adds r6, r0, r1\n\ + ldrh r1, [r6, 0x1C]\n\ + movs r2, 0x1C\n\ + ldrsh r0, [r6, r2]\n\ + cmp r0, 0xC\n\ + bgt _0802DB9C\n\ + adds r0, r1, 0x1\n\ + strh r0, [r6, 0x1C]\n\ + b _0802DC98\n\ + .align 2, 0\n\ +_0802DB98: .4byte gTasks\n\ +_0802DB9C:\n\ + ldrb r0, [r6, 0x8]\n\ + mov r9, r0\n\ + ldrh r2, [r6, 0xA]\n\ + mov r10, r2\n\ + ldrb r7, [r6, 0xC]\n\ + ldr r5, _0802DC64 @ =gHealthboxIDs\n\ + adds r5, r7, r5\n\ + ldrb r1, [r5]\n\ + adds r0, r7, 0\n\ + movs r2, 0x1\n\ + movs r3, 0\n\ + bl sub_8045C78\n\ + adds r4, r0, 0\n\ + lsls r4, 16\n\ + lsrs r4, 16\n\ + ldrb r0, [r5]\n\ + bl sub_8043DFC\n\ + lsls r4, 16\n\ + asrs r4, 16\n\ + movs r0, 0x1\n\ + negs r0, r0\n\ + cmp r4, r0\n\ + bne _0802DC98\n\ + movs r0, 0x21\n\ + bl m4aSongNumStop\n\ + movs r0, 0x64\n\ + mov r1, r9\n\ + muls r1, r0\n\ + ldr r0, _0802DC68 @ =gPlayerParty\n\ + adds r5, r1, r0\n\ + adds r0, r5, 0\n\ + movs r1, 0x38\n\ + bl GetMonData\n\ + adds r4, r0, 0\n\ + lsls r4, 24\n\ + lsrs r4, 24\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + bl GetMonData\n\ + str r0, [sp, 0x4]\n\ + adds r0, r5, 0\n\ + movs r1, 0xB\n\ + bl GetMonData\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + ldr r3, _0802DC6C @ =gExperienceTables\n\ + adds r4, 0x1\n\ + lsls r4, 2\n\ + ldr r2, _0802DC70 @ =gBaseStats\n\ + lsls r1, r0, 3\n\ + subs r1, r0\n\ + lsls r1, 2\n\ + adds r1, r2\n\ + ldrb r1, [r1, 0x13]\n\ + movs r0, 0xCA\n\ + lsls r0, 1\n\ + muls r0, r1\n\ + adds r4, r0\n\ + adds r4, r3\n\ + ldr r1, [r4]\n\ + str r1, [sp]\n\ + mov r2, r10\n\ + lsls r0, r2, 16\n\ + asrs r4, r0, 16\n\ + ldr r0, [sp, 0x4]\n\ + adds r0, r4\n\ + cmp r0, r1\n\ + blt _0802DC7C\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + mov r2, sp\n\ + bl SetMonData\n\ + adds r0, r5, 0\n\ + bl CalculateMonStats\n\ + ldr r2, [sp]\n\ + add r0, sp, 0x4\n\ + ldrh r0, [r0]\n\ + subs r2, r0\n\ + subs r2, r4, r2\n\ + ldr r4, _0802DC74 @ =gActiveBank\n\ + ldrb r5, [r4]\n\ + strb r7, [r4]\n\ + lsls r2, 16\n\ + lsrs r2, 16\n\ + movs r0, 0x1\n\ + movs r1, 0xB\n\ + bl dp01_build_cmdbuf_x21_a_bb\n\ + strb r5, [r4]\n\ + ldr r0, _0802DC78 @ =sub_802DCB0\n\ + str r0, [r6]\n\ + b _0802DC98\n\ + .align 2, 0\n\ +_0802DC64: .4byte gHealthboxIDs\n\ +_0802DC68: .4byte gPlayerParty\n\ +_0802DC6C: .4byte gExperienceTables\n\ +_0802DC70: .4byte gBaseStats\n\ +_0802DC74: .4byte gActiveBank\n\ +_0802DC78: .4byte sub_802DCB0\n\ +_0802DC7C:\n\ + str r0, [sp, 0x4]\n\ + add r2, sp, 0x4\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + bl SetMonData\n\ + ldr r1, _0802DCA8 @ =gBattleBankFunc\n\ + lsls r0, r7, 2\n\ + adds r0, r1\n\ + ldr r1, _0802DCAC @ =sub_802D90C\n\ + str r1, [r0]\n\ + mov r0, r8\n\ + bl DestroyTask\n\ +_0802DC98:\n\ + add sp, 0x8\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_0802DCA8: .4byte gBattleBankFunc\n\ +_0802DCAC: .4byte sub_802D90C\n"); +} +#endif + +void sub_802DCB0(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + u8 pkmnIndex = gTasks[taskId].data[0]; + + if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) + bank ^= 2; + move_anim_start_t4(bank, bank, bank, 0); + gTasks[taskId].func = sub_802DD10; +} + +void sub_802DD10(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + + if (!ewram17810[bank].unk0_6) + { + u8 pkmnIndex = gTasks[taskId].data[0]; + + GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value + if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) + sub_8045A5C(gHealthboxIDs[bank ^ 2], &gPlayerParty[pkmnIndex], 0); + else + sub_8045A5C(gHealthboxIDs[bank], &gPlayerParty[pkmnIndex], 0); + gTasks[taskId].func = sub_802DDC4; + } +} + +void sub_802DDC4(u8 taskId) +{ + u8 pkmnIndex; + u8 bank; + + pkmnIndex = gTasks[taskId].data[0]; + GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value + bank = gTasks[taskId].data[2]; + gBattleBankFunc[bank] = sub_802D90C; + DestroyTask(taskId); +} + +void sub_802DE10(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_9(species); + FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void sub_802DEAC(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +// Duplicate of sub_802D90C +void sub_802DF18(void) +{ + if (gUnknown_03004210.state == 0) + PlayerBufferExecCompleted(); +} + +void sub_802DF30(void) +{ + if (!gPaletteFade.active) + { + u8 r4; + + gBattleBankFunc[gActiveBank] = sub_802DF88; + r4 = gTasks[gUnknown_0300434C[gActiveBank]].data[0]; + DestroyTask(gUnknown_0300434C[gActiveBank]); + sub_8094E20(r4); + } +} + +void sub_802DF88(void) +{ + if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) + { + if (gUnknown_0202E8F4 == 1) + dp01_build_cmdbuf_x22_a_three_bytes(1, gUnknown_0202E8F5, gUnknown_02038470); + else + dp01_build_cmdbuf_x22_a_three_bytes(1, 6, NULL); + if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1) + b_link_standby_message(); + PlayerBufferExecCompleted(); + } +} + +void sub_802E004(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = sub_802E03C; + nullsub_14(); + sub_80A6DCC(); + } +} + +void sub_802E03C(void) +{ + if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) + { + dp01_build_cmdbuf_x23_aa_0(1, gScriptItemId); + PlayerBufferExecCompleted(); + } +} + +void bx_wait_t1(void) +{ + if (!gDoingBattleAnim || !ewram17810[gActiveBank].unk0_6) + PlayerBufferExecCompleted(); +} + +void bx_blink_t1(void) +{ + u8 spriteId = gObjectBankIDs[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = 0; + PlayerBufferExecCompleted(); + } + else + { + if (((u16)gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_802E12C(s32 a, const u8 *b) +{ + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + + StringCopy(gDisplayedStringBattle, b); + StringAppend(gDisplayedStringBattle, gMoveNames[r4->moves[a]]); + InitWindow( + &gUnknown_03004210, + gDisplayedStringBattle, + 0x300 + a * 20, + (a & 1) ? 11 : 1, + (a < 2) ? 0x37 : 0x39); + sub_8002F44(&gUnknown_03004210); +} + +void sub_802E1B0(void) +{ + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + s32 i; + + gUnknown_03004348 = 0; + FillWindowRect(&gUnknown_03004210, 0x1016, 1, 0x37, 0x14, 0x3A); + for (i = 0; i < 4; i++) + { + nullsub_7(i); + sub_802E12C(i, gUnknown_08400D49); + if (r4->moves[i] != 0) + gUnknown_03004348++; + } +} -- cgit v1.2.3 From e9ec2a1a561d3041b8df2cb512a0e03ff5bca74b Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Thu, 17 Aug 2017 21:05:59 +0200 Subject: start decompiling battle transition --- src/battle_setup.c | 4 +- src/battle_transition.c | 302 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 304 insertions(+), 2 deletions(-) create mode 100644 src/battle_transition.c (limited to 'src') diff --git a/src/battle_setup.c b/src/battle_setup.c index 04674e739..31c127416 100644 --- a/src/battle_setup.c +++ b/src/battle_setup.c @@ -438,7 +438,7 @@ void task01_battle_start(u8 taskId) } break; case 1: - if (sub_811AAE8() == TRUE) + if (IsBattleTransitionDone() == TRUE) { SetMainCallback2(sub_800E7C4); prev_quest_postbuffer_cursor_backup_reset(); @@ -827,7 +827,7 @@ void CB2_StartFirstBattle(void) UpdatePaletteFade(); RunTasks(); - if (sub_811AAE8() == TRUE) + if (IsBattleTransitionDone() == TRUE) { gBattleTypeFlags = BATTLE_TYPE_FIRST_BATTLE; gMain.savedCallback = HandleFirstBattleEnd; diff --git a/src/battle_transition.c b/src/battle_transition.c new file mode 100644 index 000000000..35d3baf0c --- /dev/null +++ b/src/battle_transition.c @@ -0,0 +1,302 @@ +#include "global.h" +#include "main.h" +#include "rom4.h" +#include "task.h" +#include "palette.h" +#include "trig.h" + +void sub_807DE10(void); +void dp12_8087EA4(void); + +typedef bool8 (*TransitionState)(struct Task* task); + +extern const TransitionState sMainTransitionPhases[]; +extern const TransitionState sPhase2_Transition0_Funcs[]; +extern const TransitionState sPhase2_Transition1_Funcs[]; +extern const TransitionState sPhase2_Transition2_Funcs[]; + +extern const TaskFunc sPhase1_Tasks[]; +extern const TaskFunc sPhase2_Tasks[]; + +extern u8 ewram[]; +extern s16 gUnknown_03005560[]; + +extern u16 gUnknown_03004DE0[][0x3C0]; + +struct TransitionData +{ + vs8 field_0; // now that's interesting + s8 field_1; + s16 field_2; + s16 field_4; + s16 field_6; + s16 field_8; + s16 field_A; + s16 field_C; + s16 field_E; + s16 field_10; + s16 field_12; + s16 field_14; + s16 field_16; + s16 field_18; +}; + +#define TRANSITION_STRUCT (*(struct TransitionData *) (&ewram[0xC000])) + +// this file's functions +static void LaunchBattleTransitionTask(u8 transitionID); +static void Task_BattleTransitionMain(u8 taskID); +void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +bool8 sub_811D52C(void); +void sub_811D658(void); +static void VBlankCB_Phase2_Transition1(void); +static void HBlankCB_Phase2_Transition1(void); +void VBlankCB_Phase2_Transition2(void); +void HBlankCB_Phase2_Transition2(void); +void VBlankCB_BattleTransition(void); +void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); + +void sub_811AABC(u8 transitionID) +{ + gMain.callback2 = sub_8054398; + LaunchBattleTransitionTask(transitionID); +} + +void sub_811AAD8(u8 transitionID) +{ + LaunchBattleTransitionTask(transitionID); +} + +#define tState data[0] +#define tTransitionID data[1] +#define tTransitionDone data[15] + +bool8 IsBattleTransitionDone(void) +{ + u8 taskID = FindTaskIdByFunc(Task_BattleTransitionMain); + if (gTasks[taskID].tTransitionDone) + { + DestroyTask(taskID); + return 1; + } + else + return 0; +} + +static void LaunchBattleTransitionTask(u8 transitionID) +{ + u8 taskID = CreateTask(Task_BattleTransitionMain, 2); + gTasks[taskID].tTransitionID = transitionID; +} + +static void Task_BattleTransitionMain(u8 taskID) +{ + while (sMainTransitionPhases[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Transition_Phase1(struct Task* task) +{ + sub_807DE10(); + CpuSet(gPlttBufferFaded, gPlttBufferUnfaded, 0x4000100); + if (sPhase1_Tasks[task->tTransitionID] != NULL) + { + CreateTask(sPhase1_Tasks[task->tTransitionID], 4); + task->tState++; + return 0; + } + else + { + task->tState = 2; + return 1; + } +} + +bool8 Transition_WaitForPhase1(struct Task* task) +{ + if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionID]) == 0xFF) + { + task->tState++; + return 1; + } + else + return 0; +} + +bool8 Transition_Phase2(struct Task* task) +{ + CreateTask(sPhase2_Tasks[task->tTransitionID], 0); + task->tState++; + return 0; +} + +bool8 Transition_WaitForPhase2(struct Task* task) +{ + task->tTransitionDone = 0; + if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionID]) == 0xFF) + task->tTransitionDone = 1; + return 0; +} + +void Phase1Task_TransitionAll(u8 taskID) +{ + if (gTasks[taskID].tState == 0) + { + gTasks[taskID].tState++; + sub_811D4C8(0, 0, 3, 2, 2); + } + else if (sub_811D52C()) + DestroyTask(taskID); +} + +void Phase2Task_Transition0(u8 taskID) +{ + while (sPhase2_Transition0_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition0_Func1(struct Task* task) +{ + REG_MOSAIC = 0; + REG_BG1CNT |= 0x40; + REG_BG2CNT |= 0x40; + REG_BG3CNT |= 0x40; + task->tState++; + return 1; +} + +bool8 Phase2_Transition0_Func2(struct Task* task) +{ + if (task->data[1] != 0) + task->data[1]--; + else + { + task->data[1] = 4; + if (++task->data[2] == 10) + BeginNormalPaletteFade(-1, -1, 0, 0x10, 0); + REG_MOSAIC = (task->data[2] & 15) * 17; + if (task->data[2] > 14) + task->tState++; + } + return 0; +} + +bool8 Phase2_Transition0_Func3(struct Task* task) +{ + if (!gPaletteFade.active) + { + u8 taskID = FindTaskIdByFunc(Phase2Task_Transition0); + DestroyTask(taskID); + } + return 0; +} + +void Phase2Task_Transition1(u8 taskID) +{ + while (sPhase2_Transition1_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition1_Func1(struct Task* task) +{ + u16 savedIME; + + sub_811D658(); + dp12_8087EA4(); + BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); + sub_811D6E8(gUnknown_03005560, TRANSITION_STRUCT.field_14, 0, 2, 0, 160); + + SetVBlankCallback(VBlankCB_Phase2_Transition1); + SetHBlankCallback(HBlankCB_Phase2_Transition1); + + savedIME = REG_IME; + REG_IME = 0; + REG_IE |= 3; + REG_IME = savedIME; + REG_DISPSTAT |= 0x18; + + task->tState++; + return 0; +} + +bool8 Phase2_Transition1_Func2(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + task->data[1] += 4; + task->data[2] += 8; + + sub_811D6E8(gUnknown_03004DE0[0], TRANSITION_STRUCT.field_14, task->data[1], 2, task->data[2], 160); + + if (!gPaletteFade.active) + { + u8 taskID = FindTaskIdByFunc(Phase2Task_Transition1); + DestroyTask(taskID); + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +static void VBlankCB_Phase2_Transition1(void) +{ + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); +} + +static void HBlankCB_Phase2_Transition1(void) +{ + u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; + REG_BG1HOFS = var; + REG_BG2HOFS = var; + REG_BG3HOFS = var; +} + +void Phase2Task_Transition2(u8 taskID) +{ + while (sPhase2_Transition2_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition2_Func1(struct Task* task) +{ + u16 savedIME; + + sub_811D658(); + dp12_8087EA4(); + + BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); + memset(gUnknown_03005560, TRANSITION_STRUCT.field_16, 0x140); + + SetVBlankCallback(VBlankCB_Phase2_Transition2); + SetHBlankCallback(HBlankCB_Phase2_Transition2); + + savedIME = REG_IME; + REG_IME = 0; + REG_IE |= 3; + REG_IME = savedIME; + REG_DISPSTAT |= 0x18; + + task->tState++; + return 0; +} + +bool8 Phase2_Transition2_Func2(struct Task* task) +{ + u8 i; + u16 r3, r4; + + TRANSITION_STRUCT.field_0 = 0; + r4 = task->data[1]; + r3 = task->data[2] >> 8; + task->data[1] += 4224; + task->data[2] += 384; + + for (i = 0; i < 160; i++, r4 += 4224) + { + u16 var = r4 / 256; + gUnknown_03004DE0[0][i] = Sin(var, r3) + TRANSITION_STRUCT.field_16; + } + + if (!gPaletteFade.active) + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition2)); + + TRANSITION_STRUCT.field_0++; + return 0; +} -- cgit v1.2.3 From 6ce3827987f48f4ba13f67d38382decd8206d00d Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 18 Aug 2017 18:25:44 +0200 Subject: cam fixed a function yay --- src/battle_transition.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 35d3baf0c..47adccf21 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -41,7 +41,7 @@ struct TransitionData s16 field_18; }; -#define TRANSITION_STRUCT (*(struct TransitionData *) (&ewram[0xC000])) +#define TRANSITION_STRUCT (*(struct TransitionData *) (ewram + 0xC000)) // this file's functions static void LaunchBattleTransitionTask(u8 transitionID); @@ -291,7 +291,7 @@ bool8 Phase2_Transition2_Func2(struct Task* task) for (i = 0; i < 160; i++, r4 += 4224) { u16 var = r4 / 256; - gUnknown_03004DE0[0][i] = Sin(var, r3) + TRANSITION_STRUCT.field_16; + gUnknown_03004DE0[0][i] = TRANSITION_STRUCT.field_16 + Sin(var, r3); } if (!gPaletteFade.active) -- cgit v1.2.3 From f25425cf7de8da73f371ab587275f45e774070a0 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 18 Aug 2017 19:42:44 +0200 Subject: started transition3 phase2 --- src/battle_transition.c | 90 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 88 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 47adccf21..ed6bdf387 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -14,6 +14,7 @@ extern const TransitionState sMainTransitionPhases[]; extern const TransitionState sPhase2_Transition0_Funcs[]; extern const TransitionState sPhase2_Transition1_Funcs[]; extern const TransitionState sPhase2_Transition2_Funcs[]; +extern const TransitionState sPhase2_Transition3_Funcs[]; extern const TaskFunc sPhase1_Tasks[]; extern const TaskFunc sPhase2_Tasks[]; @@ -49,12 +50,16 @@ static void Task_BattleTransitionMain(u8 taskID); void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); bool8 sub_811D52C(void); void sub_811D658(void); + static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); -void VBlankCB_Phase2_Transition2(void); -void HBlankCB_Phase2_Transition2(void); +static void VBlankCB_Phase2_Transition2(void); +static void HBlankCB_Phase2_Transition2(void); +void VBlankCB_Phase2_Transition3(void); + void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); +void sub_811D6A8(u16** a0, u16** a1); void sub_811AABC(u8 transitionID) { @@ -300,3 +305,84 @@ bool8 Phase2_Transition2_Func2(struct Task* task) TRANSITION_STRUCT.field_0++; return 0; } + +static void VBlankCB_Phase2_Transition2(void) +{ + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); +} + +static void HBlankCB_Phase2_Transition2(void) +{ + u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; + REG_BG1VOFS = var; + REG_BG2VOFS = var; + REG_BG3VOFS = var; +} + +void Phase2Task_Transition3(u8 taskID) +{ + while (sPhase2_Transition3_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +extern const u8 gUnknown_083FBB88[]; +extern const u16 gFieldEffectObjectPalette10[]; + +bool8 Phase2_Transition3_Func1(struct Task* task) +{ + u16 i; + u16 *dst1, *dst2; + + sub_811D658(); + dp12_8087EA4(); + + task->data[1] = 16; + task->data[2] = 0; + task->data[4] = 0; + task->data[5] = 0x4000; + TRANSITION_STRUCT.field_2 = 63; + TRANSITION_STRUCT.field_4 = 0; + TRANSITION_STRUCT.field_6 = 240; + TRANSITION_STRUCT.field_8 = 160; + TRANSITION_STRUCT.field_E = 0x3F41; + TRANSITION_STRUCT.field_10 = task->data[1] * 256; // 16 * 256 = 0x1000 + + for (i = 0; i < 160; i++) + { + gUnknown_03005560[i] = 240; + } + + SetVBlankCallback(VBlankCB_Phase2_Transition3); + + sub_811D6A8(&dst1, & dst2); + CpuFill16(0, dst1, 0x800); + CpuSet(gUnknown_083FBB88, dst2, 0x2C0); + LoadPalette(gFieldEffectObjectPalette10, 240, 32); + + task->tState++; + return 0; +} + +extern const u16 gUnknown_083FDB44[]; + +bool8 Phase2_Transition3_Func2(struct Task* task) +{ + s16 i, j; + u16 *dst1, *dst2; + const u16* var; + + var = gUnknown_083FDB44; + sub_811D6A8(&dst1, &dst2); + for (i = 0; i < 20; i++) + { + for (j = 0; j < 30; j++, var++) + { + dst1[i * 32 + j] = *var | 0xF000; + } + } + sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5], 160); + + task->tState++; + return 1; +} -- cgit v1.2.3 From 3e7bdf4f5fd54676c6f965325ec5b67d3d8b3eef Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Fri, 18 Aug 2017 17:08:36 -0500 Subject: finish decompiling battle_5 --- src/battle_5.c | 185 +++++++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 155 insertions(+), 30 deletions(-) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index f7dff5e70..c54caae92 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -3,10 +3,12 @@ #include "battle.h" #include "battle_interface.h" #include "item.h" +#include "items.h" #include "link.h" #include "m4a.h" #include "main.h" #include "menu_cursor.h" +#include "moves.h" #include "palette.h" #include "pokemon.h" #include "rom3.h" @@ -46,6 +48,7 @@ extern u8 gUnknown_0202E8F5; extern u8 gUnknown_02038470[]; extern u16 gScriptItemId; extern u8 gDisplayedStringBattle[]; +extern const u8 gUnknown_08400CE0[]; extern void dp11b_obj_instanciate(u8, u8, s8, s8); extern u8 GetBankIdentity(u8); @@ -53,19 +56,13 @@ extern u8 GetBankByPlayerAI(u8); extern void dp11b_obj_free(u8, u8); extern void sub_8010520(struct Sprite *); extern void sub_8010574(struct Sprite *); -extern void nullsub_7(u8); -extern void sub_802E3B4(); -extern void sub_802E220(); -extern void sub_802E2D4(); -extern void sub_802E12C(s32, const u8 *); -extern void sub_802E1B0(void); extern bool8 IsDoubleBattle(); extern void sub_804777C(); extern void sub_8141828(); extern void sub_8094E20(u8); -extern void b_link_standby_message(void); extern void nullsub_14(void); extern void sub_80A6DCC(void); +extern void ReshowBattleScreenAfterMenu(void); void PlayerHandleGetAttributes(void); void sub_802ECF0(void); @@ -188,8 +185,6 @@ void (*const gPlayerBufferCommands[])(void) = nullsub_43, }; -extern const u8 gUnknown_081FAE80[]; - void PlayerBufferRunCommand(void); void sub_802C2EC(void); void sub_802C68C(void); @@ -202,6 +197,13 @@ void sub_802DD10(u8); void sub_802DDC4(u8); void sub_802DF88(void); void sub_802E03C(void); +void sub_802E12C(s32, const u8 *); +void sub_802E1B0(void); +void sub_802E220(void); +void sub_802E2D4(void); +void sub_802E3B4(u8, int); +void nullsub_7(u8); +void b_link_standby_message(void); void nullsub_91(void) { @@ -248,7 +250,7 @@ void bx_0802E404(void) void sub_802C098(void) { - u16 r5 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); dp11b_obj_instanciate(gActiveBank, 1, 7, 1); dp11b_obj_instanciate(gActiveBank, 0, 7, 1); @@ -275,7 +277,7 @@ void sub_802C098(void) } PlayerBufferExecCompleted(); } - else if (gMain.newKeys & 0x20) + else if (gMain.newKeys & DPAD_LEFT) { if (gActionSelectionCursor[gActiveBank] & 1) { @@ -285,7 +287,7 @@ void sub_802C098(void) sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); } } - else if (gMain.newKeys & 0x10) + else if (gMain.newKeys & DPAD_RIGHT) { if (!(gActionSelectionCursor[gActiveBank] & 1)) { @@ -295,7 +297,7 @@ void sub_802C098(void) sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); } } - else if (gMain.newKeys & 0x40) + else if (gMain.newKeys & DPAD_UP) { if (gActionSelectionCursor[gActiveBank] & 2) { @@ -305,7 +307,7 @@ void sub_802C098(void) sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); } } - else if (gMain.newKeys & 0x80) + else if (gMain.newKeys & DPAD_DOWN) { if (!(gActionSelectionCursor[gActiveBank] & 2)) { @@ -324,9 +326,11 @@ void sub_802C098(void) { if (gBattleBufferA[gActiveBank][1] == 1) { - if (r5 > 12) + // Add item to bag if it is a ball + if (itemId <= ITEM_PREMIER_BALL) + AddBagItem(itemId, 1); + else return; - AddBagItem(r5, 1); } PlaySE(SE_SELECT); dp01_build_cmdbuf_x21_a_bb(1, 12, 0); @@ -334,7 +338,7 @@ void sub_802C098(void) DestroyMenuCursor(); } } - else if (gMain.newKeys & 8) + else if (gMain.newKeys & START_BUTTON) { sub_804454C(); } @@ -487,6 +491,8 @@ struct UnknownStruct1 u8 filler14[0x20-0x14]; }; +const u8 gUnknown_081FAE80[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW WHITE LIGHT_BLUE WHITE2}"); + void sub_802C68C(void) { u32 r8 = 0; @@ -498,8 +504,8 @@ void sub_802C68C(void) PlaySE(SE_SELECT); - if (r6->moves[gMoveSelectionCursor[gActiveBank]] == 0xAE) - r4 = (r6->unk12 != 7 && (r6->unk13 ^ 7)) ? 0x10 : 0; + if (r6->moves[gMoveSelectionCursor[gActiveBank]] == MOVE_CURSE) + r4 = (r6->unk12 != TYPE_GHOST && (r6->unk13 ^ 7)) ? 0x10 : 0; else r4 = gBattleMoves[r6->moves[gMoveSelectionCursor[gActiveBank]]].target; @@ -1079,7 +1085,7 @@ void sub_802DB6C(u8 taskId) s32 r10 = gTasks[taskId].data[1]; //s16? u8 r7 = gTasks[taskId].data[2]; s16 r4; - + r4 = sub_8045C78(r7, gHealthboxIDs[r7], 1, 0); sub_8043DFC(gHealthboxIDs[r7]); if (r4 == -1) @@ -1089,7 +1095,7 @@ void sub_802DB6C(u8 taskId) u32 sp4; u16 r0; u32 sp0; - + m4aSongNumStop(SE_EXP); pkmn = &gPlayerParty[r9]; r4 = GetMonData(pkmn, MON_DATA_LEVEL); @@ -1100,7 +1106,7 @@ void sub_802DB6C(u8 taskId) { u8 r5; u32 asdf; - + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp0); CalculateMonStats(pkmn); //r10 -= sp0 - sp4; @@ -1283,7 +1289,7 @@ void sub_802DCB0(u8 taskId) { u8 bank = gTasks[taskId].data[2]; u8 pkmnIndex = gTasks[taskId].data[0]; - + if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) bank ^= 2; move_anim_start_t4(bank, bank, bank, 0); @@ -1293,11 +1299,11 @@ void sub_802DCB0(u8 taskId) void sub_802DD10(u8 taskId) { u8 bank = gTasks[taskId].data[2]; - + if (!ewram17810[bank].unk0_6) { u8 pkmnIndex = gTasks[taskId].data[0]; - + GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) sub_8045A5C(gHealthboxIDs[bank ^ 2], &gPlayerParty[pkmnIndex], 0); @@ -1312,7 +1318,7 @@ void sub_802DDC4(u8 taskId) u8 pkmnIndex; u8 bank; - pkmnIndex = gTasks[taskId].data[0]; + pkmnIndex = gTasks[taskId].data[0]; GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value bank = gTasks[taskId].data[2]; gBattleBankFunc[bank] = sub_802D90C; @@ -1324,7 +1330,7 @@ void sub_802DE10(void) if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > DISPLAY_HEIGHT) { u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - + nullsub_9(species); FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); @@ -1356,7 +1362,7 @@ void sub_802DF30(void) if (!gPaletteFade.active) { u8 r4; - + gBattleBankFunc[gActiveBank] = sub_802DF88; r4 = gTasks[gUnknown_0300434C[gActiveBank]].data[0]; DestroyTask(gUnknown_0300434C[gActiveBank]); @@ -1425,7 +1431,7 @@ void bx_blink_t1(void) void sub_802E12C(s32 a, const u8 *b) { struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - + StringCopy(gDisplayedStringBattle, b); StringAppend(gDisplayedStringBattle, gMoveNames[r4->moves[a]]); InitWindow( @@ -1441,7 +1447,7 @@ void sub_802E1B0(void) { struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; s32 i; - + gUnknown_03004348 = 0; FillWindowRect(&gUnknown_03004210, 0x1016, 1, 0x37, 0x14, 0x3A); for (i = 0; i < 4; i++) @@ -1452,3 +1458,122 @@ void sub_802E1B0(void) gUnknown_03004348++; } } + +void sub_802E220(void) +{ + if (gBattleBufferA[gActiveBank][2] != 1) + { + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + u8 *str = gDisplayedStringBattle; + + str = StringCopy(str, gUnknown_08400D49); + str[0] = EXT_CTRL_CODE_BEGIN; + str[1] = 0x11; + str[2] = 2; + str += 3; + str[0] = EXT_CTRL_CODE_BEGIN; + str[1] = 0x14; + str[2] = 6; + str += 3; + str = ConvertIntToDecimalStringN(str, r4->pp[gMoveSelectionCursor[gActiveBank]], 1, 2); + *str++ = CHAR_SLASH; + ConvertIntToDecimalStringN(str, r4->unkC[gMoveSelectionCursor[gActiveBank]], 1, 2); + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2A2, 0x19, 0x37); + sub_8002F44(&gUnknown_03004210); + } +} + +extern const u8 gUnknown_08400D52[]; +extern const u8 gTypeNames[][7]; + +void sub_802E2D4(void) +{ + if (gBattleBufferA[gActiveBank][2] == 1) + { + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D52, 0x290, 0x13, 0x37); + } + else + { + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + u8 *str = gDisplayedStringBattle; + + str = StringCopy(str, gUnknown_08400D49); + StringCopy(str, gTypeNames[gBattleMoves[r4->moves[gMoveSelectionCursor[gActiveBank]]].type]); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x39, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2C0, 0x17, 0x39); + } + sub_8002F44(&gUnknown_03004210); +} + +const u8 gUnknown_081FAE89[][2] = +{ + { 8, 120}, + {88, 120}, + { 8, 136}, + {88, 136}, +}; + +const u8 gUnknown_081FAE91[][2] = +{ + {144, 120}, + {190, 120}, + {144, 136}, + {190, 136}, + { 72, 72}, + { 32, 90}, + { 80, 80}, + { 80, 88}, +}; + +void sub_802E3B4(u8 a, int unused) +{ + sub_814A958(0x48); + sub_814A880(gUnknown_081FAE89[a][0], gUnknown_081FAE89[a][1]); +} + +void nullsub_7(u8 a) +{ +} + +void sub_802E3E4(u8 a, int unused) +{ + sub_814A958(0x2A); + sub_814A880(gUnknown_081FAE91[a][0], gUnknown_081FAE91[a][1]); +} + +void nullsub_8(u8 a) +{ +} + +void sub_802E414(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void sub_802E424(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void sub_802E434(void) +{ + if (!ewram17810[gActiveBank].unk0_4) + PlayerBufferExecCompleted(); +} + +void sub_802E460(void) +{ + if (!ewram17810[gActiveBank].unk0_5) + PlayerBufferExecCompleted(); +} + +void b_link_standby_message(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + sub_8002EB0(&gUnknown_03004210, gUnknown_08400CE0, 0x90, 2, 15); + } +} -- cgit v1.2.3 From ba11084ec89d5480eeba516d78bb6980d8e12ee4 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 19 Aug 2017 17:46:21 +0200 Subject: crazy vram shaenigans --- src/battle_transition.c | 439 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 437 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index ed6bdf387..fb20853a5 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -4,6 +4,9 @@ #include "task.h" #include "palette.h" #include "trig.h" +#include "field_effect.h" +#include "rng.h" +#include "sprite.h" void sub_807DE10(void); void dp12_8087EA4(void); @@ -15,6 +18,8 @@ extern const TransitionState sPhase2_Transition0_Funcs[]; extern const TransitionState sPhase2_Transition1_Funcs[]; extern const TransitionState sPhase2_Transition2_Funcs[]; extern const TransitionState sPhase2_Transition3_Funcs[]; +extern const TransitionState sPhase2_Transition4_Funcs[]; +extern const TransitionState sPhase2_Transition5_Funcs[]; extern const TaskFunc sPhase1_Tasks[]; extern const TaskFunc sPhase2_Tasks[]; @@ -40,6 +45,17 @@ struct TransitionData s16 field_14; s16 field_16; s16 field_18; + s16 field_1A; + s16 field_1C; + s16 field_1E; + s16 field_20; + s16 field_22; + s16 field_24; + s16 field_26; + s16 field_28; + s16 field_2A; + s16 field_2C; + s16 field_2E; }; #define TRANSITION_STRUCT (*(struct TransitionData *) (ewram + 0xC000)) @@ -55,11 +71,17 @@ static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); static void VBlankCB_Phase2_Transition2(void); static void HBlankCB_Phase2_Transition2(void); -void VBlankCB_Phase2_Transition3(void); +void VBlankCB0_Phase2_Transition3(void); +void VBlankCB1_Phase2_Transition3(void); +void VBlankCB_Phase2_Transition5(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); void sub_811D6A8(u16** a0, u16** a1); +void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); +void sub_811D6D4(void); +void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); +bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); void sub_811AABC(u8 transitionID) { @@ -353,7 +375,7 @@ bool8 Phase2_Transition3_Func1(struct Task* task) gUnknown_03005560[i] = 240; } - SetVBlankCallback(VBlankCB_Phase2_Transition3); + SetVBlankCallback(VBlankCB0_Phase2_Transition3); sub_811D6A8(&dst1, & dst2); CpuFill16(0, dst1, 0x800); @@ -386,3 +408,416 @@ bool8 Phase2_Transition3_Func2(struct Task* task) task->tState++; return 1; } + +bool8 Phase2_Transition3_Func3(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + if (task->data[3] == 0 || --task->data[3] == 0) + { + task->data[2]++; + task->data[3] = 2; + } + TRANSITION_STRUCT.field_10 = (task->data[1] << 8) | task->data[2]; + if (task->data[2] > 15) + task->tState++; + task->data[4] += 8; + task->data[5] -= 256; + + sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition3_Func4(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + if (task->data[3] == 0 || --task->data[3] == 0) + { + task->data[1]--; + task->data[3] = 2; + } + TRANSITION_STRUCT.field_10 = (task->data[1] << 8) | task->data[2]; + if (task->data[1] == 0) + task->tState++; + task->data[4] += 8; + task->data[5] -= 256; + + sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition3_Func5(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + task->data[4] += 8; + task->data[5] -= 256; + + sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); + + if (task->data[5] <= 0) + { + task->tState++; + task->data[1] = 160; + task->data[2] = 256; + task->data[3] = 0; + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition3_Func6(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + if (task->data[2] < 1024) + task->data[2] += 128; + if (task->data[1] != 0) + { + task->data[1] -= (task->data[2] >> 8); + if (task->data[1] < 0) + task->data[1] = 0; + } + sub_811D764(gUnknown_03004DE0[0], 120, 80, task->data[1]); + if (task->data[1] == 0) + { + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition3)); + } + if (task->data[3] == 0) + { + task->data[3]++; + SetVBlankCallback(VBlankCB1_Phase2_Transition3); + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +static void Transition3_Vblank(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_WININ = TRANSITION_STRUCT.field_2; + REG_WINOUT = TRANSITION_STRUCT.field_4; + REG_WIN0V = TRANSITION_STRUCT.field_8; + REG_BLDCNT = TRANSITION_STRUCT.field_E; + REG_BLDALPHA = TRANSITION_STRUCT.field_10; +} + +void VBlankCB0_Phase2_Transition3(void) +{ + Transition3_Vblank(); + DmaSet(0, gUnknown_03005560, ®_BG0HOFS, 0xA2400001); +} + +void VBlankCB1_Phase2_Transition3(void) +{ + Transition3_Vblank(); + DmaSet(0, gUnknown_03005560, ®_WIN0H, 0xA2400001); +} + +void Phase2Task_Transition4(u8 taskID) +{ + while (sPhase2_Transition4_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +extern const u8 gUnknown_083FC108[]; + +bool8 Phase2_Transition4_Func1(struct Task* task) +{ + u16 *dst1, *dst2; + + sub_811D6A8(&dst1, &dst2); + CpuSet(gUnknown_083FC108, dst2, 0x20); + CpuFill32(0, dst1, 0x800); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + + task->tState++; + return 0; +} + +extern const s16 gUnknown_083FD7E4[2]; +extern const s16 gUnknown_083FD7F2[2]; +extern const s16 gUnknown_083FD7E8[5]; + +bool8 Phase2_Transition4_Func2(struct Task* task) +{ + s16 i; + s16 rand; + s16 arr0[2]; + s16 arr1[5]; + + memcpy(arr0, gUnknown_083FD7E4, sizeof(gUnknown_083FD7E4)); + memcpy(arr1, gUnknown_083FD7E8, sizeof(gUnknown_083FD7E8)); + rand = Random() & 1; + for (i = 0; i <= 4; i++, rand ^= 1) + { + gUnknown_0202FF84[0] = arr0[rand]; // x + gUnknown_0202FF84[1] = (i * 32) + 16; // y + gUnknown_0202FF84[2] = rand; + gUnknown_0202FF84[3] = arr1[i]; + FieldEffectStart(FLDEFF_POKEBALL); + } + + task->tState++; + return 0; +} + +bool8 Phase2_Transition4_Func3(struct Task* task) +{ + if (!FieldEffectActiveListContains(FLDEFF_POKEBALL)) + { + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition4)); + } + return 0; +} + +extern const struct SpriteTemplate gSpriteTemplate_83FD98C; + +bool8 FldEff_Pokeball(void) +{ + u8 spriteID = CreateSpriteAtEnd(&gSpriteTemplate_83FD98C, gUnknown_0202FF84[0], gUnknown_0202FF84[1], 0); + gSprites[spriteID].oam.priority = 0; + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].data0 = gUnknown_0202FF84[2]; + gSprites[spriteID].data1 = gUnknown_0202FF84[3]; + gSprites[spriteID].data2 = -1; + InitSpriteAffineAnim(&gSprites[spriteID]); + StartSpriteAffineAnim(&gSprites[spriteID], gUnknown_0202FF84[2]); + return 0; +} + +#ifdef NONMATCHING +void sub_811B720(struct Sprite* sprite) +{ + s16 arr0[2]; + + memcpy(arr0, gUnknown_083FD7F2, sizeof(gUnknown_083FD7F2)); + if (sprite->data1 != 0) + sprite->data1--; + else + { + if (sprite->pos1.x < 240) + { + s32 posY = sprite->pos1.y >> 3; + s32 posX = sprite->pos1.x >> 3; + if ((posX >> 3) != sprite->data2) + { + u32 var; + + sprite->data2 = (posX); + var = (((REG_BG0CNT >> 8) & 0x1F) << 10); + + vram[MULTI_DIM_ARR(posY - 2, 32, posX)] = 0xF001; + vram[MULTI_DIM_ARR(posY - 1, 32, posX)] = 0xF001; + vram[MULTI_DIM_ARR(posY - 0, 32, posX)] = 0xF001; + vram[MULTI_DIM_ARR(posY + 0, 32, posX)] = 0xF001; + } + } + sprite->pos1.x += arr0[sprite->data0]; + if (sprite->pos1.x + 15 > 270) + FieldEffectStop(sprite, FLDEFF_POKEBALL); + } +} +#else +__attribute__((naked)) +void sub_811B720(struct Sprite* sprite) +{ + asm(".syntax unified\n\ + push {r4-r6,lr}\n\ + sub sp, 0x4\n\ + adds r4, r0, 0\n\ + ldr r1, _0811B740 @ =gUnknown_083FD7F2\n\ + mov r0, sp\n\ + movs r2, 0x4\n\ + bl memcpy\n\ + ldrh r1, [r4, 0x30]\n\ + movs r2, 0x30\n\ + ldrsh r0, [r4, r2]\n\ + cmp r0, 0\n\ + beq _0811B744\n\ + subs r0, r1, 0x1\n\ + strh r0, [r4, 0x30]\n\ + b _0811B7D6\n\ + .align 2, 0\n\ +_0811B740: .4byte gUnknown_083FD7F2\n\ +_0811B744:\n\ + ldrh r0, [r4, 0x20]\n\ + lsls r1, r0, 16\n\ + lsrs r0, r1, 16\n\ + cmp r0, 0xF0\n\ + bhi _0811B7B2\n\ + asrs r0, r1, 19\n\ + lsls r0, 16\n\ + ldrh r1, [r4, 0x22]\n\ + lsls r1, 16\n\ + asrs r1, 19\n\ + lsls r1, 16\n\ + lsrs r1, 16\n\ + lsrs r2, r0, 16\n\ + asrs r5, r0, 16\n\ + movs r3, 0x32\n\ + ldrsh r0, [r4, r3]\n\ + cmp r5, r0\n\ + beq _0811B7B2\n\ + strh r2, [r4, 0x32]\n\ + ldr r0, _0811B7E0 @ =REG_BG0CNT\n\ + ldrh r2, [r0]\n\ + lsrs r2, 8\n\ + movs r0, 0x1F\n\ + ands r2, r0\n\ + lsls r2, 11\n\ + movs r0, 0xC0\n\ + lsls r0, 19\n\ + adds r2, r0\n\ + lsls r1, 16\n\ + asrs r1, 16\n\ + subs r0, r1, 0x2\n\ + lsls r0, 5\n\ + adds r0, r5\n\ + lsls r0, 1\n\ + adds r0, r2\n\ + ldr r6, _0811B7E4 @ =0x0000f001\n\ + adds r3, r6, 0\n\ + strh r3, [r0]\n\ + subs r0, r1, 0x1\n\ + lsls r0, 5\n\ + adds r0, r5\n\ + lsls r0, 1\n\ + adds r0, r2\n\ + strh r3, [r0]\n\ + lsls r0, r1, 5\n\ + adds r0, r5\n\ + lsls r0, 1\n\ + adds r0, r2\n\ + strh r3, [r0]\n\ + adds r1, 0x1\n\ + lsls r1, 5\n\ + adds r1, r5\n\ + lsls r1, 1\n\ + adds r1, r2\n\ + strh r3, [r1]\n\ +_0811B7B2:\n\ + movs r1, 0x2E\n\ + ldrsh r0, [r4, r1]\n\ + lsls r0, 1\n\ + add r0, sp\n\ + ldrh r0, [r0]\n\ + ldrh r2, [r4, 0x20]\n\ + adds r0, r2\n\ + strh r0, [r4, 0x20]\n\ + adds r0, 0xF\n\ + lsls r0, 16\n\ + movs r1, 0x87\n\ + lsls r1, 17\n\ + cmp r0, r1\n\ + bls _0811B7D6\n\ + adds r0, r4, 0\n\ + movs r1, 0x2D\n\ + bl FieldEffectStop\n\ +_0811B7D6:\n\ + add sp, 0x4\n\ + pop {r4-r6}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_0811B7E0: .4byte 0x04000008\n\ +_0811B7E4: .4byte 0x0000f001\n\ + .syntax divided"); +} +#endif // NONMATCHING + +void Phase2Task_Transition5(u8 taskID) +{ + while (sPhase2_Transition5_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition5_Func1(struct Task* task) +{ + u16 i; + + sub_811D658(); + dp12_8087EA4(); + + TRANSITION_STRUCT.field_2 = 0; + TRANSITION_STRUCT.field_4 = 63; + TRANSITION_STRUCT.field_6 = -3855; + TRANSITION_STRUCT.field_8 = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_03005560[i] = 0xF3F4; + } + + SetVBlankCallback(VBlankCB_Phase2_Transition5); + TRANSITION_STRUCT.field_2C = 120; + + task->tState++; + return 1; +} + +bool8 Phase2_Transition5_Func2(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + + sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, -1, 1, 1); + do + { + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (TRANSITION_STRUCT.field_28 + 1) | 0x7800; + } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + + TRANSITION_STRUCT.field_2C += 16; + if (TRANSITION_STRUCT.field_2C >= 240) + { + TRANSITION_STRUCT.field_2E = 0; + task->tState++; + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition5_Func3(struct Task* task) +{ + s16 r1, r3; + vu8 var = 0; + + TRANSITION_STRUCT.field_0 = 0; + + sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 240, TRANSITION_STRUCT.field_2E, 1, 1); + + while (1) + { + r1 = 120, r3 = TRANSITION_STRUCT.field_28 + 1; + if (TRANSITION_STRUCT.field_2E >= 80) + r1 = TRANSITION_STRUCT.field_28, r3 = 240; + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r3) | (r1 << 8); + if (var != 0) + break; + var = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + } + + TRANSITION_STRUCT.field_2E += 8; + if (TRANSITION_STRUCT.field_2E >= 160) + { + TRANSITION_STRUCT.field_2C = 240; + task->tState++; + } + else + { + while (TRANSITION_STRUCT.field_2A < TRANSITION_STRUCT.field_2E) + { + gUnknown_03004DE0[0][++TRANSITION_STRUCT.field_2A] = (r3) | (r1 << 8); + } + } + + TRANSITION_STRUCT.field_0++; + return 0; +} -- cgit v1.2.3 From c87e2d89e33b07ea9cbb9c73ecfdb95d7bc8d4b9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 19 Aug 2017 23:10:26 +0200 Subject: cam help plox, ninja shift --- src/battle_transition.c | 180 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 176 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index fb20853a5..fa911d411 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -20,6 +20,7 @@ extern const TransitionState sPhase2_Transition2_Funcs[]; extern const TransitionState sPhase2_Transition3_Funcs[]; extern const TransitionState sPhase2_Transition4_Funcs[]; extern const TransitionState sPhase2_Transition5_Funcs[]; +extern const TransitionState sPhase2_Transition6_Funcs[]; extern const TaskFunc sPhase1_Tasks[]; extern const TaskFunc sPhase2_Tasks[]; @@ -69,11 +70,17 @@ void sub_811D658(void); static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); + static void VBlankCB_Phase2_Transition2(void); static void HBlankCB_Phase2_Transition2(void); -void VBlankCB0_Phase2_Transition3(void); -void VBlankCB1_Phase2_Transition3(void); -void VBlankCB_Phase2_Transition5(void); + +static void VBlankCB0_Phase2_Transition3(void); +static void VBlankCB1_Phase2_Transition3(void); + +static void VBlankCB_Phase2_Transition5(void); + +void VBlankCB_Phase2_Transition6(void); +void HBlankCB_Phase2_Transition6(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); @@ -510,7 +517,7 @@ static void Transition3_Vblank(void) REG_BLDALPHA = TRANSITION_STRUCT.field_10; } -void VBlankCB0_Phase2_Transition3(void) +static void VBlankCB0_Phase2_Transition3(void) { Transition3_Vblank(); DmaSet(0, gUnknown_03005560, ®_BG0HOFS, 0xA2400001); @@ -821,3 +828,168 @@ bool8 Phase2_Transition5_Func3(struct Task* task) TRANSITION_STRUCT.field_0++; return 0; } + +bool8 Phase2_Transition5_Func4(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + + sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 160, 1, 1); + do + { + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (TRANSITION_STRUCT.field_28 << 8) | 0xF0; + } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + + TRANSITION_STRUCT.field_2C -= 16; + if (TRANSITION_STRUCT.field_2C <= 0) + { + TRANSITION_STRUCT.field_2E = 160; + task->tState++; + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition5_Func5(struct Task* task) +{ + s16 r1, r2, r3; + vu8 var = 0; + + TRANSITION_STRUCT.field_0 = 0; + + sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 0, TRANSITION_STRUCT.field_2E, 1, 1); + + while (1) + { + r1 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] & 0xFF, r2 = TRANSITION_STRUCT.field_28; + if (TRANSITION_STRUCT.field_2E <= 80) + r2 = 120, r1 = TRANSITION_STRUCT.field_28; + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r1) | (r2 << 8); + r3 = 0; + if (var != 0) + break; + var = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + } + + TRANSITION_STRUCT.field_2E -= 8; + if (TRANSITION_STRUCT.field_2E <= 0) + { + TRANSITION_STRUCT.field_2C = r3; + task->tState++; + } + else + { + while (TRANSITION_STRUCT.field_2A > TRANSITION_STRUCT.field_2E) + { + gUnknown_03004DE0[0][--TRANSITION_STRUCT.field_2A] = (r1) | (r2 << 8); + } + } + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition5_Func6(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + + sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 0, 1, 1); + do + { + s16 r2, r3; + + r2 = 120, r3 = TRANSITION_STRUCT.field_28; + if (TRANSITION_STRUCT.field_28 >= 120) + r2 = 0, r3 = 240; + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r3) | (r2 << 8); + + } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + + TRANSITION_STRUCT.field_2C += 16; + if (TRANSITION_STRUCT.field_28 > 120) + task->tState++; + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition5_Func7(struct Task* task) +{ + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition5)); + return 0; +} + +static void VBlankCB_Phase2_Transition5(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0 != 0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_WININ = TRANSITION_STRUCT.field_2; + REG_WINOUT = TRANSITION_STRUCT.field_4; + REG_WIN0V = TRANSITION_STRUCT.field_8; + REG_WIN0H = gUnknown_03004DE0[1][0]; + DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); +} + +void Phase2Task_Transition6(u8 taskID) +{ + while (sPhase2_Transition6_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition6_Func1(struct Task* task) +{ + u8 i; + + sub_811D658(); + dp12_8087EA4(); + + for (i = 0; i < 160; i++) + { + gUnknown_03005560[i] = TRANSITION_STRUCT.field_16; + } + + SetVBlankCallback(VBlankCB_Phase2_Transition6); + SetHBlankCallback(HBlankCB_Phase2_Transition6); + + REG_IE |= 2; + REG_DISPSTAT |= 0x10; + + task->tState++; + return 1; +} + +bool8 Phase2_Transition6_Func2(struct Task* task) +{ + u8 i; + u16 r3, r4, r8; + + TRANSITION_STRUCT.field_0 = 0; + + r3 = task->data[2] >> 8; + r4 = task->data[1]; + r8 = 384; + task->data[1] += 0x400; + if (task->data[2] <= 0x1FFF) + task->data[2] += 0x180; + + for (i = 0; i < 160; i++, r4 += r8) + { + s16 sinResult = Sin(r4 >> 8, r3); + gUnknown_03004DE0[0][i] = TRANSITION_STRUCT.field_16 + sinResult; + } + + if (++task->data[3] == 81) + { + task->data[4]++; + BeginNormalPaletteFade(-1, -2, 0, 0x10, 0); + } + + if (task->data[4] != 0 && !gPaletteFade.active) + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition6)); + + TRANSITION_STRUCT.field_0++; + return 0; +} -- cgit v1.2.3 From f84d0541314b043fa3ef4e2b9a56809f278787f9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 20 Aug 2017 17:27:54 +0200 Subject: mugshots tasks done --- src/battle_transition.c | 619 ++++++++++++++++++++++++++++++++++++------------ 1 file changed, 472 insertions(+), 147 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index fa911d411..5cb9de1bb 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -1,4 +1,5 @@ #include "global.h" +#include "battle_transition.h" #include "main.h" #include "rom4.h" #include "task.h" @@ -7,6 +8,8 @@ #include "field_effect.h" #include "rng.h" #include "sprite.h" +#include "sound.h" +#include "songs.h" void sub_807DE10(void); void dp12_8087EA4(void); @@ -21,6 +24,8 @@ extern const TransitionState sPhase2_Transition3_Funcs[]; extern const TransitionState sPhase2_Transition4_Funcs[]; extern const TransitionState sPhase2_Transition5_Funcs[]; extern const TransitionState sPhase2_Transition6_Funcs[]; +extern const TransitionState sPhase2_Transition7_Funcs[]; +extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; extern const TaskFunc sPhase1_Tasks[]; extern const TaskFunc sPhase2_Tasks[]; @@ -34,14 +39,14 @@ struct TransitionData { vs8 field_0; // now that's interesting s8 field_1; - s16 field_2; - s16 field_4; + s16 WININ; + s16 WINOUT; s16 field_6; - s16 field_8; + s16 WIN0V; s16 field_A; s16 field_C; - s16 field_E; - s16 field_10; + s16 BLDCNT; + s16 BLDALPHA; s16 field_12; s16 field_14; s16 field_16; @@ -79,8 +84,14 @@ static void VBlankCB1_Phase2_Transition3(void); static void VBlankCB_Phase2_Transition5(void); -void VBlankCB_Phase2_Transition6(void); -void HBlankCB_Phase2_Transition6(void); +static void VBlankCB_Phase2_Transition6(void); +static void HBlankCB_Phase2_Transition6(void); + +static void VBlankCB_Phase2_Transition7(void); + +static void VBlankCB0_Phase2_Mugshots(void); +static void VBlankCB1_Phase2_Mugshots(void); +static void HBlankCB_Phase2_Mugshots(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); @@ -89,6 +100,12 @@ void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); +static void Phase2Task_MugShotTransition(u8 taskID); +void sub_811C7B0(struct Task* task); + +void sub_811CA10(s16 spriteID, s16 value); +void sub_811CA28(s16 spriteID); +s16 sub_811CA44(s16 spriteID); void sub_811AABC(u8 transitionID) { @@ -370,12 +387,12 @@ bool8 Phase2_Transition3_Func1(struct Task* task) task->data[2] = 0; task->data[4] = 0; task->data[5] = 0x4000; - TRANSITION_STRUCT.field_2 = 63; - TRANSITION_STRUCT.field_4 = 0; + TRANSITION_STRUCT.WININ = 63; + TRANSITION_STRUCT.WINOUT = 0; TRANSITION_STRUCT.field_6 = 240; - TRANSITION_STRUCT.field_8 = 160; - TRANSITION_STRUCT.field_E = 0x3F41; - TRANSITION_STRUCT.field_10 = task->data[1] * 256; // 16 * 256 = 0x1000 + TRANSITION_STRUCT.WIN0V = 160; + TRANSITION_STRUCT.BLDCNT = 0x3F41; + TRANSITION_STRUCT.BLDALPHA = task->data[1] * 256; // 16 * 256 = 0x1000 for (i = 0; i < 160; i++) { @@ -424,7 +441,7 @@ bool8 Phase2_Transition3_Func3(struct Task* task) task->data[2]++; task->data[3] = 2; } - TRANSITION_STRUCT.field_10 = (task->data[1] << 8) | task->data[2]; + TRANSITION_STRUCT.BLDALPHA = (task->data[1] << 8) | task->data[2]; if (task->data[2] > 15) task->tState++; task->data[4] += 8; @@ -444,7 +461,7 @@ bool8 Phase2_Transition3_Func4(struct Task* task) task->data[1]--; task->data[3] = 2; } - TRANSITION_STRUCT.field_10 = (task->data[1] << 8) | task->data[2]; + TRANSITION_STRUCT.BLDALPHA = (task->data[1] << 8) | task->data[2]; if (task->data[1] == 0) task->tState++; task->data[4] += 8; @@ -510,11 +527,11 @@ static void Transition3_Vblank(void) VBlankCB_BattleTransition(); if (TRANSITION_STRUCT.field_0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); - REG_WININ = TRANSITION_STRUCT.field_2; - REG_WINOUT = TRANSITION_STRUCT.field_4; - REG_WIN0V = TRANSITION_STRUCT.field_8; - REG_BLDCNT = TRANSITION_STRUCT.field_E; - REG_BLDALPHA = TRANSITION_STRUCT.field_10; + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; + REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; + REG_BLDALPHA = TRANSITION_STRUCT.BLDALPHA; } static void VBlankCB0_Phase2_Transition3(void) @@ -601,7 +618,12 @@ bool8 FldEff_Pokeball(void) return 0; } -#ifdef NONMATCHING +#define SOME_VRAM_STORE(ptr, posY, posX, toStore) \ +{ \ + u32 index = (posY) * 32 + posX; \ + ptr[index] = toStore; \ +} + void sub_811B720(struct Sprite* sprite) { s16 arr0[2]; @@ -611,135 +633,31 @@ void sub_811B720(struct Sprite* sprite) sprite->data1--; else { - if (sprite->pos1.x < 240) + if (sprite->pos1.x >= 0 && sprite->pos1.x <= 240) { - s32 posY = sprite->pos1.y >> 3; - s32 posX = sprite->pos1.x >> 3; - if ((posX >> 3) != sprite->data2) + s16 posX = sprite->pos1.x >> 3; + s16 posY = sprite->pos1.y >> 3; + + if (posX != sprite->data2) { u32 var; + u16 *ptr; - sprite->data2 = (posX); - var = (((REG_BG0CNT >> 8) & 0x1F) << 10); + sprite->data2 = posX; + var = (((REG_BG0CNT >> 8) & 0x1F) << 11); // r2 + ptr = (u16 *)(VRAM + var); - vram[MULTI_DIM_ARR(posY - 2, 32, posX)] = 0xF001; - vram[MULTI_DIM_ARR(posY - 1, 32, posX)] = 0xF001; - vram[MULTI_DIM_ARR(posY - 0, 32, posX)] = 0xF001; - vram[MULTI_DIM_ARR(posY + 0, 32, posX)] = 0xF001; + SOME_VRAM_STORE(ptr, posY - 2, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY - 1, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY - 0, posX, 0xF001); + SOME_VRAM_STORE(ptr, posY + 1, posX, 0xF001); } } sprite->pos1.x += arr0[sprite->data0]; - if (sprite->pos1.x + 15 > 270) + if (sprite->pos1.x < -15 || sprite->pos1.x > 255) FieldEffectStop(sprite, FLDEFF_POKEBALL); } } -#else -__attribute__((naked)) -void sub_811B720(struct Sprite* sprite) -{ - asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - sub sp, 0x4\n\ - adds r4, r0, 0\n\ - ldr r1, _0811B740 @ =gUnknown_083FD7F2\n\ - mov r0, sp\n\ - movs r2, 0x4\n\ - bl memcpy\n\ - ldrh r1, [r4, 0x30]\n\ - movs r2, 0x30\n\ - ldrsh r0, [r4, r2]\n\ - cmp r0, 0\n\ - beq _0811B744\n\ - subs r0, r1, 0x1\n\ - strh r0, [r4, 0x30]\n\ - b _0811B7D6\n\ - .align 2, 0\n\ -_0811B740: .4byte gUnknown_083FD7F2\n\ -_0811B744:\n\ - ldrh r0, [r4, 0x20]\n\ - lsls r1, r0, 16\n\ - lsrs r0, r1, 16\n\ - cmp r0, 0xF0\n\ - bhi _0811B7B2\n\ - asrs r0, r1, 19\n\ - lsls r0, 16\n\ - ldrh r1, [r4, 0x22]\n\ - lsls r1, 16\n\ - asrs r1, 19\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - lsrs r2, r0, 16\n\ - asrs r5, r0, 16\n\ - movs r3, 0x32\n\ - ldrsh r0, [r4, r3]\n\ - cmp r5, r0\n\ - beq _0811B7B2\n\ - strh r2, [r4, 0x32]\n\ - ldr r0, _0811B7E0 @ =REG_BG0CNT\n\ - ldrh r2, [r0]\n\ - lsrs r2, 8\n\ - movs r0, 0x1F\n\ - ands r2, r0\n\ - lsls r2, 11\n\ - movs r0, 0xC0\n\ - lsls r0, 19\n\ - adds r2, r0\n\ - lsls r1, 16\n\ - asrs r1, 16\n\ - subs r0, r1, 0x2\n\ - lsls r0, 5\n\ - adds r0, r5\n\ - lsls r0, 1\n\ - adds r0, r2\n\ - ldr r6, _0811B7E4 @ =0x0000f001\n\ - adds r3, r6, 0\n\ - strh r3, [r0]\n\ - subs r0, r1, 0x1\n\ - lsls r0, 5\n\ - adds r0, r5\n\ - lsls r0, 1\n\ - adds r0, r2\n\ - strh r3, [r0]\n\ - lsls r0, r1, 5\n\ - adds r0, r5\n\ - lsls r0, 1\n\ - adds r0, r2\n\ - strh r3, [r0]\n\ - adds r1, 0x1\n\ - lsls r1, 5\n\ - adds r1, r5\n\ - lsls r1, 1\n\ - adds r1, r2\n\ - strh r3, [r1]\n\ -_0811B7B2:\n\ - movs r1, 0x2E\n\ - ldrsh r0, [r4, r1]\n\ - lsls r0, 1\n\ - add r0, sp\n\ - ldrh r0, [r0]\n\ - ldrh r2, [r4, 0x20]\n\ - adds r0, r2\n\ - strh r0, [r4, 0x20]\n\ - adds r0, 0xF\n\ - lsls r0, 16\n\ - movs r1, 0x87\n\ - lsls r1, 17\n\ - cmp r0, r1\n\ - bls _0811B7D6\n\ - adds r0, r4, 0\n\ - movs r1, 0x2D\n\ - bl FieldEffectStop\n\ -_0811B7D6:\n\ - add sp, 0x4\n\ - pop {r4-r6}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_0811B7E0: .4byte 0x04000008\n\ -_0811B7E4: .4byte 0x0000f001\n\ - .syntax divided"); -} -#endif // NONMATCHING void Phase2Task_Transition5(u8 taskID) { @@ -753,10 +671,10 @@ bool8 Phase2_Transition5_Func1(struct Task* task) sub_811D658(); dp12_8087EA4(); - TRANSITION_STRUCT.field_2 = 0; - TRANSITION_STRUCT.field_4 = 63; + TRANSITION_STRUCT.WININ = 0; + TRANSITION_STRUCT.WINOUT = 63; TRANSITION_STRUCT.field_6 = -3855; - TRANSITION_STRUCT.field_8 = 160; + TRANSITION_STRUCT.WIN0V = 160; for (i = 0; i < 160; i++) { @@ -927,9 +845,9 @@ static void VBlankCB_Phase2_Transition5(void) VBlankCB_BattleTransition(); if (TRANSITION_STRUCT.field_0 != 0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); - REG_WININ = TRANSITION_STRUCT.field_2; - REG_WINOUT = TRANSITION_STRUCT.field_4; - REG_WIN0V = TRANSITION_STRUCT.field_8; + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; REG_WIN0H = gUnknown_03004DE0[1][0]; DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } @@ -964,7 +882,8 @@ bool8 Phase2_Transition6_Func1(struct Task* task) bool8 Phase2_Transition6_Func2(struct Task* task) { u8 i; - u16 r3, r4, r8; + s16 r3; + u16 r4, r8; TRANSITION_STRUCT.field_0 = 0; @@ -977,8 +896,11 @@ bool8 Phase2_Transition6_Func2(struct Task* task) for (i = 0; i < 160; i++, r4 += r8) { - s16 sinResult = Sin(r4 >> 8, r3); - gUnknown_03004DE0[0][i] = TRANSITION_STRUCT.field_16 + sinResult; + // todo: fix the asm + s16 var = r4 >> 8; + asm(""); + gUnknown_03004DE0[0][i] = TRANSITION_STRUCT.field_16 + Sin(var, r3); + asm(""); } if (++task->data[3] == 81) @@ -993,3 +915,406 @@ bool8 Phase2_Transition6_Func2(struct Task* task) TRANSITION_STRUCT.field_0++; return 0; } + +static void VBlankCB_Phase2_Transition6(void) +{ + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); +} + +static void HBlankCB_Phase2_Transition6(void) +{ + u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; + REG_BG1VOFS = var; + REG_BG2VOFS = var; + REG_BG3VOFS = var; +} + +void Phase2Task_Transition7(u8 taskID) +{ + while (sPhase2_Transition7_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition7_Func1(struct Task* task) +{ + u8 i; + + sub_811D658(); + dp12_8087EA4(); + + TRANSITION_STRUCT.WININ = 63; + TRANSITION_STRUCT.WINOUT = 0; + TRANSITION_STRUCT.field_6 = 240; + TRANSITION_STRUCT.WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_03004DE0[1][i] = 242; + } + + SetVBlankCallback(VBlankCB_Phase2_Transition7); + + task->tState++; + return 1; +} + +bool8 Phase2_Transition7_Func2(struct Task* task) +{ + u8 i, r5; + u16* toStore; + bool8 nextFunc; + + TRANSITION_STRUCT.field_0 = 0; + toStore = gUnknown_03004DE0[0]; + r5 = task->data[2]; + task->data[2] += 16; + task->data[1] += 8; + + for (i = 0, nextFunc = TRUE; i < 160; i++, r5 += 4, toStore++) + { + s16 value = task->data[1] + Sin(r5, 40); + if (value < 0) + value = 0; + if (value > 240) + value = 240; + *toStore = (value << 8) | (0xF1); + if (value < 240) + nextFunc = FALSE; + } + if (nextFunc) + task->tState++; + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Transition7_Func3(struct Task* task) +{ + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition7)); + return 0; +} + +static void VBlankCB_Phase2_Transition7(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0 != 0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; + DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); +} + +#define tMugshotID data[15] + +void Phase2Task_Transition_Sydney(u8 taskID) +{ + gTasks[taskID].tMugshotID = MUGSHOT_SYDNEY; + Phase2Task_MugShotTransition(taskID); +} + +void Phase2Task_Transition_Phoebe(u8 taskID) +{ + gTasks[taskID].tMugshotID = MUGSHOT_PHOEBE; + Phase2Task_MugShotTransition(taskID); +} + +void Phase2Task_Transition_Glacia(u8 taskID) +{ + gTasks[taskID].tMugshotID = MUGSHOT_GLACIA; + Phase2Task_MugShotTransition(taskID); +} + +void Phase2Task_Transition_Drake(u8 taskID) +{ + gTasks[taskID].tMugshotID = MUGSHOT_DRAKE; + Phase2Task_MugShotTransition(taskID); +} + +void Phase2Task_Transition_Steven(u8 taskID) +{ + gTasks[taskID].tMugshotID = MUGSHOT_STEVEN; + Phase2Task_MugShotTransition(taskID); +} + +static void Phase2Task_MugShotTransition(u8 taskID) +{ + while (sPhase2_Mugshot_Transition_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Mugshot_Func1(struct Task* task) +{ + u8 i; + + sub_811D658(); + dp12_8087EA4(); + sub_811C7B0(task); + + task->data[1] = 0; + task->data[2] = 1; + task->data[3] = 239; + TRANSITION_STRUCT.WININ = 63; + TRANSITION_STRUCT.WINOUT = 62; + TRANSITION_STRUCT.WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_03004DE0[1][i] = 0xF0F1; + } + + SetVBlankCallback(VBlankCB0_Phase2_Mugshots); + + task->tState++; + return 0; +} + +extern const u8 gUnknown_083FC348[]; +extern const u16 gUnknown_083FDFF4[]; +extern const u8 * const sOpponentMugshotsPals[]; +extern const u8 * const sPlayerMugshotsPals[2]; + +bool8 Phase2_Mugshot_Func2(struct Task* task) +{ + s16 i, j; + u16 *dst1, *dst2; + const u16* var; + + var = gUnknown_083FDFF4; + sub_811D6A8(&dst1, &dst2); + CpuSet(gUnknown_083FC348, dst2, 0xF0); + LoadPalette(sOpponentMugshotsPals[task->tMugshotID], 0xF0, 0x20); + LoadPalette(sPlayerMugshotsPals[gSaveBlock2.playerGender], 0xFA, 0xC); + + for (i = 0; i < 20; i++) + { + for (j = 0; j < 32; j++, var++) + { + dst1[i * 32 + j] = *var | 0xF000; + } + } + + REG_IE |= 2; + REG_DISPSTAT |= 0x10; + SetHBlankCallback(HBlankCB_Phase2_Mugshots); + task->tState++; + return 0; +} + +bool8 Phase2_Mugshot_Func3(struct Task* task) +{ + u8 i, r5; + u16* toStore; + s16 value; + s32 mergedValue; + + TRANSITION_STRUCT.field_0 = 0; + + toStore = gUnknown_03004DE0[0]; + r5 = task->data[1]; + task->data[1] += 0x10; + + for (i = 0; i < 80; i++, toStore++, r5 += 0x10) + { + value = task->data[2] + Sin(r5, 0x10); + if (value < 0) + value = 1; + if (value > 0xF0) + value = 0xF0; + *toStore = value; + } + for (; i < 160; i++, toStore++, r5 += 0x10) + { + value = task->data[3] - Sin(r5, 0x10); + if (value < 0) + value = 0; + if (value > 0xEF) + value = 0xEF; + *toStore = (value << 8) | (0xF0); + } + + task->data[2] += 8; + task->data[3] -= 8; + if (task->data[2] > 0xF0) + task->data[2] = 0xF0; + if (task->data[3] < 0) + task->data[3] = 0; + mergedValue = *(s32*)(&task->data[2]); + if (mergedValue == 0xF0) + task->tState++; + + TRANSITION_STRUCT.field_18 -= 8; + TRANSITION_STRUCT.field_1A += 8; + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Mugshot_Func4(struct Task* task) +{ + u8 i; + u16* toStore; + + TRANSITION_STRUCT.field_0 = 0; + + for (i = 0, toStore = gUnknown_03004DE0[0]; i < 160; i++, toStore++) + { + *toStore = 0xF0; + } + + task->tState++; + task->data[1] = 0; + task->data[2] = 0; + task->data[3] = 0; + TRANSITION_STRUCT.field_18 -= 8; + TRANSITION_STRUCT.field_1A += 8; + + sub_811CA10(task->data[13], 0); + sub_811CA10(task->data[14], 1); + sub_811CA28(task->data[13]); + + PlaySE(SE_BT_START); + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Mugshot_Func5(struct Task* task) +{ + TRANSITION_STRUCT.field_18 -= 8; + TRANSITION_STRUCT.field_1A += 8; + if (sub_811CA44(task->data[13])) + { + task->tState++; + sub_811CA28(task->data[14]); + } + return 0; +} + +bool8 Phase2_Mugshot_Func6(struct Task* task) +{ + TRANSITION_STRUCT.field_18 -= 8; + TRANSITION_STRUCT.field_1A += 8; + if (sub_811CA44(task->data[14])) + { + TRANSITION_STRUCT.field_0 = 0; + SetVBlankCallback(NULL); + DmaStop(0); + memset(gUnknown_03004DE0[0], 0, 0x140); + memset(gUnknown_03004DE0[1], 0, 0x140); + REG_WIN0H = 0xF0; + REG_BLDY = 0; + task->tState++; + task->data[3] = 0; + task->data[4] = 0; + TRANSITION_STRUCT.BLDCNT = 0xBF; + SetVBlankCallback(VBlankCB1_Phase2_Mugshots); + } + return 0; +} + +bool8 Phase2_Mugshot_Func7(struct Task* task) +{ + bool32 r6; + + TRANSITION_STRUCT.field_0 = 0; + r6 = TRUE; + TRANSITION_STRUCT.field_18 -= 8; + TRANSITION_STRUCT.field_1A += 8; + + if (task->data[4] < 0x50) + task->data[4] += 2; + if (task->data[4] > 0x50) + task->data[4] = 0x50; + + if (++task->data[3] & 1) + { + s16 i; + for (i = 0, r6 = FALSE; i <= task->data[4]; i++) + { + s16 index1 = 0x50 - i; + s16 index2 = 0x50 + i; + if (gUnknown_03004DE0[0][index1] <= 15) + { + r6 = TRUE; + gUnknown_03004DE0[0][index1]++; + } + if (gUnknown_03004DE0[0][index2] <= 15) + { + r6 = TRUE; + gUnknown_03004DE0[0][index2]++; + } + } + } + + if (task->data[4] == 0x50 && !r6) + task->tState++; + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Mugshot_Func8(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + BlendPalettes(-1, 0x10, 0x7FFF); + TRANSITION_STRUCT.BLDCNT = 0xFF; + task->data[3] = 0; + + task->tState++; + return 1; +} + +bool8 Phase2_Mugshot_Func9(struct Task* task) +{ + TRANSITION_STRUCT.field_0 = 0; + + task->data[3]++; + memset(gUnknown_03004DE0[0], task->data[3], 0x140); + if (task->data[3] > 15) + task->tState++; + + TRANSITION_STRUCT.field_0++; + return 0; +} + +bool8 Phase2_Mugshot_Func10(struct Task* task) +{ + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(task->func)); + return 0; +} + +static void VBlankCB0_Phase2_Mugshots(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0 != 0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_BG0VOFS = TRANSITION_STRUCT.field_1C; + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; + DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); +} + +static void VBlankCB1_Phase2_Mugshots(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.field_0 != 0) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; + DmaSet(0, gUnknown_03004DE0[1], ®_BLDY, 0xA2400001); +} + +static void HBlankCB_Phase2_Mugshots(void) +{ + if (REG_VCOUNT < 80) + REG_BG0HOFS = TRANSITION_STRUCT.field_18; + else + REG_BG0HOFS = TRANSITION_STRUCT.field_1A; +} -- cgit v1.2.3 From ab913c9e63d21a604001c5fee48f0a225d9964ee Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 20 Aug 2017 17:42:43 +0200 Subject: german build fixed --- src/battle_message.c | 524 ++++++++++++++++++++++++++------------------------- 1 file changed, 263 insertions(+), 261 deletions(-) (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c index d4b8f86c6..350856818 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -42,57 +42,57 @@ extern u16 gBattlePartyID[4]; extern struct BattleEnigmaBerry gEnigmaBerries[4]; extern u8 gBattleBufferA[4][0x200]; -extern const u8 gUnknown_084005DB[]; -extern const u8 gUnknown_084005C7[]; -extern const u8 gUnknown_084005AA[]; -extern const u8 gUnknown_08400568[]; -extern const u8 gUnknown_08400590[]; -extern const u8 gUnknown_0840057B[]; -extern const u8 gUnknown_08400555[]; -extern const u8 gUnknown_084006F1[]; -extern const u8 gUnknown_084006A4[]; -extern const u8 gUnknown_0840069C[]; -extern const u8 gUnknown_0840065C[]; -extern const u8 gUnknown_08400645[]; -extern const u8 gUnknown_08400608[]; -extern const u8 gUnknown_08400635[]; -extern const u8 gUnknown_084005F5[]; -extern const u8 gUnknown_08400709[]; -extern const u8 gUnknown_08400727[]; -extern const u8 gUnknown_08400736[]; -extern const u8 gUnknown_08400749[]; -extern const u8 gUnknown_08400781[]; -extern const u8 gUnknown_08400771[]; -extern const u8 gUnknown_0840075E[]; -extern const u8 gUnknown_084006B3[]; -extern const u8 gUnknown_084006BB[]; -extern const u8 gUnknown_084006C6[]; -extern const u8 gUnknown_084006D5[]; -extern const u8 gUnknown_0840068C[]; -extern const u8 gUnknown_0840067C[]; -extern const u8 gUnknown_08400622[]; -extern const u8 gUnknown_084007BD[]; -extern const u8 gUnknown_083FFEFC[]; -extern const u8 gUnknown_083FFFF7[]; -extern const u8 gUnknown_083FFFEA[]; -extern const u8 gUnknown_083FFF6A[]; -extern const u8 gUnknown_083FFF99[]; -extern const u8 gUnknown_083FFFCB[]; -extern const u8 gUnknown_083FFF56[]; -extern const u8 gUnknown_083FFF81[]; -extern const u8 gUnknown_083FFFB3[]; -extern const u8 gUnknown_08400A78[]; -extern const u8 gUnknown_08400A85[]; -extern const u8 gUnknown_08400797[]; -extern const u8 gUnknown_08400791[]; -extern const u8 gUnknown_084007B7[]; -extern const u8 gUnknown_084007B2[]; -extern const u8 gUnknown_0840079C[]; -extern const u8 gUnknown_084007A1[]; -extern const u8 gUnknown_084007A7[]; -extern const u8 gUnknown_084007AC[]; -extern const u8 gUnknown_084009ED[]; -extern const u8 gUnknown_084009F7[]; +extern const u8 gUnknown_084005DB[]; +extern const u8 gUnknown_084005C7[]; +extern const u8 gUnknown_084005AA[]; +extern const u8 gUnknown_08400568[]; +extern const u8 gUnknown_08400590[]; +extern const u8 gUnknown_0840057B[]; +extern const u8 gUnknown_08400555[]; +extern const u8 gUnknown_084006F1[]; +extern const u8 gUnknown_084006A4[]; +extern const u8 gUnknown_0840069C[]; +extern const u8 gUnknown_0840065C[]; +extern const u8 gUnknown_08400645[]; +extern const u8 gUnknown_08400608[]; +extern const u8 gUnknown_08400635[]; +extern const u8 gUnknown_084005F5[]; +extern const u8 gUnknown_08400709[]; +extern const u8 gUnknown_08400727[]; +extern const u8 gUnknown_08400736[]; +extern const u8 gUnknown_08400749[]; +extern const u8 gUnknown_08400781[]; +extern const u8 gUnknown_08400771[]; +extern const u8 gUnknown_0840075E[]; +extern const u8 gUnknown_084006B3[]; +extern const u8 gUnknown_084006BB[]; +extern const u8 gUnknown_084006C6[]; +extern const u8 gUnknown_084006D5[]; +extern const u8 gUnknown_0840068C[]; +extern const u8 gUnknown_0840067C[]; +extern const u8 gUnknown_08400622[]; +extern const u8 gUnknown_084007BD[]; +extern const u8 gUnknown_083FFEFC[]; +extern const u8 gUnknown_083FFFF7[]; +extern const u8 gUnknown_083FFFEA[]; +extern const u8 gUnknown_083FFF6A[]; +extern const u8 gUnknown_083FFF99[]; +extern const u8 gUnknown_083FFFCB[]; +extern const u8 gUnknown_083FFF56[]; +extern const u8 gUnknown_083FFF81[]; +extern const u8 gUnknown_083FFFB3[]; +extern const u8 gUnknown_08400A78[]; +extern const u8 gUnknown_08400A85[]; +extern const u8 gUnknown_08400797[]; +extern const u8 gUnknown_08400791[]; +extern const u8 gUnknown_084007B7[]; +extern const u8 gUnknown_084007B2[]; +extern const u8 gUnknown_0840079C[]; +extern const u8 gUnknown_084007A1[]; +extern const u8 gUnknown_084007A7[]; +extern const u8 gUnknown_084007AC[]; +extern const u8 gUnknown_084009ED[]; +extern const u8 gUnknown_084009F7[]; extern const u8 gUnknown_084007C8[]; extern const u8 gUnknown_084007CA[]; extern const u8 gUnknown_084007CC[]; @@ -134,9 +134,9 @@ struct StringInfo extern struct StringInfo* gSelectedOrderFromParty; #define gStringInfo gSelectedOrderFromParty -static void sub_8121D1C(u8* textBuff); -static void sub_8121D74(u8* textBuff); -static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst); +void sub_8121D1C(u8* textBuff); +void sub_8121D74(u8* textBuff); +void StrCpyDecodeBattleTextBuff(u8* src, u8* dst); u8 GetBankSide(u8 bank); s32 sub_803FC34(u16); @@ -147,6 +147,9 @@ u8 GetMultiplayerId(void); u8 GetBankByPlayerAI(u8 ID); u8 GetBankSide(u8 bank); u8 GetBankIdentity(u8 bank); +#ifdef GERMAN +extern u8 *de_sub_804110C(); +#endif void BufferStringBattle(u16 stringID) { @@ -184,7 +187,12 @@ void BufferStringBattle(u16 stringID) stringPtr = gUnknown_084005C7; } else + { stringPtr = gUnknown_084005AA; +#ifdef GERMAN + stringPtr = de_sub_804110C(0xFFFF, stringPtr); +#endif + } } else { @@ -220,12 +228,22 @@ void BufferStringBattle(u16 stringID) else if (gBattleTypeFlags & BATTLE_TYPE_LINK) stringPtr = gUnknown_08400645; else + { stringPtr = gUnknown_08400608; +#ifdef GERMAN + stringPtr = de_sub_804110C(0xFFFF, stringPtr); +#endif + } } else if (gBattleTypeFlags & BATTLE_TYPE_LINK) stringPtr = gUnknown_08400635; else + { stringPtr = gUnknown_084005F5; +#ifdef GERMAN + stringPtr = de_sub_804110C(0xFFFF, stringPtr); +#endif + } } break; case 2: // sending poke to ball msg @@ -250,7 +268,12 @@ void BufferStringBattle(u16 stringID) stringPtr = gUnknown_08400771; } else + { stringPtr = gUnknown_0840075E; +#ifdef GERMAN + stringPtr = de_sub_804110C(0xFFFF, stringPtr); +#endif + } } break; case 3: // switch-in msg @@ -275,7 +298,12 @@ void BufferStringBattle(u16 stringID) stringPtr = gUnknown_0840067C; } else + { stringPtr = gUnknown_08400622; +#ifdef GERMAN + stringPtr = de_sub_804110C(0xFFFF, stringPtr); +#endif + } } break; case 4: // pokemon used a move msg @@ -346,7 +374,12 @@ void BufferStringBattle(u16 stringID) return; } else + { stringPtr = gBattleStringsTable[stringID - BATTLESTRING_TO_SUB]; +#ifdef GERMAN + stringPtr = de_sub_804110C(stringID, stringPtr); +#endif + } break; } StrCpyDecodeToDisplayedStringBattle(stringPtr); @@ -357,7 +390,7 @@ u32 StrCpyDecodeToDisplayedStringBattle(const u8* src) StrCpyDecodeBattle(src, gDisplayedStringBattle); } -static const u8* AppendStatusString(u8* src) +const u8* AppendStatusString(u8* src) { u32 i; u8 status[8]; @@ -385,6 +418,59 @@ static const u8* AppendStatusString(u8* src) return NULL; } +#ifdef GERMAN +extern u8 *de_sub_8073174(u8 *, const u8 *); +extern u8 *de_sub_8041024(s32, u32); +#endif + +#ifdef ENGLISH +#define HANDLE_NICKNAME_STRING_CASE(bank, monIndex) \ + if (GetBankSide(bank) != 0) \ + { \ + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) \ + toCpy = gUnknown_08400797; \ + else \ + toCpy = gUnknown_08400791; \ + while (*toCpy != EOS) \ + { \ + dst[dstID] = *toCpy; \ + dstID++; \ + toCpy++; \ + } \ + GetMonData(&gEnemyParty[monIndex], MON_DATA_NICKNAME, text); \ + } \ + else \ + { \ + GetMonData(&gPlayerParty[monIndex], MON_DATA_NICKNAME, text); \ + } \ + StringGetEnd10(text); \ + toCpy = text; +#else +#define HANDLE_NICKNAME_STRING_CASE(bank, monIndex) \ + if (GetBankSide(bank) != 0) \ + { \ + GetMonData(&gEnemyParty[monIndex], MON_DATA_NICKNAME, text); \ + StringGetEnd10(text); \ + toCpy = text; \ + while (*toCpy != EOS) \ + { \ + dst[dstID] = *toCpy; \ + dstID++; \ + toCpy++; \ + } \ + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) \ + toCpy = gUnknown_08400797; \ + else \ + toCpy = gUnknown_08400791; \ + } \ + else \ + { \ + GetMonData(&gPlayerParty[monIndex], MON_DATA_NICKNAME, text); \ + StringGetEnd10(text); \ + toCpy = text; \ + } +#endif + u32 StrCpyDecodeBattle(const u8* src, u8* dst) { u32 dstID = 0; // if they used dstID, why not use srcID as well? @@ -471,25 +557,7 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) toCpy = text; break; case 10: // attacker name with prefix, only bank 0/1 - if (GetBankSide(gBankAttacker) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1)]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1)]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(gBankAttacker, gBattlePartyID[GetBankByPlayerAI(GetBankIdentity(gBankAttacker) & 1)]) break; case 11: // attacker partner name, only bank 0/1 if (GetBankSide(gBankAttacker) == 0) @@ -501,109 +569,19 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) toCpy = text; break; case 12: // attacker name with prefix - if (GetBankSide(gBankAttacker) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[gBankAttacker]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[gBankAttacker]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(gBankAttacker, gBattlePartyID[gBankAttacker]) break; case 13: // target name with prefix - if (GetBankSide(gBankTarget) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[gBankTarget]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(gBankTarget, gBattlePartyID[gBankTarget]) break; case 14: // effect bank name with prefix - if (GetBankSide(gEffectBank) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[gEffectBank]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[gEffectBank]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(gEffectBank, gBattlePartyID[gEffectBank]) break; case 15: // active bank name with prefix - if (GetBankSide(gActiveBank) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(gActiveBank, gBattlePartyID[gActiveBank]) break; case 16: // scripting active bank name with prefix - if (GetBankSide(BATTLE_STRUCT->scriptingActive) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[gBattlePartyID[BATTLE_STRUCT->scriptingActive]], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[gBattlePartyID[BATTLE_STRUCT->scriptingActive]], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(BATTLE_STRUCT->scriptingActive, gBattlePartyID[BATTLE_STRUCT->scriptingActive]) break; case 17: // current move name if (gStringInfo->currentMove > 0x162) @@ -625,7 +603,11 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) if (gLinkPlayers[BATTLE_STRUCT->linkPlayerIndex].lp_field_18 == gStringBank) { StringCopy(text, gEnigmaBerries[gStringBank].name); +#ifdef ENGLISH StringAppend(text, gUnknown_08400A85); +#else + de_sub_8073174(text, gUnknown_08400A85); +#endif toCpy = text; } else @@ -659,6 +641,7 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) toCpy = gAbilityNames[gAbilitiesPerBank[gEffectBank]]; break; case 25: // trainer class name +#ifdef ENGLISH if (gTrainerBattleOpponent == 0x400) toCpy = gTrainerClassNames[GetSecretBaseTrainerNameIndex()]; else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) @@ -668,6 +651,17 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) else toCpy = gTrainerClassNames[gTrainers[gTrainerBattleOpponent].trainerClass]; break; +#else + if (gTrainerBattleOpponent == 0x400) + toCpy = de_sub_8041024(gTrainerBattleOpponent, 0); + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + toCpy = de_sub_8041024(BATTLE_TYPE_BATTLE_TOWER, 0); + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + toCpy = de_sub_8041024(BATTLE_TYPE_EREADER_TRAINER, 0); + else + toCpy = de_sub_8041024(0, gTrainerBattleOpponent); + break; +#endif case 26: // trainer name if (gTrainerBattleOpponent == 0x400) { @@ -710,25 +704,7 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) toCpy = sub_8082830(); break; case 34: // ? - if (GetBankSide(BATTLE_STRUCT->scriptingActive) != 0) - { - if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) - toCpy = gUnknown_08400797; - else - toCpy = gUnknown_08400791; - while (*toCpy != EOS) - { - dst[dstID] = *toCpy; - dstID++; - toCpy++; - } - GetMonData(&gEnemyParty[BATTLE_STRUCT->unk1605E], MON_DATA_NICKNAME, text); - } - else - GetMonData(&gPlayerParty[BATTLE_STRUCT->unk1605E], MON_DATA_NICKNAME, text); - - StringGetEnd10(text); - toCpy = text; + HANDLE_NICKNAME_STRING_CASE(BATTLE_STRUCT->scriptingActive, BATTLE_STRUCT->unk1605E) break; case 35: // lanette pc if (FlagGet(SYS_PC_LANETTE)) @@ -773,7 +749,7 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) toCpy = gUnknown_084007B2; break; } - //if (toCpy != NULL) really GF, why did you forgot about this + //if (toCpy != NULL) really GF, why did you forget about this? while (*toCpy != EOS) { dst[dstID] = *toCpy; @@ -803,23 +779,26 @@ u32 StrCpyDecodeBattle(const u8* src, u8* dst) #define ByteRead16(ptr) ((ptr)[0] | ((ptr)[1] << 8)) #define ByteRead32(ptr) ((ptr)[0] | (ptr)[1] << 8 | (ptr)[2] << 16 | (ptr)[3] << 24) -static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) +void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) { u32 srcID = 1; u32 value = 0; u8 text[12]; + u16 hword; *dst = EOS; while (src[srcID] != EOS) { switch (src[srcID]) { - case 0: // battlescript ptr - { - u16 BS_ID = ByteRead16(&src[srcID + 1]); - StringAppend(dst, gBattleStringsTable[BS_ID - BATTLESTRING_TO_SUB]); + case 0: // battle string + hword = ByteRead16(&src[srcID + 1]); +#ifdef GERMAN + if (hword == 209 || hword == 211) srcID += 3; - } +#endif + StringAppend(dst, gBattleStringsTable[hword - BATTLESTRING_TO_SUB]); + srcID += 3; break; case 1: // int to string switch (src[srcID + 1]) @@ -846,6 +825,7 @@ static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) srcID += 2; break; case 4: // poke nick with prefix +#ifdef ENGLISH if (GetBankSide(src[srcID + 1]) == 0) { GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text); @@ -860,6 +840,24 @@ static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) } StringGetEnd10(text); StringAppend(dst, text); +#else + if (GetBankSide(src[srcID + 1]) == 0) + { + GetMonData(&gPlayerParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + StringAppend(dst, text); + } + else + { + GetMonData(&gEnemyParty[src[srcID + 2]], MON_DATA_NICKNAME, text); + StringGetEnd10(text); + StringAppend(dst, text); + if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) + StringAppend(dst, gUnknown_08400797); + else + StringAppend(dst, gUnknown_08400791); + } +#endif srcID += 3; break; case 5: // stats @@ -888,24 +886,28 @@ static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) break; case 10: // item name { - u16 item = ByteRead16(&src[srcID + 1]); + hword = ByteRead16(&src[srcID + 1]); if (gBattleTypeFlags & BATTLE_TYPE_LINK) { - if (item == ITEM_ENIGMA_BERRY) + if (hword == ITEM_ENIGMA_BERRY) { if (gLinkPlayers[BATTLE_STRUCT->linkPlayerIndex].lp_field_18 == gStringBank) { StringCopy(dst, gEnigmaBerries[gStringBank].name); +#ifdef ENGLISH StringAppend(dst, gUnknown_08400A85); +#else + de_sub_8073174(dst, gUnknown_08400A85); +#endif } else StringAppend(dst, gUnknown_08400A78); } else - CopyItemName(item, dst); + CopyItemName(hword, dst); } else - CopyItemName(item, dst); + CopyItemName(hword, dst); srcID += 3; } break; @@ -913,7 +915,7 @@ static void StrCpyDecodeBattleTextBuff(u8* src, u8* dst) } } -static void sub_8121D1C(u8* textBuff) +void sub_8121D1C(u8* textBuff) { s32 counter = 0; u32 i = 0; @@ -937,7 +939,7 @@ static void sub_8121D1C(u8* textBuff) #ifdef NONMATCHING -static void sub_8121D74(u8* dst) +void sub_8121D74(u8* dst) { s32 counter = 0; s32 i; @@ -975,88 +977,88 @@ static void sub_8121D74(u8* dst) #else __attribute__((naked)) -static void sub_8121D74(u8* dst) +void sub_8121D74(u8* dst) { asm(".syntax unified\n\ - push {r4,r5,lr}\n\ - adds r3, r0, 0\n\ - movs r4, 0\n\ - b _08121D7E\n\ + push {r4,r5,lr}\n\ + adds r3, r0, 0\n\ + movs r4, 0\n\ + b _08121D7E\n\ _08121D7C:\n\ - adds r3, 0x1\n\ + adds r3, 0x1\n\ _08121D7E:\n\ - ldrb r0, [r3]\n\ - cmp r0, 0xFF\n\ - bne _08121D7C\n\ - ldr r1, _08121DB4 @ =gUnknown_084016BC\n\ - ldr r5, _08121DB8 @ =gSelectedOrderFromParty\n\ - movs r0, 0\n\ - lsls r0, 1\n\ - adds r2, r0, r1\n\ + ldrb r0, [r3]\n\ + cmp r0, 0xFF\n\ + bne _08121D7C\n\ + ldr r1, _08121DB4 @ =gUnknown_084016BC\n\ + ldr r5, _08121DB8 @ =gSelectedOrderFromParty\n\ + movs r0, 0\n\ + lsls r0, 1\n\ + adds r2, r0, r1\n\ _08121D8E:\n\ - cmp r4, 0x4\n\ - beq _08121DA8\n\ - ldrh r1, [r2]\n\ - cmp r1, 0\n\ - bne _08121D9A\n\ - adds r4, 0x1\n\ + cmp r4, 0x4\n\ + beq _08121DA8\n\ + ldrh r1, [r2]\n\ + cmp r1, 0\n\ + bne _08121D9A\n\ + adds r4, 0x1\n\ _08121D9A:\n\ - ldr r0, [r5]\n\ - adds r2, 0x2\n\ - ldrh r0, [r0]\n\ - cmp r1, r0\n\ - bne _08121D8E\n\ - cmp r4, 0x4\n\ - bhi _08121E04\n\ + ldr r0, [r5]\n\ + adds r2, 0x2\n\ + ldrh r0, [r0]\n\ + cmp r1, r0\n\ + bne _08121D8E\n\ + cmp r4, 0x4\n\ + bhi _08121E04\n\ _08121DA8:\n\ - lsls r0, r4, 2\n\ - ldr r1, _08121DBC @ =_08121DC0\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ + lsls r0, r4, 2\n\ + ldr r1, _08121DBC @ =_08121DC0\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ _08121DB4: .4byte gUnknown_084016BC\n\ _08121DB8: .4byte gSelectedOrderFromParty\n\ _08121DBC: .4byte _08121DC0\n\ - .align 2, 0\n\ + .align 2, 0\n\ _08121DC0:\n\ - .4byte _08121DD4\n\ - .4byte _08121DDC\n\ - .4byte _08121DE4\n\ - .4byte _08121DEC\n\ - .4byte _08121DFC\n\ + .4byte _08121DD4\n\ + .4byte _08121DDC\n\ + .4byte _08121DE4\n\ + .4byte _08121DEC\n\ + .4byte _08121DFC\n\ _08121DD4:\n\ - ldr r1, _08121DD8 @ =gUnknown_084007C8\n\ - b _08121DEE\n\ - .align 2, 0\n\ + ldr r1, _08121DD8 @ =gUnknown_084007C8\n\ + b _08121DEE\n\ + .align 2, 0\n\ _08121DD8: .4byte gUnknown_084007C8\n\ _08121DDC:\n\ - ldr r1, _08121DE0 @ =gUnknown_084007CA\n\ - b _08121DEE\n\ - .align 2, 0\n\ + ldr r1, _08121DE0 @ =gUnknown_084007CA\n\ + b _08121DEE\n\ + .align 2, 0\n\ _08121DE0: .4byte gUnknown_084007CA\n\ _08121DE4:\n\ - ldr r1, _08121DE8 @ =gUnknown_084007CC\n\ - b _08121DEE\n\ - .align 2, 0\n\ + ldr r1, _08121DE8 @ =gUnknown_084007CC\n\ + b _08121DEE\n\ + .align 2, 0\n\ _08121DE8: .4byte gUnknown_084007CC\n\ _08121DEC:\n\ - ldr r1, _08121DF8 @ =gUnknown_084007CE\n\ + ldr r1, _08121DF8 @ =gUnknown_084007CE\n\ _08121DEE:\n\ - adds r0, r3, 0\n\ - bl StringCopy\n\ - b _08121E04\n\ - .align 2, 0\n\ + adds r0, r3, 0\n\ + bl StringCopy\n\ + b _08121E04\n\ + .align 2, 0\n\ _08121DF8: .4byte gUnknown_084007CE\n\ _08121DFC:\n\ - ldr r1, _08121E0C @ =gUnknown_084007D0\n\ - adds r0, r3, 0\n\ - bl StringCopy\n\ + ldr r1, _08121E0C @ =gUnknown_084007D0\n\ + adds r0, r3, 0\n\ + bl StringCopy\n\ _08121E04:\n\ - pop {r4,r5}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ + pop {r4,r5}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ _08121E0C: .4byte gUnknown_084007D0\n\ .syntax divided"); } -- cgit v1.2.3 From 169714a6d4f2fcaef2f55baf6954620f8b9655e7 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 20 Aug 2017 21:32:41 +0200 Subject: mugshots done, moved some data to C --- src/battle_transition.c | 283 ++++++++++++++++++++++++++++++++++++++---------- src/field_effect.c | 10 +- src/main_menu.c | 4 +- 3 files changed, 230 insertions(+), 67 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 5cb9de1bb..8d87f12f6 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -14,25 +14,8 @@ void sub_807DE10(void); void dp12_8087EA4(void); -typedef bool8 (*TransitionState)(struct Task* task); - -extern const TransitionState sMainTransitionPhases[]; -extern const TransitionState sPhase2_Transition0_Funcs[]; -extern const TransitionState sPhase2_Transition1_Funcs[]; -extern const TransitionState sPhase2_Transition2_Funcs[]; -extern const TransitionState sPhase2_Transition3_Funcs[]; -extern const TransitionState sPhase2_Transition4_Funcs[]; -extern const TransitionState sPhase2_Transition5_Funcs[]; -extern const TransitionState sPhase2_Transition6_Funcs[]; -extern const TransitionState sPhase2_Transition7_Funcs[]; -extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; - -extern const TaskFunc sPhase1_Tasks[]; -extern const TaskFunc sPhase2_Tasks[]; - extern u8 ewram[]; extern s16 gUnknown_03005560[]; - extern u16 gUnknown_03004DE0[][0x3C0]; struct TransitionData @@ -73,6 +56,25 @@ void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); bool8 sub_811D52C(void); void sub_811D658(void); +static void Phase1Task_TransitionAll(u8 taskID); +static void Phase2Task_Transition0(u8 taskID); +static void Phase2Task_Transition1(u8 taskID); +static void Phase2Task_Transition2(u8 taskID); +static void Phase2Task_Transition3(u8 taskID); +static void Phase2Task_Transition4(u8 taskID); +static void Phase2Task_Transition5(u8 taskID); +static void Phase2Task_Transition6(u8 taskID); +static void Phase2Task_Transition7(u8 taskID); + void Phase2Task_Transition8(u8 taskID); + void Phase2Task_Transition9(u8 taskID); + void Phase2Task_Transition10(u8 taskID); + void Phase2Task_Transition11(u8 taskID); +static void Phase2Task_Transition_Sydney(u8 taskID); +static void Phase2Task_Transition_Phoebe(u8 taskID); +static void Phase2Task_Transition_Glacia(u8 taskID); +static void Phase2Task_Transition_Drake(u8 taskID); +static void Phase2Task_Transition_Steven(u8 taskID); + static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); @@ -101,11 +103,77 @@ void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); static void Phase2Task_MugShotTransition(u8 taskID); -void sub_811C7B0(struct Task* task); +static void Mugshots_CreateOpponentPlayerSprites(struct Task* task); +static void sub_811CA10(s16 spriteID, s16 value); +static void sub_811CA28(s16 spriteID); +static s16 sub_811CA44(s16 spriteID); -void sub_811CA10(s16 spriteID, s16 value); -void sub_811CA28(s16 spriteID); -s16 sub_811CA44(s16 spriteID); +// const data +typedef bool8 (*TransitionState)(struct Task* task); +typedef bool8 (*TransitionSpriteCallback)(struct Sprite* sprite); + +extern const TransitionState sMainTransitionPhases[]; +extern const TransitionState sPhase2_Transition0_Funcs[]; +extern const TransitionState sPhase2_Transition1_Funcs[]; +extern const TransitionState sPhase2_Transition2_Funcs[]; +extern const TransitionState sPhase2_Transition3_Funcs[]; +extern const TransitionState sPhase2_Transition4_Funcs[]; +extern const TransitionState sPhase2_Transition5_Funcs[]; +extern const TransitionState sPhase2_Transition6_Funcs[]; +extern const TransitionState sPhase2_Transition7_Funcs[]; +extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; +extern const u16 gFieldEffectObjectPalette10[]; +extern const u16 gUnknown_083FDB44[]; +extern const s16 gUnknown_083FD7E4[2]; +extern const s16 gUnknown_083FD7F2[2]; +extern const s16 gUnknown_083FD7E8[5]; +extern const struct SpriteTemplate gSpriteTemplate_83FD98C; +extern const u16 gUnknown_083FDFF4[]; +extern const u8 * const sOpponentMugshotsPals[]; +extern const u8 * const sPlayerMugshotsPals[2]; +extern const u8 sMugshotsTrainerPicIDsTable[]; +extern const s16 sMugshotsOpponentCoords[][2]; +extern const s16 sMugshotsOpponentRotationScales[][2]; +extern const TransitionSpriteCallback gUnknown_083FD880[]; +extern const s16 gUnknown_083FD89C[2]; +extern const s16 gUnknown_083FD8A0[2]; + +static const u32 gUnknown_083FBB88[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); +static const u32 gUnknown_083FC108[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); +const u32 gSpriteImage_83FC148[] = INCBIN_U32("graphics/battle_transitions/pokeball.4bpp"); +static const u32 gUnknown_083FC348[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); +const u32 gSpriteImage_83FC528[] = INCBIN_U32("graphics/battle_transitions/unused_brendan.4bpp"); +const u32 gSpriteImage_83FCD28[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); +const u32 gUnknown_083FD528[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); +struct TransitionData * const sTransitionStructPtr = &TRANSITION_STRUCT; + +static const TaskFunc sPhase1_Tasks[TRANSITIONS_NO] = +{ + [0 ... TRANSITIONS_NO - 1] = &Phase1Task_TransitionAll +}; + +static const TaskFunc sPhase2_Tasks[TRANSITIONS_NO] = +{ + &Phase2Task_Transition0, // 0 + &Phase2Task_Transition1, // 1 + &Phase2Task_Transition2, // 2 + &Phase2Task_Transition3, // 3 + &Phase2Task_Transition4, // 4 + &Phase2Task_Transition5, // 5 + &Phase2Task_Transition6, // 6 + &Phase2Task_Transition7, // 7 + &Phase2Task_Transition8, // 8 + &Phase2Task_Transition9, // 9 + &Phase2Task_Transition10, // 10 + &Phase2Task_Transition11, // 11 + &Phase2Task_Transition_Sydney, // 12 + &Phase2Task_Transition_Phoebe, // 13 + &Phase2Task_Transition_Glacia, // 14 + &Phase2Task_Transition_Drake, // 15 + &Phase2Task_Transition_Steven, // 16 +}; + +void sub_811C90C(struct Sprite* sprite); void sub_811AABC(u8 transitionID) { @@ -188,7 +256,7 @@ bool8 Transition_WaitForPhase2(struct Task* task) return 0; } -void Phase1Task_TransitionAll(u8 taskID) +static void Phase1Task_TransitionAll(u8 taskID) { if (gTasks[taskID].tState == 0) { @@ -199,7 +267,7 @@ void Phase1Task_TransitionAll(u8 taskID) DestroyTask(taskID); } -void Phase2Task_Transition0(u8 taskID) +static void Phase2Task_Transition0(u8 taskID) { while (sPhase2_Transition0_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } @@ -240,7 +308,7 @@ bool8 Phase2_Transition0_Func3(struct Task* task) return 0; } -void Phase2Task_Transition1(u8 taskID) +static void Phase2Task_Transition1(u8 taskID) { while (sPhase2_Transition1_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } @@ -300,7 +368,7 @@ static void HBlankCB_Phase2_Transition1(void) REG_BG3HOFS = var; } -void Phase2Task_Transition2(u8 taskID) +static void Phase2Task_Transition2(u8 taskID) { while (sPhase2_Transition2_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } @@ -367,14 +435,11 @@ static void HBlankCB_Phase2_Transition2(void) REG_BG3VOFS = var; } -void Phase2Task_Transition3(u8 taskID) +static void Phase2Task_Transition3(u8 taskID) { while (sPhase2_Transition3_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -extern const u8 gUnknown_083FBB88[]; -extern const u16 gFieldEffectObjectPalette10[]; - bool8 Phase2_Transition3_Func1(struct Task* task) { u16 i; @@ -410,8 +475,6 @@ bool8 Phase2_Transition3_Func1(struct Task* task) return 0; } -extern const u16 gUnknown_083FDB44[]; - bool8 Phase2_Transition3_Func2(struct Task* task) { s16 i, j; @@ -546,13 +609,11 @@ void VBlankCB1_Phase2_Transition3(void) DmaSet(0, gUnknown_03005560, ®_WIN0H, 0xA2400001); } -void Phase2Task_Transition4(u8 taskID) +static void Phase2Task_Transition4(u8 taskID) { while (sPhase2_Transition4_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -extern const u8 gUnknown_083FC108[]; - bool8 Phase2_Transition4_Func1(struct Task* task) { u16 *dst1, *dst2; @@ -566,10 +627,6 @@ bool8 Phase2_Transition4_Func1(struct Task* task) return 0; } -extern const s16 gUnknown_083FD7E4[2]; -extern const s16 gUnknown_083FD7F2[2]; -extern const s16 gUnknown_083FD7E8[5]; - bool8 Phase2_Transition4_Func2(struct Task* task) { s16 i; @@ -603,8 +660,6 @@ bool8 Phase2_Transition4_Func3(struct Task* task) return 0; } -extern const struct SpriteTemplate gSpriteTemplate_83FD98C; - bool8 FldEff_Pokeball(void) { u8 spriteID = CreateSpriteAtEnd(&gSpriteTemplate_83FD98C, gUnknown_0202FF84[0], gUnknown_0202FF84[1], 0); @@ -659,7 +714,7 @@ void sub_811B720(struct Sprite* sprite) } } -void Phase2Task_Transition5(u8 taskID) +static void Phase2Task_Transition5(u8 taskID) { while (sPhase2_Transition5_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } @@ -931,7 +986,7 @@ static void HBlankCB_Phase2_Transition6(void) REG_BG3VOFS = var; } -void Phase2Task_Transition7(u8 taskID) +static void Phase2Task_Transition7(u8 taskID) { while (sPhase2_Transition7_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } @@ -1009,33 +1064,35 @@ static void VBlankCB_Phase2_Transition7(void) DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } -#define tMugshotID data[15] +#define tMugshotOpponentID data[13] +#define tMugshotPlayerID data[14] +#define tMugshotID data[15] -void Phase2Task_Transition_Sydney(u8 taskID) +static void Phase2Task_Transition_Sydney(u8 taskID) { gTasks[taskID].tMugshotID = MUGSHOT_SYDNEY; Phase2Task_MugShotTransition(taskID); } -void Phase2Task_Transition_Phoebe(u8 taskID) +static void Phase2Task_Transition_Phoebe(u8 taskID) { gTasks[taskID].tMugshotID = MUGSHOT_PHOEBE; Phase2Task_MugShotTransition(taskID); } -void Phase2Task_Transition_Glacia(u8 taskID) +static void Phase2Task_Transition_Glacia(u8 taskID) { gTasks[taskID].tMugshotID = MUGSHOT_GLACIA; Phase2Task_MugShotTransition(taskID); } -void Phase2Task_Transition_Drake(u8 taskID) +static void Phase2Task_Transition_Drake(u8 taskID) { gTasks[taskID].tMugshotID = MUGSHOT_DRAKE; Phase2Task_MugShotTransition(taskID); } -void Phase2Task_Transition_Steven(u8 taskID) +static void Phase2Task_Transition_Steven(u8 taskID) { gTasks[taskID].tMugshotID = MUGSHOT_STEVEN; Phase2Task_MugShotTransition(taskID); @@ -1052,7 +1109,7 @@ bool8 Phase2_Mugshot_Func1(struct Task* task) sub_811D658(); dp12_8087EA4(); - sub_811C7B0(task); + Mugshots_CreateOpponentPlayerSprites(task); task->data[1] = 0; task->data[2] = 1; @@ -1072,11 +1129,6 @@ bool8 Phase2_Mugshot_Func1(struct Task* task) return 0; } -extern const u8 gUnknown_083FC348[]; -extern const u16 gUnknown_083FDFF4[]; -extern const u8 * const sOpponentMugshotsPals[]; -extern const u8 * const sPlayerMugshotsPals[2]; - bool8 Phase2_Mugshot_Func2(struct Task* task) { s16 i, j; @@ -1171,9 +1223,9 @@ bool8 Phase2_Mugshot_Func4(struct Task* task) TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; - sub_811CA10(task->data[13], 0); - sub_811CA10(task->data[14], 1); - sub_811CA28(task->data[13]); + sub_811CA10(task->tMugshotOpponentID, 0); + sub_811CA10(task->tMugshotPlayerID, 1); + sub_811CA28(task->tMugshotOpponentID); PlaySE(SE_BT_START); @@ -1185,10 +1237,10 @@ bool8 Phase2_Mugshot_Func5(struct Task* task) { TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; - if (sub_811CA44(task->data[13])) + if (sub_811CA44(task->tMugshotOpponentID)) { task->tState++; - sub_811CA28(task->data[14]); + sub_811CA28(task->tMugshotPlayerID); } return 0; } @@ -1197,7 +1249,7 @@ bool8 Phase2_Mugshot_Func6(struct Task* task) { TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; - if (sub_811CA44(task->data[14])) + if (sub_811CA44(task->tMugshotPlayerID)) { TRANSITION_STRUCT.field_0 = 0; SetVBlankCallback(NULL); @@ -1318,3 +1370,114 @@ static void HBlankCB_Phase2_Mugshots(void) else REG_BG0HOFS = TRANSITION_STRUCT.field_1A; } + +static void Mugshots_CreateOpponentPlayerSprites(struct Task* task) +{ + struct Sprite *opponentSprite, *playerSprite; + + s16 mugshotID = task->tMugshotID; + task->tMugshotOpponentID = CreateTrainerSprite(sMugshotsTrainerPicIDsTable[mugshotID], + sMugshotsOpponentCoords[mugshotID][0] - 32, + sMugshotsOpponentCoords[mugshotID][1] + 42, + 0, &ewram[0xC03C]); + task->tMugshotPlayerID = CreateTrainerSprite(gSaveBlock2.playerGender, 272, 106, 0, &ewram[0xC03C]); + + opponentSprite = &gSprites[task->tMugshotOpponentID]; + playerSprite = &gSprites[task->tMugshotPlayerID]; + + opponentSprite->callback = sub_811C90C; + playerSprite->callback = sub_811C90C; + + opponentSprite->oam.affineMode = 3; + playerSprite->oam.affineMode = 3; + + opponentSprite->oam.matrixNum = AllocOamMatrix(); + playerSprite->oam.matrixNum = AllocOamMatrix(); + + opponentSprite->oam.shape = 1; + playerSprite->oam.shape = 1; + + opponentSprite->oam.size = 3; + playerSprite->oam.size = 3; + + CalcCenterToCornerVec(opponentSprite, 1, 3, 3); + CalcCenterToCornerVec(playerSprite, 1, 3, 3); + + SetOamMatrixRotationScaling(opponentSprite->oam.matrixNum, sMugshotsOpponentRotationScales[mugshotID][0], sMugshotsOpponentRotationScales[mugshotID][1], 0); + SetOamMatrixRotationScaling(playerSprite->oam.matrixNum, -512, 0x200, 0); +} + +void sub_811C90C(struct Sprite* sprite) +{ + while (gUnknown_083FD880[sprite->data0](sprite)); +} + +bool8 sub_811C934(struct Sprite* sprite) +{ + return 0; +} + +bool8 sub_811C938(struct Sprite* sprite) +{ + s16 arr0[2]; + s16 arr1[2]; + + memcpy(arr0, gUnknown_083FD89C, sizeof(gUnknown_083FD89C)); + memcpy(arr1, gUnknown_083FD8A0, sizeof(gUnknown_083FD8A0)); + + sprite->data0++; + sprite->data1 = arr0[sprite->data7]; + sprite->data2 = arr1[sprite->data7]; + return 1; +} + +bool8 sub_811C984(struct Sprite* sprite) +{ + sprite->pos1.x += sprite->data1; + if (sprite->data7 && sprite->pos1.x < 133) + sprite->data0++; + else if (!sprite->data7 && sprite->pos1.x > 103) + sprite->data0++; + return 0; +} + +bool8 sub_811C9B8(struct Sprite* sprite) +{ + sprite->data1 += sprite->data2; + sprite->pos1.x += sprite->data1; + if (sprite->data1 == 0) + { + sprite->data0++; + sprite->data2 = -sprite->data2; + sprite->data6 = 1; + } + return 0; +} + +bool8 sub_811C9E4(struct Sprite* sprite) +{ + sprite->data1 += sprite->data2; + sprite->pos1.x += sprite->data1; + if (sprite->pos1.x < -31 || sprite->pos1.x > 271) + sprite->data0++; + return 0; +} + +static void sub_811CA10(s16 spriteID, s16 value) +{ + gSprites[spriteID].data7 = value; +} + +static void sub_811CA28(s16 spriteID) +{ + gSprites[spriteID].data0++; +} + +static s16 sub_811CA44(s16 spriteID) +{ + return gSprites[spriteID].data6; +} + +#undef tMugshotOpponentID +#undef tMugshotPlayerID +#undef tMugshotID diff --git a/src/field_effect.c b/src/field_effect.c index 3632d7053..cffed2614 100644 --- a/src/field_effect.c +++ b/src/field_effect.c @@ -618,13 +618,13 @@ bool8 FieldEffectActiveListContains(u8 id) return FALSE; } -u8 CreateTrainerSprite_BirchSpeech(u8 gender, s16 x, s16 y, u8 subpriority, u8 *buffer) +u8 CreateTrainerSprite(u8 trainerSpriteID, s16 x, s16 y, u8 subpriority, u8 *buffer) { struct SpriteTemplate spriteTemplate; - LoadCompressedObjectPaletteOverrideBuffer(&gTrainerFrontPicPaletteTable[gender], buffer); - LoadCompressedObjectPicOverrideBuffer(&gTrainerFrontPicTable[gender], buffer); - spriteTemplate.tileTag = gTrainerFrontPicTable[gender].tag; - spriteTemplate.paletteTag = gTrainerFrontPicPaletteTable[gender].tag; + LoadCompressedObjectPaletteOverrideBuffer(&gTrainerFrontPicPaletteTable[trainerSpriteID], buffer); + LoadCompressedObjectPicOverrideBuffer(&gTrainerFrontPicTable[trainerSpriteID], buffer); + spriteTemplate.tileTag = gTrainerFrontPicTable[trainerSpriteID].tag; + spriteTemplate.paletteTag = gTrainerFrontPicPaletteTable[trainerSpriteID].tag; spriteTemplate.oam = &gOamData_839F0F4; spriteTemplate.anims = gDummySpriteAnimTable; spriteTemplate.images = NULL; diff --git a/src/main_menu.c b/src/main_menu.c index 09fd06d9e..3b616065b 100644 --- a/src/main_menu.c +++ b/src/main_menu.c @@ -1421,14 +1421,14 @@ void AddBirchSpeechObjects(u8 taskId) gTasks[taskId].data[TD_AZURILL_SPRITE_ID] = spriteId; //Create Brendan sprite - spriteId = CreateTrainerSprite_BirchSpeech(0, 120, 60, 0, unk_2000000); + spriteId = CreateTrainerSprite(0, 120, 60, 0, unk_2000000); gSprites[spriteId].callback = nullsub_34; gSprites[spriteId].invisible = 1; gSprites[spriteId].oam.priority = 0; gTasks[taskId].data[TD_BRENDAN_SPRITE_ID] = spriteId; //Create May sprite - spriteId = CreateTrainerSprite_BirchSpeech(1, 120, 60, 0, unk_2000000 + 0x800); + spriteId = CreateTrainerSprite(1, 120, 60, 0, unk_2000000 + 0x800); gSprites[spriteId].callback = nullsub_34; gSprites[spriteId].invisible = 1; gSprites[spriteId].oam.priority = 0; -- cgit v1.2.3 From a5b770a5112914468158842885b0b37f5425c887 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 20 Aug 2017 23:12:00 +0200 Subject: some more functions --- src/battle_transition.c | 52 ++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 47 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 8d87f12f6..9ef012bb2 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -74,6 +74,10 @@ static void Phase2Task_Transition_Phoebe(u8 taskID); static void Phase2Task_Transition_Glacia(u8 taskID); static void Phase2Task_Transition_Drake(u8 taskID); static void Phase2Task_Transition_Steven(u8 taskID); +static bool8 Transition_Phase1(struct Task* task); +static bool8 Transition_WaitForPhase1(struct Task* task); +static bool8 Transition_Phase2(struct Task* task); +static bool8 Transition_WaitForPhase2(struct Task* task); static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); @@ -112,7 +116,6 @@ static s16 sub_811CA44(s16 spriteID); typedef bool8 (*TransitionState)(struct Task* task); typedef bool8 (*TransitionSpriteCallback)(struct Sprite* sprite); -extern const TransitionState sMainTransitionPhases[]; extern const TransitionState sPhase2_Transition0_Funcs[]; extern const TransitionState sPhase2_Transition1_Funcs[]; extern const TransitionState sPhase2_Transition2_Funcs[]; @@ -121,6 +124,7 @@ extern const TransitionState sPhase2_Transition4_Funcs[]; extern const TransitionState sPhase2_Transition5_Funcs[]; extern const TransitionState sPhase2_Transition6_Funcs[]; extern const TransitionState sPhase2_Transition7_Funcs[]; +extern const TransitionState sPhase2_Transition8_Funcs[]; extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; extern const u16 gFieldEffectObjectPalette10[]; extern const u16 gUnknown_083FDB44[]; @@ -173,6 +177,14 @@ static const TaskFunc sPhase2_Tasks[TRANSITIONS_NO] = &Phase2Task_Transition_Steven, // 16 }; +static const TransitionState sMainTransitionPhases[] = +{ + &Transition_Phase1, + &Transition_WaitForPhase1, + &Transition_Phase2, + &Transition_WaitForPhase2 +}; + void sub_811C90C(struct Sprite* sprite); void sub_811AABC(u8 transitionID) @@ -213,7 +225,7 @@ static void Task_BattleTransitionMain(u8 taskID) while (sMainTransitionPhases[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Transition_Phase1(struct Task* task) +static bool8 Transition_Phase1(struct Task* task) { sub_807DE10(); CpuSet(gPlttBufferFaded, gPlttBufferUnfaded, 0x4000100); @@ -230,7 +242,7 @@ bool8 Transition_Phase1(struct Task* task) } } -bool8 Transition_WaitForPhase1(struct Task* task) +static bool8 Transition_WaitForPhase1(struct Task* task) { if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionID]) == 0xFF) { @@ -241,14 +253,14 @@ bool8 Transition_WaitForPhase1(struct Task* task) return 0; } -bool8 Transition_Phase2(struct Task* task) +static bool8 Transition_Phase2(struct Task* task) { CreateTask(sPhase2_Tasks[task->tTransitionID], 0); task->tState++; return 0; } -bool8 Transition_WaitForPhase2(struct Task* task) +static bool8 Transition_WaitForPhase2(struct Task* task) { task->tTransitionDone = 0; if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionID]) == 0xFF) @@ -1481,3 +1493,33 @@ static s16 sub_811CA44(s16 spriteID) #undef tMugshotOpponentID #undef tMugshotPlayerID #undef tMugshotID + +void Phase2Task_Transition8(u8 taskID) +{ + while (sPhase2_Transition8_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition7_Func1(struct Task* task) +{ + u8 i; + + sub_811D658(); + dp12_8087EA4(); + + task->data[2] = 256; + task->data[3] = 256; + TRANSITION_STRUCT.WININ = 63; + TRANSITION_STRUCT.WINOUT = 0; + TRANSITION_STRUCT.WIN0V = 160; + + for (i = 0; i < 160; i++) + { + gUnknown_03004DE0[1][i] = TRANSITION_STRUCT.field_14; + gUnknown_03004DE0[1][160 + i] = 0xF0; + } + + SetVBlankCallback(VBlankCB_Phase2_Transition7); + + task->tState++; + return 1; +} -- cgit v1.2.3 From 872c04bd73b5fb1f68f5f5a668b70cdd778a397f Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 20 Aug 2017 23:15:13 +0200 Subject: cam fixed the last nonmatching function --- src/battle_message.c | 96 ++-------------------------------------------------- 1 file changed, 2 insertions(+), 94 deletions(-) (limited to 'src') diff --git a/src/battle_message.c b/src/battle_message.c index 350856818..37ec14459 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -937,17 +937,14 @@ void sub_8121D1C(u8* textBuff) } } -#ifdef NONMATCHING - void sub_8121D74(u8* dst) { s32 counter = 0; - s32 i; + s32 i = 0; while (*dst != EOS) dst++; - i = 0; while (counter != 4) { if (gUnknown_084016BC[i] == 0) @@ -955,6 +952,7 @@ void sub_8121D74(u8* dst) if (gUnknown_084016BC[i++] == gStringInfo->currentMove) break; } + switch (counter) { case 0: @@ -974,93 +972,3 @@ void sub_8121D74(u8* dst) break; } } - -#else -__attribute__((naked)) -void sub_8121D74(u8* dst) -{ - asm(".syntax unified\n\ - push {r4,r5,lr}\n\ - adds r3, r0, 0\n\ - movs r4, 0\n\ - b _08121D7E\n\ -_08121D7C:\n\ - adds r3, 0x1\n\ -_08121D7E:\n\ - ldrb r0, [r3]\n\ - cmp r0, 0xFF\n\ - bne _08121D7C\n\ - ldr r1, _08121DB4 @ =gUnknown_084016BC\n\ - ldr r5, _08121DB8 @ =gSelectedOrderFromParty\n\ - movs r0, 0\n\ - lsls r0, 1\n\ - adds r2, r0, r1\n\ -_08121D8E:\n\ - cmp r4, 0x4\n\ - beq _08121DA8\n\ - ldrh r1, [r2]\n\ - cmp r1, 0\n\ - bne _08121D9A\n\ - adds r4, 0x1\n\ -_08121D9A:\n\ - ldr r0, [r5]\n\ - adds r2, 0x2\n\ - ldrh r0, [r0]\n\ - cmp r1, r0\n\ - bne _08121D8E\n\ - cmp r4, 0x4\n\ - bhi _08121E04\n\ -_08121DA8:\n\ - lsls r0, r4, 2\n\ - ldr r1, _08121DBC @ =_08121DC0\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ -_08121DB4: .4byte gUnknown_084016BC\n\ -_08121DB8: .4byte gSelectedOrderFromParty\n\ -_08121DBC: .4byte _08121DC0\n\ - .align 2, 0\n\ -_08121DC0:\n\ - .4byte _08121DD4\n\ - .4byte _08121DDC\n\ - .4byte _08121DE4\n\ - .4byte _08121DEC\n\ - .4byte _08121DFC\n\ -_08121DD4:\n\ - ldr r1, _08121DD8 @ =gUnknown_084007C8\n\ - b _08121DEE\n\ - .align 2, 0\n\ -_08121DD8: .4byte gUnknown_084007C8\n\ -_08121DDC:\n\ - ldr r1, _08121DE0 @ =gUnknown_084007CA\n\ - b _08121DEE\n\ - .align 2, 0\n\ -_08121DE0: .4byte gUnknown_084007CA\n\ -_08121DE4:\n\ - ldr r1, _08121DE8 @ =gUnknown_084007CC\n\ - b _08121DEE\n\ - .align 2, 0\n\ -_08121DE8: .4byte gUnknown_084007CC\n\ -_08121DEC:\n\ - ldr r1, _08121DF8 @ =gUnknown_084007CE\n\ -_08121DEE:\n\ - adds r0, r3, 0\n\ - bl StringCopy\n\ - b _08121E04\n\ - .align 2, 0\n\ -_08121DF8: .4byte gUnknown_084007CE\n\ -_08121DFC:\n\ - ldr r1, _08121E0C @ =gUnknown_084007D0\n\ - adds r0, r3, 0\n\ - bl StringCopy\n\ -_08121E04:\n\ - pop {r4,r5}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_08121E0C: .4byte gUnknown_084007D0\n\ - .syntax divided"); -} - -#endif // NONMATCHING -- cgit v1.2.3 From 88f0eef3f20dc3e1c8411c02862700669dad0932 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sun, 20 Aug 2017 16:27:51 -0500 Subject: make IsMonAllowedInBattleTower match --- src/choose_party.c | 96 ++++-------------------------------------------------- 1 file changed, 7 insertions(+), 89 deletions(-) (limited to 'src') diff --git a/src/choose_party.c b/src/choose_party.c index d8df44028..7b2c833e1 100644 --- a/src/choose_party.c +++ b/src/choose_party.c @@ -211,11 +211,10 @@ bool8 sub_8121E78(void) return FALSE; } -#ifdef NONMATCHING static bool8 IsMonAllowedInBattleTower(struct Pokemon *pkmn) { - u16 r3; - s32 i; + u16 species; + s32 i = 0; if (GetMonData(pkmn, MON_DATA_IS_EGG)) return FALSE; @@ -232,97 +231,16 @@ static bool8 IsMonAllowedInBattleTower(struct Pokemon *pkmn) && GetMonData(pkmn, MON_DATA_LEVEL) > 50) return FALSE; - r3 = GetMonData(pkmn, MON_DATA_SPECIES); - // Can't stop the compiler from optimizing out the first index - for (i = 0; gBattleTowerBanlist[i] != 0xFFFF; i++) + // Check if the pkmn is in the ban list + species = GetMonData(pkmn, MON_DATA_SPECIES); + while (gBattleTowerBanlist[i] != 0xFFFF) { - if (gBattleTowerBanlist[i] == r3) + if (gBattleTowerBanlist[i] == species) return FALSE; + i++; } return TRUE; } -#else -__attribute__((naked)) -static bool8 IsMonAllowedInBattleTower(struct Pokemon *pkmn) -{ - asm_unified( - "push {r4,lr}\n\ - adds r4, r0, 0\n\ - movs r1, 0x2D\n\ - bl GetMonData\n\ - cmp r0, 0\n\ - bne _0812207C\n\ - ldr r0, _08122058 @ =0x0201b000\n\ - ldr r1, _0812205C @ =0x00000263\n\ - adds r0, r1\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - bne _08122060\n\ - adds r0, r4, 0\n\ - movs r1, 0x39\n\ - bl GetMonData\n\ - cmp r0, 0\n\ - beq _0812207C\n\ - b _081220B6\n\ - .align 2, 0\n\ -_08122058: .4byte 0x0201b000\n\ -_0812205C: .4byte 0x00000263\n\ -_08122060:\n\ - ldr r0, _08122080 @ =gSaveBlock2\n\ - ldr r1, _08122084 @ =0x00000554\n\ - adds r0, r1\n\ - ldrb r1, [r0]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08122088\n\ - adds r0, r4, 0\n\ - movs r1, 0x38\n\ - bl GetMonData\n\ - cmp r0, 0x32\n\ - bls _08122088\n\ -_0812207C:\n\ - movs r0, 0\n\ - b _081220B8\n\ - .align 2, 0\n\ -_08122080: .4byte gSaveBlock2\n\ -_08122084: .4byte 0x00000554\n\ -_08122088:\n\ - adds r0, r4, 0\n\ - movs r1, 0xB\n\ - bl GetMonData\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - ldr r1, _081220C0 @ =gBattleTowerBanlist\n\ - movs r0, 0\n\ - lsls r0, 1\n\ - adds r2, r0, r1\n\ - ldrh r0, [r2]\n\ - ldr r1, _081220C4 @ =0x0000ffff\n\ - cmp r0, r1\n\ - beq _081220B6\n\ - adds r4, r1, 0\n\ - adds r1, r2, 0\n\ -_081220A8:\n\ - ldrh r0, [r1]\n\ - cmp r0, r3\n\ - beq _0812207C\n\ - adds r1, 0x2\n\ - ldrh r0, [r1]\n\ - cmp r0, r4\n\ - bne _081220A8\n\ -_081220B6:\n\ - movs r0, 0x1\n\ -_081220B8:\n\ - pop {r4}\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ -_081220C0: .4byte gBattleTowerBanlist\n\ -_081220C4: .4byte 0x0000ffff\n" - ); -} -#endif static u8 sub_81220C8(void) { -- cgit v1.2.3 From aa053f1948dcb03213105c63ed81f197909222c6 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sun, 20 Aug 2017 21:32:22 -0400 Subject: sub_80B33D0 --- src/shop.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index d53646a88..5cc1f276e 100644 --- a/src/shop.c +++ b/src/shop.c @@ -340,3 +340,12 @@ void BuyMenuDrawMapMetatile(int var1, int var2, u16 *var3, s8 var4) break; } } + +void sub_80B33D0(s16 var1, int var2, u16 *var3) +{ + s16 offset1 = var1 * 2; + s16 offset2 = (var2 * 0x40) + 0x40; + + BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[3], offset1, offset2, var3); + BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[2], offset1, offset2, var3 + 4); +} -- cgit v1.2.3 From 56eacd725bb6da9c4ff0b0b4f8058341deba3e97 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 21 Aug 2017 10:41:07 +0200 Subject: fix german build of berry blender --- src/berry_blender.c | 41 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 38 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index cbf50fdb3..d1c90fcbb 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -201,6 +201,9 @@ void sub_814A880(u8 a1, u8 a2); u8 sub_814A5C0(u8 a1, u16 a2, u8 a3, u16 a4, u8 a5); s8 sub_810CA00(void); bool8 sub_810CA34(struct Pokeblock *pokeblock); +#ifdef GERMAN +extern void de_sub_8073110(); +#endif extern struct MusicPlayerInfo gMPlay_SE2; extern struct MusicPlayerInfo gMPlay_BGM; @@ -584,7 +587,7 @@ static void sub_804E884(u8 a0) if (a0) { for (i = 0; i < 4; i++) - gLinkPlayers[i].language = LANGUAGE_ENGLISH; + gLinkPlayers[i].language = GAME_LANGUAGE; } switch (a0) { @@ -2179,7 +2182,7 @@ static void sub_8050954(void) UpdatePaletteFade(); } -static bool8 sub_8050CE8(void) +bool8 sub_8050CE8(void) { switch (gBerryBlenderData->field_1C4) { @@ -2255,16 +2258,26 @@ static void sub_8050E30(void) gBerryBlenderData->field_6F = 3; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); +#ifdef ENGLISH StringCopy(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); StringAppend(gStringVar4, gOtherText_OtherCaseIsFull); +#else + StringCopy(gStringVar4, gOtherText_OtherCaseIsFull); + de_sub_8073110(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); +#endif MenuPrintMessage(gStringVar4, 1, 15); break; case 2: gBerryBlenderData->field_6F++; DestroyMenuCursor(); MenuZeroFillWindowRect(23, 8, 28, 13); +#ifdef ENGLISH StringCopy(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); StringAppend(gStringVar4, gOtherText_NoBerriesForBlend); +#else + StringCopy(gStringVar4, gOtherText_NoBerriesForBlend); + de_sub_8073110(gStringVar4, gLinkPlayers[gBerryBlenderData->field_7A].name); +#endif MenuPrintMessage(gStringVar4, 1, 15); break; case 3: @@ -2855,7 +2868,11 @@ static bool8 Blender_PrintBlendingResults(void) StringCopy(textPtr, gBerryBlenderData->blendedBerries[place].name); ConvertInternationalString(textPtr, gLinkPlayers[place].language); +#ifdef ENGLISH StringAppend(textPtr, gOtherText_Berry); +#else + de_sub_8073174(textPtr, gOtherText_Berry); +#endif textPtr = gBerryBlenderData->stringVar; textPtr = ConvertIntToDecimalString(textPtr, i + 1); textPtr[0] = CHAR_SPACE; @@ -2871,12 +2888,16 @@ static bool8 Blender_PrintBlendingResults(void) textPtr = StringCopy(textPtr, gOtherText_MaxSpeed); textPtr = sub_8072C14(textPtr, gBerryBlenderData->max_RPM / 100, 121, 1); +#ifdef ENGLISH textPtr[0] = CHAR_SPACE; textPtr[1] = CHAR_PERIOD; textPtr[2] = CHAR_SPACE; textPtr += 3; - textPtr = sub_8072C74(textPtr, text[0], 142, 1); +#else + *textPtr++ = CHAR_COMMA; + textPtr = sub_8072C74(textPtr, text[0], 136, 1); +#endif StringCopy(textPtr, gOtherText_RPM); MenuPrint(gBerryBlenderData->stringVar, 5, 13); @@ -2888,7 +2909,11 @@ static bool8 Blender_PrintBlendingResults(void) textPtr = gBerryBlenderData->stringVar; textPtr = StringCopy(textPtr, gOtherText_RequiredTime); +#ifdef ENGLISH textPtr = sub_8072C74(textPtr, text[0], 102, 1); +#else + textPtr = sub_8072C74(textPtr, text[0], 99, 1); +#endif textPtr = StringAppend(textPtr, gOtherText_Min); textPtr = sub_8072C74(textPtr, text[1], 136, 1); @@ -2939,7 +2964,11 @@ static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* ds dst[0] = EOS; StringCopy(dst, gPokeblockNames[pokeblock->color]); +#ifdef ENGLISH StringAppend(dst, gOtherText_PokeBlockMade); +#else + de_sub_8073174(dst, gOtherText_PokeBlockMade); +#endif StringAppend(dst, gUnknown_082162C8); flavourLvl = sub_810C9B0(pokeblock); @@ -3335,10 +3364,16 @@ void ShowBerryBlenderRecordWindow(void) { u32 record = gSaveBlock1.berryBlenderRecords[i]; u8* txtPtr = sub_8072C14(text, record / 100, 18, 1); + +#ifdef ENGLISH txtPtr[0] = CHAR_SPACE; txtPtr[1] = CHAR_PERIOD; txtPtr[2] = CHAR_SPACE; txtPtr += 3; +#else + *txtPtr++ = CHAR_COMMA; +#endif + txtPtr = ConvertIntToDecimalStringN(txtPtr, record % 100, 2, 2); StringAppend(txtPtr, gOtherText_RPM); MenuPrint(text, 15, i * 2 + 9); -- cgit v1.2.3 From bfbe446e73b945926e3581ef25d50291451b06b0 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 21 Aug 2017 13:42:49 +0200 Subject: moved all data to C --- src/berry_blender.c | 672 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 580 insertions(+), 92 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index d1c90fcbb..772de43f7 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -212,53 +212,21 @@ extern u16 gScriptItemId; extern u8 gUnknown_020297ED; extern u8 byte_3002A68; -// rom data to do - extern const u8 gUnknown_08E6C100[]; -extern const u8 gUnknown_08215C2C[]; extern const u8 gUnknown_08E6C920[]; extern const u8 gUnknown_08E6D354[]; -extern const u16 gUnknown_08215C0C[]; -extern const u16 gUnknown_0821602C[]; -extern const struct SpriteSheet gUnknown_082163DC; -extern const struct SpriteSheet gUnknown_082164F4; -extern const struct SpriteSheet gUnknown_08216454; -extern const struct SpriteSheet gUnknown_08216540; -extern const struct SpriteSheet gUnknown_08216574; -extern const struct SpritePalette gUnknown_082163EC; -extern const struct SpritePalette gUnknown_082163E4; extern const struct WindowConfig gWindowConfig_81E6F68; -extern const u8 sBlenderSyncArrowsPos[][2]; -extern const struct SpriteTemplate sBlenderSyncArrow_SpriteTemplate; -extern const s16 gUnknown_08216594[][5]; -extern const u8* const gUnknown_082162B8[]; -extern const u8 gUnknown_082162EC[3][4]; -extern const u16 gUnknown_082162F8[]; -extern const u8 gUnknown_08216300[]; -extern const struct SpriteTemplate gSpriteTemplate_8216548; -extern const u8 gUnknown_08216303[]; -extern const u8 gUnknown_082165BC[][3]; -extern const u8 gUnknown_082162C4[]; -extern const u8 gUnknown_082162D4[][2]; -extern const TaskFunc gUnknown_08216308[]; -extern const s8 gUnknown_082162CC[][2]; -extern const struct SpriteTemplate gSpriteTemplate_821645C; -extern const u8 gUnknown_082165DA[]; -extern const u8 gUnknown_082165DF[]; -extern const struct SpriteTemplate gSpriteTemplate_82164FC; -extern const u8* const gUnknown_08216284[]; -extern const struct SpriteTemplate gSpriteTemplate_821657C; -extern const u8 gUnknown_082165E9[]; -extern const u8 gUnknown_082165EE[]; -extern const u8 gUnknown_08216249[]; -extern const u8 gUnknown_082162C8[]; extern const u8 *const gPokeblockNames[]; -extern const u8 gUnknown_082165F3[]; -extern const u8 gOtherText_BPMAndDash[]; -extern const u8 gUnknown_082165F8[]; -extern const u8 gUnknown_08216600[]; extern const struct Berry gBerries[]; +extern const u8 gBerryBlenderArrowTiles[]; +extern const u8 gBerryBlenderMarubatsuTiles[]; +extern const u8 gBerryBlenderParticlesTiles[]; +extern const u8 gBerryBlenderCountdownNumbersTiles[]; +extern const u8 gBerryBlenderStartTiles[]; +extern const u16 gBerryBlenderMiscPalette[]; +extern const u16 gBerryBlenderArrowPalette[]; + // ewram static EWRAM_DATA u8 gUnknown_020297DC = 0; static EWRAM_DATA u32 gUnknown_020297E0 = 0; @@ -267,7 +235,7 @@ static EWRAM_DATA u8 gUnknown_020297E8 = 0; // iwram common u16 gUnknown_03004830; -u8 gUnknown_03004834; +u8 gInGameOpponentsNo; u16 gUnknown_03004840[10]; struct BerryBlenderData* gBerryBlenderData; @@ -287,7 +255,7 @@ void Blender_SetBankBerryData(u8 bank, u16 itemID); static void sub_80514A4(void); static void sub_80514F0(void); static void sub_804E56C(void); -static void sub_804E884(u8 a0); +static void Blender_SetPlayerNamesLocal(u8 NoOfOpponents); static void sub_8051474(void); static void sub_804E9F8(void); static void sub_804F378(void); @@ -313,6 +281,526 @@ static void sub_805197C(u16 a0, u16 a1); static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst); static void sub_8052BD0(u8 taskID); static void sub_8052AF8(void); +static void sub_804F8C8(u8 taskID); +static void sub_804F9F4(u8 taskID); +static void sub_804FB1C(u8 taskID); +static void sub_8051C04(struct Sprite* sprite); +static void sub_8051650(struct Sprite* sprite); +static void sub_805181C(struct Sprite* sprite); +static void sub_80518CC(struct Sprite* sprite); + +// const data +static const u16 sBlenderCenterPal[] = INCBIN_U16("graphics/berry_blender/center.gbapal"); +static const u8 sBlenderCenterMap[] = INCBIN_U8("graphics/berry_blender/center_map.bin"); +static const u16 sBlenderOuterPal[] = INCBIN_U16("graphics/berry_blender/outer.gbapal"); + +// unreferenced pals? +static const u16 sUnknownPal_0[] = INCBIN_U16("graphics/unused/unknown/821604C.gbapal"); +static const u16 sUnknownArray_1[224] = {0}; + +// unreferenced Japanese strings +static const u8 sUnknownJpnString0[] = _("▶"); +static const u8 sUnknownJpnString1[] = _(" "); +static const u8 sUnknownJpnString2[] = _("カッコイ"); // "cool" (missing an イ at the end) +static const u8 sUnknownJpnString3[] = _("カワイイ"); // "cute" +static const u8 sUnknownJpnString4[] = _("ウツクシ"); // "beautiful" (missing an イ at the end) +static const u8 sUnknownJpnString5[] = _("カシコイ"); // "smart" +static const u8 sUnknownJpnString6[] = _("タクマシ"); // "tough" (missing an イ at the end) + +static const u8 gUnknown_08216249[] = _("\p"); + +// unreferenced; These appear to be the first names of four people who worked on the game. +static const u8 sUnknownJpnString7[10] = _("てつじ"); // Tetsuji (Ohta) +static const u8 sUnknownJpnString8[10] = _("あきと"); // Akito (Mori) +static const u8 sUnknownJpnString9[10] = _("シゲル"); // Shigeru (Ohmori) +static const u8 sUnknownJpnString10[10] = _("ヨシノリ"); // Yoshinori (Matsuda) + +static const u8 sUnknownText_2Pok[] = _("2Pok"); +static const u8 sUnknownText_3Pok[] = _("3Pok"); +static const u8 sUnknownText_4Pok[] = _("4Pok"); +static const u8* const gUnknown_08216284[] = +{ + sUnknownText_2Pok, sUnknownText_3Pok, sUnknownText_4Pok +}; + +// unreferenced player strings +static const u8 sUnknown1PString[4] = _("1P"); +static const u8 sUnknown2PString[4] = _("2P"); +static const u8 sUnknown3PString[4] = _("3P"); +static const u8 sUnknown4PString[4] = _("4P"); + +#ifdef ENGLISH +static const u8 sBlenderOpponentName1[] = _("MISTER"); +static const u8 sBlenderOpponentName2[] = _("LADDIE"); +static const u8 sBlenderOpponentName3[] = _("LASSIE"); +#else // GERMAN +static const u8 sBlenderOpponentName1[] = _("OPI"); +static const u8 sBlenderOpponentName2[] = _("KUMPEL"); +static const u8 sBlenderOpponentName3[] = _("TUSSI"); +#endif // ENGLISH +static const u8* const sBlenderOpponentsNames[] = +{ + sBlenderOpponentName1, sBlenderOpponentName2, sBlenderOpponentName3 +}; + +static const u8 sRedColorString[] = _("{COLOR RED}"); +static const u8 sNewLineString_0[] = _("\n"); +static const u8 sSpaceString_0[] = _(" "); + +static const s8 gUnknown_082162CC[][2] = +{ + {-1, -1}, {1, -1}, {-1, 1}, {1, 1} +}; + +static const u8 gUnknown_082162D4[][2] = +{ + {2, 6}, {23, 6}, {2, 12}, {23, 12}, {1, 6}, {22, 6}, {1, 12}, {22, 12} +}; + +static const u8 sBlenderSyncArrowsPos[][2] = +{ + {72, 32}, {168, 32}, {72, 128}, {168, 128} +}; + +static const u8 gUnknown_082162EC[3][4] = +{ + {-1, 0, 1, -1}, {-1, 0, 1, 2}, {0, 1, 2, 3} +}; + +static const u16 gUnknown_082162F8[] = {0, 0xC000, 0x4000, 0x8000}; +static const u8 gUnknown_08216300[] = {1, 1, 0}; +static const u8 gUnknown_08216303[] = {32, 224, 96, 160, 0}; + +static const TaskFunc gUnknown_08216308[] = +{ + &sub_804F8C8, &sub_804F9F4, &sub_804FB1C +}; + +static const struct OamData sOamData_8216314 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 2, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_821631C[] = +{ + ANIMCMD_FRAME(16, 5, 1, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216324[] = +{ + ANIMCMD_FRAME(16, 5, 0, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821632C[] = +{ + ANIMCMD_FRAME(16, 5, 1, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216334[] = +{ + ANIMCMD_FRAME(16, 5, 0, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821633C[] = +{ + ANIMCMD_FRAME(48, 2, 1, 1), + ANIMCMD_FRAME(32, 5, 1, 1), + ANIMCMD_FRAME(48, 3, 1, 1), + ANIMCMD_FRAME(16, 5, 1, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216350[] = +{ + ANIMCMD_FRAME(48, 2, 0, 1), + ANIMCMD_FRAME(32, 5, 0, 1), + ANIMCMD_FRAME(48, 3, 0, 1), + ANIMCMD_FRAME(16, 5, 0, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216364[] = +{ + ANIMCMD_FRAME(48, 2, 1, 0), + ANIMCMD_FRAME(32, 5, 1, 0), + ANIMCMD_FRAME(48, 3, 1, 0), + ANIMCMD_FRAME(16, 5, 1, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216378[] = +{ + ANIMCMD_FRAME(48, 2, 0, 0), + ANIMCMD_FRAME(32, 5, 0, 0), + ANIMCMD_FRAME(48, 3, 0, 0), + ANIMCMD_FRAME(16, 5, 0, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821638C[] = +{ + ANIMCMD_FRAME(0, 5, 1, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216394[] = +{ + ANIMCMD_FRAME(0, 5, 0, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821639C[] = +{ + ANIMCMD_FRAME(0, 5, 1, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_82163A4[] = +{ + ANIMCMD_FRAME(0, 5, 0, 0), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_82163AC[] = +{ + sSpriteAnim_821631C, + sSpriteAnim_8216324, + sSpriteAnim_821632C, + sSpriteAnim_8216334, + sSpriteAnim_821633C, + sSpriteAnim_8216350, + sSpriteAnim_8216364, + sSpriteAnim_8216378, + sSpriteAnim_821638C, + sSpriteAnim_8216394, + sSpriteAnim_821639C, + sSpriteAnim_82163A4 +}; + +static const struct SpriteSheet gUnknown_082163DC = +{ + gBerryBlenderArrowTiles, 0x800, 46545 +}; + +static const struct SpritePalette gUnknown_082163E4 = +{ + gBerryBlenderMiscPalette, 46546 +}; + +static const struct SpritePalette gUnknown_082163EC = +{ + gBerryBlenderArrowPalette, 12312 +}; + +static const struct SpriteTemplate sBlenderSyncArrow_SpriteTemplate = +{ + .tileTag = 46545, + .paletteTag = 12312, + .oam = &sOamData_8216314, + .anims = sSpriteAnimTable_82163AC, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8051C04 +}; + +static const struct OamData sOamData_821640C = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 1, + .tileNum = 0, + .priority = 0, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_8216414[] = +{ + ANIMCMD_FRAME(0, 20), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821641C[] = +{ + ANIMCMD_FRAME(4, 20, 1, 0), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216424[] = +{ + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_FRAME(12, 4), + ANIMCMD_FRAME(8, 4), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821643C[] = +{ + ANIMCMD_FRAME(8, 4), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_8216444[] = +{ + sSpriteAnim_8216414, + sSpriteAnim_821641C, + sSpriteAnim_8216424, + sSpriteAnim_821643C, +}; + +static const struct SpriteSheet gUnknown_08216454 = +{ + gBerryBlenderMarubatsuTiles, 0x200, 48888 +}; + +static const struct SpriteTemplate sSpriteTemplate_821645C = +{ + .tileTag = 48888, + .paletteTag = 46546, + .oam = &sOamData_821640C, + .anims = sSpriteAnimTable_8216444, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_8051650 +}; + +static const struct OamData sOamData_8216474 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 0, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_821647C[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(3, 5), + ANIMCMD_FRAME(1, 4), + ANIMCMD_FRAME(0, 3), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216494[] = +{ + ANIMCMD_FRAME(0, 3), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(4, 5), + ANIMCMD_FRAME(2, 4), + ANIMCMD_FRAME(0, 3), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_82164AC[] = +{ + ANIMCMD_FRAME(0, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(4, 4), + ANIMCMD_FRAME(3, 3), + ANIMCMD_FRAME(2, 2), + ANIMCMD_FRAME(1, 2), + ANIMCMD_FRAME(0, 2), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_82164D0[] = +{ + ANIMCMD_FRAME(5, 5, 1, 1), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_82164D8[] = +{ + ANIMCMD_FRAME(6, 5, 1, 1), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_82164E0[] = +{ + sSpriteAnim_821647C, + sSpriteAnim_8216494, + sSpriteAnim_82164AC, + sSpriteAnim_82164D0, + sSpriteAnim_82164D8, +}; + +static const struct SpriteSheet gUnknown_082164F4 = +{ + gBerryBlenderParticlesTiles, 0xE0, 23456 +}; + +static const struct SpriteTemplate sSpriteTemplate_82164FC = +{ + .tileTag = 23456, + .paletteTag = 46546, + .oam = &sOamData_8216474, + .anims = sSpriteAnimTable_82164E0, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = SpriteCallbackDummy +}; + +static const struct OamData sOamData_8216514 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 2, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_821651C[] = +{ + ANIMCMD_FRAME(32, 30), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_8216524[] = +{ + ANIMCMD_FRAME(16, 30), + ANIMCMD_END +}; + +static const union AnimCmd sSpriteAnim_821652C[] = +{ + ANIMCMD_FRAME(0, 30), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_8216534[] = +{ + sSpriteAnim_821651C, + sSpriteAnim_8216524, + sSpriteAnim_821652C, +}; + +static const struct SpriteSheet gUnknown_08216540 = +{ + gBerryBlenderCountdownNumbersTiles, 0x600, 12345 +}; + +static const struct SpriteTemplate sSpriteTemplate_8216548 = +{ + .tileTag = 12345, + .paletteTag = 46546, + .oam = &sOamData_8216514, + .anims = sSpriteAnimTable_8216534, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_805181C +}; + +static const struct OamData sOamData_8216560 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 1, + .x = 0, + .matrixNum = 0, + .size = 3, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_8216568[] = +{ + ANIMCMD_FRAME(0, 30), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_8216570[] = +{ + sSpriteAnim_8216568, +}; + +static const struct SpriteSheet gUnknown_08216574 = +{ + gBerryBlenderStartTiles, 0x400, 12346 +}; + +static const struct SpriteTemplate sSpriteTemplate_821657C = +{ + .tileTag = 12346, + .paletteTag = 46546, + .oam = &sOamData_8216560, + .anims = sSpriteAnimTable_8216570, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_80518CC +}; + +static const s16 gUnknown_08216594[][5] = +{ + {-10, 20, 10, 2, 1}, + {250, 20, 10, -2, 1}, + {-10, 140, 10, 2, -1}, + {250, 140, 10, -2, -1}, +}; + +static const u8 gUnknown_082165BC[][3] = +{ + {4, 3, 2}, {0, 4, 3}, {1, 0, 4}, {2, 1, 0}, {3, 2, 1}, {0, 2, 3}, {1, 3, 4}, {2, 4, 0}, {3, 0, 1}, {4, 1, 2}, +}; + +static const u8 gUnknown_082165DA[] = {1, 1, 2, 3, 4}; +static const u8 gUnknown_082165DF[] = {0x1C, 0x16, 0x13, 0x1A, 0x19, 0x0E, 0x0D, 0x0B, 0x07, 0x15}; +static const u8 gUnknown_082165E9[] = {6, 6, 6, 6, 5}; +static const u8 gUnknown_082165EE[] = {3, 3, 3, 2, 2}; +static const u8 gUnknown_082165F3[] = {3, 3, 3, 3, 2}; + +static const u8 sText_Space[] = _(" "); +static const u8 sText_BPM[] = _("BPM"); +static const u8 sText_Dash[] = _("-"); +static const u8 sNewLineString_1[] = _("\n"); +static const u8 sNewLineString_2[] = _("\n"); static void Blender_ControlHitPitch(void) { @@ -345,11 +833,11 @@ static bool8 sub_804E2EC(void) break; case 1: { - const void* offsetRead = gUnknown_08215C2C; + const void* offsetRead = sBlenderCenterMap; void* offsetWrite = (void*)(VRAM + 0x4000); DmaCopy16(3, offsetRead, offsetWrite, 0x400); - LoadPalette(gUnknown_08215C0C, 0, 0x100); + LoadPalette(sBlenderCenterPal, 0, 0x100); gBerryBlenderData->field_1++; } break; @@ -413,7 +901,7 @@ static bool8 sub_804E2EC(void) offsetRead = &ewram[0x13000]; offsetWrite = (void*)(VRAM + 0x6000); DmaCopy16(3, offsetRead, offsetWrite, 0x500); - LoadPalette(gUnknown_0821602C, 0x80, 0x20); + LoadPalette(sBlenderOuterPal, 0x80, 0x20); gBerryBlenderData->field_1++; } break; @@ -455,7 +943,7 @@ void sub_804E538(void) gBerryBlenderData->field_0 = 0; *field6F = 0; - sub_804E884(gSpecialVar_0x8004); + Blender_SetPlayerNamesLocal(gSpecialVar_0x8004); SetMainCallback2(sub_804E56C); } @@ -581,39 +1069,39 @@ static void Blender_CopyBerryData(struct BlenderBerry* berry, u16 itemID) berry->smoothness = berryInfo->smoothness; } -static void sub_804E884(u8 a0) +static void Blender_SetPlayerNamesLocal(u8 NoOfOpponents) { int i; - if (a0) + if (NoOfOpponents) { for (i = 0; i < 4; i++) gLinkPlayers[i].language = GAME_LANGUAGE; } - switch (a0) + switch (NoOfOpponents) { case 0: - gUnknown_03004834 = 0; + gInGameOpponentsNo = 0; break; case 1: - gUnknown_03004834 = 1; + gInGameOpponentsNo = 1; gBerryBlenderData->playersNo = 2; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); - StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); + StringCopy(gLinkPlayers[1].name, sBlenderOpponentsNames[0]); break; case 2: - gUnknown_03004834 = 2; + gInGameOpponentsNo = 2; gBerryBlenderData->playersNo = 3; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); - StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); - StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); + StringCopy(gLinkPlayers[1].name, sBlenderOpponentsNames[0]); + StringCopy(gLinkPlayers[2].name, sBlenderOpponentsNames[1]); break; case 3: - gUnknown_03004834 = 3; + gInGameOpponentsNo = 3; gBerryBlenderData->playersNo = 4; StringCopy(gLinkPlayers[0].name, gSaveBlock2.playerName); - StringCopy(gLinkPlayers[1].name, gUnknown_082162B8[0]); - StringCopy(gLinkPlayers[2].name, gUnknown_082162B8[1]); - StringCopy(gLinkPlayers[3].name, gUnknown_082162B8[2]); + StringCopy(gLinkPlayers[1].name, sBlenderOpponentsNames[0]); + StringCopy(gLinkPlayers[2].name, sBlenderOpponentsNames[1]); + StringCopy(gLinkPlayers[3].name, sBlenderOpponentsNames[2]); break; } } @@ -630,7 +1118,7 @@ void sub_804E990(void) { gBerryBlenderData->chosenItemID[i] = 0; } - sub_804E884(gSpecialVar_0x8004); + Blender_SetPlayerNamesLocal(gSpecialVar_0x8004); if (gSpecialVar_0x8004 == 0) SetMainCallback2(sub_804E9F8); else @@ -793,7 +1281,7 @@ static void sub_804E9F8(void) sub_8051414(&gBerryBlenderData->field_168); break; case 16: - CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); + CreateSprite(&sSpriteTemplate_8216548, 120, -16, 3); gBerryBlenderData->field_0++; break; case 18: @@ -936,7 +1424,7 @@ static void sub_804F2A8(void) gBerryBlenderData->SyncArrowSpriteID[gBerryBlenderData->field_9A[i]] = gBerryBlenderData->SyncArrowSprite2ID[i]; StartSpriteAnim(&gSprites[gBerryBlenderData->SyncArrowSpriteID[gBerryBlenderData->field_9A[i]]], i); if (GetMultiplayerId() == gBerryBlenderData->field_9A[i]) - stringPtr = StringCopy(stringPtr, gUnknown_082162C4); + stringPtr = StringCopy(stringPtr, sRedColorString); StringCopy(stringPtr, gLinkPlayers[gBerryBlenderData->field_9A[i]].name); MenuPrint_PixelCoords(gStringVar1, gUnknown_082162D4[i][0] * 8 + 1, gUnknown_082162D4[i][1] * 8, 1); } @@ -1051,7 +1539,7 @@ static void sub_804F378(void) sub_8051414(&gBerryBlenderData->field_168); break; case 16: - CreateSprite(&gSpriteTemplate_8216548, 120, -16, 3); + CreateSprite(&sSpriteTemplate_8216548, 120, -16, 3); gBerryBlenderData->field_0++; break; case 18: @@ -1119,7 +1607,7 @@ static void sub_804F890(u8 a0, u8 a1) gTasks[taskID].data[2] = a0; } -void sub_804F8C8(u8 taskID) +static void sub_804F8C8(u8 taskID) { if (sub_804F16C(gBerryBlenderData->arrowPos, 1) == 2) { @@ -1170,7 +1658,7 @@ void sub_804F8C8(u8 taskID) gTasks[taskID].data[0] = 0; } -void sub_804F9F4(u8 taskID) +static void sub_804F9F4(u8 taskID) { u32 var1 = (gBerryBlenderData->arrowPos + 0x1800) & 0xFFFF; u32 var2 = gBerryBlenderData->field_A2[2] & 0xFF; @@ -1213,7 +1701,7 @@ void sub_804F9F4(u8 taskID) gTasks[taskID].data[0] = 0; } -void sub_804FB1C(u8 taskID) +static void sub_804FB1C(u8 taskID) { u32 var1, var2; @@ -1264,7 +1752,7 @@ static void sub_804FC48(u16 a0, u8 a1) { u8 spriteID; - spriteID = CreateSprite(&gSpriteTemplate_821645C, + spriteID = CreateSprite(&sSpriteTemplate_821645C, sBlenderSyncArrowsPos[a1][0] - (10 * gUnknown_082162CC[a1][0]), sBlenderSyncArrowsPos[a1][1] - (10 * gUnknown_082162CC[a1][1]), 1); @@ -2077,7 +2565,7 @@ static void sub_8050954(void) case 6: if (Blender_PrintBlendingResults()) { - if (gUnknown_03004834 == 0) + if (gInGameOpponentsNo == 0) IncrementGameStat(34); else IncrementGameStat(33); @@ -2152,7 +2640,7 @@ static void sub_8050954(void) } break; case 12: - if (gUnknown_03004834) + if (gInGameOpponentsNo) { SetMainCallback2(sub_80510E8); gBerryBlenderData->field_6F = 0; @@ -2547,7 +3035,7 @@ static void sub_805156C(void) x = gSineTable[(rand & 0xFF) + 64] / 4; y = gSineTable[(rand & 0xFF)] / 4; - spriteID = CreateSprite(&gSpriteTemplate_82164FC, x + 120, y + 80, 1); + spriteID = CreateSprite(&sSpriteTemplate_82164FC, x + 120, y + 80, 1); gSprites[spriteID].data0 = 16 - (Random() % 32); gSprites[spriteID].data1 = 16 - (Random() % 32); @@ -2555,7 +3043,7 @@ static void sub_805156C(void) } } -void sub_8051650(struct Sprite* sprite) +static void sub_8051650(struct Sprite* sprite) { sprite->data0++; sprite->pos2.y = -(sprite->data0 / 3); @@ -2619,7 +3107,7 @@ void unref_sub_80516F8(u8 taskID) } } -void sub_805181C(struct Sprite* sprite) +static void sub_805181C(struct Sprite* sprite) { switch (sprite->data0) { @@ -2647,7 +3135,7 @@ void sub_805181C(struct Sprite* sprite) if (++sprite->data3 == 3) { DestroySprite(sprite); - CreateSprite(&gSpriteTemplate_821657C, 120, -20, 2); + CreateSprite(&sSpriteTemplate_821657C, 120, -20, 2); } else { @@ -2661,7 +3149,7 @@ void sub_805181C(struct Sprite* sprite) sprite->pos2.y = sprite->data1; } -void sub_80518CC(struct Sprite* sprite) +static void sub_80518CC(struct Sprite* sprite) { switch (sprite->data0) { @@ -2810,7 +3298,7 @@ static bool8 sub_8051B8C(void) return 0; } -void sub_8051C04(struct Sprite* sprite) +static void sub_8051C04(struct Sprite* sprite) { sprite->pos2.x = -(gBerryBlenderData->field_144); sprite->pos2.y = -(gBerryBlenderData->field_146); @@ -2969,7 +3457,7 @@ static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* ds #else de_sub_8073174(dst, gOtherText_PokeBlockMade); #endif - StringAppend(dst, gUnknown_082162C8); + StringAppend(dst, sNewLineString_0); flavourLvl = sub_810C9B0(pokeblock); feel = sub_810C9E8(pokeblock); @@ -3050,14 +3538,14 @@ static bool8 Blender_PrintBlendingRanking(void) MenuDrawTextWindow(4, 2, 25, 17); sub_8072BD8(gOtherText_Ranking, 5, 3, 160); - gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST] = CreateSprite(&gSpriteTemplate_821645C, 140, 52, 0); + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST] = CreateSprite(&sSpriteTemplate_821645C, 140, 52, 0); gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]].callback = SpriteCallbackDummy; StartSpriteAnim(&gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_BEST]], 3); - gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD] = CreateSprite(&gSpriteTemplate_821645C, 164, 52, 0); + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD] = CreateSprite(&sSpriteTemplate_821645C, 164, 52, 0); gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_GOOD]].callback = SpriteCallbackDummy; - gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS] = CreateSprite(&gSpriteTemplate_821645C, 188, 52, 0); + gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS] = CreateSprite(&sSpriteTemplate_821645C, 188, 52, 0); gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]].callback = SpriteCallbackDummy; StartSpriteAnim(&gSprites[gBerryBlenderData->scoreIconIDs[BLENDER_SCORE_MISS]], 1); @@ -3135,7 +3623,7 @@ static void BlenderDebug_PrintBerryData(void) u8 text[128]; u8 i; - StringCopy(text, gOtherText_BPMAndDash); + StringCopy(text, sText_BPM); MenuPrint(text, 2, 0); ConvertIntToDecimalStringN(text, sBlenderDebug.BPM / 100, 2, 3); @@ -3160,19 +3648,19 @@ static void BlenderDebug_PrintBerryData(void) MenuPrint(text, 2, var); ConvertIntToDecimalStringN(&text[0], gBerries[sBlenderDebug.berries[i]].spicy, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToDecimalStringN(&text[3], gBerries[sBlenderDebug.berries[i]].dry, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToDecimalStringN(&text[6], gBerries[sBlenderDebug.berries[i]].sweet, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToDecimalStringN(&text[9], gBerries[sBlenderDebug.berries[i]].bitter, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToDecimalStringN(&text[12], gBerries[sBlenderDebug.berries[i]].sour, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToDecimalStringN(&text[15], gBerries[sBlenderDebug.berries[i]].smoothness, 2, 2); @@ -3185,19 +3673,19 @@ static void BlenderDebug_PrintBerryData(void) MenuPrint(text, 2, 15); ConvertIntToHexStringN(&text[0], sBlenderDebug.spicy, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(&text[3], sBlenderDebug.dry, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(&text[6], sBlenderDebug.sweet, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(&text[9], sBlenderDebug.bitter, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(&text[12], sBlenderDebug.sour, 2, 2); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(&text[15], sBlenderDebug.feel, 2, 2); @@ -3241,11 +3729,11 @@ static void sub_80527BC(void) ConvertIntToHexStringN(buffer, gUnknown_03004830, 2, 8); StringAppend(text, buffer); - StringAppend(text, gUnknown_082165F8); + StringAppend(text, sText_Space); ConvertIntToHexStringN(buffer, gUnknown_020297E0, 2, 8); StringAppend(text, buffer); - StringAppend(text, gUnknown_08216600); + StringAppend(text, sNewLineString_1); if (gUnknown_020297DC == 3) { -- cgit v1.2.3 From e7f670bf790a96e63b1302bc004bfaa55c8ac7ea Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Mon, 21 Aug 2017 10:47:43 -0400 Subject: i am useless --- src/shop.c | 368 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 368 insertions(+) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 5cc1f276e..b832b5a26 100644 --- a/src/shop.c +++ b/src/shop.c @@ -16,6 +16,7 @@ #include "task.h" #include "tv.h" #include "unknown_task.h" +#include "field_map_obj.h" struct UnknownShopStruct { @@ -349,3 +350,370 @@ void sub_80B33D0(s16 var1, int var2, u16 *var3) BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[3], offset1, offset2, var3); BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[2], offset1, offset2, var3 + 4); } + +// no. for loop too hard. +__attribute__((naked)) +void sub_80B3420() // dont know args +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x4\n\ + mov r4, sp\n\ + adds r4, 0x2\n\ + mov r0, sp\n\ + adds r1, r4, 0\n\ + bl GetXYCoordsOneStepInFrontOfPlayer\n\ + mov r1, sp\n\ + mov r0, sp\n\ + ldrh r0, [r0]\n\ + subs r0, 0x3\n\ + strh r0, [r1]\n\ + ldrh r0, [r4]\n\ + subs r0, 0x3\n\ + strh r0, [r4]\n\ + movs r1, 0\n\ + ldr r0, _080B34A8 @ =0x000001ff\n\ + mov r10, r0\n\ + ldr r2, _080B34AC @ =gMapHeader\n\ + mov r9, r2\n\ +_080B3452:\n\ + movs r4, 0\n\ + lsls r1, 16\n\ + mov r8, r1\n\ + asrs r7, r1, 16\n\ +_080B345A:\n\ + mov r0, sp\n\ + movs r3, 0\n\ + ldrsh r0, [r0, r3]\n\ + lsls r4, 16\n\ + asrs r6, r4, 16\n\ + adds r0, r6\n\ + mov r2, sp\n\ + movs r3, 0x2\n\ + ldrsh r1, [r2, r3]\n\ + adds r1, r7\n\ + bl MapGridGetMetatileIdAt\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ + cmp r7, 0x5\n\ + beq _080B34D0\n\ + cmp r6, 0x6\n\ + beq _080B34D0\n\ + mov r0, sp\n\ + movs r1, 0\n\ + ldrsh r0, [r0, r1]\n\ + adds r0, r6\n\ + mov r2, sp\n\ + movs r3, 0x2\n\ + ldrsh r1, [r2, r3]\n\ + adds r1, r7\n\ + bl MapGridGetMetatileLayerTypeAt\n\ + lsls r0, 24\n\ + lsrs r3, r0, 24\n\ + cmp r5, r10\n\ + bhi _080B34B0\n\ + mov r1, r9\n\ + ldr r0, [r1]\n\ + ldr r0, [r0, 0x10]\n\ + lsls r1, r5, 4\n\ + ldr r2, [r0, 0xC]\n\ + adds r2, r1\n\ + b _080B34C0\n\ + .align 2, 0\n\ +_080B34A8: .4byte 0x000001ff\n\ +_080B34AC: .4byte gMapHeader\n\ +_080B34B0:\n\ + mov r2, r9\n\ + ldr r0, [r2]\n\ + ldr r1, [r0, 0x14]\n\ + ldr r2, _080B34CC @ =0xfffffe00\n\ + adds r0, r5, r2\n\ + lsls r0, 4\n\ + ldr r2, [r1, 0xC]\n\ + adds r2, r0\n\ +_080B34C0:\n\ + adds r0, r6, 0\n\ + adds r1, r7, 0\n\ + bl BuyMenuDrawMapMetatile\n\ + b _080B3506\n\ + .align 2, 0\n\ +_080B34CC: .4byte 0xfffffe00\n\ +_080B34D0:\n\ + cmp r5, r10\n\ + bhi _080B34EC\n\ + asrs r0, r4, 16\n\ + mov r3, r9\n\ + ldr r1, [r3]\n\ + ldr r1, [r1, 0x10]\n\ + lsls r3, r5, 4\n\ + ldr r2, [r1, 0xC]\n\ + adds r2, r3\n\ + mov r3, r8\n\ + asrs r1, r3, 16\n\ + bl sub_80B33D0\n\ + b _080B3506\n\ +_080B34EC:\n\ + asrs r0, r4, 16\n\ + mov r2, r9\n\ + ldr r1, [r2]\n\ + ldr r2, [r1, 0x14]\n\ + ldr r3, _080B354C @ =0xfffffe00\n\ + adds r1, r5, r3\n\ + lsls r1, 4\n\ + ldr r2, [r2, 0xC]\n\ + adds r2, r1\n\ + mov r3, r8\n\ + asrs r1, r3, 16\n\ + bl sub_80B33D0\n\ +_080B3506:\n\ + cmp r7, 0\n\ + bne _080B3520\n\ + asrs r1, r4, 16\n\ + cmp r1, 0\n\ + beq _080B3520\n\ + cmp r1, 0x6\n\ + beq _080B3520\n\ + lsls r1, 17\n\ + asrs r1, 16\n\ + ldr r0, _080B3550 @ =gBGTilemapBuffers + 0x800\n\ + movs r2, 0x40\n\ + bl sub_80B32EC\n\ +_080B3520:\n\ + movs r1, 0x80\n\ + lsls r1, 9\n\ + adds r0, r4, r1\n\ + lsrs r4, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x6\n\ + ble _080B345A\n\ + adds r0, r1, 0\n\ + add r0, r8\n\ + lsrs r1, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x5\n\ + ble _080B3452\n\ + add sp, 0x4\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_080B354C: .4byte 0xfffffe00\n\ +_080B3550: .4byte gBGTilemapBuffers + 0x800\n\ + .syntax divided"); +} + +void BuyMenuDrawMapGraphics(void) +{ + sub_80F9020(); + sub_80B356C(); + sub_80B368C(); + sub_80B3420(); +} + +// yet another difficult multi for-loop. No. +__attribute__((naked)) +void sub_80B356C(void) // PopulateShopViewWindowObjectInfo ? +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x8\n\ + movs r0, 0\n\ + mov r8, r0\n\ + mov r4, sp\n\ + adds r4, 0x2\n\ + mov r0, sp\n\ + adds r1, r4, 0\n\ + bl GetXYCoordsOneStepInFrontOfPlayer\n\ + bl PlayerGetZCoord\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + str r0, [sp, 0x4]\n\ + movs r5, 0\n\ + ldr r2, _080B3674 @ =gUnknown_020386A4\n\ + movs r1, 0x10\n\ +_080B3598:\n\ + lsls r0, r5, 3\n\ + adds r0, r2\n\ + strh r1, [r0]\n\ + adds r0, r5, 0x1\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + cmp r5, 0xF\n\ + bls _080B3598\n\ + movs r5, 0\n\ + ldr r7, _080B3678 @ =gUnknown_020386AA\n\ + subs r1, r7, 0x6\n\ + mov r9, r1\n\ +_080B35B0:\n\ + movs r4, 0\n\ + adds r2, r5, 0x1\n\ + mov r10, r2\n\ +_080B35B6:\n\ + mov r1, sp\n\ + ldr r3, _080B367C @ =0x0000fffd\n\ + adds r0, r3, 0\n\ + ldrh r1, [r1]\n\ + adds r0, r1\n\ + adds r0, r4\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + ldr r2, _080B3680 @ =0x0000fffe\n\ + adds r1, r2, 0\n\ + mov r3, sp\n\ + ldrh r3, [r3, 0x2]\n\ + adds r1, r3\n\ + adds r1, r5\n\ + lsls r1, 16\n\ + lsrs r1, 16\n\ + ldr r2, [sp, 0x4]\n\ + bl GetFieldObjectIdByXYZ\n\ + lsls r0, 24\n\ + lsrs r2, r0, 24\n\ + cmp r2, 0x10\n\ + beq _080B3650\n\ + mov r0, r8\n\ + lsls r3, r0, 3\n\ + mov r1, r9\n\ + adds r0, r3, r1\n\ + movs r6, 0\n\ + strh r2, [r0]\n\ + mov r0, r9\n\ + adds r0, 0x2\n\ + adds r0, r3, r0\n\ + strh r4, [r0]\n\ + ldr r1, _080B3684 @ =gUnknown_020386A8\n\ + adds r0, r3, r1\n\ + strh r5, [r0]\n\ + ldr r1, _080B3688 @ =gMapObjects\n\ + lsls r0, r2, 3\n\ + adds r0, r2\n\ + lsls r0, 2\n\ + adds r2, r0, r1\n\ + ldrb r0, [r2, 0x18]\n\ + lsls r0, 28\n\ + lsrs r0, 28\n\ + cmp r0, 0x1\n\ + bne _080B3616\n\ + adds r0, r3, r7\n\ + strh r6, [r0]\n\ +_080B3616:\n\ + ldrb r0, [r2, 0x18]\n\ + lsls r0, 28\n\ + lsrs r0, 28\n\ + cmp r0, 0x2\n\ + bne _080B3626\n\ + adds r1, r3, r7\n\ + movs r0, 0x1\n\ + strh r0, [r1]\n\ +_080B3626:\n\ + ldrb r0, [r2, 0x18]\n\ + lsls r0, 28\n\ + lsrs r0, 28\n\ + cmp r0, 0x3\n\ + bne _080B3636\n\ + adds r1, r3, r7\n\ + movs r0, 0x2\n\ + strh r0, [r1]\n\ +_080B3636:\n\ + ldrb r0, [r2, 0x18]\n\ + lsls r0, 28\n\ + lsrs r0, 28\n\ + cmp r0, 0x4\n\ + bne _080B3646\n\ + adds r1, r3, r7\n\ + movs r0, 0x3\n\ + strh r0, [r1]\n\ +_080B3646:\n\ + mov r0, r8\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r8, r0\n\ +_080B3650:\n\ + adds r0, r4, 0x1\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + cmp r4, 0x6\n\ + bls _080B35B6\n\ + mov r2, r10\n\ + lsls r0, r2, 24\n\ + lsrs r5, r0, 24\n\ + cmp r5, 0x4\n\ + bls _080B35B0\n\ + add sp, 0x8\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_080B3674: .4byte gUnknown_020386A4\n\ +_080B3678: .4byte gUnknown_020386AA\n\ +_080B367C: .4byte 0x0000fffd\n\ +_080B3680: .4byte 0x0000fffe\n\ +_080B3684: .4byte gUnknown_020386A8\n\ +_080B3688: .4byte gMapObjects\n\ + .syntax divided"); +} +/* +struct UnkStruct_20386A4 +{ + s16 mapObjId; + u16 unk2; + u16 unk4; + u8 unk6[2]; +}; +*/ + +//extern s16 gUnknown_020386A4[][]; +//extern struct UnkStruct_20386A4 gUnknown_020386A4[]; + +// all 3 of these are incredibly hard, please help +/*void sub_80B368C(void) +{ + // r0 = spriteId + // r1 = gUnknown_020386A4 + 6 + // r2 = gSprites[spriteId] + // r3 = gUnknown_020386A4[i].unk4 + 32 + // r4 = i * 8 + // r5 = 0 (i) + // r6 = gUnknown_020386A4 + // r7 = gMapObjects + // r8 = gUnknown_020386A4 + 6 + // r9 = + // r10 = + // r11 = + // r12 = + + u8 i = 0; + u8 *unkArray = (u8 *)&gUnknown_020386A4[6]; + + for(; i < 16; i++) // max objects? + { + s16 mapObjId = unkStruct[i].mapObjId; + if(mapObjId != 16) + { + u8 spriteId = AddPseudoFieldObject( + gMapObjects[mapObjId].graphicsId, + SpriteCallbackDummy, + unkStruct[i].unk2 * 16 + 8, + unkStruct[i].unk4 + 12, + 2); + StartSpriteAnim(&gSprites[spriteId], unkArray[i]); + } + } +}*/ -- cgit v1.2.3 From a10592da1afeec6945e31f8321b94990c503e937 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 21 Aug 2017 21:11:42 +0200 Subject: transition main functions are done --- src/battle_transition.c | 556 +++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 485 insertions(+), 71 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 9ef012bb2..ae2e26d21 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -20,17 +20,16 @@ extern u16 gUnknown_03004DE0[][0x3C0]; struct TransitionData { - vs8 field_0; // now that's interesting - s8 field_1; - s16 WININ; - s16 WINOUT; - s16 field_6; - s16 WIN0V; - s16 field_A; - s16 field_C; - s16 BLDCNT; - s16 BLDALPHA; - s16 field_12; + vs8 VBlank_DMA; + u16 WININ; + u16 WINOUT; + u16 field_6; + u16 WIN0V; + u16 field_A; + u16 field_C; + u16 BLDCNT; + u16 BLDALPHA; + u16 field_12; s16 field_14; s16 field_16; s16 field_18; @@ -65,10 +64,10 @@ static void Phase2Task_Transition4(u8 taskID); static void Phase2Task_Transition5(u8 taskID); static void Phase2Task_Transition6(u8 taskID); static void Phase2Task_Transition7(u8 taskID); - void Phase2Task_Transition8(u8 taskID); - void Phase2Task_Transition9(u8 taskID); - void Phase2Task_Transition10(u8 taskID); - void Phase2Task_Transition11(u8 taskID); +static void Phase2Task_Transition8(u8 taskID); +static void Phase2Task_Transition9(u8 taskID); +static void Phase2Task_Transition10(u8 taskID); +static void Phase2Task_Transition11(u8 taskID); static void Phase2Task_Transition_Sydney(u8 taskID); static void Phase2Task_Transition_Phoebe(u8 taskID); static void Phase2Task_Transition_Glacia(u8 taskID); @@ -78,30 +77,30 @@ static bool8 Transition_Phase1(struct Task* task); static bool8 Transition_WaitForPhase1(struct Task* task); static bool8 Transition_Phase2(struct Task* task); static bool8 Transition_WaitForPhase2(struct Task* task); - static void VBlankCB_Phase2_Transition1(void); static void HBlankCB_Phase2_Transition1(void); - static void VBlankCB_Phase2_Transition2(void); static void HBlankCB_Phase2_Transition2(void); - static void VBlankCB0_Phase2_Transition3(void); static void VBlankCB1_Phase2_Transition3(void); - static void VBlankCB_Phase2_Transition5(void); - static void VBlankCB_Phase2_Transition6(void); static void HBlankCB_Phase2_Transition6(void); - static void VBlankCB_Phase2_Transition7(void); - +static void VBlankCB_Phase2_Transition8(void); +static void HBlankCB_Phase2_Transition8(void); +static void VBlankCB0_Phase2_Transition9(void); +static void VBlankCB1_Phase2_Transition9(void); +static void HBlankCB_Phase2_Transition9(void); static void VBlankCB0_Phase2_Mugshots(void); static void VBlankCB1_Phase2_Mugshots(void); static void HBlankCB_Phase2_Mugshots(void); +static void VBlankCB_Phase2_Transition11(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); void sub_811D6A8(u16** a0, u16** a1); +void sub_811D690(u16** a0); void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); @@ -111,6 +110,7 @@ static void Mugshots_CreateOpponentPlayerSprites(struct Task* task); static void sub_811CA10(s16 spriteID, s16 value); static void sub_811CA28(s16 spriteID); static s16 sub_811CA44(s16 spriteID); +void sub_811CFD0(struct Sprite* sprite); // const data typedef bool8 (*TransitionState)(struct Task* task); @@ -125,6 +125,9 @@ extern const TransitionState sPhase2_Transition5_Funcs[]; extern const TransitionState sPhase2_Transition6_Funcs[]; extern const TransitionState sPhase2_Transition7_Funcs[]; extern const TransitionState sPhase2_Transition8_Funcs[]; +extern const TransitionState sPhase2_Transition9_Funcs[]; +extern const TransitionState sPhase2_Transition10_Funcs[]; +extern const TransitionState sPhase2_Transition11_Funcs[]; extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; extern const u16 gFieldEffectObjectPalette10[]; extern const u16 gUnknown_083FDB44[]; @@ -349,7 +352,7 @@ bool8 Phase2_Transition1_Func1(struct Task* task) bool8 Phase2_Transition1_Func2(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; task->data[1] += 4; task->data[2] += 8; @@ -361,14 +364,14 @@ bool8 Phase2_Transition1_Func2(struct Task* task) DestroyTask(taskID); } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } static void VBlankCB_Phase2_Transition1(void) { VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0) + if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } @@ -413,7 +416,7 @@ bool8 Phase2_Transition2_Func2(struct Task* task) u8 i; u16 r3, r4; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; r4 = task->data[1]; r3 = task->data[2] >> 8; task->data[1] += 4224; @@ -428,14 +431,14 @@ bool8 Phase2_Transition2_Func2(struct Task* task) if (!gPaletteFade.active) DestroyTask(FindTaskIdByFunc(Phase2Task_Transition2)); - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } static void VBlankCB_Phase2_Transition2(void) { VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0) + if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } @@ -510,7 +513,7 @@ bool8 Phase2_Transition3_Func2(struct Task* task) bool8 Phase2_Transition3_Func3(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) { task->data[2]++; @@ -524,13 +527,13 @@ bool8 Phase2_Transition3_Func3(struct Task* task) sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Transition3_Func4(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) { task->data[1]--; @@ -544,13 +547,13 @@ bool8 Phase2_Transition3_Func4(struct Task* task) sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Transition3_Func5(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; task->data[4] += 8; task->data[5] -= 256; @@ -564,13 +567,13 @@ bool8 Phase2_Transition3_Func5(struct Task* task) task->data[3] = 0; } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Transition3_Func6(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[2] < 1024) task->data[2] += 128; if (task->data[1] != 0) @@ -592,7 +595,7 @@ bool8 Phase2_Transition3_Func6(struct Task* task) SetVBlankCallback(VBlankCB1_Phase2_Transition3); } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -600,7 +603,7 @@ static void Transition3_Vblank(void) { DmaStop(0); VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0) + if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); REG_WININ = TRANSITION_STRUCT.WININ; REG_WINOUT = TRANSITION_STRUCT.WINOUT; @@ -757,7 +760,7 @@ bool8 Phase2_Transition5_Func1(struct Task* task) bool8 Phase2_Transition5_Func2(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, -1, 1, 1); do @@ -772,7 +775,7 @@ bool8 Phase2_Transition5_Func2(struct Task* task) task->tState++; } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -781,7 +784,7 @@ bool8 Phase2_Transition5_Func3(struct Task* task) s16 r1, r3; vu8 var = 0; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 240, TRANSITION_STRUCT.field_2E, 1, 1); @@ -810,13 +813,13 @@ bool8 Phase2_Transition5_Func3(struct Task* task) } } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Transition5_Func4(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 160, 1, 1); do @@ -831,7 +834,7 @@ bool8 Phase2_Transition5_Func4(struct Task* task) task->tState++; } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -840,7 +843,7 @@ bool8 Phase2_Transition5_Func5(struct Task* task) s16 r1, r2, r3; vu8 var = 0; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 0, TRANSITION_STRUCT.field_2E, 1, 1); @@ -870,13 +873,13 @@ bool8 Phase2_Transition5_Func5(struct Task* task) } } - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Transition5_Func6(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 0, 1, 1); do @@ -894,7 +897,7 @@ bool8 Phase2_Transition5_Func6(struct Task* task) if (TRANSITION_STRUCT.field_28 > 120) task->tState++; - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -910,7 +913,7 @@ static void VBlankCB_Phase2_Transition5(void) { DmaStop(0); VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0 != 0) + if (TRANSITION_STRUCT.VBlank_DMA != 0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); REG_WININ = TRANSITION_STRUCT.WININ; REG_WINOUT = TRANSITION_STRUCT.WINOUT; @@ -952,7 +955,7 @@ bool8 Phase2_Transition6_Func2(struct Task* task) s16 r3; u16 r4, r8; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; r3 = task->data[2] >> 8; r4 = task->data[1]; @@ -979,14 +982,14 @@ bool8 Phase2_Transition6_Func2(struct Task* task) if (task->data[4] != 0 && !gPaletteFade.active) DestroyTask(FindTaskIdByFunc(Phase2Task_Transition6)); - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } static void VBlankCB_Phase2_Transition6(void) { VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0) + if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } @@ -1032,7 +1035,7 @@ bool8 Phase2_Transition7_Func2(struct Task* task) u16* toStore; bool8 nextFunc; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; toStore = gUnknown_03004DE0[0]; r5 = task->data[2]; task->data[2] += 16; @@ -1052,7 +1055,7 @@ bool8 Phase2_Transition7_Func2(struct Task* task) if (nextFunc) task->tState++; - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -1068,7 +1071,7 @@ static void VBlankCB_Phase2_Transition7(void) { DmaStop(0); VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0 != 0) + if (TRANSITION_STRUCT.VBlank_DMA != 0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); REG_WININ = TRANSITION_STRUCT.WININ; REG_WINOUT = TRANSITION_STRUCT.WINOUT; @@ -1175,7 +1178,7 @@ bool8 Phase2_Mugshot_Func3(struct Task* task) s16 value; s32 mergedValue; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; toStore = gUnknown_03004DE0[0]; r5 = task->data[1]; @@ -1212,7 +1215,7 @@ bool8 Phase2_Mugshot_Func3(struct Task* task) TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -1221,7 +1224,7 @@ bool8 Phase2_Mugshot_Func4(struct Task* task) u8 i; u16* toStore; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; for (i = 0, toStore = gUnknown_03004DE0[0]; i < 160; i++, toStore++) { @@ -1241,7 +1244,7 @@ bool8 Phase2_Mugshot_Func4(struct Task* task) PlaySE(SE_BT_START); - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -1263,7 +1266,7 @@ bool8 Phase2_Mugshot_Func6(struct Task* task) TRANSITION_STRUCT.field_1A += 8; if (sub_811CA44(task->tMugshotPlayerID)) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; SetVBlankCallback(NULL); DmaStop(0); memset(gUnknown_03004DE0[0], 0, 0x140); @@ -1283,7 +1286,7 @@ bool8 Phase2_Mugshot_Func7(struct Task* task) { bool32 r6; - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; r6 = TRUE; TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; @@ -1316,13 +1319,13 @@ bool8 Phase2_Mugshot_Func7(struct Task* task) if (task->data[4] == 0x50 && !r6) task->tState++; - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } bool8 Phase2_Mugshot_Func8(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; BlendPalettes(-1, 0x10, 0x7FFF); TRANSITION_STRUCT.BLDCNT = 0xFF; task->data[3] = 0; @@ -1333,14 +1336,14 @@ bool8 Phase2_Mugshot_Func8(struct Task* task) bool8 Phase2_Mugshot_Func9(struct Task* task) { - TRANSITION_STRUCT.field_0 = 0; + TRANSITION_STRUCT.VBlank_DMA = 0; task->data[3]++; memset(gUnknown_03004DE0[0], task->data[3], 0x140); if (task->data[3] > 15) task->tState++; - TRANSITION_STRUCT.field_0++; + TRANSITION_STRUCT.VBlank_DMA++; return 0; } @@ -1356,7 +1359,7 @@ static void VBlankCB0_Phase2_Mugshots(void) { DmaStop(0); VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0 != 0) + if (TRANSITION_STRUCT.VBlank_DMA != 0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); REG_BG0VOFS = TRANSITION_STRUCT.field_1C; REG_WININ = TRANSITION_STRUCT.WININ; @@ -1369,7 +1372,7 @@ static void VBlankCB1_Phase2_Mugshots(void) { DmaStop(0); VBlankCB_BattleTransition(); - if (TRANSITION_STRUCT.field_0 != 0) + if (TRANSITION_STRUCT.VBlank_DMA != 0) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; DmaSet(0, gUnknown_03004DE0[1], ®_BLDY, 0xA2400001); @@ -1494,20 +1497,20 @@ static s16 sub_811CA44(s16 spriteID) #undef tMugshotPlayerID #undef tMugshotID -void Phase2Task_Transition8(u8 taskID) +static void Phase2Task_Transition8(u8 taskID) { while (sPhase2_Transition8_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition7_Func1(struct Task* task) +bool8 Phase2_Transition8_Func1(struct Task* task) { - u8 i; + u16 i; sub_811D658(); dp12_8087EA4(); task->data[2] = 256; - task->data[3] = 256; + task->data[3] = 1; TRANSITION_STRUCT.WININ = 63; TRANSITION_STRUCT.WINOUT = 0; TRANSITION_STRUCT.WIN0V = 160; @@ -1518,8 +1521,419 @@ bool8 Phase2_Transition7_Func1(struct Task* task) gUnknown_03004DE0[1][160 + i] = 0xF0; } - SetVBlankCallback(VBlankCB_Phase2_Transition7); + REG_IE |= 2; + REG_DISPSTAT |= 0x10; + + SetVBlankCallback(VBlankCB_Phase2_Transition8); + SetHBlankCallback(HBlankCB_Phase2_Transition8); + + task->tState++; + return 1; +} + +bool8 Phase2_Transition8_Func2(struct Task* task) +{ + u16 i; + + TRANSITION_STRUCT.VBlank_DMA = 0; + + task->data[1] += (task->data[2] >> 8); + if (task->data[1] > 0xF0) + task->data[1] = 0xF0; + if (task->data[2] <= 0xFFF) + task->data[2] += task->data[3]; + if (task->data[3] < 128) + task->data[3] <<= 1; // multiplying by two + + for (i = 0; i < 160; i++) + { + u16* storeLoc1 = &gUnknown_03004DE0[0][i]; + u16* storeLoc2 = &gUnknown_03004DE0[0][i + 160]; + if (1 & i) + { + *storeLoc1 = TRANSITION_STRUCT.field_14 + task->data[1]; + *storeLoc2 = 0xF0 - task->data[1]; + } + else + { + *storeLoc1 = TRANSITION_STRUCT.field_14 - task->data[1]; + *storeLoc2 = (task->data[1] << 8) | (0xF1); + } + } + + if (task->data[1] > 0xEF) + task->tState++; + + TRANSITION_STRUCT.VBlank_DMA++; + return 0; +} + +bool8 Phase2_Transition8_Func3(struct Task* task) +{ + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition8)); + return 0; +} + +static void VBlankCB_Phase2_Transition8(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; + if (TRANSITION_STRUCT.VBlank_DMA) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 640); + DmaSet(0, &gUnknown_03004DE0[1][160], ®_WIN0H, 0xA2400001); +} + +static void HBlankCB_Phase2_Transition8(void) +{ + u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; + REG_BG1HOFS = var; + REG_BG2HOFS = var; + REG_BG3HOFS = var; +} + +static void Phase2Task_Transition9(u8 taskID) +{ + while (sPhase2_Transition9_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition9_Func1(struct Task* task) +{ + u16 i; + + sub_811D658(); + dp12_8087EA4(); + + TRANSITION_STRUCT.BLDCNT = 0xBF; + TRANSITION_STRUCT.field_12 = 0; + TRANSITION_STRUCT.WININ = 0x1E; + TRANSITION_STRUCT.WINOUT = 0x3F; + TRANSITION_STRUCT.WIN0V = 0xA0; + + for (i = 0; i < 160; i++) + { + gUnknown_03004DE0[1][i] = 0; + gUnknown_03004DE0[1][i + 160] = 0xF0; + } + + REG_IE |= 2; + REG_DISPSTAT |= 0x10; + + SetHBlankCallback(HBlankCB_Phase2_Transition9); + SetVBlankCallback(VBlankCB0_Phase2_Transition9); + + task->tState++; + return 0; +} + +extern const s16 gUnknown_083FD8C4[8]; + +bool8 Phase2_Transition9_Func2(struct Task* task) +{ + s16 i, posY; + s16 arr1[8]; + struct Sprite* sprite; + + memcpy(arr1, gUnknown_083FD8C4, sizeof(gUnknown_083FD8C4)); + for (i = 0, posY = 0; i < 8; i++, posY += 0x14) + { + sprite = &gSprites[CreateInvisibleSprite(sub_811CFD0)]; + sprite->pos1.x = 0xF0; + sprite->pos1.y = posY; + sprite->data5 = arr1[i]; + } + sprite->data6++; + + task->tState++; + return 0; +} + +bool8 Phase2_Transition9_Func3(struct Task* task) +{ + TRANSITION_STRUCT.VBlank_DMA = 0; + if (TRANSITION_STRUCT.field_20 > 7) + { + BlendPalettes(-1, 0x10, 0x7FFF); + task->tState++; + } + return 0; +} + +bool8 Phase2_Transition9_Func4(struct Task* task) +{ + TRANSITION_STRUCT.VBlank_DMA = 0; + + DmaStop(0); + SetVBlankCallback(0); + SetHBlankCallback(0); + + TRANSITION_STRUCT.field_6 = 0xF0; + TRANSITION_STRUCT.field_12 = 0; + TRANSITION_STRUCT.BLDCNT = 0xFF; + TRANSITION_STRUCT.WININ = 0x3F; + + SetVBlankCallback(VBlankCB1_Phase2_Transition9); + + task->tState++; + return 0; +} + +bool8 Phase2_Transition9_Func5(struct Task* task) +{ + if (++TRANSITION_STRUCT.field_12 > 16) + { + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition9)); + } + return 0; +} + +static void VBlankCB0_Phase2_Transition9(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.field_6; + if (TRANSITION_STRUCT.VBlank_DMA) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 640); + DmaSet(0, &gUnknown_03004DE0[1][160], ®_WIN0H, 0xA2400001); +} + +static void VBlankCB1_Phase2_Transition9(void) +{ + VBlankCB_BattleTransition(); + REG_BLDY = TRANSITION_STRUCT.field_12; + REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0H = TRANSITION_STRUCT.field_6; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; +} + +static void HBlankCB_Phase2_Transition9(void) +{ + REG_BLDY = gUnknown_03004DE0[1][REG_VCOUNT]; +} + +void sub_811CFD0(struct Sprite* sprite) +{ + if (sprite->data5) + { + sprite->data5--; + if (sprite->data6) + TRANSITION_STRUCT.VBlank_DMA = 1; + } + else + { + u16 i; + u16* ptr1 = &gUnknown_03004DE0[0][sprite->pos1.y]; + u16* ptr2 = &gUnknown_03004DE0[0][sprite->pos1.y + 160]; + for (i = 0; i < 20; i++) + { + ptr1[i] = sprite->data0 >> 8; + ptr2[i] = (u8)(sprite->pos1.x); + } + if (sprite->pos1.x == 0 && sprite->data0 == 0x1000) + sprite->data1 = 1; + + sprite->pos1.x -= 16; + sprite->data0 += 0x80; + + if (sprite->pos1.x < 0) + sprite->pos1.x = 0; + if (sprite->data0 > 0x1000) + sprite->data0 = 0x1000; + + if (sprite->data6) + TRANSITION_STRUCT.VBlank_DMA = 1; + + if (sprite->data1) + { + if (sprite->data6 == 0 || (TRANSITION_STRUCT.field_20 > 6 && sprite->data2++ > 7)) + { + TRANSITION_STRUCT.field_20++; + DestroySprite(sprite); + } + } + } +} + +static void Phase2Task_Transition10(u8 taskID) +{ + while (sPhase2_Transition10_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition10_Func1(struct Task* task) +{ + u16 *dst1, *dst2; + + sub_811D6A8(&dst1, &dst2); + CpuSet(gUnknown_083FD528, dst2, 0x10); + CpuFill16(0xF000, dst1, 0x800); + LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); + task->tState++; + return 0; +} + +bool8 Phase2_Transition10_Func2(struct Task* task) +{ + u16* dst1; + + if (task->data[1] == 0) + { + sub_811D690(&dst1); + task->data[1] = 3; + task->data[2]++; + CpuSet(gUnknown_083FD528 + (task->data[2] * 8), dst1, 0x10); + if (task->data[2] > 0xD) + { + task->tState++; + task->data[1] = 16; + } + } + + task->data[1]--; + return 0; +} + +bool8 Phase2_Transition10_Func3(struct Task* task) +{ + if (--task->data[1] == 0) + { + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition10)); + } + return 0; +} + +static void Phase2Task_Transition11(u8 taskID) +{ + while (sPhase2_Transition11_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +bool8 Phase2_Transition11_Func1(struct Task* task) +{ + u16 i; + + sub_811D658(); + dp12_8087EA4(); + + TRANSITION_STRUCT.WININ = 0x3F; + TRANSITION_STRUCT.WINOUT = 0; + TRANSITION_STRUCT.WIN0V = 0xA0; + + for (i = 0; i < 160; i++) + { + gUnknown_03004DE0[0][i] = 0xF0; + } + + CpuSet(gUnknown_03004DE0[0], gUnknown_03004DE0[1], 0xA0); + SetVBlankCallback(VBlankCB_Phase2_Transition11); + + task->tState++; + return 1; +} + +extern const s16 gUnknown_083FD8F4[][5]; + +bool8 Phase2_Transition11_Func2(struct Task* task) +{ + sub_811D8FC(&TRANSITION_STRUCT.field_24, + gUnknown_083FD8F4[task->data[1]][0], + gUnknown_083FD8F4[task->data[1]][1], + gUnknown_083FD8F4[task->data[1]][2], + gUnknown_083FD8F4[task->data[1]][3], + 1, 1); + task->data[2] = gUnknown_083FD8F4[task->data[1]][4]; task->tState++; return 1; } + +bool8 Phase2_Transition11_Func3(struct Task* task) +{ + s16 i; + bool8 nextFunc; + + TRANSITION_STRUCT.VBlank_DMA = 0; + + for (i = 0, nextFunc = FALSE; i < 16; i++) + { + s16 r3 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] >> 8; + s16 r4 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] & 0xFF; + if (task->data[2] == 0) + { + if (r3 < TRANSITION_STRUCT.field_28) + r3 = TRANSITION_STRUCT.field_28; + if (r3 > r4) + r3 = r4; + } + else + { + if (r4 > TRANSITION_STRUCT.field_28) + r4 = TRANSITION_STRUCT.field_28; + if (r4 <= r3) + r4 = r3; + } + gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r4) | (r3 << 8); + if (nextFunc) + { + task->tState++; + break; + } + else + nextFunc = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + } + + TRANSITION_STRUCT.VBlank_DMA++; + return 0; +} + +extern const s16 gUnknown_083FD93A[]; + +bool8 Phase2_Transition11_Func4(struct Task* task) +{ + if (++task->data[1] < 7) + { + task->tState++; + task->data[3] = gUnknown_083FD93A[task->data[1] - 1]; + return 1; + } + else + { + DmaStop(0); + sub_811D6D4(); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition11)); + return 0; + } +} + +bool8 Phase2_Transition11_Func5(struct Task* task) +{ + if (--task->data[3] == 0) + { + task->tState = 1; + return 1; + } + else + return 0; +} + +static void VBlankCB_Phase2_Transition11(void) +{ + DmaStop(0); + VBlankCB_BattleTransition(); + if (TRANSITION_STRUCT.VBlank_DMA) + DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); + REG_WININ = TRANSITION_STRUCT.WININ; + REG_WINOUT = TRANSITION_STRUCT.WINOUT; + REG_WIN0V = TRANSITION_STRUCT.WIN0V; + REG_WIN0H = gUnknown_03004DE0[1][0]; + DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); +} -- cgit v1.2.3 From f3191f7aa13529f73d28bc48cf74406a204962c9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 21 Aug 2017 23:05:56 +0200 Subject: name suggestions, phase2 data to C --- src/battle_transition.c | 385 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 282 insertions(+), 103 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index ae2e26d21..c0770f793 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -10,9 +10,11 @@ #include "sprite.h" #include "sound.h" #include "songs.h" +#include "trainer.h" void sub_807DE10(void); void dp12_8087EA4(void); +void sub_811C90C(struct Sprite* sprite); extern u8 ewram[]; extern s16 gUnknown_03005560[]; @@ -47,14 +49,12 @@ struct TransitionData }; #define TRANSITION_STRUCT (*(struct TransitionData *) (ewram + 0xC000)) +typedef bool8 (*TransitionState)(struct Task* task); +typedef bool8 (*TransitionSpriteCallback)(struct Sprite* sprite); // this file's functions static void LaunchBattleTransitionTask(u8 transitionID); static void Task_BattleTransitionMain(u8 taskID); -void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); -bool8 sub_811D52C(void); -void sub_811D658(void); - static void Phase1Task_TransitionAll(u8 taskID); static void Phase2Task_Transition0(u8 taskID); static void Phase2Task_Transition1(u8 taskID); @@ -96,7 +96,74 @@ static void VBlankCB0_Phase2_Mugshots(void); static void VBlankCB1_Phase2_Mugshots(void); static void HBlankCB_Phase2_Mugshots(void); static void VBlankCB_Phase2_Transition11(void); +static bool8 Phase2_Transition0_Func1(struct Task* task); +static bool8 Phase2_Transition0_Func2(struct Task* task); +static bool8 Phase2_Transition0_Func3(struct Task* task); +static bool8 Phase2_Transition1_Func1(struct Task* task); +static bool8 Phase2_Transition1_Func2(struct Task* task); +static bool8 Phase2_Transition2_Func1(struct Task* task); +static bool8 Phase2_Transition2_Func2(struct Task* task); +static bool8 Phase2_Transition3_Func1(struct Task* task); +static bool8 Phase2_Transition3_Func2(struct Task* task); +static bool8 Phase2_Transition3_Func3(struct Task* task); +static bool8 Phase2_Transition3_Func4(struct Task* task); +static bool8 Phase2_Transition3_Func5(struct Task* task); +static bool8 Phase2_Transition3_Func6(struct Task* task); +static bool8 Phase2_Transition4_Func1(struct Task* task); +static bool8 Phase2_Transition4_Func2(struct Task* task); +static bool8 Phase2_Transition4_Func3(struct Task* task); +static bool8 Phase2_Transition5_Func1(struct Task* task); +static bool8 Phase2_Transition5_Func2(struct Task* task); +static bool8 Phase2_Transition5_Func3(struct Task* task); +static bool8 Phase2_Transition5_Func4(struct Task* task); +static bool8 Phase2_Transition5_Func5(struct Task* task); +static bool8 Phase2_Transition5_Func6(struct Task* task); +static bool8 Phase2_Transition5_Func7(struct Task* task); +static bool8 Phase2_Transition6_Func1(struct Task* task); +static bool8 Phase2_Transition6_Func2(struct Task* task); +static bool8 Phase2_Transition7_Func1(struct Task* task); +static bool8 Phase2_Transition7_Func2(struct Task* task); +static bool8 Phase2_Transition7_Func3(struct Task* task); +static bool8 Phase2_Transition8_Func1(struct Task* task); +static bool8 Phase2_Transition8_Func2(struct Task* task); +static bool8 Phase2_Transition8_Func3(struct Task* task); +static bool8 Phase2_Transition9_Func1(struct Task* task); +static bool8 Phase2_Transition9_Func2(struct Task* task); +static bool8 Phase2_Transition9_Func3(struct Task* task); +static bool8 Phase2_Transition9_Func4(struct Task* task); +static bool8 Phase2_Transition9_Func5(struct Task* task); +static bool8 Phase2_Transition10_Func1(struct Task* task); +static bool8 Phase2_Transition10_Func2(struct Task* task); +static bool8 Phase2_Transition10_Func3(struct Task* task); +static bool8 Phase2_Transition11_Func1(struct Task* task); +static bool8 Phase2_Transition11_Func2(struct Task* task); +static bool8 Phase2_Transition11_Func3(struct Task* task); +static bool8 Phase2_Transition11_Func4(struct Task* task); +static bool8 Phase2_Transition11_Func5(struct Task* task); +static bool8 Phase2_Mugshot_Func1(struct Task* task); +static bool8 Phase2_Mugshot_Func2(struct Task* task); +static bool8 Phase2_Mugshot_Func3(struct Task* task); +static bool8 Phase2_Mugshot_Func4(struct Task* task); +static bool8 Phase2_Mugshot_Func5(struct Task* task); +static bool8 Phase2_Mugshot_Func6(struct Task* task); +static bool8 Phase2_Mugshot_Func7(struct Task* task); +static bool8 Phase2_Mugshot_Func8(struct Task* task); +static bool8 Phase2_Mugshot_Func9(struct Task* task); +static bool8 Phase2_Mugshot_Func10(struct Task* task); +static void Phase2Task_MugShotTransition(u8 taskID); +static void Mugshots_CreateOpponentPlayerSprites(struct Task* task); +static void sub_811CA10(s16 spriteID, s16 value); +static void sub_811CA28(s16 spriteID); +static s16 sub_811CA44(s16 spriteID); +static bool8 sub_811C934(struct Sprite* sprite); +static bool8 sub_811C938(struct Sprite* sprite); +static bool8 sub_811C984(struct Sprite* sprite); +static bool8 sub_811C9B8(struct Sprite* sprite); +static bool8 sub_811C9E4(struct Sprite* sprite); +void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +bool8 sub_811D52C(void); +void sub_811D658(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); void sub_811D6A8(u16** a0, u16** a1); @@ -105,45 +172,9 @@ void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); -static void Phase2Task_MugShotTransition(u8 taskID); -static void Mugshots_CreateOpponentPlayerSprites(struct Task* task); -static void sub_811CA10(s16 spriteID, s16 value); -static void sub_811CA28(s16 spriteID); -static s16 sub_811CA44(s16 spriteID); void sub_811CFD0(struct Sprite* sprite); // const data -typedef bool8 (*TransitionState)(struct Task* task); -typedef bool8 (*TransitionSpriteCallback)(struct Sprite* sprite); - -extern const TransitionState sPhase2_Transition0_Funcs[]; -extern const TransitionState sPhase2_Transition1_Funcs[]; -extern const TransitionState sPhase2_Transition2_Funcs[]; -extern const TransitionState sPhase2_Transition3_Funcs[]; -extern const TransitionState sPhase2_Transition4_Funcs[]; -extern const TransitionState sPhase2_Transition5_Funcs[]; -extern const TransitionState sPhase2_Transition6_Funcs[]; -extern const TransitionState sPhase2_Transition7_Funcs[]; -extern const TransitionState sPhase2_Transition8_Funcs[]; -extern const TransitionState sPhase2_Transition9_Funcs[]; -extern const TransitionState sPhase2_Transition10_Funcs[]; -extern const TransitionState sPhase2_Transition11_Funcs[]; -extern const TransitionState sPhase2_Mugshot_Transition_Funcs[]; -extern const u16 gFieldEffectObjectPalette10[]; -extern const u16 gUnknown_083FDB44[]; -extern const s16 gUnknown_083FD7E4[2]; -extern const s16 gUnknown_083FD7F2[2]; -extern const s16 gUnknown_083FD7E8[5]; -extern const struct SpriteTemplate gSpriteTemplate_83FD98C; -extern const u16 gUnknown_083FDFF4[]; -extern const u8 * const sOpponentMugshotsPals[]; -extern const u8 * const sPlayerMugshotsPals[2]; -extern const u8 sMugshotsTrainerPicIDsTable[]; -extern const s16 sMugshotsOpponentCoords[][2]; -extern const s16 sMugshotsOpponentRotationScales[][2]; -extern const TransitionSpriteCallback gUnknown_083FD880[]; -extern const s16 gUnknown_083FD89C[2]; -extern const s16 gUnknown_083FD8A0[2]; static const u32 gUnknown_083FBB88[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); static const u32 gUnknown_083FC108[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); @@ -152,6 +183,7 @@ static const u32 gUnknown_083FC348[] = INCBIN_U32("graphics/battle_transitions/e const u32 gSpriteImage_83FC528[] = INCBIN_U32("graphics/battle_transitions/unused_brendan.4bpp"); const u32 gSpriteImage_83FCD28[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); const u32 gUnknown_083FD528[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); + struct TransitionData * const sTransitionStructPtr = &TRANSITION_STRUCT; static const TaskFunc sPhase1_Tasks[TRANSITIONS_NO] = @@ -188,7 +220,160 @@ static const TransitionState sMainTransitionPhases[] = &Transition_WaitForPhase2 }; -void sub_811C90C(struct Sprite* sprite); +static const TransitionState sPhase2_Transition0_Funcs[] = +{ + &Phase2_Transition0_Func1, + &Phase2_Transition0_Func2, + &Phase2_Transition0_Func3 +}; + +static const TransitionState sPhase2_Transition1_Funcs[] = +{ + &Phase2_Transition1_Func1, + &Phase2_Transition1_Func2, +}; + +static const TransitionState sPhase2_Transition2_Funcs[] = +{ + &Phase2_Transition2_Func1, + &Phase2_Transition2_Func2, +}; + +static const TransitionState sPhase2_Transition3_Funcs[] = +{ + &Phase2_Transition3_Func1, + &Phase2_Transition3_Func2, + &Phase2_Transition3_Func3, + &Phase2_Transition3_Func4, + &Phase2_Transition3_Func5, + &Phase2_Transition3_Func6 +}; + +static const TransitionState sPhase2_Transition4_Funcs[] = +{ + &Phase2_Transition4_Func1, + &Phase2_Transition4_Func2, + &Phase2_Transition4_Func3 +}; + +static const s16 gUnknown_083FD7E4[2] = {-16, 256}; +static const s16 gUnknown_083FD7E8[5] = {0, 32, 64, 18, 48}; +static const s16 gUnknown_083FD7F2[2] = {8, -8}; + +static const TransitionState sPhase2_Transition5_Funcs[] = +{ + &Phase2_Transition5_Func1, + &Phase2_Transition5_Func2, + &Phase2_Transition5_Func3, + &Phase2_Transition5_Func4, + &Phase2_Transition5_Func5, + &Phase2_Transition5_Func6, + &Phase2_Transition5_Func7 +}; + +static const TransitionState sPhase2_Transition6_Funcs[] = +{ + &Phase2_Transition6_Func1, + &Phase2_Transition6_Func2 +}; + +static const TransitionState sPhase2_Transition7_Funcs[] = +{ + &Phase2_Transition7_Func1, + &Phase2_Transition7_Func2, + &Phase2_Transition7_Func3 +}; + +static const TransitionState sPhase2_Mugshot_Transition_Funcs[] = +{ + &Phase2_Mugshot_Func1, + &Phase2_Mugshot_Func2, + &Phase2_Mugshot_Func3, + &Phase2_Mugshot_Func4, + &Phase2_Mugshot_Func5, + &Phase2_Mugshot_Func6, + &Phase2_Mugshot_Func7, + &Phase2_Mugshot_Func8, + &Phase2_Mugshot_Func9, + &Phase2_Mugshot_Func10 +}; + +static const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_NO] = {TRAINER_PIC_SIDNEY, TRAINER_PIC_PHOEBE, TRAINER_PIC_GLACIA, TRAINER_PIC_DRAKE, TRAINER_PIC_STEVEN}; +static const s16 sMugshotsOpponentRotationScales[MUGSHOTS_NO][2] = +{ + {0x200, 0x200}, + {0x200, 0x200}, + {0x1B0, 0x1B0}, + {0x1A0, 0x1A0}, + {0x188, 0x188}, +}; +static const s16 sMugshotsOpponentCoords[MUGSHOTS_NO][2] = +{ + {0, 0}, + {0, 0}, + {-4, 4}, + {0, 5}, + {0, 7}, +}; + +static const TransitionSpriteCallback gUnknown_083FD880[] = +{ + &sub_811C934, + &sub_811C938, + &sub_811C984, + &sub_811C9B8, + &sub_811C934, + &sub_811C9E4, + &sub_811C934 +}; + +static const s16 gUnknown_083FD89C[2] = {12, -12}; +static const s16 gUnknown_083FD8A0[2] = {-1, 1}; + +static const TransitionState sPhase2_Transition8_Funcs[] = +{ + &Phase2_Transition8_Func1, + &Phase2_Transition8_Func2, + &Phase2_Transition8_Func3 +}; + +static const TransitionState sPhase2_Transition9_Funcs[] = +{ + &Phase2_Transition9_Func1, + &Phase2_Transition9_Func2, + &Phase2_Transition9_Func3, + &Phase2_Transition9_Func4, + &Phase2_Transition9_Func5 +}; + +static const s16 gUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; + +static const TransitionState sPhase2_Transition10_Funcs[] = +{ + &Phase2_Transition10_Func1, + &Phase2_Transition10_Func2, + &Phase2_Transition10_Func3 +}; + +static const TransitionState sPhase2_Transition11_Funcs[] = +{ + &Phase2_Transition11_Func1, + &Phase2_Transition11_Func2, + &Phase2_Transition11_Func3, + &Phase2_Transition11_Func4, + &Phase2_Transition11_Func5 +}; + +extern const u16 gFieldEffectObjectPalette10[]; +extern const u16 gUnknown_083FDB44[]; +extern const struct SpriteTemplate gSpriteTemplate_83FD98C; +extern const u16 gUnknown_083FDFF4[]; +extern const u8 * const sOpponentMugshotsPals[]; +extern const u8 * const sPlayerMugshotsPals[2]; +extern const s16 gUnknown_083FD8F4[][5]; +extern const s16 gUnknown_083FD93A[]; + +// actual code starts here void sub_811AABC(u8 transitionID) { @@ -287,7 +472,7 @@ static void Phase2Task_Transition0(u8 taskID) while (sPhase2_Transition0_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition0_Func1(struct Task* task) +static bool8 Phase2_Transition0_Func1(struct Task* task) { REG_MOSAIC = 0; REG_BG1CNT |= 0x40; @@ -297,7 +482,7 @@ bool8 Phase2_Transition0_Func1(struct Task* task) return 1; } -bool8 Phase2_Transition0_Func2(struct Task* task) +static bool8 Phase2_Transition0_Func2(struct Task* task) { if (task->data[1] != 0) task->data[1]--; @@ -313,7 +498,7 @@ bool8 Phase2_Transition0_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition0_Func3(struct Task* task) +static bool8 Phase2_Transition0_Func3(struct Task* task) { if (!gPaletteFade.active) { @@ -328,7 +513,7 @@ static void Phase2Task_Transition1(u8 taskID) while (sPhase2_Transition1_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition1_Func1(struct Task* task) +static bool8 Phase2_Transition1_Func1(struct Task* task) { u16 savedIME; @@ -350,7 +535,7 @@ bool8 Phase2_Transition1_Func1(struct Task* task) return 0; } -bool8 Phase2_Transition1_Func2(struct Task* task) +static bool8 Phase2_Transition1_Func2(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; task->data[1] += 4; @@ -388,7 +573,7 @@ static void Phase2Task_Transition2(u8 taskID) while (sPhase2_Transition2_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition2_Func1(struct Task* task) +static bool8 Phase2_Transition2_Func1(struct Task* task) { u16 savedIME; @@ -411,7 +596,7 @@ bool8 Phase2_Transition2_Func1(struct Task* task) return 0; } -bool8 Phase2_Transition2_Func2(struct Task* task) +static bool8 Phase2_Transition2_Func2(struct Task* task) { u8 i; u16 r3, r4; @@ -455,7 +640,7 @@ static void Phase2Task_Transition3(u8 taskID) while (sPhase2_Transition3_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition3_Func1(struct Task* task) +static bool8 Phase2_Transition3_Func1(struct Task* task) { u16 i; u16 *dst1, *dst2; @@ -490,7 +675,7 @@ bool8 Phase2_Transition3_Func1(struct Task* task) return 0; } -bool8 Phase2_Transition3_Func2(struct Task* task) +static bool8 Phase2_Transition3_Func2(struct Task* task) { s16 i, j; u16 *dst1, *dst2; @@ -511,7 +696,7 @@ bool8 Phase2_Transition3_Func2(struct Task* task) return 1; } -bool8 Phase2_Transition3_Func3(struct Task* task) +static bool8 Phase2_Transition3_Func3(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) @@ -531,7 +716,7 @@ bool8 Phase2_Transition3_Func3(struct Task* task) return 0; } -bool8 Phase2_Transition3_Func4(struct Task* task) +static bool8 Phase2_Transition3_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) @@ -551,7 +736,7 @@ bool8 Phase2_Transition3_Func4(struct Task* task) return 0; } -bool8 Phase2_Transition3_Func5(struct Task* task) +static bool8 Phase2_Transition3_Func5(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; task->data[4] += 8; @@ -571,7 +756,7 @@ bool8 Phase2_Transition3_Func5(struct Task* task) return 0; } -bool8 Phase2_Transition3_Func6(struct Task* task) +static bool8 Phase2_Transition3_Func6(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[2] < 1024) @@ -618,7 +803,7 @@ static void VBlankCB0_Phase2_Transition3(void) DmaSet(0, gUnknown_03005560, ®_BG0HOFS, 0xA2400001); } -void VBlankCB1_Phase2_Transition3(void) +static void VBlankCB1_Phase2_Transition3(void) { Transition3_Vblank(); DmaSet(0, gUnknown_03005560, ®_WIN0H, 0xA2400001); @@ -629,7 +814,7 @@ static void Phase2Task_Transition4(u8 taskID) while (sPhase2_Transition4_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition4_Func1(struct Task* task) +static bool8 Phase2_Transition4_Func1(struct Task* task) { u16 *dst1, *dst2; @@ -642,7 +827,7 @@ bool8 Phase2_Transition4_Func1(struct Task* task) return 0; } -bool8 Phase2_Transition4_Func2(struct Task* task) +static bool8 Phase2_Transition4_Func2(struct Task* task) { s16 i; s16 rand; @@ -665,7 +850,7 @@ bool8 Phase2_Transition4_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition4_Func3(struct Task* task) +static bool8 Phase2_Transition4_Func3(struct Task* task) { if (!FieldEffectActiveListContains(FLDEFF_POKEBALL)) { @@ -734,7 +919,7 @@ static void Phase2Task_Transition5(u8 taskID) while (sPhase2_Transition5_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition5_Func1(struct Task* task) +static bool8 Phase2_Transition5_Func1(struct Task* task) { u16 i; @@ -758,7 +943,7 @@ bool8 Phase2_Transition5_Func1(struct Task* task) return 1; } -bool8 Phase2_Transition5_Func2(struct Task* task) +static bool8 Phase2_Transition5_Func2(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -779,7 +964,7 @@ bool8 Phase2_Transition5_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition5_Func3(struct Task* task) +static bool8 Phase2_Transition5_Func3(struct Task* task) { s16 r1, r3; vu8 var = 0; @@ -817,7 +1002,7 @@ bool8 Phase2_Transition5_Func3(struct Task* task) return 0; } -bool8 Phase2_Transition5_Func4(struct Task* task) +static bool8 Phase2_Transition5_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -838,7 +1023,7 @@ bool8 Phase2_Transition5_Func4(struct Task* task) return 0; } -bool8 Phase2_Transition5_Func5(struct Task* task) +static bool8 Phase2_Transition5_Func5(struct Task* task) { s16 r1, r2, r3; vu8 var = 0; @@ -877,7 +1062,7 @@ bool8 Phase2_Transition5_Func5(struct Task* task) return 0; } -bool8 Phase2_Transition5_Func6(struct Task* task) +static bool8 Phase2_Transition5_Func6(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -901,7 +1086,7 @@ bool8 Phase2_Transition5_Func6(struct Task* task) return 0; } -bool8 Phase2_Transition5_Func7(struct Task* task) +static bool8 Phase2_Transition5_Func7(struct Task* task) { DmaStop(0); sub_811D6D4(); @@ -922,12 +1107,12 @@ static void VBlankCB_Phase2_Transition5(void) DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } -void Phase2Task_Transition6(u8 taskID) +static void Phase2Task_Transition6(u8 taskID) { while (sPhase2_Transition6_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition6_Func1(struct Task* task) +static bool8 Phase2_Transition6_Func1(struct Task* task) { u8 i; @@ -949,7 +1134,7 @@ bool8 Phase2_Transition6_Func1(struct Task* task) return 1; } -bool8 Phase2_Transition6_Func2(struct Task* task) +static bool8 Phase2_Transition6_Func2(struct Task* task) { u8 i; s16 r3; @@ -1006,7 +1191,7 @@ static void Phase2Task_Transition7(u8 taskID) while (sPhase2_Transition7_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition7_Func1(struct Task* task) +static bool8 Phase2_Transition7_Func1(struct Task* task) { u8 i; @@ -1029,7 +1214,7 @@ bool8 Phase2_Transition7_Func1(struct Task* task) return 1; } -bool8 Phase2_Transition7_Func2(struct Task* task) +static bool8 Phase2_Transition7_Func2(struct Task* task) { u8 i, r5; u16* toStore; @@ -1059,7 +1244,7 @@ bool8 Phase2_Transition7_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition7_Func3(struct Task* task) +static bool8 Phase2_Transition7_Func3(struct Task* task) { DmaStop(0); sub_811D6D4(); @@ -1118,7 +1303,7 @@ static void Phase2Task_MugShotTransition(u8 taskID) while (sPhase2_Mugshot_Transition_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Mugshot_Func1(struct Task* task) +static bool8 Phase2_Mugshot_Func1(struct Task* task) { u8 i; @@ -1144,7 +1329,7 @@ bool8 Phase2_Mugshot_Func1(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func2(struct Task* task) +static bool8 Phase2_Mugshot_Func2(struct Task* task) { s16 i, j; u16 *dst1, *dst2; @@ -1171,7 +1356,7 @@ bool8 Phase2_Mugshot_Func2(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func3(struct Task* task) +static bool8 Phase2_Mugshot_Func3(struct Task* task) { u8 i, r5; u16* toStore; @@ -1219,7 +1404,7 @@ bool8 Phase2_Mugshot_Func3(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func4(struct Task* task) +static bool8 Phase2_Mugshot_Func4(struct Task* task) { u8 i; u16* toStore; @@ -1248,7 +1433,7 @@ bool8 Phase2_Mugshot_Func4(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func5(struct Task* task) +static bool8 Phase2_Mugshot_Func5(struct Task* task) { TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; @@ -1260,7 +1445,7 @@ bool8 Phase2_Mugshot_Func5(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func6(struct Task* task) +static bool8 Phase2_Mugshot_Func6(struct Task* task) { TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; @@ -1282,7 +1467,7 @@ bool8 Phase2_Mugshot_Func6(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func7(struct Task* task) +static bool8 Phase2_Mugshot_Func7(struct Task* task) { bool32 r6; @@ -1323,7 +1508,7 @@ bool8 Phase2_Mugshot_Func7(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func8(struct Task* task) +static bool8 Phase2_Mugshot_Func8(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; BlendPalettes(-1, 0x10, 0x7FFF); @@ -1334,7 +1519,7 @@ bool8 Phase2_Mugshot_Func8(struct Task* task) return 1; } -bool8 Phase2_Mugshot_Func9(struct Task* task) +static bool8 Phase2_Mugshot_Func9(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -1347,7 +1532,7 @@ bool8 Phase2_Mugshot_Func9(struct Task* task) return 0; } -bool8 Phase2_Mugshot_Func10(struct Task* task) +static bool8 Phase2_Mugshot_Func10(struct Task* task) { DmaStop(0); sub_811D6D4(); @@ -1502,7 +1687,7 @@ static void Phase2Task_Transition8(u8 taskID) while (sPhase2_Transition8_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition8_Func1(struct Task* task) +static bool8 Phase2_Transition8_Func1(struct Task* task) { u16 i; @@ -1531,7 +1716,7 @@ bool8 Phase2_Transition8_Func1(struct Task* task) return 1; } -bool8 Phase2_Transition8_Func2(struct Task* task) +static bool8 Phase2_Transition8_Func2(struct Task* task) { u16 i; @@ -1568,7 +1753,7 @@ bool8 Phase2_Transition8_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition8_Func3(struct Task* task) +static bool8 Phase2_Transition8_Func3(struct Task* task) { DmaStop(0); sub_811D6D4(); @@ -1601,7 +1786,7 @@ static void Phase2Task_Transition9(u8 taskID) while (sPhase2_Transition9_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition9_Func1(struct Task* task) +static bool8 Phase2_Transition9_Func1(struct Task* task) { u16 i; @@ -1630,9 +1815,7 @@ bool8 Phase2_Transition9_Func1(struct Task* task) return 0; } -extern const s16 gUnknown_083FD8C4[8]; - -bool8 Phase2_Transition9_Func2(struct Task* task) +static bool8 Phase2_Transition9_Func2(struct Task* task) { s16 i, posY; s16 arr1[8]; @@ -1652,7 +1835,7 @@ bool8 Phase2_Transition9_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition9_Func3(struct Task* task) +static bool8 Phase2_Transition9_Func3(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (TRANSITION_STRUCT.field_20 > 7) @@ -1663,7 +1846,7 @@ bool8 Phase2_Transition9_Func3(struct Task* task) return 0; } -bool8 Phase2_Transition9_Func4(struct Task* task) +static bool8 Phase2_Transition9_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -1682,7 +1865,7 @@ bool8 Phase2_Transition9_Func4(struct Task* task) return 0; } -bool8 Phase2_Transition9_Func5(struct Task* task) +static bool8 Phase2_Transition9_Func5(struct Task* task) { if (++TRANSITION_STRUCT.field_12 > 16) { @@ -1769,7 +1952,7 @@ static void Phase2Task_Transition10(u8 taskID) while (sPhase2_Transition10_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition10_Func1(struct Task* task) +static bool8 Phase2_Transition10_Func1(struct Task* task) { u16 *dst1, *dst2; @@ -1782,7 +1965,7 @@ bool8 Phase2_Transition10_Func1(struct Task* task) return 0; } -bool8 Phase2_Transition10_Func2(struct Task* task) +static bool8 Phase2_Transition10_Func2(struct Task* task) { u16* dst1; @@ -1803,7 +1986,7 @@ bool8 Phase2_Transition10_Func2(struct Task* task) return 0; } -bool8 Phase2_Transition10_Func3(struct Task* task) +static bool8 Phase2_Transition10_Func3(struct Task* task) { if (--task->data[1] == 0) { @@ -1818,7 +2001,7 @@ static void Phase2Task_Transition11(u8 taskID) while (sPhase2_Transition11_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -bool8 Phase2_Transition11_Func1(struct Task* task) +static bool8 Phase2_Transition11_Func1(struct Task* task) { u16 i; @@ -1841,9 +2024,7 @@ bool8 Phase2_Transition11_Func1(struct Task* task) return 1; } -extern const s16 gUnknown_083FD8F4[][5]; - -bool8 Phase2_Transition11_Func2(struct Task* task) +static bool8 Phase2_Transition11_Func2(struct Task* task) { sub_811D8FC(&TRANSITION_STRUCT.field_24, gUnknown_083FD8F4[task->data[1]][0], @@ -1856,7 +2037,7 @@ bool8 Phase2_Transition11_Func2(struct Task* task) return 1; } -bool8 Phase2_Transition11_Func3(struct Task* task) +static bool8 Phase2_Transition11_Func3(struct Task* task) { s16 i; bool8 nextFunc; @@ -1895,9 +2076,7 @@ bool8 Phase2_Transition11_Func3(struct Task* task) return 0; } -extern const s16 gUnknown_083FD93A[]; - -bool8 Phase2_Transition11_Func4(struct Task* task) +static bool8 Phase2_Transition11_Func4(struct Task* task) { if (++task->data[1] < 7) { @@ -1914,7 +2093,7 @@ bool8 Phase2_Transition11_Func4(struct Task* task) } } -bool8 Phase2_Transition11_Func5(struct Task* task) +static bool8 Phase2_Transition11_Func5(struct Task* task) { if (--task->data[3] == 0) { -- cgit v1.2.3 From fc9f7853a0e8dde9f80c1e16bee3a05978d29d15 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Mon, 21 Aug 2017 23:40:13 +0200 Subject: up to sub_811D584 --- src/battle_transition.c | 52 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 48 insertions(+), 4 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index c0770f793..9f4126822 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -160,9 +160,9 @@ static bool8 sub_811C938(struct Sprite* sprite); static bool8 sub_811C984(struct Sprite* sprite); static bool8 sub_811C9B8(struct Sprite* sprite); static bool8 sub_811C9E4(struct Sprite* sprite); +static void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +static bool8 sub_811D52C(void); -void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); -bool8 sub_811D52C(void); void sub_811D658(void); void VBlankCB_BattleTransition(void); void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); @@ -173,6 +173,9 @@ void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); void sub_811CFD0(struct Sprite* sprite); +void sub_811D54C(u8 taskID); +bool8 sub_811D584(struct Task* task); +bool8 sub_811D5E0(struct Task* task); // const data @@ -364,14 +367,31 @@ static const TransitionState sPhase2_Transition11_Funcs[] = &Phase2_Transition11_Func5 }; +static const s16 gUnknown_083FD8F4[][5] = +{ + {56, 0, 0, 160, 0}, + {104, 160, 240, 88, 1}, + {240, 72, 56, 0, 1}, + {0, 32, 144, 160, 0}, + {144, 160, 184, 0, 1}, + {56, 0, 168, 160, 0}, + {168, 160, 48, 0, 1}, +}; + +static const s16 gUnknown_083FD93A[] = {8, 4, 2, 1, 1, 1, 0}; + +static const TransitionState gUnknown_083FD948[] = +{ + &sub_811D584, + &sub_811D5E0 +}; + extern const u16 gFieldEffectObjectPalette10[]; extern const u16 gUnknown_083FDB44[]; extern const struct SpriteTemplate gSpriteTemplate_83FD98C; extern const u16 gUnknown_083FDFF4[]; extern const u8 * const sOpponentMugshotsPals[]; extern const u8 * const sPlayerMugshotsPals[2]; -extern const s16 gUnknown_083FD8F4[][5]; -extern const s16 gUnknown_083FD93A[]; // actual code starts here @@ -2116,3 +2136,27 @@ static void VBlankCB_Phase2_Transition11(void) REG_WIN0H = gUnknown_03004DE0[1][0]; DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } + +static void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) +{ + u8 taskID = CreateTask(sub_811D54C, 3); + gTasks[taskID].data[1] = a0; + gTasks[taskID].data[2] = a1; + gTasks[taskID].data[3] = a2; + gTasks[taskID].data[4] = a3; + gTasks[taskID].data[5] = a4; + gTasks[taskID].data[6] = a0; +} + +static bool8 sub_811D52C(void) +{ + if (FindTaskIdByFunc(sub_811D54C) == 0xFF) + return 1; + else + return 0; +} + +void sub_811D54C(u8 taskID) +{ + while (gUnknown_083FD948[gTasks[taskID].tState](&gTasks[taskID])); +} -- cgit v1.2.3 From 878b0d50996ba8be9d18a8c0df39b1f7f255033b Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Mon, 21 Aug 2017 18:46:20 -0400 Subject: thanks cam. --- src/shop.c | 446 +++++++++++++------------------------------------------------ 1 file changed, 94 insertions(+), 352 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index b832b5a26..06ec45292 100644 --- a/src/shop.c +++ b/src/shop.c @@ -17,6 +17,8 @@ #include "tv.h" #include "unknown_task.h" #include "field_map_obj.h" +#include "field_player_avatar.h" +#include "fieldmap.h" struct UnknownShopStruct { @@ -319,7 +321,7 @@ void BuyMenuDrawMapMetatileLayer(u16 *array, s16 offset1, s16 offset2, u16 *arra array[offset1 + offset2 + 33] = array2[3]; } -void BuyMenuDrawMapMetatile(int var1, int var2, u16 *var3, s8 var4) +void BuyMenuDrawMapMetatile(int var1, int var2, u16 *var3, s32 var4) { u8 tempVar4 = var4; s16 offset1 = var1 * 2; @@ -351,163 +353,44 @@ void sub_80B33D0(s16 var1, int var2, u16 *var3) BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[2], offset1, offset2, var3 + 4); } -// no. for loop too hard. -__attribute__((naked)) -void sub_80B3420() // dont know args +void sub_80B3420(void) { - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x4\n\ - mov r4, sp\n\ - adds r4, 0x2\n\ - mov r0, sp\n\ - adds r1, r4, 0\n\ - bl GetXYCoordsOneStepInFrontOfPlayer\n\ - mov r1, sp\n\ - mov r0, sp\n\ - ldrh r0, [r0]\n\ - subs r0, 0x3\n\ - strh r0, [r1]\n\ - ldrh r0, [r4]\n\ - subs r0, 0x3\n\ - strh r0, [r4]\n\ - movs r1, 0\n\ - ldr r0, _080B34A8 @ =0x000001ff\n\ - mov r10, r0\n\ - ldr r2, _080B34AC @ =gMapHeader\n\ - mov r9, r2\n\ -_080B3452:\n\ - movs r4, 0\n\ - lsls r1, 16\n\ - mov r8, r1\n\ - asrs r7, r1, 16\n\ -_080B345A:\n\ - mov r0, sp\n\ - movs r3, 0\n\ - ldrsh r0, [r0, r3]\n\ - lsls r4, 16\n\ - asrs r6, r4, 16\n\ - adds r0, r6\n\ - mov r2, sp\n\ - movs r3, 0x2\n\ - ldrsh r1, [r2, r3]\n\ - adds r1, r7\n\ - bl MapGridGetMetatileIdAt\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ - cmp r7, 0x5\n\ - beq _080B34D0\n\ - cmp r6, 0x6\n\ - beq _080B34D0\n\ - mov r0, sp\n\ - movs r1, 0\n\ - ldrsh r0, [r0, r1]\n\ - adds r0, r6\n\ - mov r2, sp\n\ - movs r3, 0x2\n\ - ldrsh r1, [r2, r3]\n\ - adds r1, r7\n\ - bl MapGridGetMetatileLayerTypeAt\n\ - lsls r0, 24\n\ - lsrs r3, r0, 24\n\ - cmp r5, r10\n\ - bhi _080B34B0\n\ - mov r1, r9\n\ - ldr r0, [r1]\n\ - ldr r0, [r0, 0x10]\n\ - lsls r1, r5, 4\n\ - ldr r2, [r0, 0xC]\n\ - adds r2, r1\n\ - b _080B34C0\n\ - .align 2, 0\n\ -_080B34A8: .4byte 0x000001ff\n\ -_080B34AC: .4byte gMapHeader\n\ -_080B34B0:\n\ - mov r2, r9\n\ - ldr r0, [r2]\n\ - ldr r1, [r0, 0x14]\n\ - ldr r2, _080B34CC @ =0xfffffe00\n\ - adds r0, r5, r2\n\ - lsls r0, 4\n\ - ldr r2, [r1, 0xC]\n\ - adds r2, r0\n\ -_080B34C0:\n\ - adds r0, r6, 0\n\ - adds r1, r7, 0\n\ - bl BuyMenuDrawMapMetatile\n\ - b _080B3506\n\ - .align 2, 0\n\ -_080B34CC: .4byte 0xfffffe00\n\ -_080B34D0:\n\ - cmp r5, r10\n\ - bhi _080B34EC\n\ - asrs r0, r4, 16\n\ - mov r3, r9\n\ - ldr r1, [r3]\n\ - ldr r1, [r1, 0x10]\n\ - lsls r3, r5, 4\n\ - ldr r2, [r1, 0xC]\n\ - adds r2, r3\n\ - mov r3, r8\n\ - asrs r1, r3, 16\n\ - bl sub_80B33D0\n\ - b _080B3506\n\ -_080B34EC:\n\ - asrs r0, r4, 16\n\ - mov r2, r9\n\ - ldr r1, [r2]\n\ - ldr r2, [r1, 0x14]\n\ - ldr r3, _080B354C @ =0xfffffe00\n\ - adds r1, r5, r3\n\ - lsls r1, 4\n\ - ldr r2, [r2, 0xC]\n\ - adds r2, r1\n\ - mov r3, r8\n\ - asrs r1, r3, 16\n\ - bl sub_80B33D0\n\ -_080B3506:\n\ - cmp r7, 0\n\ - bne _080B3520\n\ - asrs r1, r4, 16\n\ - cmp r1, 0\n\ - beq _080B3520\n\ - cmp r1, 0x6\n\ - beq _080B3520\n\ - lsls r1, 17\n\ - asrs r1, 16\n\ - ldr r0, _080B3550 @ =gBGTilemapBuffers + 0x800\n\ - movs r2, 0x40\n\ - bl sub_80B32EC\n\ -_080B3520:\n\ - movs r1, 0x80\n\ - lsls r1, 9\n\ - adds r0, r4, r1\n\ - lsrs r4, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x6\n\ - ble _080B345A\n\ - adds r0, r1, 0\n\ - add r0, r8\n\ - lsrs r1, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x5\n\ - ble _080B3452\n\ - add sp, 0x4\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_080B354C: .4byte 0xfffffe00\n\ -_080B3550: .4byte gBGTilemapBuffers + 0x800\n\ - .syntax divided"); + s16 facingX; + s16 facingY; + s16 x; + s16 y; + + GetXYCoordsOneStepInFrontOfPlayer(&facingX, &facingY); + facingX -= 3; + facingY -= 3; + + for (y = 0; y < 6; y++) + { + for (x = 0; x < 7; x++) + { + u16 metatileId = MapGridGetMetatileIdAt(facingX + x, facingY + y); + + if (y != 5 && x != 6) + { + s32 r3 = MapGridGetMetatileLayerTypeAt(facingX + x, facingY + y); + + if (metatileId < 512) + BuyMenuDrawMapMetatile(x, y, (u16 *)gMapHeader.mapData->primaryTileset->metatiles + metatileId * 8, r3); + else + BuyMenuDrawMapMetatile(x, y, (u16 *)gMapHeader.mapData->secondaryTileset->metatiles + (metatileId - 512) * 8, r3); + } + else + { + if (metatileId < 512) + sub_80B33D0(x, y, (u16 *)gMapHeader.mapData->primaryTileset->metatiles + metatileId * 8); + else + sub_80B33D0(x, y, (u16 *)gMapHeader.mapData->secondaryTileset->metatiles + (metatileId - 512) * 8); + } + + if (y == 0 && x != 0 && x != 6) + sub_80B32EC(gBGTilemapBuffers[1], x * 2, 64); + } + } } void BuyMenuDrawMapGraphics(void) @@ -518,202 +401,61 @@ void BuyMenuDrawMapGraphics(void) sub_80B3420(); } -// yet another difficult multi for-loop. No. -__attribute__((naked)) -void sub_80B356C(void) // PopulateShopViewWindowObjectInfo ? +extern s16 gUnknown_020386A4[][4]; + +void sub_80B356C(void) { - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x8\n\ - movs r0, 0\n\ - mov r8, r0\n\ - mov r4, sp\n\ - adds r4, 0x2\n\ - mov r0, sp\n\ - adds r1, r4, 0\n\ - bl GetXYCoordsOneStepInFrontOfPlayer\n\ - bl PlayerGetZCoord\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x4]\n\ - movs r5, 0\n\ - ldr r2, _080B3674 @ =gUnknown_020386A4\n\ - movs r1, 0x10\n\ -_080B3598:\n\ - lsls r0, r5, 3\n\ - adds r0, r2\n\ - strh r1, [r0]\n\ - adds r0, r5, 0x1\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - cmp r5, 0xF\n\ - bls _080B3598\n\ - movs r5, 0\n\ - ldr r7, _080B3678 @ =gUnknown_020386AA\n\ - subs r1, r7, 0x6\n\ - mov r9, r1\n\ -_080B35B0:\n\ - movs r4, 0\n\ - adds r2, r5, 0x1\n\ - mov r10, r2\n\ -_080B35B6:\n\ - mov r1, sp\n\ - ldr r3, _080B367C @ =0x0000fffd\n\ - adds r0, r3, 0\n\ - ldrh r1, [r1]\n\ - adds r0, r1\n\ - adds r0, r4\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - ldr r2, _080B3680 @ =0x0000fffe\n\ - adds r1, r2, 0\n\ - mov r3, sp\n\ - ldrh r3, [r3, 0x2]\n\ - adds r1, r3\n\ - adds r1, r5\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - ldr r2, [sp, 0x4]\n\ - bl GetFieldObjectIdByXYZ\n\ - lsls r0, 24\n\ - lsrs r2, r0, 24\n\ - cmp r2, 0x10\n\ - beq _080B3650\n\ - mov r0, r8\n\ - lsls r3, r0, 3\n\ - mov r1, r9\n\ - adds r0, r3, r1\n\ - movs r6, 0\n\ - strh r2, [r0]\n\ - mov r0, r9\n\ - adds r0, 0x2\n\ - adds r0, r3, r0\n\ - strh r4, [r0]\n\ - ldr r1, _080B3684 @ =gUnknown_020386A8\n\ - adds r0, r3, r1\n\ - strh r5, [r0]\n\ - ldr r1, _080B3688 @ =gMapObjects\n\ - lsls r0, r2, 3\n\ - adds r0, r2\n\ - lsls r0, 2\n\ - adds r2, r0, r1\n\ - ldrb r0, [r2, 0x18]\n\ - lsls r0, 28\n\ - lsrs r0, 28\n\ - cmp r0, 0x1\n\ - bne _080B3616\n\ - adds r0, r3, r7\n\ - strh r6, [r0]\n\ -_080B3616:\n\ - ldrb r0, [r2, 0x18]\n\ - lsls r0, 28\n\ - lsrs r0, 28\n\ - cmp r0, 0x2\n\ - bne _080B3626\n\ - adds r1, r3, r7\n\ - movs r0, 0x1\n\ - strh r0, [r1]\n\ -_080B3626:\n\ - ldrb r0, [r2, 0x18]\n\ - lsls r0, 28\n\ - lsrs r0, 28\n\ - cmp r0, 0x3\n\ - bne _080B3636\n\ - adds r1, r3, r7\n\ - movs r0, 0x2\n\ - strh r0, [r1]\n\ -_080B3636:\n\ - ldrb r0, [r2, 0x18]\n\ - lsls r0, 28\n\ - lsrs r0, 28\n\ - cmp r0, 0x4\n\ - bne _080B3646\n\ - adds r1, r3, r7\n\ - movs r0, 0x3\n\ - strh r0, [r1]\n\ -_080B3646:\n\ - mov r0, r8\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r8, r0\n\ -_080B3650:\n\ - adds r0, r4, 0x1\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - cmp r4, 0x6\n\ - bls _080B35B6\n\ - mov r2, r10\n\ - lsls r0, r2, 24\n\ - lsrs r5, r0, 24\n\ - cmp r5, 0x4\n\ - bls _080B35B0\n\ - add sp, 0x8\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_080B3674: .4byte gUnknown_020386A4\n\ -_080B3678: .4byte gUnknown_020386AA\n\ -_080B367C: .4byte 0x0000fffd\n\ -_080B3680: .4byte 0x0000fffe\n\ -_080B3684: .4byte gUnknown_020386A8\n\ -_080B3688: .4byte gMapObjects\n\ - .syntax divided"); + s16 facingX; + s16 facingY; + u8 playerHeight; + u8 y; + u8 x; + u8 r8 = 0; + + GetXYCoordsOneStepInFrontOfPlayer(&facingX, &facingY); + playerHeight = PlayerGetZCoord(); + for (y = 0; y < 16; y++) + gUnknown_020386A4[y][0] = 16; + for (y = 0; y < 5; y++) + { + for (x = 0; x < 7; x++) + { + u8 mapObjId = GetFieldObjectIdByXYZ(facingX - 3 + x, facingY - 2 + y, playerHeight); + + if (mapObjId != 16) + { + gUnknown_020386A4[r8][0] = mapObjId; + gUnknown_020386A4[r8][1] = x; + gUnknown_020386A4[r8][2] = y; + if (gMapObjects[mapObjId].mapobj_unk_18 == 1) + gUnknown_020386A4[r8][3] = 0; + if (gMapObjects[mapObjId].mapobj_unk_18 == 2) + gUnknown_020386A4[r8][3] = 1; + if (gMapObjects[mapObjId].mapobj_unk_18 == 3) + gUnknown_020386A4[r8][3] = 2; + if (gMapObjects[mapObjId].mapobj_unk_18 == 4) + gUnknown_020386A4[r8][3] = 3; + r8++; + } + } + } } -/* -struct UnkStruct_20386A4 -{ - s16 mapObjId; - u16 unk2; - u16 unk4; - u8 unk6[2]; -}; -*/ - -//extern s16 gUnknown_020386A4[][]; -//extern struct UnkStruct_20386A4 gUnknown_020386A4[]; -// all 3 of these are incredibly hard, please help -/*void sub_80B368C(void) +void sub_80B368C(void) { - // r0 = spriteId - // r1 = gUnknown_020386A4 + 6 - // r2 = gSprites[spriteId] - // r3 = gUnknown_020386A4[i].unk4 + 32 - // r4 = i * 8 - // r5 = 0 (i) - // r6 = gUnknown_020386A4 - // r7 = gMapObjects - // r8 = gUnknown_020386A4 + 6 - // r9 = - // r10 = - // r11 = - // r12 = - - u8 i = 0; - u8 *unkArray = (u8 *)&gUnknown_020386A4[6]; - - for(; i < 16; i++) // max objects? - { - s16 mapObjId = unkStruct[i].mapObjId; - if(mapObjId != 16) - { - u8 spriteId = AddPseudoFieldObject( - gMapObjects[mapObjId].graphicsId, - SpriteCallbackDummy, - unkStruct[i].unk2 * 16 + 8, - unkStruct[i].unk4 + 12, - 2); - StartSpriteAnim(&gSprites[spriteId], unkArray[i]); - } - } -}*/ + u8 i; + + for(i = 0; i < 16; i++) // max objects? + { + if(gUnknown_020386A4[i][0] == 16) + continue; + + StartSpriteAnim(&gSprites[AddPseudoFieldObject( + gMapObjects[gUnknown_020386A4[i][0]].graphicsId, + SpriteCallbackDummy, + (u16)gUnknown_020386A4[i][1] * 16 + 8, + (u16)gUnknown_020386A4[i][2] * 16 + 32, + 2)], + gUnknown_020386A4[i][3]); + } +} -- cgit v1.2.3 From 05c2f2e4fc7ad2fc98315e53a0b1adb7d4d4c0d1 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Tue, 22 Aug 2017 02:33:18 -0400 Subject: decompile up to sub_80B37F8 --- src/shop.c | 121 +++++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 93 insertions(+), 28 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 06ec45292..aca48cc2e 100644 --- a/src/shop.c +++ b/src/shop.c @@ -19,13 +19,17 @@ #include "field_map_obj.h" #include "field_player_avatar.h" #include "fieldmap.h" +#include "item.h" + +extern void sub_80B39D0(int, int, int); +extern void sub_80B3A70(void); struct UnknownShopStruct { /* 0x0 */ void (* callback) (void); /* 0x4 */ u16 *itemList; /* 0x8 */ u8 itemCount; - /* 0x9 */ u8 unk9; + /* 0x9 */ u8 cursor; /* 0xA */ u8 unkA; /* 0xB */ u8 unkB; /* 0xC */ bool8 unkC; @@ -35,10 +39,26 @@ struct UnknownShopStruct extern struct UnknownShopStruct gUnknown_03000708; extern struct MenuAction gUnknown_083CC6D0[]; +extern u8 ewram[]; + extern u8 gUnknown_083CC6E8[]; extern u8 gUnknown_083CC6EB[]; extern u8 gBuyMenuFrame_Gfx[]; +#define ewram18000 ((u16 *)(ewram + 0x18000)) +#define ewram18300 ((u16 *)(ewram + 0x18300)) + +// shop view window NPC info enum +enum +{ + MAP_OBJ_ID, + X_COORD, + Y_COORD, + ANIM_NUM +}; + +extern s16 gUnknown_020386A4[][4]; // game freak barely uses 2d arrays wtf? + extern u16 gBuyMenuFrame_Tilemap[]; extern u16 gMenuMoneyPal[16]; extern u16 gUnknown_083CC710[2]; @@ -47,7 +67,7 @@ u8 CreateShopMenu(bool8 var) { ScriptContext2_Enable(); gUnknown_03000708.unkC = var; - gUnknown_03000708.unk9 = 0; + gUnknown_03000708.cursor = 0; if(var == FALSE) { @@ -89,35 +109,35 @@ void sub_80B2E38(u8 var) { const u8 local = var; - if(gMain.newAndRepeatedKeys & 0x40) + if(gMain.newAndRepeatedKeys & DPAD_UP) { - if(gUnknown_03000708.unk9) + if(gUnknown_03000708.cursor) // can move cursor up? { PlaySE(0x5); - gUnknown_03000708.unk9 = MoveMenuCursor(-1); + gUnknown_03000708.cursor = MoveMenuCursor(-1); } } - else if(gMain.newAndRepeatedKeys & 0x80) + else if(gMain.newAndRepeatedKeys & DPAD_DOWN) { - if(gUnknown_03000708.unk9 != gUnknown_03000708.unkA) + if(gUnknown_03000708.cursor != gUnknown_03000708.unkA) // can move cursor down? { PlaySE(0x5); - gUnknown_03000708.unk9 = MoveMenuCursor(1); + gUnknown_03000708.cursor = MoveMenuCursor(1); } } - else if (gMain.newKeys & 1) + else if (gMain.newKeys & A_BUTTON) { PlaySE(0x5); if(!gUnknown_03000708.unkC) { - gUnknown_083CC6D0[gUnknown_083CC6E8[gUnknown_03000708.unk9]].func(local); + gUnknown_083CC6D0[gUnknown_083CC6E8[gUnknown_03000708.cursor]].func(local); } else { - gUnknown_083CC6D0[gUnknown_083CC6EB[gUnknown_03000708.unk9]].func(local); + gUnknown_083CC6D0[gUnknown_083CC6EB[gUnknown_03000708.cursor]].func(local); } } - else if(gMain.newKeys & 2) + else if(gMain.newKeys & B_BUTTON) { PlaySE(0x5); HandleShopMenuQuit(local); @@ -256,7 +276,7 @@ void BuyMenuDrawGraphics(void) SetUpWindowConfig(&gWindowConfig_81E6DFC); InitMenuWindow(&gWindowConfig_81E6DFC); BuyMenuDrawMapGraphics(); - gUnknown_03000708.unk9 = zero; + gUnknown_03000708.cursor = zero; gUnknown_03000708.unkB = zero2; MenuZeroFillWindowRect(0, 0, 0x20, 0x20); sub_80B7C14(gSaveBlock1.money, 0, 0); @@ -401,8 +421,6 @@ void BuyMenuDrawMapGraphics(void) sub_80B3420(); } -extern s16 gUnknown_020386A4[][4]; - void sub_80B356C(void) { s16 facingX; @@ -415,7 +433,7 @@ void sub_80B356C(void) GetXYCoordsOneStepInFrontOfPlayer(&facingX, &facingY); playerHeight = PlayerGetZCoord(); for (y = 0; y < 16; y++) - gUnknown_020386A4[y][0] = 16; + gUnknown_020386A4[y][MAP_OBJ_ID] = 16; for (y = 0; y < 5; y++) { for (x = 0; x < 7; x++) @@ -424,17 +442,17 @@ void sub_80B356C(void) if (mapObjId != 16) { - gUnknown_020386A4[r8][0] = mapObjId; - gUnknown_020386A4[r8][1] = x; - gUnknown_020386A4[r8][2] = y; + gUnknown_020386A4[r8][MAP_OBJ_ID] = mapObjId; + gUnknown_020386A4[r8][X_COORD] = x; + gUnknown_020386A4[r8][Y_COORD] = y; if (gMapObjects[mapObjId].mapobj_unk_18 == 1) - gUnknown_020386A4[r8][3] = 0; + gUnknown_020386A4[r8][ANIM_NUM] = 0; if (gMapObjects[mapObjId].mapobj_unk_18 == 2) - gUnknown_020386A4[r8][3] = 1; + gUnknown_020386A4[r8][ANIM_NUM] = 1; if (gMapObjects[mapObjId].mapobj_unk_18 == 3) - gUnknown_020386A4[r8][3] = 2; + gUnknown_020386A4[r8][ANIM_NUM] = 2; if (gMapObjects[mapObjId].mapobj_unk_18 == 4) - gUnknown_020386A4[r8][3] = 3; + gUnknown_020386A4[r8][ANIM_NUM] = 3; r8++; } } @@ -447,15 +465,62 @@ void sub_80B368C(void) for(i = 0; i < 16; i++) // max objects? { - if(gUnknown_020386A4[i][0] == 16) + if(gUnknown_020386A4[i][MAP_OBJ_ID] == 16) continue; StartSpriteAnim(&gSprites[AddPseudoFieldObject( - gMapObjects[gUnknown_020386A4[i][0]].graphicsId, + gMapObjects[gUnknown_020386A4[i][MAP_OBJ_ID]].graphicsId, SpriteCallbackDummy, - (u16)gUnknown_020386A4[i][1] * 16 + 8, - (u16)gUnknown_020386A4[i][2] * 16 + 32, + (u16)gUnknown_020386A4[i][X_COORD] * 16 + 8, + (u16)gUnknown_020386A4[i][Y_COORD] * 16 + 32, 2)], - gUnknown_020386A4[i][3]); + gUnknown_020386A4[i][ANIM_NUM]); + } +} + +void sub_80B3720(void) +{ + s16 i; + + for (i = 0; i < 0x400; i++) + { + if (ewram18000[i] != 0) + gBGTilemapBuffers[1][i] = ewram18000[i] + 0xC3E0; } } + +void sub_80B3764(int var1, int var2) +{ + sub_80B3720(); + sub_80B39D0(var1, var2, 0); + InitMenu(0, 0xE, 0x2, 0x8, gUnknown_03000708.cursor, 0xF); +} + +void sub_80B379C(void) +{ + u16 i, j; + + for(i = 0; i < 8; i++) + for(j = 0; j < 14; j++) + gBGTilemapBuffers[1][32 * (i + 12) + j] = ewram18300[32 * i + j] + 0xC3E0; +} + +void sub_80B37EC(void) +{ + sub_80B3A70(); +} + +void sub_80B37F8(u8 taskId) +{ + u16 itemListIndex = gUnknown_03000708.unkB + gUnknown_03000708.cursor; + u16 itemId = *(gUnknown_03000708.itemList + itemListIndex); + u32 price = (ItemId_GetPrice(itemId) >> GetPriceReduction(1)); + + sub_80B7A94(gTasks[taskId].data[1] * price, 6, 6, 11); + gStringVar1[0] = EXT_CTRL_CODE_BEGIN; + gStringVar1[1] = 0x14; + gStringVar1[2] = 0x6; + ConvertIntToDecimalStringN(&gStringVar1[3], gTasks[taskId].data[1], 1, 2); + MenuPrint(gOtherText_xString1, 1, 11); + sub_80A3FA0(gBGTilemapBuffers[1], 1, 11, 12, 2, 0xC3E1); +} -- cgit v1.2.3 From 13f917d4ffeff59ad13ea80fa8dbc994e4b687c0 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 22 Aug 2017 10:34:45 +0200 Subject: cleaning up the file --- src/berry_blender.c | 101 ++++++++++++++++++++++++++-------------------------- 1 file changed, 51 insertions(+), 50 deletions(-) (limited to 'src') diff --git a/src/berry_blender.c b/src/berry_blender.c index 772de43f7..f54c6271d 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -373,7 +373,7 @@ static const u8 gUnknown_08216303[] = {32, 224, 96, 160, 0}; static const TaskFunc gUnknown_08216308[] = { - &sub_804F8C8, &sub_804F9F4, &sub_804FB1C + sub_804F8C8, sub_804F9F4, sub_804FB1C }; static const struct OamData sOamData_8216314 = @@ -401,13 +401,13 @@ static const union AnimCmd sSpriteAnim_821631C[] = static const union AnimCmd sSpriteAnim_8216324[] = { - ANIMCMD_FRAME(16, 5, 0, 1), + ANIMCMD_FRAME(16, 5, .vFlip = TRUE), ANIMCMD_END }; static const union AnimCmd sSpriteAnim_821632C[] = { - ANIMCMD_FRAME(16, 5, 1, 0), + ANIMCMD_FRAME(16, 5, .hFlip = TRUE), ANIMCMD_END }; @@ -428,19 +428,19 @@ static const union AnimCmd sSpriteAnim_821633C[] = static const union AnimCmd sSpriteAnim_8216350[] = { - ANIMCMD_FRAME(48, 2, 0, 1), - ANIMCMD_FRAME(32, 5, 0, 1), - ANIMCMD_FRAME(48, 3, 0, 1), - ANIMCMD_FRAME(16, 5, 0, 1), + ANIMCMD_FRAME(48, 2, .vFlip = TRUE), + ANIMCMD_FRAME(32, 5, .vFlip = TRUE), + ANIMCMD_FRAME(48, 3, .vFlip = TRUE), + ANIMCMD_FRAME(16, 5, .vFlip = TRUE), ANIMCMD_END }; static const union AnimCmd sSpriteAnim_8216364[] = { - ANIMCMD_FRAME(48, 2, 1, 0), - ANIMCMD_FRAME(32, 5, 1, 0), - ANIMCMD_FRAME(48, 3, 1, 0), - ANIMCMD_FRAME(16, 5, 1, 0), + ANIMCMD_FRAME(48, 2, .hFlip = TRUE), + ANIMCMD_FRAME(32, 5, .hFlip = TRUE), + ANIMCMD_FRAME(48, 3, .hFlip = TRUE), + ANIMCMD_FRAME(16, 5, .hFlip = TRUE), ANIMCMD_END }; @@ -461,13 +461,13 @@ static const union AnimCmd sSpriteAnim_821638C[] = static const union AnimCmd sSpriteAnim_8216394[] = { - ANIMCMD_FRAME(0, 5, 0, 1), + ANIMCMD_FRAME(0, 5, .vFlip = TRUE), ANIMCMD_END }; static const union AnimCmd sSpriteAnim_821639C[] = { - ANIMCMD_FRAME(0, 5, 1, 0), + ANIMCMD_FRAME(0, 5, .hFlip = TRUE), ANIMCMD_END }; @@ -917,9 +917,9 @@ static bool8 sub_804E2EC(void) LoadSpritePalette(&gUnknown_082163EC); LoadSpritePalette(&gUnknown_082163E4); gBerryBlenderData->field_1 = 0; - return 1; + return TRUE; } - return 0; + return FALSE; } static void sub_804E4FC(void) @@ -1031,7 +1031,7 @@ void sub_804E738(struct Sprite* sprite) if (++sprite->data5 > 3) DestroySprite(sprite); else - PlaySE(116); + PlaySE(SE_TB_KARA); } sprite->pos1.x = sprite->data1; sprite->pos1.y = sprite->data2; @@ -1306,7 +1306,7 @@ static void sub_804E9F8(void) { gBerryBlenderData->field_178 = GetCurrentMapMusic(); } - PlayBGM(403); + PlayBGM(BGM_CYCLING); break; case 100: MenuDrawTextWindow(0, 13, 29, 19); @@ -1512,7 +1512,7 @@ static void sub_804F378(void) case 13: gBerryBlenderData->field_0++; sub_804F238(); - PlaySE(43); + PlaySE(SE_RU_HYUU); sub_8051414(&gBerryBlenderData->field_168); break; case 14: @@ -1526,7 +1526,7 @@ static void sub_804F378(void) gBerryBlenderData->arrowPos = gUnknown_082162F8[gUnknown_08216300[gBerryBlenderData->playersNo - 2]]; REG_BG2CNT = 0x4882; gBerryBlenderData->framesToWait = 0; - PlaySE(52); + PlaySE(SE_TRACK_DOOR);; sub_804F2A8(); } sub_8051414(&gBerryBlenderData->field_168); @@ -1568,8 +1568,8 @@ static void sub_804F378(void) { gBerryBlenderData->field_178 = GetCurrentMapMusic(); } - PlayBGM(403); - PlaySE(53); + PlayBGM(BGM_CYCLING); + PlaySE(SE_MOTER); Blender_ControlHitPitch(); break; } @@ -1760,17 +1760,17 @@ static void sub_804FC48(u16 a0, u8 a1) { StartSpriteAnim(&gSprites[spriteID], 2); gSprites[spriteID].callback = sub_8051684; - PlaySE(40); + PlaySE(SE_RU_GASHIN); } else if (a0 == 0x5432) { StartSpriteAnim(&gSprites[spriteID], 0); - PlaySE(31); + PlaySE(SE_SEIKAI); } else if (a0 == 0x2345) { StartSpriteAnim(&gSprites[spriteID], 1); - PlaySE(32); + PlaySE(SE_HAZURE); } sub_805156C(); } @@ -1926,20 +1926,21 @@ static void sub_80501FC(void) UpdatePaletteFade(); } -#define ARE_FLAVOURS_SAME(flavours1, flavours2)(((*(u32*)(&flavours1[-1]) & 0xFFFFFF00) == (*(u32*)(&flavours2[-1]) & 0xFFFFFF00)&& (*(u32*)(&flavours1[3]) & 0xFFFFFF) == (*(u32*)(&flavours2[3]) & 0xFFFFFF))) - static bool8 sub_80502A4(struct BlenderBerry* berries, u8 index1, u8 index2) { if (berries[index1].itemID != berries[index2].itemID - || (StringCompare(berries[index1].name, berries[index2].name) == 0 - && ARE_FLAVOURS_SAME(berries[index1].flavours, berries[index2].flavours))) - return 1; + || (StringCompare(berries[index1].name, berries[index2].name) == 0 + && (berries[index1].flavours[0] == berries[index2].flavours[0] + && berries[index1].flavours[1] == berries[index2].flavours[1] + && berries[index1].flavours[2] == berries[index2].flavours[2] + && berries[index1].flavours[3] == berries[index2].flavours[3] + && berries[index1].flavours[4] == berries[index2].flavours[4] + && berries[index1].smoothness == berries[index2].smoothness))) + return TRUE; else - return 0; + return FALSE; } -#undef ARE_FLAVOURS_SAME - u32 Blender_GetPokeblockColor(struct BlenderBerry* berries, s16* a1, u8 playersNo, u8 a3) { s16 vars[5]; @@ -2448,7 +2449,7 @@ static void BlenderDebug_CalculatePokeblock(struct BlenderBerry* berries, struct static void sub_8050760(void) { u32 frames = (u16)(gBerryBlenderData->gameFrameTime); - u32 max_RPM = (u16)(gBerryBlenderData->max_RPM); + u16 max_RPM = gBerryBlenderData->max_RPM; s16 var = 0; if (frames < 900) @@ -2466,23 +2467,23 @@ static void sub_8050760(void) var = 0; if (max_RPM <= 64) { - if ((u16)(max_RPM - 50) < 50) + if (max_RPM >= 50 && max_RPM < 100) var = -1; - else if ((u16)(max_RPM - 100) < 50) + else if (max_RPM >= 100 && max_RPM < 150) var = -2; - else if ((u16)(max_RPM - 150) < 50) + else if (max_RPM >= 150 && max_RPM < 200) var = -3; - else if ((u16)(max_RPM - 200) < 50) + else if (max_RPM >= 200 && max_RPM < 250) var = -4; - else if ((u16)(max_RPM - 250) < 50) + else if (max_RPM >= 250 && max_RPM < 300) var = -5; - else if ((u16)(max_RPM - 350) < 50) + else if (max_RPM >= 350 && max_RPM < 400) var = -6; - else if ((u16)(max_RPM - 400) < 50) + else if (max_RPM >= 400 && max_RPM < 450) var = -7; - else if ((u16)(max_RPM - 500) < 50) + else if (max_RPM >= 500 && max_RPM < 550) var = -8; - else if ((u16)(max_RPM - 550) < 50) + else if (max_RPM >= 550 && max_RPM < 600) var = -9; else if (max_RPM >= 600) var = -10; @@ -2718,11 +2719,11 @@ bool8 sub_8050CE8(void) if (++gBerryBlenderData->framesToWait > 5) { gSoftResetDisabled = FALSE; - return 1; + return TRUE; } break; } - return 0; + return FALSE; } static void sub_8050E30(void) @@ -3292,10 +3293,10 @@ static bool8 sub_8051B8C(void) { gBerryBlenderData->field_144 = 0; gBerryBlenderData->field_146 = 0; - return 1; + return TRUE; } else - return 0; + return FALSE; } static void sub_8051C04(struct Sprite* sprite) @@ -3438,11 +3439,11 @@ static bool8 Blender_PrintBlendingResults(void) if (MenuUpdateWindowText()) { Blender_TrySettingRecord(); - return 1; + return TRUE; } break; } - return 0; + return FALSE; } static void Blender_PrintMadePokeblockString(struct Pokeblock* pokeblock, u8* dst) @@ -3592,9 +3593,9 @@ static bool8 Blender_PrintBlendingRanking(void) break; case 6: gBerryBlenderData->field_0 = 0; - return 1; + return TRUE; } - return 0; + return FALSE; } // debug menu goes here -- cgit v1.2.3 From be47f6b54bd4b586d435d6fbff56bc315ff72efc Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 22 Aug 2017 17:10:50 +0200 Subject: a really hard math function --- src/battle_transition.c | 353 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 261 insertions(+), 92 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 9f4126822..fcf49a7fb 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -11,6 +11,7 @@ #include "sound.h" #include "songs.h" #include "trainer.h" +#include "field_camera.h" void sub_807DE10(void); void dp12_8087EA4(void); @@ -46,6 +47,12 @@ struct TransitionData s16 field_2A; s16 field_2C; s16 field_2E; + s16 field_30; + s16 field_32; + s16 field_34; + s16 field_36; + s16 field_38; + s16 field_3A; }; #define TRANSITION_STRUCT (*(struct TransitionData *) (ewram + 0xC000)) @@ -160,22 +167,22 @@ static bool8 sub_811C938(struct Sprite* sprite); static bool8 sub_811C984(struct Sprite* sprite); static bool8 sub_811C9B8(struct Sprite* sprite); static bool8 sub_811C9E4(struct Sprite* sprite); -static void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); +static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4); static bool8 sub_811D52C(void); +static void Phase1_Task_RunFuncs(u8 taskID); +static bool8 Phase1_TransitionAll_Func1(struct Task* task); +static bool8 Phase1_TransitionAll_Func2(struct Task* task); +static void sub_811D658(void); +static void VBlankCB_BattleTransition(void); +static void sub_811D6A8(u16** a0, u16** a1); +static void sub_811D690(u16** a0); +static void sub_811D6D4(void); +static void sub_811D6E8(s16* array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); -void sub_811D658(void); -void VBlankCB_BattleTransition(void); -void sub_811D6E8(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5); -void sub_811D6A8(u16** a0, u16** a1); -void sub_811D690(u16** a0); void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); -void sub_811D6D4(void); void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); void sub_811CFD0(struct Sprite* sprite); -void sub_811D54C(u8 taskID); -bool8 sub_811D584(struct Task* task); -bool8 sub_811D5E0(struct Task* task); // const data @@ -187,7 +194,7 @@ const u32 gSpriteImage_83FC528[] = INCBIN_U32("graphics/battle_transitions/unuse const u32 gSpriteImage_83FCD28[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); const u32 gUnknown_083FD528[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); -struct TransitionData * const sTransitionStructPtr = &TRANSITION_STRUCT; +static struct TransitionData * const sTransitionStructPtr = &TRANSITION_STRUCT; static const TaskFunc sPhase1_Tasks[TRANSITIONS_NO] = { @@ -380,10 +387,10 @@ static const s16 gUnknown_083FD8F4[][5] = static const s16 gUnknown_083FD93A[] = {8, 4, 2, 1, 1, 1, 0}; -static const TransitionState gUnknown_083FD948[] = +static const TransitionState sPhase1_TransitionAll_Funcs[] = { - &sub_811D584, - &sub_811D5E0 + &Phase1_TransitionAll_Func1, + &Phase1_TransitionAll_Func2 }; extern const u16 gFieldEffectObjectPalette10[]; @@ -416,10 +423,10 @@ bool8 IsBattleTransitionDone(void) if (gTasks[taskID].tTransitionDone) { DestroyTask(taskID); - return 1; + return TRUE; } else - return 0; + return FALSE; } static void LaunchBattleTransitionTask(u8 transitionID) @@ -441,12 +448,12 @@ static bool8 Transition_Phase1(struct Task* task) { CreateTask(sPhase1_Tasks[task->tTransitionID], 4); task->tState++; - return 0; + return FALSE; } else { task->tState = 2; - return 1; + return TRUE; } } @@ -455,17 +462,17 @@ static bool8 Transition_WaitForPhase1(struct Task* task) if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionID]) == 0xFF) { task->tState++; - return 1; + return TRUE; } else - return 0; + return FALSE; } static bool8 Transition_Phase2(struct Task* task) { CreateTask(sPhase2_Tasks[task->tTransitionID], 0); task->tState++; - return 0; + return FALSE; } static bool8 Transition_WaitForPhase2(struct Task* task) @@ -473,7 +480,7 @@ static bool8 Transition_WaitForPhase2(struct Task* task) task->tTransitionDone = 0; if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionID]) == 0xFF) task->tTransitionDone = 1; - return 0; + return FALSE; } static void Phase1Task_TransitionAll(u8 taskID) @@ -481,7 +488,7 @@ static void Phase1Task_TransitionAll(u8 taskID) if (gTasks[taskID].tState == 0) { gTasks[taskID].tState++; - sub_811D4C8(0, 0, 3, 2, 2); + CreatePhase1Task(0, 0, 3, 2, 2); } else if (sub_811D52C()) DestroyTask(taskID); @@ -499,7 +506,7 @@ static bool8 Phase2_Transition0_Func1(struct Task* task) REG_BG2CNT |= 0x40; REG_BG3CNT |= 0x40; task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition0_Func2(struct Task* task) @@ -515,7 +522,7 @@ static bool8 Phase2_Transition0_Func2(struct Task* task) if (task->data[2] > 14) task->tState++; } - return 0; + return FALSE; } static bool8 Phase2_Transition0_Func3(struct Task* task) @@ -525,7 +532,7 @@ static bool8 Phase2_Transition0_Func3(struct Task* task) u8 taskID = FindTaskIdByFunc(Phase2Task_Transition0); DestroyTask(taskID); } - return 0; + return FALSE; } static void Phase2Task_Transition1(u8 taskID) @@ -552,7 +559,7 @@ static bool8 Phase2_Transition1_Func1(struct Task* task) REG_DISPSTAT |= 0x18; task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition1_Func2(struct Task* task) @@ -570,7 +577,7 @@ static bool8 Phase2_Transition1_Func2(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition1(void) @@ -613,7 +620,7 @@ static bool8 Phase2_Transition2_Func1(struct Task* task) REG_DISPSTAT |= 0x18; task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition2_Func2(struct Task* task) @@ -637,7 +644,7 @@ static bool8 Phase2_Transition2_Func2(struct Task* task) DestroyTask(FindTaskIdByFunc(Phase2Task_Transition2)); TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition2(void) @@ -692,7 +699,7 @@ static bool8 Phase2_Transition3_Func1(struct Task* task) LoadPalette(gFieldEffectObjectPalette10, 240, 32); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition3_Func2(struct Task* task) @@ -713,7 +720,7 @@ static bool8 Phase2_Transition3_Func2(struct Task* task) sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5], 160); task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition3_Func3(struct Task* task) @@ -733,7 +740,7 @@ static bool8 Phase2_Transition3_Func3(struct Task* task) sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition3_Func4(struct Task* task) @@ -753,7 +760,7 @@ static bool8 Phase2_Transition3_Func4(struct Task* task) sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5] >> 8, 160); TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition3_Func5(struct Task* task) @@ -773,7 +780,7 @@ static bool8 Phase2_Transition3_Func5(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition3_Func6(struct Task* task) @@ -801,7 +808,7 @@ static bool8 Phase2_Transition3_Func6(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static void Transition3_Vblank(void) @@ -844,7 +851,7 @@ static bool8 Phase2_Transition4_Func1(struct Task* task) LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition4_Func2(struct Task* task) @@ -867,7 +874,7 @@ static bool8 Phase2_Transition4_Func2(struct Task* task) } task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition4_Func3(struct Task* task) @@ -877,7 +884,7 @@ static bool8 Phase2_Transition4_Func3(struct Task* task) sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition4)); } - return 0; + return FALSE; } bool8 FldEff_Pokeball(void) @@ -890,7 +897,7 @@ bool8 FldEff_Pokeball(void) gSprites[spriteID].data2 = -1; InitSpriteAffineAnim(&gSprites[spriteID]); StartSpriteAffineAnim(&gSprites[spriteID], gUnknown_0202FF84[2]); - return 0; + return FALSE; } #define SOME_VRAM_STORE(ptr, posY, posX, toStore) \ @@ -960,7 +967,7 @@ static bool8 Phase2_Transition5_Func1(struct Task* task) TRANSITION_STRUCT.field_2C = 120; task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition5_Func2(struct Task* task) @@ -981,7 +988,7 @@ static bool8 Phase2_Transition5_Func2(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition5_Func3(struct Task* task) @@ -1019,7 +1026,7 @@ static bool8 Phase2_Transition5_Func3(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition5_Func4(struct Task* task) @@ -1040,7 +1047,7 @@ static bool8 Phase2_Transition5_Func4(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition5_Func5(struct Task* task) @@ -1079,7 +1086,7 @@ static bool8 Phase2_Transition5_Func5(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition5_Func6(struct Task* task) @@ -1103,7 +1110,7 @@ static bool8 Phase2_Transition5_Func6(struct Task* task) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition5_Func7(struct Task* task) @@ -1111,7 +1118,7 @@ static bool8 Phase2_Transition5_Func7(struct Task* task) DmaStop(0); sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition5)); - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition5(void) @@ -1151,7 +1158,7 @@ static bool8 Phase2_Transition6_Func1(struct Task* task) REG_DISPSTAT |= 0x10; task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition6_Func2(struct Task* task) @@ -1188,7 +1195,7 @@ static bool8 Phase2_Transition6_Func2(struct Task* task) DestroyTask(FindTaskIdByFunc(Phase2Task_Transition6)); TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition6(void) @@ -1231,7 +1238,7 @@ static bool8 Phase2_Transition7_Func1(struct Task* task) SetVBlankCallback(VBlankCB_Phase2_Transition7); task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition7_Func2(struct Task* task) @@ -1261,7 +1268,7 @@ static bool8 Phase2_Transition7_Func2(struct Task* task) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition7_Func3(struct Task* task) @@ -1269,7 +1276,7 @@ static bool8 Phase2_Transition7_Func3(struct Task* task) DmaStop(0); sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition7)); - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition7(void) @@ -1346,7 +1353,7 @@ static bool8 Phase2_Mugshot_Func1(struct Task* task) SetVBlankCallback(VBlankCB0_Phase2_Mugshots); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func2(struct Task* task) @@ -1373,7 +1380,7 @@ static bool8 Phase2_Mugshot_Func2(struct Task* task) REG_DISPSTAT |= 0x10; SetHBlankCallback(HBlankCB_Phase2_Mugshots); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func3(struct Task* task) @@ -1421,7 +1428,7 @@ static bool8 Phase2_Mugshot_Func3(struct Task* task) TRANSITION_STRUCT.field_18 -= 8; TRANSITION_STRUCT.field_1A += 8; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func4(struct Task* task) @@ -1450,7 +1457,7 @@ static bool8 Phase2_Mugshot_Func4(struct Task* task) PlaySE(SE_BT_START); TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func5(struct Task* task) @@ -1462,7 +1469,7 @@ static bool8 Phase2_Mugshot_Func5(struct Task* task) task->tState++; sub_811CA28(task->tMugshotPlayerID); } - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func6(struct Task* task) @@ -1484,7 +1491,7 @@ static bool8 Phase2_Mugshot_Func6(struct Task* task) TRANSITION_STRUCT.BLDCNT = 0xBF; SetVBlankCallback(VBlankCB1_Phase2_Mugshots); } - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func7(struct Task* task) @@ -1525,7 +1532,7 @@ static bool8 Phase2_Mugshot_Func7(struct Task* task) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func8(struct Task* task) @@ -1536,7 +1543,7 @@ static bool8 Phase2_Mugshot_Func8(struct Task* task) task->data[3] = 0; task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Mugshot_Func9(struct Task* task) @@ -1549,7 +1556,7 @@ static bool8 Phase2_Mugshot_Func9(struct Task* task) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Mugshot_Func10(struct Task* task) @@ -1557,7 +1564,7 @@ static bool8 Phase2_Mugshot_Func10(struct Task* task) DmaStop(0); sub_811D6D4(); DestroyTask(FindTaskIdByFunc(task->func)); - return 0; + return FALSE; } static void VBlankCB0_Phase2_Mugshots(void) @@ -1634,7 +1641,7 @@ void sub_811C90C(struct Sprite* sprite) bool8 sub_811C934(struct Sprite* sprite) { - return 0; + return FALSE; } bool8 sub_811C938(struct Sprite* sprite) @@ -1648,7 +1655,7 @@ bool8 sub_811C938(struct Sprite* sprite) sprite->data0++; sprite->data1 = arr0[sprite->data7]; sprite->data2 = arr1[sprite->data7]; - return 1; + return TRUE; } bool8 sub_811C984(struct Sprite* sprite) @@ -1658,7 +1665,7 @@ bool8 sub_811C984(struct Sprite* sprite) sprite->data0++; else if (!sprite->data7 && sprite->pos1.x > 103) sprite->data0++; - return 0; + return FALSE; } bool8 sub_811C9B8(struct Sprite* sprite) @@ -1671,7 +1678,7 @@ bool8 sub_811C9B8(struct Sprite* sprite) sprite->data2 = -sprite->data2; sprite->data6 = 1; } - return 0; + return FALSE; } bool8 sub_811C9E4(struct Sprite* sprite) @@ -1680,7 +1687,7 @@ bool8 sub_811C9E4(struct Sprite* sprite) sprite->pos1.x += sprite->data1; if (sprite->pos1.x < -31 || sprite->pos1.x > 271) sprite->data0++; - return 0; + return FALSE; } static void sub_811CA10(s16 spriteID, s16 value) @@ -1733,7 +1740,7 @@ static bool8 Phase2_Transition8_Func1(struct Task* task) SetHBlankCallback(HBlankCB_Phase2_Transition8); task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition8_Func2(struct Task* task) @@ -1770,7 +1777,7 @@ static bool8 Phase2_Transition8_Func2(struct Task* task) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition8_Func3(struct Task* task) @@ -1778,7 +1785,7 @@ static bool8 Phase2_Transition8_Func3(struct Task* task) DmaStop(0); sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition8)); - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition8(void) @@ -1832,7 +1839,7 @@ static bool8 Phase2_Transition9_Func1(struct Task* task) SetVBlankCallback(VBlankCB0_Phase2_Transition9); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition9_Func2(struct Task* task) @@ -1852,7 +1859,7 @@ static bool8 Phase2_Transition9_Func2(struct Task* task) sprite->data6++; task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition9_Func3(struct Task* task) @@ -1863,7 +1870,7 @@ static bool8 Phase2_Transition9_Func3(struct Task* task) BlendPalettes(-1, 0x10, 0x7FFF); task->tState++; } - return 0; + return FALSE; } static bool8 Phase2_Transition9_Func4(struct Task* task) @@ -1882,7 +1889,7 @@ static bool8 Phase2_Transition9_Func4(struct Task* task) SetVBlankCallback(VBlankCB1_Phase2_Transition9); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition9_Func5(struct Task* task) @@ -1892,7 +1899,7 @@ static bool8 Phase2_Transition9_Func5(struct Task* task) sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition9)); } - return 0; + return FALSE; } static void VBlankCB0_Phase2_Transition9(void) @@ -1982,7 +1989,7 @@ static bool8 Phase2_Transition10_Func1(struct Task* task) LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); task->tState++; - return 0; + return FALSE; } static bool8 Phase2_Transition10_Func2(struct Task* task) @@ -2003,7 +2010,7 @@ static bool8 Phase2_Transition10_Func2(struct Task* task) } task->data[1]--; - return 0; + return FALSE; } static bool8 Phase2_Transition10_Func3(struct Task* task) @@ -2013,7 +2020,7 @@ static bool8 Phase2_Transition10_Func3(struct Task* task) sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition10)); } - return 0; + return FALSE; } static void Phase2Task_Transition11(u8 taskID) @@ -2041,7 +2048,7 @@ static bool8 Phase2_Transition11_Func1(struct Task* task) SetVBlankCallback(VBlankCB_Phase2_Transition11); task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition11_Func2(struct Task* task) @@ -2054,7 +2061,7 @@ static bool8 Phase2_Transition11_Func2(struct Task* task) 1, 1); task->data[2] = gUnknown_083FD8F4[task->data[1]][4]; task->tState++; - return 1; + return TRUE; } static bool8 Phase2_Transition11_Func3(struct Task* task) @@ -2093,7 +2100,7 @@ static bool8 Phase2_Transition11_Func3(struct Task* task) } TRANSITION_STRUCT.VBlank_DMA++; - return 0; + return FALSE; } static bool8 Phase2_Transition11_Func4(struct Task* task) @@ -2102,14 +2109,14 @@ static bool8 Phase2_Transition11_Func4(struct Task* task) { task->tState++; task->data[3] = gUnknown_083FD93A[task->data[1] - 1]; - return 1; + return TRUE; } else { DmaStop(0); sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition11)); - return 0; + return FALSE; } } @@ -2118,10 +2125,10 @@ static bool8 Phase2_Transition11_Func5(struct Task* task) if (--task->data[3] == 0) { task->tState = 1; - return 1; + return TRUE; } else - return 0; + return FALSE; } static void VBlankCB_Phase2_Transition11(void) @@ -2137,9 +2144,9 @@ static void VBlankCB_Phase2_Transition11(void) DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } -static void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) +static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) { - u8 taskID = CreateTask(sub_811D54C, 3); + u8 taskID = CreateTask(Phase1_Task_RunFuncs, 3); gTasks[taskID].data[1] = a0; gTasks[taskID].data[2] = a1; gTasks[taskID].data[3] = a2; @@ -2150,13 +2157,175 @@ static void sub_811D4C8(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4) static bool8 sub_811D52C(void) { - if (FindTaskIdByFunc(sub_811D54C) == 0xFF) - return 1; + if (FindTaskIdByFunc(Phase1_Task_RunFuncs) == 0xFF) + return TRUE; else - return 0; + return FALSE; } -void sub_811D54C(u8 taskID) +static void Phase1_Task_RunFuncs(u8 taskID) { - while (gUnknown_083FD948[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase1_TransitionAll_Funcs[gTasks[taskID].tState](&gTasks[taskID])); +} + +static bool8 Phase1_TransitionAll_Func1(struct Task* task) +{ + if (task->data[6] == 0 || --task->data[6] == 0) + { + task->data[6] = task->data[1]; + task->data[7] += task->data[4]; + if (task->data[7] > 16) + task->data[7] = 16; + BlendPalettes(-1, task->data[7], 0x2D6B); + } + if (task->data[7] > 15) + { + task->tState++; + task->data[6] = task->data[2]; + } + return FALSE; +} + +static bool8 Phase1_TransitionAll_Func2(struct Task* task) +{ + if (task->data[6] == 0 || --task->data[6] == 0) + { + task->data[6] = task->data[2]; + task->data[7] -= task->data[5]; + if (task->data[7] < 0) + task->data[7] = 0; + BlendPalettes(-1, task->data[7], 0x2D6B); + } + if (task->data[7] == 0) + { + if (--task->data[3] == 0) + DestroyTask(FindTaskIdByFunc(Phase1_Task_RunFuncs)); + else + { + task->data[6] = task->data[1]; + task->tState = 0; + } + } + return FALSE; +} + +static void sub_811D658(void) +{ + struct TransitionData* const* dummy = &sTransitionStructPtr; + memset(*dummy, 0, sizeof(struct TransitionData)); + sub_8057B14(&TRANSITION_STRUCT.field_14, &TRANSITION_STRUCT.field_16); +} + +static void VBlankCB_BattleTransition(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +static void sub_811D690(u16** a0) +{ + u16 reg, *vram; + + reg = REG_BG0CNT >> 2; + reg <<= 0xE; + vram = (u16*)(VRAM + reg); + + *a0 = vram; +} + +static void sub_811D6A8(u16** a0, u16** a1) +{ + u16 reg0, reg1, *vram0, *vram1; + + reg0 = REG_BG0CNT >> 8; + reg1 = REG_BG0CNT >> 2; + + reg0 <<= 0xB; + reg1 <<= 0xE; + + vram0 = (u16*)(VRAM + reg0); + *a0 = vram0; + + vram1 = (u16*)(VRAM + reg1); + *a1 = vram1; +} + +static void sub_811D6D4(void) +{ + BlendPalettes(-1, 0x10, 0); +} + +static void sub_811D6E8(s16* array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize) +{ + u8 i; + for (i = 0; arrSize > 0; arrSize--, i++, index += indexIncrementer) + { + array[i] = sinAdd + Sin(0xFF & index, amplitude); + } +} + +void sub_811D764(u16* array, s16 a1, s16 a2, s16 a3) +{ + s16 i; + + memset(array, 0xA, 160 * sizeof(s16)); + for (i = 0; i < 64; i++) + { + s16 sinResult, cosResult, r1, r6, r7, r8; + s16 r2, r3; + s16 j; + + sinResult = Sin(i, a3); + cosResult = Cos(i, a3); + + r1 = a1 - sinResult; + r6 = a1 + sinResult; + r7 = a2 - cosResult; + r8 = a2 + cosResult; + + if (r1 < 0) + r1 = 0; + if (r6 > 0xF0) + r6 = 0xF0; + if (r7 < 0) + r7 = 0; + if (r8 > 0x9F) + r8 = 0x9F; + + r6 |= (r1 << 8); + array[r7] = r6; + array[r8] = r6; + + cosResult = Cos(i + 1, a3); + r3 = a2 - cosResult; + r2 = a2 + cosResult; + + if (r3 < 0) + r3 = 0; + if (r2 > 0x9F) + r2 = 0x9F; + + j = r7; + while (j > r3) + { + array[--j] = r6; + } + j = r7; + while (j < r3) + { + array[++j] = r6; + } + + j = r8; + while (j > r2) + { + array[--j] = r6; + } + j = r8; + while (j < r2) + { + array[++j] = r6; + } + } } -- cgit v1.2.3 From 77cfea2ecfdcb28fa286b967c9635b5e10ff99a2 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 22 Aug 2017 19:05:38 +0200 Subject: all functions decompiled --- src/battle_transition.c | 248 ++++++++++++++++++++++++++++-------------------- 1 file changed, 145 insertions(+), 103 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index fcf49a7fb..88d3330f9 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -41,18 +41,7 @@ struct TransitionData s16 field_1E; s16 field_20; s16 field_22; - s16 field_24; - s16 field_26; - s16 field_28; - s16 field_2A; - s16 field_2C; - s16 field_2E; - s16 field_30; - s16 field_32; - s16 field_34; - s16 field_36; - s16 field_38; - s16 field_3A; + s16 data[11]; }; #define TRANSITION_STRUCT (*(struct TransitionData *) (ewram + 0xC000)) @@ -178,11 +167,10 @@ static void sub_811D6A8(u16** a0, u16** a1); static void sub_811D690(u16** a0); static void sub_811D6D4(void); static void sub_811D6E8(s16* array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize); - -void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); -void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); -bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); -void sub_811CFD0(struct Sprite* sprite); +static void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); +static void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); +static bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); +static void sub_811CFD0(struct Sprite* sprite); // const data @@ -964,7 +952,7 @@ static bool8 Phase2_Transition5_Func1(struct Task* task) } SetVBlankCallback(VBlankCB_Phase2_Transition5); - TRANSITION_STRUCT.field_2C = 120; + TRANSITION_STRUCT.data[4] = 120; task->tState++; return TRUE; @@ -974,16 +962,16 @@ static bool8 Phase2_Transition5_Func2(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; - sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, -1, 1, 1); + sub_811D8FC(TRANSITION_STRUCT.data, 120, 80, TRANSITION_STRUCT.data[4], -1, 1, 1); do { - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (TRANSITION_STRUCT.field_28 + 1) | 0x7800; - } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (TRANSITION_STRUCT.data[2] + 1) | 0x7800; + } while (!sub_811D978(TRANSITION_STRUCT.data, 1, 1)); - TRANSITION_STRUCT.field_2C += 16; - if (TRANSITION_STRUCT.field_2C >= 240) + TRANSITION_STRUCT.data[4] += 16; + if (TRANSITION_STRUCT.data[4] >= 240) { - TRANSITION_STRUCT.field_2E = 0; + TRANSITION_STRUCT.data[5] = 0; task->tState++; } @@ -998,30 +986,30 @@ static bool8 Phase2_Transition5_Func3(struct Task* task) TRANSITION_STRUCT.VBlank_DMA = 0; - sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 240, TRANSITION_STRUCT.field_2E, 1, 1); + sub_811D8FC(TRANSITION_STRUCT.data, 120, 80, 240, TRANSITION_STRUCT.data[5], 1, 1); while (1) { - r1 = 120, r3 = TRANSITION_STRUCT.field_28 + 1; - if (TRANSITION_STRUCT.field_2E >= 80) - r1 = TRANSITION_STRUCT.field_28, r3 = 240; - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r3) | (r1 << 8); + r1 = 120, r3 = TRANSITION_STRUCT.data[2] + 1; + if (TRANSITION_STRUCT.data[5] >= 80) + r1 = TRANSITION_STRUCT.data[2], r3 = 240; + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (r3) | (r1 << 8); if (var != 0) break; - var = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + var = sub_811D978(TRANSITION_STRUCT.data, 1, 1); } - TRANSITION_STRUCT.field_2E += 8; - if (TRANSITION_STRUCT.field_2E >= 160) + TRANSITION_STRUCT.data[5] += 8; + if (TRANSITION_STRUCT.data[5] >= 160) { - TRANSITION_STRUCT.field_2C = 240; + TRANSITION_STRUCT.data[4] = 240; task->tState++; } else { - while (TRANSITION_STRUCT.field_2A < TRANSITION_STRUCT.field_2E) + while (TRANSITION_STRUCT.data[3] < TRANSITION_STRUCT.data[5]) { - gUnknown_03004DE0[0][++TRANSITION_STRUCT.field_2A] = (r3) | (r1 << 8); + gUnknown_03004DE0[0][++TRANSITION_STRUCT.data[3]] = (r3) | (r1 << 8); } } @@ -1033,16 +1021,16 @@ static bool8 Phase2_Transition5_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; - sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 160, 1, 1); + sub_811D8FC(TRANSITION_STRUCT.data, 120, 80, TRANSITION_STRUCT.data[4], 160, 1, 1); do { - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (TRANSITION_STRUCT.field_28 << 8) | 0xF0; - } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (TRANSITION_STRUCT.data[2] << 8) | 0xF0; + } while (!sub_811D978(TRANSITION_STRUCT.data, 1, 1)); - TRANSITION_STRUCT.field_2C -= 16; - if (TRANSITION_STRUCT.field_2C <= 0) + TRANSITION_STRUCT.data[4] -= 16; + if (TRANSITION_STRUCT.data[4] <= 0) { - TRANSITION_STRUCT.field_2E = 160; + TRANSITION_STRUCT.data[5] = 160; task->tState++; } @@ -1057,31 +1045,31 @@ static bool8 Phase2_Transition5_Func5(struct Task* task) TRANSITION_STRUCT.VBlank_DMA = 0; - sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, 0, TRANSITION_STRUCT.field_2E, 1, 1); + sub_811D8FC(TRANSITION_STRUCT.data, 120, 80, 0, TRANSITION_STRUCT.data[5], 1, 1); while (1) { - r1 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] & 0xFF, r2 = TRANSITION_STRUCT.field_28; - if (TRANSITION_STRUCT.field_2E <= 80) - r2 = 120, r1 = TRANSITION_STRUCT.field_28; - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r1) | (r2 << 8); + r1 = gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] & 0xFF, r2 = TRANSITION_STRUCT.data[2]; + if (TRANSITION_STRUCT.data[5] <= 80) + r2 = 120, r1 = TRANSITION_STRUCT.data[2]; + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (r1) | (r2 << 8); r3 = 0; if (var != 0) break; - var = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + var = sub_811D978(TRANSITION_STRUCT.data, 1, 1); } - TRANSITION_STRUCT.field_2E -= 8; - if (TRANSITION_STRUCT.field_2E <= 0) + TRANSITION_STRUCT.data[5] -= 8; + if (TRANSITION_STRUCT.data[5] <= 0) { - TRANSITION_STRUCT.field_2C = r3; + TRANSITION_STRUCT.data[4] = r3; task->tState++; } else { - while (TRANSITION_STRUCT.field_2A > TRANSITION_STRUCT.field_2E) + while (TRANSITION_STRUCT.data[3] > TRANSITION_STRUCT.data[5]) { - gUnknown_03004DE0[0][--TRANSITION_STRUCT.field_2A] = (r1) | (r2 << 8); + gUnknown_03004DE0[0][--TRANSITION_STRUCT.data[3]] = (r1) | (r2 << 8); } } @@ -1093,20 +1081,20 @@ static bool8 Phase2_Transition5_Func6(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; - sub_811D8FC(&TRANSITION_STRUCT.field_24, 120, 80, TRANSITION_STRUCT.field_2C, 0, 1, 1); + sub_811D8FC(TRANSITION_STRUCT.data, 120, 80, TRANSITION_STRUCT.data[4], 0, 1, 1); do { s16 r2, r3; - r2 = 120, r3 = TRANSITION_STRUCT.field_28; - if (TRANSITION_STRUCT.field_28 >= 120) + r2 = 120, r3 = TRANSITION_STRUCT.data[2]; + if (TRANSITION_STRUCT.data[2] >= 120) r2 = 0, r3 = 240; - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r3) | (r2 << 8); + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (r3) | (r2 << 8); - } while (!sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1)); + } while (!sub_811D978(TRANSITION_STRUCT.data, 1, 1)); - TRANSITION_STRUCT.field_2C += 16; - if (TRANSITION_STRUCT.field_28 > 120) + TRANSITION_STRUCT.data[4] += 16; + if (TRANSITION_STRUCT.data[2] > 120) task->tState++; TRANSITION_STRUCT.VBlank_DMA++; @@ -1639,12 +1627,12 @@ void sub_811C90C(struct Sprite* sprite) while (gUnknown_083FD880[sprite->data0](sprite)); } -bool8 sub_811C934(struct Sprite* sprite) +static bool8 sub_811C934(struct Sprite* sprite) { return FALSE; } -bool8 sub_811C938(struct Sprite* sprite) +static bool8 sub_811C938(struct Sprite* sprite) { s16 arr0[2]; s16 arr1[2]; @@ -1658,7 +1646,7 @@ bool8 sub_811C938(struct Sprite* sprite) return TRUE; } -bool8 sub_811C984(struct Sprite* sprite) +static bool8 sub_811C984(struct Sprite* sprite) { sprite->pos1.x += sprite->data1; if (sprite->data7 && sprite->pos1.x < 133) @@ -1668,7 +1656,7 @@ bool8 sub_811C984(struct Sprite* sprite) return FALSE; } -bool8 sub_811C9B8(struct Sprite* sprite) +static bool8 sub_811C9B8(struct Sprite* sprite) { sprite->data1 += sprite->data2; sprite->pos1.x += sprite->data1; @@ -1681,7 +1669,7 @@ bool8 sub_811C9B8(struct Sprite* sprite) return FALSE; } -bool8 sub_811C9E4(struct Sprite* sprite) +static bool8 sub_811C9E4(struct Sprite* sprite) { sprite->data1 += sprite->data2; sprite->pos1.x += sprite->data1; @@ -1931,7 +1919,7 @@ static void HBlankCB_Phase2_Transition9(void) REG_BLDY = gUnknown_03004DE0[1][REG_VCOUNT]; } -void sub_811CFD0(struct Sprite* sprite) +static void sub_811CFD0(struct Sprite* sprite) { if (sprite->data5) { @@ -2053,7 +2041,7 @@ static bool8 Phase2_Transition11_Func1(struct Task* task) static bool8 Phase2_Transition11_Func2(struct Task* task) { - sub_811D8FC(&TRANSITION_STRUCT.field_24, + sub_811D8FC(TRANSITION_STRUCT.data, gUnknown_083FD8F4[task->data[1]][0], gUnknown_083FD8F4[task->data[1]][1], gUnknown_083FD8F4[task->data[1]][2], @@ -2073,30 +2061,30 @@ static bool8 Phase2_Transition11_Func3(struct Task* task) for (i = 0, nextFunc = FALSE; i < 16; i++) { - s16 r3 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] >> 8; - s16 r4 = gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] & 0xFF; + s16 r3 = gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] >> 8; + s16 r4 = gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] & 0xFF; if (task->data[2] == 0) { - if (r3 < TRANSITION_STRUCT.field_28) - r3 = TRANSITION_STRUCT.field_28; + if (r3 < TRANSITION_STRUCT.data[2]) + r3 = TRANSITION_STRUCT.data[2]; if (r3 > r4) r3 = r4; } else { - if (r4 > TRANSITION_STRUCT.field_28) - r4 = TRANSITION_STRUCT.field_28; + if (r4 > TRANSITION_STRUCT.data[2]) + r4 = TRANSITION_STRUCT.data[2]; if (r4 <= r3) r4 = r3; } - gUnknown_03004DE0[0][TRANSITION_STRUCT.field_2A] = (r4) | (r3 << 8); + gUnknown_03004DE0[0][TRANSITION_STRUCT.data[3]] = (r4) | (r3 << 8); if (nextFunc) { task->tState++; break; } else - nextFunc = sub_811D978(&TRANSITION_STRUCT.field_24, 1, 1); + nextFunc = sub_811D978(TRANSITION_STRUCT.data, 1, 1); } TRANSITION_STRUCT.VBlank_DMA++; @@ -2265,37 +2253,36 @@ static void sub_811D6E8(s16* array, s16 sinAdd, s16 index, s16 indexIncrementer, } } -void sub_811D764(u16* array, s16 a1, s16 a2, s16 a3) +static void sub_811D764(u16* array, s16 a1, s16 a2, s16 a3) { s16 i; memset(array, 0xA, 160 * sizeof(s16)); for (i = 0; i < 64; i++) { - s16 sinResult, cosResult, r1, r6, r7, r8; - s16 r2, r3; - s16 j; + s16 sinResult, cosResult; + s16 toStoreOrr, r2, r3, toStore, r7, r8; sinResult = Sin(i, a3); cosResult = Cos(i, a3); - r1 = a1 - sinResult; - r6 = a1 + sinResult; + toStoreOrr = a1 - sinResult; + toStore = a1 + sinResult; r7 = a2 - cosResult; r8 = a2 + cosResult; - if (r1 < 0) - r1 = 0; - if (r6 > 0xF0) - r6 = 0xF0; + if (toStoreOrr < 0) + toStoreOrr = 0; + if (toStore > 0xF0) + toStore = 0xF0; if (r7 < 0) r7 = 0; if (r8 > 0x9F) r8 = 0x9F; - r6 |= (r1 << 8); - array[r7] = r6; - array[r8] = r6; + toStore |= (toStoreOrr << 8); + array[r7] = toStore; + array[r8] = toStore; cosResult = Cos(i + 1, a3); r3 = a2 - cosResult; @@ -2306,26 +2293,81 @@ void sub_811D764(u16* array, s16 a1, s16 a2, s16 a3) if (r2 > 0x9F) r2 = 0x9F; - j = r7; - while (j > r3) - { - array[--j] = r6; - } - j = r7; - while (j < r3) - { - array[++j] = r6; - } + while (r7 > r3) + array[--r7] = toStore; + while (r7 < r3) + array[++r7] = toStore; + + while (r8 > r2) + array[--r8] = toStore; + while (r8 < r2) + array[++r8] = toStore; + } +} + +static void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) +{ + a0[0] = a1; + a0[1] = a2; + a0[2] = a1; + a0[3] = a2; + a0[4] = a3; + a0[5] = a4; + a0[6] = a5; + a0[7] = a6; + a0[8] = a3 - a1; + if (a0[8] < 0) + { + a0[8] = -a0[8]; + a0[6] = -a5; + } + a0[9] = a4 - a2; + if (a0[9] < 0) + { + a0[9] = -a0[9]; + a0[7] = -a6; + } + a0[10] = 0; +} - j = r8; - while (j > r2) +static bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2) +{ + u8 var; + if (a0[8] > a0[9]) + { + a0[2] += a0[6]; + a0[10] += a0[9]; + if (a0[10] > a0[8]) { - array[--j] = r6; + a0[3] += a0[7]; + a0[10] -= a0[8]; } - j = r8; - while (j < r2) + } + else + { + a0[3] += a0[7]; + a0[10] += a0[8]; + if (a0[10] > a0[9]) { - array[++j] = r6; + a0[2] += a0[6]; + a0[10] -= a0[9]; } } + var = 0; + if ((a0[6] > 0 && a0[2] >= a0[4]) || (a0[6] < 0 && a0[2] <= a0[4])) + { + var++; + if (a1) + a0[2] = a0[4]; + } + if ((a0[7] > 0 && a0[3] >= a0[5]) || (a0[7] < 0 && a0[3] <= a0[5])) + { + var++; + if (a2) + a0[3] = a0[5]; + } + if (var == 2) + return TRUE; + else + return FALSE; } -- cgit v1.2.3 From aa3988cc1ace31f97590b4ac3b33c4fa3a5e13dc Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 22 Aug 2017 20:51:53 +0200 Subject: move all data to C --- src/battle_transition.c | 328 ++++++++++++++++++++++++++++++++++-------------- 1 file changed, 234 insertions(+), 94 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 88d3330f9..363a52148 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -15,12 +15,13 @@ void sub_807DE10(void); void dp12_8087EA4(void); -void sub_811C90C(struct Sprite* sprite); extern u8 ewram[]; -extern s16 gUnknown_03005560[]; +extern u16 gUnknown_03005560[]; extern u16 gUnknown_03004DE0[][0x3C0]; +extern const struct OamData gFieldOamData_32x32; + struct TransitionData { vs8 VBlank_DMA; @@ -32,15 +33,15 @@ struct TransitionData u16 field_C; u16 BLDCNT; u16 BLDALPHA; - u16 field_12; + u16 BLDY; s16 field_14; s16 field_16; s16 field_18; s16 field_1A; s16 field_1C; - s16 field_1E; + s16 field_1E; // unused s16 field_20; - s16 field_22; + s16 field_22; // unused s16 data[11]; }; @@ -171,16 +172,18 @@ static void sub_811D764(u16* a0, s16 a1, s16 a2, s16 a3); static void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6); static bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2); static void sub_811CFD0(struct Sprite* sprite); +static void sub_811B720(struct Sprite* sprite); +static void sub_811C90C(struct Sprite* sprite); // const data -static const u32 gUnknown_083FBB88[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); -static const u32 gUnknown_083FC108[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); -const u32 gSpriteImage_83FC148[] = INCBIN_U32("graphics/battle_transitions/pokeball.4bpp"); -static const u32 gUnknown_083FC348[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); -const u32 gSpriteImage_83FC528[] = INCBIN_U32("graphics/battle_transitions/unused_brendan.4bpp"); -const u32 gSpriteImage_83FCD28[] = INCBIN_U32("graphics/battle_transitions/unused_lass.4bpp"); -const u32 gUnknown_083FD528[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); +static const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp"); +static const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp"); +static const u8 sSpriteImage_83FC148[] = INCBIN_U8("graphics/battle_transitions/pokeball.4bpp"); +static const u32 sUnknown_083FC348[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp"); +static const u8 sSpriteImage_83FC528[] = INCBIN_U8("graphics/battle_transitions/unused_brendan.4bpp"); +static const u8 sSpriteImage_83FCD28[] = INCBIN_U8("graphics/battle_transitions/unused_lass.4bpp"); +static const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp"); static struct TransitionData * const sTransitionStructPtr = &TRANSITION_STRUCT; @@ -254,9 +257,9 @@ static const TransitionState sPhase2_Transition4_Funcs[] = &Phase2_Transition4_Func3 }; -static const s16 gUnknown_083FD7E4[2] = {-16, 256}; -static const s16 gUnknown_083FD7E8[5] = {0, 32, 64, 18, 48}; -static const s16 gUnknown_083FD7F2[2] = {8, -8}; +static const s16 sUnknown_083FD7E4[2] = {-16, 256}; +static const s16 sUnknown_083FD7E8[5] = {0, 32, 64, 18, 48}; +static const s16 sUnknown_083FD7F2[2] = {8, -8}; static const TransitionState sPhase2_Transition5_Funcs[] = { @@ -314,7 +317,7 @@ static const s16 sMugshotsOpponentCoords[MUGSHOTS_NO][2] = {0, 7}, }; -static const TransitionSpriteCallback gUnknown_083FD880[] = +static const TransitionSpriteCallback sUnknown_083FD880[] = { &sub_811C934, &sub_811C938, @@ -325,8 +328,8 @@ static const TransitionSpriteCallback gUnknown_083FD880[] = &sub_811C934 }; -static const s16 gUnknown_083FD89C[2] = {12, -12}; -static const s16 gUnknown_083FD8A0[2] = {-1, 1}; +static const s16 sUnknown_083FD89C[2] = {12, -12}; +static const s16 sUnknown_083FD8A0[2] = {-1, 1}; static const TransitionState sPhase2_Transition8_Funcs[] = { @@ -344,7 +347,7 @@ static const TransitionState sPhase2_Transition9_Funcs[] = &Phase2_Transition9_Func5 }; -static const s16 gUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; +static const s16 sUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; static const TransitionState sPhase2_Transition10_Funcs[] = { @@ -362,7 +365,7 @@ static const TransitionState sPhase2_Transition11_Funcs[] = &Phase2_Transition11_Func5 }; -static const s16 gUnknown_083FD8F4[][5] = +static const s16 sUnknown_083FD8F4[][5] = { {56, 0, 0, 160, 0}, {104, 160, 240, 88, 1}, @@ -373,7 +376,7 @@ static const s16 gUnknown_083FD8F4[][5] = {168, 160, 48, 0, 1}, }; -static const s16 gUnknown_083FD93A[] = {8, 4, 2, 1, 1, 1, 0}; +static const s16 sUnknown_083FD93A[] = {8, 4, 2, 1, 1, 1, 0}; static const TransitionState sPhase1_TransitionAll_Funcs[] = { @@ -381,12 +384,149 @@ static const TransitionState sPhase1_TransitionAll_Funcs[] = &Phase1_TransitionAll_Func2 }; -extern const u16 gFieldEffectObjectPalette10[]; -extern const u16 gUnknown_083FDB44[]; -extern const struct SpriteTemplate gSpriteTemplate_83FD98C; -extern const u16 gUnknown_083FDFF4[]; -extern const u8 * const sOpponentMugshotsPals[]; -extern const u8 * const sPlayerMugshotsPals[2]; +static const struct SpriteFrameImage sSpriteImageTable_83FD950[] = +{ + sSpriteImage_83FC148, 0x200 +}; + +static const union AnimCmd sSpriteAnim_83FD958[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_83FD960[] = +{ + sSpriteAnim_83FD958 +}; + +static const union AffineAnimCmd sSpriteAffineAnim_83FD964[] = +{ + AFFINEANIMCMD_FRAME(0, 0, -4, 1), + AFFINEANIMCMD_JUMP(0) +}; + +static const union AffineAnimCmd sSpriteAffineAnim_83FD974[] = +{ + AFFINEANIMCMD_FRAME(0, 0, 4, 1), + AFFINEANIMCMD_JUMP(0) +}; + +static const union AffineAnimCmd *const sSpriteAffineAnimTable_83FD984[] = +{ + sSpriteAffineAnim_83FD964, + sSpriteAffineAnim_83FD974 +}; + +static const struct SpriteTemplate sSpriteTemplate_83FD98C = +{ + .tileTag = 0xFFFF, + .paletteTag = 4105, + .oam = &gFieldOamData_32x32, + .anims = sSpriteAnimTable_83FD960, + .images = sSpriteImageTable_83FD950, + .affineAnims = sSpriteAffineAnimTable_83FD984, + .callback = sub_811B720 +}; + +static const struct OamData gOamData_83FD9A4 = +{ + .y = 0, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 3, + .tileNum = 0, + .priority = 0, + .paletteNum = 0, + .affineParam = 0, +}; + +static const struct SpriteFrameImage sSpriteImageTable_83FD9AC[] = +{ + sSpriteImage_83FC528, 0x800 +}; + +static const struct SpriteFrameImage sSpriteImageTable_83FD9B4[] = +{ + sSpriteImage_83FCD28, 0x800 +}; + +static const union AnimCmd sSpriteAnim_83FD9BC[] = +{ + ANIMCMD_FRAME(0, 1), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_83FD9C4[] = +{ + sSpriteAnim_83FD9BC +}; + +static const struct SpriteTemplate sSpriteTemplate_83FD9C8 = +{ + .tileTag = 0xFFFF, + .paletteTag = 4106, + .oam = &gOamData_83FD9A4, + .anims = sSpriteAnimTable_83FD9C4, + .images = sSpriteImageTable_83FD9AC, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_811C90C +}; + +static const struct SpriteTemplate sSpriteTemplate_83FD9E0 = +{ + .tileTag = 0xFFFF, + .paletteTag = 4106, + .oam = &gOamData_83FD9A4, + .anims = sSpriteAnimTable_83FD9C4, + .images = sSpriteImageTable_83FD9B4, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = sub_811C90C +}; + +static const u16 gFieldEffectObjectPalette10[] = INCBIN_U16("graphics/field_effect_objects/palettes/10.gbapal"); + +const struct SpritePalette gFieldEffectObjectPaletteInfo10 = +{ + gFieldEffectObjectPalette10, 0x1009 +}; + +static const u16 sMugshotPal_Sydney[] = INCBIN_U16("graphics/battle_transitions/sidney_bg.gbapal"); +static const u16 sMugshotPal_Phoebe[] = INCBIN_U16("graphics/battle_transitions/phoebe_bg.gbapal"); +static const u16 sMugshotPal_Glacia[] = INCBIN_U16("graphics/battle_transitions/glacia_bg.gbapal"); +static const u16 sMugshotPal_Drake[] = INCBIN_U16("graphics/battle_transitions/drake_bg.gbapal"); +static const u16 sMugshotPal_Steven[] = INCBIN_U16("graphics/battle_transitions/steven_bg.gbapal"); +static const u16 sMugshotPal_Brendan[] = INCBIN_U16("graphics/battle_transitions/brendan_bg.gbapal"); +static const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may_bg.gbapal"); + +static const u16 * const sOpponentMugshotsPals[MUGSHOTS_NO] = +{ + sMugshotPal_Sydney, + sMugshotPal_Phoebe, + sMugshotPal_Glacia, + sMugshotPal_Drake, + sMugshotPal_Steven +}; + +static const u16 * const sPlayerMugshotsPals[2] = +{ + sMugshotPal_Brendan, + sMugshotPal_May +}; + +static const u16 sUnusedTrainerPalette[] = INCBIN_U16("graphics/battle_transitions/unused_trainer.gbapal"); +static const struct SpritePalette sSpritePalette_UnusedTrainer = +{ + sUnusedTrainerPalette, 0x100A +}; + +static const u16 sBigPokeball_Tilemap[] = INCBIN_U16("graphics/battle_transitions/big_pokeball_map.bin"); +static const u16 sMugshotsTilemap[] = INCBIN_U16("graphics/battle_transitions/elite_four_bg_map.bin"); // actual code starts here @@ -683,7 +823,7 @@ static bool8 Phase2_Transition3_Func1(struct Task* task) sub_811D6A8(&dst1, & dst2); CpuFill16(0, dst1, 0x800); - CpuSet(gUnknown_083FBB88, dst2, 0x2C0); + CpuSet(sBigPokeball_Tileset, dst2, 0x2C0); LoadPalette(gFieldEffectObjectPalette10, 240, 32); task->tState++; @@ -694,15 +834,15 @@ static bool8 Phase2_Transition3_Func2(struct Task* task) { s16 i, j; u16 *dst1, *dst2; - const u16* var; + const u16* BigPokeballMap; - var = gUnknown_083FDB44; + BigPokeballMap = sBigPokeball_Tilemap; sub_811D6A8(&dst1, &dst2); for (i = 0; i < 20; i++) { - for (j = 0; j < 30; j++, var++) + for (j = 0; j < 30; j++, BigPokeballMap++) { - dst1[i * 32 + j] = *var | 0xF000; + dst1[i * 32 + j] = *BigPokeballMap | 0xF000; } } sub_811D6E8(gUnknown_03004DE0[0], 0, task->data[4], 132, task->data[5], 160); @@ -834,7 +974,7 @@ static bool8 Phase2_Transition4_Func1(struct Task* task) u16 *dst1, *dst2; sub_811D6A8(&dst1, &dst2); - CpuSet(gUnknown_083FC108, dst2, 0x20); + CpuSet(sPokeballTrail_Tileset, dst2, 0x20); CpuFill32(0, dst1, 0x800); LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); @@ -849,8 +989,8 @@ static bool8 Phase2_Transition4_Func2(struct Task* task) s16 arr0[2]; s16 arr1[5]; - memcpy(arr0, gUnknown_083FD7E4, sizeof(gUnknown_083FD7E4)); - memcpy(arr1, gUnknown_083FD7E8, sizeof(gUnknown_083FD7E8)); + memcpy(arr0, sUnknown_083FD7E4, sizeof(sUnknown_083FD7E4)); + memcpy(arr1, sUnknown_083FD7E8, sizeof(sUnknown_083FD7E8)); rand = Random() & 1; for (i = 0; i <= 4; i++, rand ^= 1) { @@ -877,7 +1017,7 @@ static bool8 Phase2_Transition4_Func3(struct Task* task) bool8 FldEff_Pokeball(void) { - u8 spriteID = CreateSpriteAtEnd(&gSpriteTemplate_83FD98C, gUnknown_0202FF84[0], gUnknown_0202FF84[1], 0); + u8 spriteID = CreateSpriteAtEnd(&sSpriteTemplate_83FD98C, gUnknown_0202FF84[0], gUnknown_0202FF84[1], 0); gSprites[spriteID].oam.priority = 0; gSprites[spriteID].oam.affineMode = 1; gSprites[spriteID].data0 = gUnknown_0202FF84[2]; @@ -894,11 +1034,11 @@ bool8 FldEff_Pokeball(void) ptr[index] = toStore; \ } -void sub_811B720(struct Sprite* sprite) +static void sub_811B720(struct Sprite* sprite) { s16 arr0[2]; - memcpy(arr0, gUnknown_083FD7F2, sizeof(gUnknown_083FD7F2)); + memcpy(arr0, sUnknown_083FD7F2, sizeof(sUnknown_083FD7F2)); if (sprite->data1 != 0) sprite->data1--; else @@ -1348,19 +1488,19 @@ static bool8 Phase2_Mugshot_Func2(struct Task* task) { s16 i, j; u16 *dst1, *dst2; - const u16* var; + const u16* MugshotsMap; - var = gUnknown_083FDFF4; + MugshotsMap = sMugshotsTilemap; sub_811D6A8(&dst1, &dst2); - CpuSet(gUnknown_083FC348, dst2, 0xF0); + CpuSet(sUnknown_083FC348, dst2, 0xF0); LoadPalette(sOpponentMugshotsPals[task->tMugshotID], 0xF0, 0x20); LoadPalette(sPlayerMugshotsPals[gSaveBlock2.playerGender], 0xFA, 0xC); for (i = 0; i < 20; i++) { - for (j = 0; j < 32; j++, var++) + for (j = 0; j < 32; j++, MugshotsMap++) { - dst1[i * 32 + j] = *var | 0xF000; + dst1[i * 32 + j] = *MugshotsMap | 0xF000; } } @@ -1622,9 +1762,9 @@ static void Mugshots_CreateOpponentPlayerSprites(struct Task* task) SetOamMatrixRotationScaling(playerSprite->oam.matrixNum, -512, 0x200, 0); } -void sub_811C90C(struct Sprite* sprite) +static void sub_811C90C(struct Sprite* sprite) { - while (gUnknown_083FD880[sprite->data0](sprite)); + while (sUnknown_083FD880[sprite->data0](sprite)); } static bool8 sub_811C934(struct Sprite* sprite) @@ -1637,8 +1777,8 @@ static bool8 sub_811C938(struct Sprite* sprite) s16 arr0[2]; s16 arr1[2]; - memcpy(arr0, gUnknown_083FD89C, sizeof(gUnknown_083FD89C)); - memcpy(arr1, gUnknown_083FD8A0, sizeof(gUnknown_083FD8A0)); + memcpy(arr0, sUnknown_083FD89C, sizeof(sUnknown_083FD89C)); + memcpy(arr1, sUnknown_083FD8A0, sizeof(sUnknown_083FD8A0)); sprite->data0++; sprite->data1 = arr0[sprite->data7]; @@ -1809,7 +1949,7 @@ static bool8 Phase2_Transition9_Func1(struct Task* task) dp12_8087EA4(); TRANSITION_STRUCT.BLDCNT = 0xBF; - TRANSITION_STRUCT.field_12 = 0; + TRANSITION_STRUCT.BLDY = 0; TRANSITION_STRUCT.WININ = 0x1E; TRANSITION_STRUCT.WINOUT = 0x3F; TRANSITION_STRUCT.WIN0V = 0xA0; @@ -1836,7 +1976,7 @@ static bool8 Phase2_Transition9_Func2(struct Task* task) s16 arr1[8]; struct Sprite* sprite; - memcpy(arr1, gUnknown_083FD8C4, sizeof(gUnknown_083FD8C4)); + memcpy(arr1, sUnknown_083FD8C4, sizeof(sUnknown_083FD8C4)); for (i = 0, posY = 0; i < 8; i++, posY += 0x14) { sprite = &gSprites[CreateInvisibleSprite(sub_811CFD0)]; @@ -1870,7 +2010,7 @@ static bool8 Phase2_Transition9_Func4(struct Task* task) SetHBlankCallback(0); TRANSITION_STRUCT.field_6 = 0xF0; - TRANSITION_STRUCT.field_12 = 0; + TRANSITION_STRUCT.BLDY = 0; TRANSITION_STRUCT.BLDCNT = 0xFF; TRANSITION_STRUCT.WININ = 0x3F; @@ -1882,7 +2022,7 @@ static bool8 Phase2_Transition9_Func4(struct Task* task) static bool8 Phase2_Transition9_Func5(struct Task* task) { - if (++TRANSITION_STRUCT.field_12 > 16) + if (++TRANSITION_STRUCT.BLDY > 16) { sub_811D6D4(); DestroyTask(FindTaskIdByFunc(Phase2Task_Transition9)); @@ -1906,7 +2046,7 @@ static void VBlankCB0_Phase2_Transition9(void) static void VBlankCB1_Phase2_Transition9(void) { VBlankCB_BattleTransition(); - REG_BLDY = TRANSITION_STRUCT.field_12; + REG_BLDY = TRANSITION_STRUCT.BLDY; REG_BLDCNT = TRANSITION_STRUCT.BLDCNT; REG_WININ = TRANSITION_STRUCT.WININ; REG_WINOUT = TRANSITION_STRUCT.WINOUT; @@ -1972,7 +2112,7 @@ static bool8 Phase2_Transition10_Func1(struct Task* task) u16 *dst1, *dst2; sub_811D6A8(&dst1, &dst2); - CpuSet(gUnknown_083FD528, dst2, 0x10); + CpuSet(sShrinkingBoxTileset, dst2, 0x10); CpuFill16(0xF000, dst1, 0x800); LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20); @@ -1989,7 +2129,7 @@ static bool8 Phase2_Transition10_Func2(struct Task* task) sub_811D690(&dst1); task->data[1] = 3; task->data[2]++; - CpuSet(gUnknown_083FD528 + (task->data[2] * 8), dst1, 0x10); + CpuSet(sShrinkingBoxTileset + (task->data[2] * 8), dst1, 0x10); if (task->data[2] > 0xD) { task->tState++; @@ -2042,12 +2182,12 @@ static bool8 Phase2_Transition11_Func1(struct Task* task) static bool8 Phase2_Transition11_Func2(struct Task* task) { sub_811D8FC(TRANSITION_STRUCT.data, - gUnknown_083FD8F4[task->data[1]][0], - gUnknown_083FD8F4[task->data[1]][1], - gUnknown_083FD8F4[task->data[1]][2], - gUnknown_083FD8F4[task->data[1]][3], + sUnknown_083FD8F4[task->data[1]][0], + sUnknown_083FD8F4[task->data[1]][1], + sUnknown_083FD8F4[task->data[1]][2], + sUnknown_083FD8F4[task->data[1]][3], 1, 1); - task->data[2] = gUnknown_083FD8F4[task->data[1]][4]; + task->data[2] = sUnknown_083FD8F4[task->data[1]][4]; task->tState++; return TRUE; } @@ -2096,7 +2236,7 @@ static bool8 Phase2_Transition11_Func4(struct Task* task) if (++task->data[1] < 7) { task->tState++; - task->data[3] = gUnknown_083FD93A[task->data[1] - 1]; + task->data[3] = sUnknown_083FD93A[task->data[1] - 1]; return TRUE; } else @@ -2305,66 +2445,66 @@ static void sub_811D764(u16* array, s16 a1, s16 a2, s16 a3) } } -static void sub_811D8FC(s16* a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) +static void sub_811D8FC(s16* data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6) { - a0[0] = a1; - a0[1] = a2; - a0[2] = a1; - a0[3] = a2; - a0[4] = a3; - a0[5] = a4; - a0[6] = a5; - a0[7] = a6; - a0[8] = a3 - a1; - if (a0[8] < 0) + data[0] = a1; + data[1] = a2; + data[2] = a1; + data[3] = a2; + data[4] = a3; + data[5] = a4; + data[6] = a5; + data[7] = a6; + data[8] = a3 - a1; + if (data[8] < 0) { - a0[8] = -a0[8]; - a0[6] = -a5; + data[8] = -data[8]; + data[6] = -a5; } - a0[9] = a4 - a2; - if (a0[9] < 0) + data[9] = a4 - a2; + if (data[9] < 0) { - a0[9] = -a0[9]; - a0[7] = -a6; + data[9] = -data[9]; + data[7] = -a6; } - a0[10] = 0; + data[10] = 0; } -static bool8 sub_811D978(s16* a0, bool8 a1, bool8 a2) +static bool8 sub_811D978(s16* data, bool8 a1, bool8 a2) { u8 var; - if (a0[8] > a0[9]) + if (data[8] > data[9]) { - a0[2] += a0[6]; - a0[10] += a0[9]; - if (a0[10] > a0[8]) + data[2] += data[6]; + data[10] += data[9]; + if (data[10] > data[8]) { - a0[3] += a0[7]; - a0[10] -= a0[8]; + data[3] += data[7]; + data[10] -= data[8]; } } else { - a0[3] += a0[7]; - a0[10] += a0[8]; - if (a0[10] > a0[9]) + data[3] += data[7]; + data[10] += data[8]; + if (data[10] > data[9]) { - a0[2] += a0[6]; - a0[10] -= a0[9]; + data[2] += data[6]; + data[10] -= data[9]; } } var = 0; - if ((a0[6] > 0 && a0[2] >= a0[4]) || (a0[6] < 0 && a0[2] <= a0[4])) + if ((data[6] > 0 && data[2] >= data[4]) || (data[6] < 0 && data[2] <= data[4])) { var++; if (a1) - a0[2] = a0[4]; + data[2] = data[4]; } - if ((a0[7] > 0 && a0[3] >= a0[5]) || (a0[7] < 0 && a0[3] <= a0[5])) + if ((data[7] > 0 && data[3] >= data[5]) || (data[7] < 0 && data[3] <= data[5])) { var++; if (a2) - a0[3] = a0[5]; + data[3] = data[5]; } if (var == 2) return TRUE; -- cgit v1.2.3 From c8d77612267c04444b5318f3e058d0a77859a3db Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Tue, 22 Aug 2017 21:19:55 +0200 Subject: meaningful names to transitions given --- src/battle_transition.c | 558 ++++++++++++++++++++++++------------------------ 1 file changed, 279 insertions(+), 279 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 363a52148..35f001bc7 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -53,18 +53,18 @@ typedef bool8 (*TransitionSpriteCallback)(struct Sprite* sprite); static void LaunchBattleTransitionTask(u8 transitionID); static void Task_BattleTransitionMain(u8 taskID); static void Phase1Task_TransitionAll(u8 taskID); -static void Phase2Task_Transition0(u8 taskID); -static void Phase2Task_Transition1(u8 taskID); -static void Phase2Task_Transition2(u8 taskID); -static void Phase2Task_Transition3(u8 taskID); -static void Phase2Task_Transition4(u8 taskID); -static void Phase2Task_Transition5(u8 taskID); -static void Phase2Task_Transition6(u8 taskID); -static void Phase2Task_Transition7(u8 taskID); -static void Phase2Task_Transition8(u8 taskID); -static void Phase2Task_Transition9(u8 taskID); -static void Phase2Task_Transition10(u8 taskID); -static void Phase2Task_Transition11(u8 taskID); +static void Phase2Task_Transition_Blur(u8 taskID); +static void Phase2Task_Transition_Swirl(u8 taskID); +static void Phase2Task_Transition_Shuffle(u8 taskID); +static void Phase2Task_Transition_BigPokeball(u8 taskID); +static void Phase2Task_Transition_PokeballsTrail(u8 taskID); +static void Phase2Task_Transition_Clockwise_BlackFade(u8 taskID); +static void Phase2Task_Transition_Ripple(u8 taskID); +static void Phase2Task_Transition_Wave(u8 taskID); +static void Phase2Task_Transition_Slice(u8 taskID); +static void Phase2Task_Transition_WhiteFade(u8 taskID); +static void Phase2Task_Transition_GridSquares(u8 taskID); +static void Phase2Task_Transition_Shards(u8 taskID); static void Phase2Task_Transition_Sydney(u8 taskID); static void Phase2Task_Transition_Phoebe(u8 taskID); static void Phase2Task_Transition_Glacia(u8 taskID); @@ -74,69 +74,69 @@ static bool8 Transition_Phase1(struct Task* task); static bool8 Transition_WaitForPhase1(struct Task* task); static bool8 Transition_Phase2(struct Task* task); static bool8 Transition_WaitForPhase2(struct Task* task); -static void VBlankCB_Phase2_Transition1(void); -static void HBlankCB_Phase2_Transition1(void); -static void VBlankCB_Phase2_Transition2(void); -static void HBlankCB_Phase2_Transition2(void); -static void VBlankCB0_Phase2_Transition3(void); -static void VBlankCB1_Phase2_Transition3(void); -static void VBlankCB_Phase2_Transition5(void); -static void VBlankCB_Phase2_Transition6(void); -static void HBlankCB_Phase2_Transition6(void); -static void VBlankCB_Phase2_Transition7(void); -static void VBlankCB_Phase2_Transition8(void); -static void HBlankCB_Phase2_Transition8(void); -static void VBlankCB0_Phase2_Transition9(void); -static void VBlankCB1_Phase2_Transition9(void); -static void HBlankCB_Phase2_Transition9(void); +static void VBlankCB_Phase2_Transition_Swirl(void); +static void HBlankCB_Phase2_Transition_Swirl(void); +static void VBlankCB_Phase2_Transition_Shuffle(void); +static void HBlankCB_Phase2_Transition_Shuffle(void); +static void VBlankCB0_Phase2_Transition_BigPokeball(void); +static void VBlankCB1_Phase2_Transition_BigPokeball(void); +static void VBlankCB_Phase2_Transition_Clockwise_BlackFade(void); +static void VBlankCB_Phase2_Transition_Ripple(void); +static void HBlankCB_Phase2_Transition_Ripple(void); +static void VBlankCB_Phase2_Transition_Wave(void); +static void VBlankCB_Phase2_Transition_Slice(void); +static void HBlankCB_Phase2_Transition_Slice(void); +static void VBlankCB0_Phase2_Transition_WhiteFade(void); +static void VBlankCB1_Phase2_Transition_WhiteFade(void); +static void HBlankCB_Phase2_Transition_WhiteFade(void); static void VBlankCB0_Phase2_Mugshots(void); static void VBlankCB1_Phase2_Mugshots(void); static void HBlankCB_Phase2_Mugshots(void); -static void VBlankCB_Phase2_Transition11(void); -static bool8 Phase2_Transition0_Func1(struct Task* task); -static bool8 Phase2_Transition0_Func2(struct Task* task); -static bool8 Phase2_Transition0_Func3(struct Task* task); -static bool8 Phase2_Transition1_Func1(struct Task* task); -static bool8 Phase2_Transition1_Func2(struct Task* task); -static bool8 Phase2_Transition2_Func1(struct Task* task); -static bool8 Phase2_Transition2_Func2(struct Task* task); -static bool8 Phase2_Transition3_Func1(struct Task* task); -static bool8 Phase2_Transition3_Func2(struct Task* task); -static bool8 Phase2_Transition3_Func3(struct Task* task); -static bool8 Phase2_Transition3_Func4(struct Task* task); -static bool8 Phase2_Transition3_Func5(struct Task* task); -static bool8 Phase2_Transition3_Func6(struct Task* task); -static bool8 Phase2_Transition4_Func1(struct Task* task); -static bool8 Phase2_Transition4_Func2(struct Task* task); -static bool8 Phase2_Transition4_Func3(struct Task* task); -static bool8 Phase2_Transition5_Func1(struct Task* task); -static bool8 Phase2_Transition5_Func2(struct Task* task); -static bool8 Phase2_Transition5_Func3(struct Task* task); -static bool8 Phase2_Transition5_Func4(struct Task* task); -static bool8 Phase2_Transition5_Func5(struct Task* task); -static bool8 Phase2_Transition5_Func6(struct Task* task); -static bool8 Phase2_Transition5_Func7(struct Task* task); -static bool8 Phase2_Transition6_Func1(struct Task* task); -static bool8 Phase2_Transition6_Func2(struct Task* task); -static bool8 Phase2_Transition7_Func1(struct Task* task); -static bool8 Phase2_Transition7_Func2(struct Task* task); -static bool8 Phase2_Transition7_Func3(struct Task* task); -static bool8 Phase2_Transition8_Func1(struct Task* task); -static bool8 Phase2_Transition8_Func2(struct Task* task); -static bool8 Phase2_Transition8_Func3(struct Task* task); -static bool8 Phase2_Transition9_Func1(struct Task* task); -static bool8 Phase2_Transition9_Func2(struct Task* task); -static bool8 Phase2_Transition9_Func3(struct Task* task); -static bool8 Phase2_Transition9_Func4(struct Task* task); -static bool8 Phase2_Transition9_Func5(struct Task* task); -static bool8 Phase2_Transition10_Func1(struct Task* task); -static bool8 Phase2_Transition10_Func2(struct Task* task); -static bool8 Phase2_Transition10_Func3(struct Task* task); -static bool8 Phase2_Transition11_Func1(struct Task* task); -static bool8 Phase2_Transition11_Func2(struct Task* task); -static bool8 Phase2_Transition11_Func3(struct Task* task); -static bool8 Phase2_Transition11_Func4(struct Task* task); -static bool8 Phase2_Transition11_Func5(struct Task* task); +static void VBlankCB_Phase2_Transition_Shards(void); +static bool8 Phase2_Transition_Blur_Func1(struct Task* task); +static bool8 Phase2_Transition_Blur_Func2(struct Task* task); +static bool8 Phase2_Transition_Blur_Func3(struct Task* task); +static bool8 Phase2_Transition_Swirl_Func1(struct Task* task); +static bool8 Phase2_Transition_Swirl_Func2(struct Task* task); +static bool8 Phase2_Transition_Shuffle_Func1(struct Task* task); +static bool8 Phase2_Transition_Shuffle_Func2(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func1(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func2(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func3(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func4(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func5(struct Task* task); +static bool8 Phase2_Transition_BigPokeball_Func6(struct Task* task); +static bool8 Phase2_Transition_PokeballsTrail_Func1(struct Task* task); +static bool8 Phase2_Transition_PokeballsTrail_Func2(struct Task* task); +static bool8 Phase2_Transition_PokeballsTrail_Func3(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func1(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func2(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func3(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func4(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func5(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func6(struct Task* task); +static bool8 Phase2_Transition_Clockwise_BlackFade_Func7(struct Task* task); +static bool8 Phase2_Transition_Ripple_Func1(struct Task* task); +static bool8 Phase2_Transition_Ripple_Func2(struct Task* task); +static bool8 Phase2_Transition_Wave_Func1(struct Task* task); +static bool8 Phase2_Transition_Wave_Func2(struct Task* task); +static bool8 Phase2_Transition_Wave_Func3(struct Task* task); +static bool8 Phase2_Transition_Slice_Func1(struct Task* task); +static bool8 Phase2_Transition_Slice_Func2(struct Task* task); +static bool8 Phase2_Transition_Slice_Func3(struct Task* task); +static bool8 Phase2_Transition_WhiteFade_Func1(struct Task* task); +static bool8 Phase2_Transition_WhiteFade_Func2(struct Task* task); +static bool8 Phase2_Transition_WhiteFade_Func3(struct Task* task); +static bool8 Phase2_Transition_WhiteFade_Func4(struct Task* task); +static bool8 Phase2_Transition_WhiteFade_Func5(struct Task* task); +static bool8 Phase2_Transition_GridSquares_Func1(struct Task* task); +static bool8 Phase2_Transition_GridSquares_Func2(struct Task* task); +static bool8 Phase2_Transition_GridSquares_Func3(struct Task* task); +static bool8 Phase2_Transition_Shards_Func1(struct Task* task); +static bool8 Phase2_Transition_Shards_Func2(struct Task* task); +static bool8 Phase2_Transition_Shards_Func3(struct Task* task); +static bool8 Phase2_Transition_Shards_Func4(struct Task* task); +static bool8 Phase2_Transition_Shards_Func5(struct Task* task); static bool8 Phase2_Mugshot_Func1(struct Task* task); static bool8 Phase2_Mugshot_Func2(struct Task* task); static bool8 Phase2_Mugshot_Func3(struct Task* task); @@ -194,23 +194,23 @@ static const TaskFunc sPhase1_Tasks[TRANSITIONS_NO] = static const TaskFunc sPhase2_Tasks[TRANSITIONS_NO] = { - &Phase2Task_Transition0, // 0 - &Phase2Task_Transition1, // 1 - &Phase2Task_Transition2, // 2 - &Phase2Task_Transition3, // 3 - &Phase2Task_Transition4, // 4 - &Phase2Task_Transition5, // 5 - &Phase2Task_Transition6, // 6 - &Phase2Task_Transition7, // 7 - &Phase2Task_Transition8, // 8 - &Phase2Task_Transition9, // 9 - &Phase2Task_Transition10, // 10 - &Phase2Task_Transition11, // 11 - &Phase2Task_Transition_Sydney, // 12 - &Phase2Task_Transition_Phoebe, // 13 - &Phase2Task_Transition_Glacia, // 14 - &Phase2Task_Transition_Drake, // 15 - &Phase2Task_Transition_Steven, // 16 + Phase2Task_Transition_Blur, // 0 + Phase2Task_Transition_Swirl, // 1 + Phase2Task_Transition_Shuffle, // 2 + Phase2Task_Transition_BigPokeball, // 3 + Phase2Task_Transition_PokeballsTrail, // 4 + Phase2Task_Transition_Clockwise_BlackFade, // 5 + Phase2Task_Transition_Ripple, // 6 + Phase2Task_Transition_Wave, // 7 + Phase2Task_Transition_Slice, // 8 + Phase2Task_Transition_WhiteFade, // 9 + Phase2Task_Transition_GridSquares, // 10 + Phase2Task_Transition_Shards, // 11 + Phase2Task_Transition_Sydney, // 12 + Phase2Task_Transition_Phoebe, // 13 + Phase2Task_Transition_Glacia, // 14 + Phase2Task_Transition_Drake, // 15 + Phase2Task_Transition_Steven, // 16 }; static const TransitionState sMainTransitionPhases[] = @@ -221,82 +221,82 @@ static const TransitionState sMainTransitionPhases[] = &Transition_WaitForPhase2 }; -static const TransitionState sPhase2_Transition0_Funcs[] = +static const TransitionState sPhase2_Transition_Blur_Funcs[] = { - &Phase2_Transition0_Func1, - &Phase2_Transition0_Func2, - &Phase2_Transition0_Func3 + Phase2_Transition_Blur_Func1, + Phase2_Transition_Blur_Func2, + Phase2_Transition_Blur_Func3 }; -static const TransitionState sPhase2_Transition1_Funcs[] = +static const TransitionState sPhase2_Transition_Swirl_Funcs[] = { - &Phase2_Transition1_Func1, - &Phase2_Transition1_Func2, + Phase2_Transition_Swirl_Func1, + Phase2_Transition_Swirl_Func2, }; -static const TransitionState sPhase2_Transition2_Funcs[] = +static const TransitionState sPhase2_Transition_Shuffle_Funcs[] = { - &Phase2_Transition2_Func1, - &Phase2_Transition2_Func2, + Phase2_Transition_Shuffle_Func1, + Phase2_Transition_Shuffle_Func2, }; -static const TransitionState sPhase2_Transition3_Funcs[] = +static const TransitionState sPhase2_Transition_BigPokeball_Funcs[] = { - &Phase2_Transition3_Func1, - &Phase2_Transition3_Func2, - &Phase2_Transition3_Func3, - &Phase2_Transition3_Func4, - &Phase2_Transition3_Func5, - &Phase2_Transition3_Func6 + Phase2_Transition_BigPokeball_Func1, + Phase2_Transition_BigPokeball_Func2, + Phase2_Transition_BigPokeball_Func3, + Phase2_Transition_BigPokeball_Func4, + Phase2_Transition_BigPokeball_Func5, + Phase2_Transition_BigPokeball_Func6 }; -static const TransitionState sPhase2_Transition4_Funcs[] = +static const TransitionState sPhase2_Transition_PokeballsTrail_Funcs[] = { - &Phase2_Transition4_Func1, - &Phase2_Transition4_Func2, - &Phase2_Transition4_Func3 + Phase2_Transition_PokeballsTrail_Func1, + Phase2_Transition_PokeballsTrail_Func2, + Phase2_Transition_PokeballsTrail_Func3 }; static const s16 sUnknown_083FD7E4[2] = {-16, 256}; static const s16 sUnknown_083FD7E8[5] = {0, 32, 64, 18, 48}; static const s16 sUnknown_083FD7F2[2] = {8, -8}; -static const TransitionState sPhase2_Transition5_Funcs[] = +static const TransitionState sPhase2_Transition_Clockwise_BlackFade_Funcs[] = { - &Phase2_Transition5_Func1, - &Phase2_Transition5_Func2, - &Phase2_Transition5_Func3, - &Phase2_Transition5_Func4, - &Phase2_Transition5_Func5, - &Phase2_Transition5_Func6, - &Phase2_Transition5_Func7 + Phase2_Transition_Clockwise_BlackFade_Func1, + Phase2_Transition_Clockwise_BlackFade_Func2, + Phase2_Transition_Clockwise_BlackFade_Func3, + Phase2_Transition_Clockwise_BlackFade_Func4, + Phase2_Transition_Clockwise_BlackFade_Func5, + Phase2_Transition_Clockwise_BlackFade_Func6, + Phase2_Transition_Clockwise_BlackFade_Func7 }; -static const TransitionState sPhase2_Transition6_Funcs[] = +static const TransitionState sPhase2_Transition_Ripple_Funcs[] = { - &Phase2_Transition6_Func1, - &Phase2_Transition6_Func2 + Phase2_Transition_Ripple_Func1, + Phase2_Transition_Ripple_Func2 }; -static const TransitionState sPhase2_Transition7_Funcs[] = +static const TransitionState sPhase2_Transition_Wave_Funcs[] = { - &Phase2_Transition7_Func1, - &Phase2_Transition7_Func2, - &Phase2_Transition7_Func3 + Phase2_Transition_Wave_Func1, + Phase2_Transition_Wave_Func2, + Phase2_Transition_Wave_Func3 }; static const TransitionState sPhase2_Mugshot_Transition_Funcs[] = { - &Phase2_Mugshot_Func1, - &Phase2_Mugshot_Func2, - &Phase2_Mugshot_Func3, - &Phase2_Mugshot_Func4, - &Phase2_Mugshot_Func5, - &Phase2_Mugshot_Func6, - &Phase2_Mugshot_Func7, - &Phase2_Mugshot_Func8, - &Phase2_Mugshot_Func9, - &Phase2_Mugshot_Func10 + Phase2_Mugshot_Func1, + Phase2_Mugshot_Func2, + Phase2_Mugshot_Func3, + Phase2_Mugshot_Func4, + Phase2_Mugshot_Func5, + Phase2_Mugshot_Func6, + Phase2_Mugshot_Func7, + Phase2_Mugshot_Func8, + Phase2_Mugshot_Func9, + Phase2_Mugshot_Func10 }; static const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_NO] = {TRAINER_PIC_SIDNEY, TRAINER_PIC_PHOEBE, TRAINER_PIC_GLACIA, TRAINER_PIC_DRAKE, TRAINER_PIC_STEVEN}; @@ -319,50 +319,50 @@ static const s16 sMugshotsOpponentCoords[MUGSHOTS_NO][2] = static const TransitionSpriteCallback sUnknown_083FD880[] = { - &sub_811C934, - &sub_811C938, - &sub_811C984, - &sub_811C9B8, - &sub_811C934, - &sub_811C9E4, - &sub_811C934 + sub_811C934, + sub_811C938, + sub_811C984, + sub_811C9B8, + sub_811C934, + sub_811C9E4, + sub_811C934 }; static const s16 sUnknown_083FD89C[2] = {12, -12}; static const s16 sUnknown_083FD8A0[2] = {-1, 1}; -static const TransitionState sPhase2_Transition8_Funcs[] = +static const TransitionState sPhase2_Transition_Slice_Funcs[] = { - &Phase2_Transition8_Func1, - &Phase2_Transition8_Func2, - &Phase2_Transition8_Func3 + Phase2_Transition_Slice_Func1, + Phase2_Transition_Slice_Func2, + Phase2_Transition_Slice_Func3 }; -static const TransitionState sPhase2_Transition9_Funcs[] = +static const TransitionState sPhase2_Transition_WhiteFade_Funcs[] = { - &Phase2_Transition9_Func1, - &Phase2_Transition9_Func2, - &Phase2_Transition9_Func3, - &Phase2_Transition9_Func4, - &Phase2_Transition9_Func5 + Phase2_Transition_WhiteFade_Func1, + Phase2_Transition_WhiteFade_Func2, + Phase2_Transition_WhiteFade_Func3, + Phase2_Transition_WhiteFade_Func4, + Phase2_Transition_WhiteFade_Func5 }; static const s16 sUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; -static const TransitionState sPhase2_Transition10_Funcs[] = +static const TransitionState sPhase2_Transition_GridSquares_Funcs[] = { - &Phase2_Transition10_Func1, - &Phase2_Transition10_Func2, - &Phase2_Transition10_Func3 + Phase2_Transition_GridSquares_Func1, + Phase2_Transition_GridSquares_Func2, + Phase2_Transition_GridSquares_Func3 }; -static const TransitionState sPhase2_Transition11_Funcs[] = +static const TransitionState sPhase2_Transition_Shards_Funcs[] = { - &Phase2_Transition11_Func1, - &Phase2_Transition11_Func2, - &Phase2_Transition11_Func3, - &Phase2_Transition11_Func4, - &Phase2_Transition11_Func5 + Phase2_Transition_Shards_Func1, + Phase2_Transition_Shards_Func2, + Phase2_Transition_Shards_Func3, + Phase2_Transition_Shards_Func4, + Phase2_Transition_Shards_Func5 }; static const s16 sUnknown_083FD8F4[][5] = @@ -380,8 +380,8 @@ static const s16 sUnknown_083FD93A[] = {8, 4, 2, 1, 1, 1, 0}; static const TransitionState sPhase1_TransitionAll_Funcs[] = { - &Phase1_TransitionAll_Func1, - &Phase1_TransitionAll_Func2 + Phase1_TransitionAll_Func1, + Phase1_TransitionAll_Func2 }; static const struct SpriteFrameImage sSpriteImageTable_83FD950[] = @@ -622,12 +622,12 @@ static void Phase1Task_TransitionAll(u8 taskID) DestroyTask(taskID); } -static void Phase2Task_Transition0(u8 taskID) +static void Phase2Task_Transition_Blur(u8 taskID) { - while (sPhase2_Transition0_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Blur_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition0_Func1(struct Task* task) +static bool8 Phase2_Transition_Blur_Func1(struct Task* task) { REG_MOSAIC = 0; REG_BG1CNT |= 0x40; @@ -637,7 +637,7 @@ static bool8 Phase2_Transition0_Func1(struct Task* task) return TRUE; } -static bool8 Phase2_Transition0_Func2(struct Task* task) +static bool8 Phase2_Transition_Blur_Func2(struct Task* task) { if (task->data[1] != 0) task->data[1]--; @@ -653,22 +653,22 @@ static bool8 Phase2_Transition0_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition0_Func3(struct Task* task) +static bool8 Phase2_Transition_Blur_Func3(struct Task* task) { if (!gPaletteFade.active) { - u8 taskID = FindTaskIdByFunc(Phase2Task_Transition0); + u8 taskID = FindTaskIdByFunc(Phase2Task_Transition_Blur); DestroyTask(taskID); } return FALSE; } -static void Phase2Task_Transition1(u8 taskID) +static void Phase2Task_Transition_Swirl(u8 taskID) { - while (sPhase2_Transition1_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Swirl_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition1_Func1(struct Task* task) +static bool8 Phase2_Transition_Swirl_Func1(struct Task* task) { u16 savedIME; @@ -677,8 +677,8 @@ static bool8 Phase2_Transition1_Func1(struct Task* task) BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); sub_811D6E8(gUnknown_03005560, TRANSITION_STRUCT.field_14, 0, 2, 0, 160); - SetVBlankCallback(VBlankCB_Phase2_Transition1); - SetHBlankCallback(HBlankCB_Phase2_Transition1); + SetVBlankCallback(VBlankCB_Phase2_Transition_Swirl); + SetHBlankCallback(HBlankCB_Phase2_Transition_Swirl); savedIME = REG_IME; REG_IME = 0; @@ -690,7 +690,7 @@ static bool8 Phase2_Transition1_Func1(struct Task* task) return FALSE; } -static bool8 Phase2_Transition1_Func2(struct Task* task) +static bool8 Phase2_Transition_Swirl_Func2(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; task->data[1] += 4; @@ -700,7 +700,7 @@ static bool8 Phase2_Transition1_Func2(struct Task* task) if (!gPaletteFade.active) { - u8 taskID = FindTaskIdByFunc(Phase2Task_Transition1); + u8 taskID = FindTaskIdByFunc(Phase2Task_Transition_Swirl); DestroyTask(taskID); } @@ -708,14 +708,14 @@ static bool8 Phase2_Transition1_Func2(struct Task* task) return FALSE; } -static void VBlankCB_Phase2_Transition1(void) +static void VBlankCB_Phase2_Transition_Swirl(void) { VBlankCB_BattleTransition(); if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } -static void HBlankCB_Phase2_Transition1(void) +static void HBlankCB_Phase2_Transition_Swirl(void) { u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; REG_BG1HOFS = var; @@ -723,12 +723,12 @@ static void HBlankCB_Phase2_Transition1(void) REG_BG3HOFS = var; } -static void Phase2Task_Transition2(u8 taskID) +static void Phase2Task_Transition_Shuffle(u8 taskID) { - while (sPhase2_Transition2_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Shuffle_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition2_Func1(struct Task* task) +static bool8 Phase2_Transition_Shuffle_Func1(struct Task* task) { u16 savedIME; @@ -738,8 +738,8 @@ static bool8 Phase2_Transition2_Func1(struct Task* task) BeginNormalPaletteFade(-1, 4, 0, 0x10, 0); memset(gUnknown_03005560, TRANSITION_STRUCT.field_16, 0x140); - SetVBlankCallback(VBlankCB_Phase2_Transition2); - SetHBlankCallback(HBlankCB_Phase2_Transition2); + SetVBlankCallback(VBlankCB_Phase2_Transition_Shuffle); + SetHBlankCallback(HBlankCB_Phase2_Transition_Shuffle); savedIME = REG_IME; REG_IME = 0; @@ -751,7 +751,7 @@ static bool8 Phase2_Transition2_Func1(struct Task* task) return FALSE; } -static bool8 Phase2_Transition2_Func2(struct Task* task) +static bool8 Phase2_Transition_Shuffle_Func2(struct Task* task) { u8 i; u16 r3, r4; @@ -769,20 +769,20 @@ static bool8 Phase2_Transition2_Func2(struct Task* task) } if (!gPaletteFade.active) - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition2)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Shuffle)); TRANSITION_STRUCT.VBlank_DMA++; return FALSE; } -static void VBlankCB_Phase2_Transition2(void) +static void VBlankCB_Phase2_Transition_Shuffle(void) { VBlankCB_BattleTransition(); if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } -static void HBlankCB_Phase2_Transition2(void) +static void HBlankCB_Phase2_Transition_Shuffle(void) { u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; REG_BG1VOFS = var; @@ -790,12 +790,12 @@ static void HBlankCB_Phase2_Transition2(void) REG_BG3VOFS = var; } -static void Phase2Task_Transition3(u8 taskID) +static void Phase2Task_Transition_BigPokeball(u8 taskID) { - while (sPhase2_Transition3_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_BigPokeball_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition3_Func1(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func1(struct Task* task) { u16 i; u16 *dst1, *dst2; @@ -819,7 +819,7 @@ static bool8 Phase2_Transition3_Func1(struct Task* task) gUnknown_03005560[i] = 240; } - SetVBlankCallback(VBlankCB0_Phase2_Transition3); + SetVBlankCallback(VBlankCB0_Phase2_Transition_BigPokeball); sub_811D6A8(&dst1, & dst2); CpuFill16(0, dst1, 0x800); @@ -830,7 +830,7 @@ static bool8 Phase2_Transition3_Func1(struct Task* task) return FALSE; } -static bool8 Phase2_Transition3_Func2(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func2(struct Task* task) { s16 i, j; u16 *dst1, *dst2; @@ -851,7 +851,7 @@ static bool8 Phase2_Transition3_Func2(struct Task* task) return TRUE; } -static bool8 Phase2_Transition3_Func3(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func3(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) @@ -871,7 +871,7 @@ static bool8 Phase2_Transition3_Func3(struct Task* task) return FALSE; } -static bool8 Phase2_Transition3_Func4(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[3] == 0 || --task->data[3] == 0) @@ -891,7 +891,7 @@ static bool8 Phase2_Transition3_Func4(struct Task* task) return FALSE; } -static bool8 Phase2_Transition3_Func5(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func5(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; task->data[4] += 8; @@ -911,7 +911,7 @@ static bool8 Phase2_Transition3_Func5(struct Task* task) return FALSE; } -static bool8 Phase2_Transition3_Func6(struct Task* task) +static bool8 Phase2_Transition_BigPokeball_Func6(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (task->data[2] < 1024) @@ -927,19 +927,19 @@ static bool8 Phase2_Transition3_Func6(struct Task* task) { DmaStop(0); sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition3)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_BigPokeball)); } if (task->data[3] == 0) { task->data[3]++; - SetVBlankCallback(VBlankCB1_Phase2_Transition3); + SetVBlankCallback(VBlankCB1_Phase2_Transition_BigPokeball); } TRANSITION_STRUCT.VBlank_DMA++; return FALSE; } -static void Transition3_Vblank(void) +static void Transition_BigPokeball_Vblank(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -952,24 +952,24 @@ static void Transition3_Vblank(void) REG_BLDALPHA = TRANSITION_STRUCT.BLDALPHA; } -static void VBlankCB0_Phase2_Transition3(void) +static void VBlankCB0_Phase2_Transition_BigPokeball(void) { - Transition3_Vblank(); + Transition_BigPokeball_Vblank(); DmaSet(0, gUnknown_03005560, ®_BG0HOFS, 0xA2400001); } -static void VBlankCB1_Phase2_Transition3(void) +static void VBlankCB1_Phase2_Transition_BigPokeball(void) { - Transition3_Vblank(); + Transition_BigPokeball_Vblank(); DmaSet(0, gUnknown_03005560, ®_WIN0H, 0xA2400001); } -static void Phase2Task_Transition4(u8 taskID) +static void Phase2Task_Transition_PokeballsTrail(u8 taskID) { - while (sPhase2_Transition4_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_PokeballsTrail_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition4_Func1(struct Task* task) +static bool8 Phase2_Transition_PokeballsTrail_Func1(struct Task* task) { u16 *dst1, *dst2; @@ -982,7 +982,7 @@ static bool8 Phase2_Transition4_Func1(struct Task* task) return FALSE; } -static bool8 Phase2_Transition4_Func2(struct Task* task) +static bool8 Phase2_Transition_PokeballsTrail_Func2(struct Task* task) { s16 i; s16 rand; @@ -1005,12 +1005,12 @@ static bool8 Phase2_Transition4_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition4_Func3(struct Task* task) +static bool8 Phase2_Transition_PokeballsTrail_Func3(struct Task* task) { if (!FieldEffectActiveListContains(FLDEFF_POKEBALL)) { sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition4)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_PokeballsTrail)); } return FALSE; } @@ -1069,12 +1069,12 @@ static void sub_811B720(struct Sprite* sprite) } } -static void Phase2Task_Transition5(u8 taskID) +static void Phase2Task_Transition_Clockwise_BlackFade(u8 taskID) { - while (sPhase2_Transition5_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Clockwise_BlackFade_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition5_Func1(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func1(struct Task* task) { u16 i; @@ -1091,14 +1091,14 @@ static bool8 Phase2_Transition5_Func1(struct Task* task) gUnknown_03005560[i] = 0xF3F4; } - SetVBlankCallback(VBlankCB_Phase2_Transition5); + SetVBlankCallback(VBlankCB_Phase2_Transition_Clockwise_BlackFade); TRANSITION_STRUCT.data[4] = 120; task->tState++; return TRUE; } -static bool8 Phase2_Transition5_Func2(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func2(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -1119,7 +1119,7 @@ static bool8 Phase2_Transition5_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition5_Func3(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func3(struct Task* task) { s16 r1, r3; vu8 var = 0; @@ -1157,7 +1157,7 @@ static bool8 Phase2_Transition5_Func3(struct Task* task) return FALSE; } -static bool8 Phase2_Transition5_Func4(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -1178,7 +1178,7 @@ static bool8 Phase2_Transition5_Func4(struct Task* task) return FALSE; } -static bool8 Phase2_Transition5_Func5(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func5(struct Task* task) { s16 r1, r2, r3; vu8 var = 0; @@ -1217,7 +1217,7 @@ static bool8 Phase2_Transition5_Func5(struct Task* task) return FALSE; } -static bool8 Phase2_Transition5_Func6(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func6(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -1241,15 +1241,15 @@ static bool8 Phase2_Transition5_Func6(struct Task* task) return FALSE; } -static bool8 Phase2_Transition5_Func7(struct Task* task) +static bool8 Phase2_Transition_Clockwise_BlackFade_Func7(struct Task* task) { DmaStop(0); sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition5)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Clockwise_BlackFade)); return FALSE; } -static void VBlankCB_Phase2_Transition5(void) +static void VBlankCB_Phase2_Transition_Clockwise_BlackFade(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -1262,12 +1262,12 @@ static void VBlankCB_Phase2_Transition5(void) DmaSet(0, gUnknown_03004DE0[1], ®_WIN0H, 0xA2400001); } -static void Phase2Task_Transition6(u8 taskID) +static void Phase2Task_Transition_Ripple(u8 taskID) { - while (sPhase2_Transition6_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Ripple_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition6_Func1(struct Task* task) +static bool8 Phase2_Transition_Ripple_Func1(struct Task* task) { u8 i; @@ -1279,8 +1279,8 @@ static bool8 Phase2_Transition6_Func1(struct Task* task) gUnknown_03005560[i] = TRANSITION_STRUCT.field_16; } - SetVBlankCallback(VBlankCB_Phase2_Transition6); - SetHBlankCallback(HBlankCB_Phase2_Transition6); + SetVBlankCallback(VBlankCB_Phase2_Transition_Ripple); + SetHBlankCallback(HBlankCB_Phase2_Transition_Ripple); REG_IE |= 2; REG_DISPSTAT |= 0x10; @@ -1289,7 +1289,7 @@ static bool8 Phase2_Transition6_Func1(struct Task* task) return TRUE; } -static bool8 Phase2_Transition6_Func2(struct Task* task) +static bool8 Phase2_Transition_Ripple_Func2(struct Task* task) { u8 i; s16 r3; @@ -1320,20 +1320,20 @@ static bool8 Phase2_Transition6_Func2(struct Task* task) } if (task->data[4] != 0 && !gPaletteFade.active) - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition6)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Ripple)); TRANSITION_STRUCT.VBlank_DMA++; return FALSE; } -static void VBlankCB_Phase2_Transition6(void) +static void VBlankCB_Phase2_Transition_Ripple(void) { VBlankCB_BattleTransition(); if (TRANSITION_STRUCT.VBlank_DMA) DmaCopy16(3, gUnknown_03004DE0[0], gUnknown_03004DE0[1], 320); } -static void HBlankCB_Phase2_Transition6(void) +static void HBlankCB_Phase2_Transition_Ripple(void) { u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; REG_BG1VOFS = var; @@ -1341,12 +1341,12 @@ static void HBlankCB_Phase2_Transition6(void) REG_BG3VOFS = var; } -static void Phase2Task_Transition7(u8 taskID) +static void Phase2Task_Transition_Wave(u8 taskID) { - while (sPhase2_Transition7_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Wave_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition7_Func1(struct Task* task) +static bool8 Phase2_Transition_Wave_Func1(struct Task* task) { u8 i; @@ -1363,13 +1363,13 @@ static bool8 Phase2_Transition7_Func1(struct Task* task) gUnknown_03004DE0[1][i] = 242; } - SetVBlankCallback(VBlankCB_Phase2_Transition7); + SetVBlankCallback(VBlankCB_Phase2_Transition_Wave); task->tState++; return TRUE; } -static bool8 Phase2_Transition7_Func2(struct Task* task) +static bool8 Phase2_Transition_Wave_Func2(struct Task* task) { u8 i, r5; u16* toStore; @@ -1399,15 +1399,15 @@ static bool8 Phase2_Transition7_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition7_Func3(struct Task* task) +static bool8 Phase2_Transition_Wave_Func3(struct Task* task) { DmaStop(0); sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition7)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Wave)); return FALSE; } -static void VBlankCB_Phase2_Transition7(void) +static void VBlankCB_Phase2_Transition_Wave(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -1837,12 +1837,12 @@ static s16 sub_811CA44(s16 spriteID) #undef tMugshotPlayerID #undef tMugshotID -static void Phase2Task_Transition8(u8 taskID) +static void Phase2Task_Transition_Slice(u8 taskID) { - while (sPhase2_Transition8_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Slice_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition8_Func1(struct Task* task) +static bool8 Phase2_Transition_Slice_Func1(struct Task* task) { u16 i; @@ -1864,14 +1864,14 @@ static bool8 Phase2_Transition8_Func1(struct Task* task) REG_IE |= 2; REG_DISPSTAT |= 0x10; - SetVBlankCallback(VBlankCB_Phase2_Transition8); - SetHBlankCallback(HBlankCB_Phase2_Transition8); + SetVBlankCallback(VBlankCB_Phase2_Transition_Slice); + SetHBlankCallback(HBlankCB_Phase2_Transition_Slice); task->tState++; return TRUE; } -static bool8 Phase2_Transition8_Func2(struct Task* task) +static bool8 Phase2_Transition_Slice_Func2(struct Task* task) { u16 i; @@ -1908,15 +1908,15 @@ static bool8 Phase2_Transition8_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition8_Func3(struct Task* task) +static bool8 Phase2_Transition_Slice_Func3(struct Task* task) { DmaStop(0); sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition8)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Slice)); return FALSE; } -static void VBlankCB_Phase2_Transition8(void) +static void VBlankCB_Phase2_Transition_Slice(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -1928,7 +1928,7 @@ static void VBlankCB_Phase2_Transition8(void) DmaSet(0, &gUnknown_03004DE0[1][160], ®_WIN0H, 0xA2400001); } -static void HBlankCB_Phase2_Transition8(void) +static void HBlankCB_Phase2_Transition_Slice(void) { u16 var = gUnknown_03004DE0[1][REG_VCOUNT]; REG_BG1HOFS = var; @@ -1936,12 +1936,12 @@ static void HBlankCB_Phase2_Transition8(void) REG_BG3HOFS = var; } -static void Phase2Task_Transition9(u8 taskID) +static void Phase2Task_Transition_WhiteFade(u8 taskID) { - while (sPhase2_Transition9_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_WhiteFade_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition9_Func1(struct Task* task) +static bool8 Phase2_Transition_WhiteFade_Func1(struct Task* task) { u16 i; @@ -1963,14 +1963,14 @@ static bool8 Phase2_Transition9_Func1(struct Task* task) REG_IE |= 2; REG_DISPSTAT |= 0x10; - SetHBlankCallback(HBlankCB_Phase2_Transition9); - SetVBlankCallback(VBlankCB0_Phase2_Transition9); + SetHBlankCallback(HBlankCB_Phase2_Transition_WhiteFade); + SetVBlankCallback(VBlankCB0_Phase2_Transition_WhiteFade); task->tState++; return FALSE; } -static bool8 Phase2_Transition9_Func2(struct Task* task) +static bool8 Phase2_Transition_WhiteFade_Func2(struct Task* task) { s16 i, posY; s16 arr1[8]; @@ -1990,7 +1990,7 @@ static bool8 Phase2_Transition9_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition9_Func3(struct Task* task) +static bool8 Phase2_Transition_WhiteFade_Func3(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; if (TRANSITION_STRUCT.field_20 > 7) @@ -2001,7 +2001,7 @@ static bool8 Phase2_Transition9_Func3(struct Task* task) return FALSE; } -static bool8 Phase2_Transition9_Func4(struct Task* task) +static bool8 Phase2_Transition_WhiteFade_Func4(struct Task* task) { TRANSITION_STRUCT.VBlank_DMA = 0; @@ -2014,23 +2014,23 @@ static bool8 Phase2_Transition9_Func4(struct Task* task) TRANSITION_STRUCT.BLDCNT = 0xFF; TRANSITION_STRUCT.WININ = 0x3F; - SetVBlankCallback(VBlankCB1_Phase2_Transition9); + SetVBlankCallback(VBlankCB1_Phase2_Transition_WhiteFade); task->tState++; return FALSE; } -static bool8 Phase2_Transition9_Func5(struct Task* task) +static bool8 Phase2_Transition_WhiteFade_Func5(struct Task* task) { if (++TRANSITION_STRUCT.BLDY > 16) { sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition9)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_WhiteFade)); } return FALSE; } -static void VBlankCB0_Phase2_Transition9(void) +static void VBlankCB0_Phase2_Transition_WhiteFade(void) { DmaStop(0); VBlankCB_BattleTransition(); @@ -2043,7 +2043,7 @@ static void VBlankCB0_Phase2_Transition9(void) DmaSet(0, &gUnknown_03004DE0[1][160], ®_WIN0H, 0xA2400001); } -static void VBlankCB1_Phase2_Transition9(void) +static void VBlankCB1_Phase2_Transition_WhiteFade(void) { VBlankCB_BattleTransition(); REG_BLDY = TRANSITION_STRUCT.BLDY; @@ -2054,7 +2054,7 @@ static void VBlankCB1_Phase2_Transition9(void) REG_WIN0V = TRANSITION_STRUCT.WIN0V; } -static void HBlankCB_Phase2_Transition9(void) +static void HBlankCB_Phase2_Transition_WhiteFade(void) { REG_BLDY = gUnknown_03004DE0[1][REG_VCOUNT]; } @@ -2102,12 +2102,12 @@ static void sub_811CFD0(struct Sprite* sprite) } } -static void Phase2Task_Transition10(u8 taskID) +static void Phase2Task_Transition_GridSquares(u8 taskID) { - while (sPhase2_Transition10_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_GridSquares_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition10_Func1(struct Task* task) +static bool8 Phase2_Transition_GridSquares_Func1(struct Task* task) { u16 *dst1, *dst2; @@ -2120,7 +2120,7 @@ static bool8 Phase2_Transition10_Func1(struct Task* task) return FALSE; } -static bool8 Phase2_Transition10_Func2(struct Task* task) +static bool8 Phase2_Transition_GridSquares_Func2(struct Task* task) { u16* dst1; @@ -2141,22 +2141,22 @@ static bool8 Phase2_Transition10_Func2(struct Task* task) return FALSE; } -static bool8 Phase2_Transition10_Func3(struct Task* task) +static bool8 Phase2_Transition_GridSquares_Func3(struct Task* task) { if (--task->data[1] == 0) { sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition10)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_GridSquares)); } return FALSE; } -static void Phase2Task_Transition11(u8 taskID) +static void Phase2Task_Transition_Shards(u8 taskID) { - while (sPhase2_Transition11_Funcs[gTasks[taskID].tState](&gTasks[taskID])); + while (sPhase2_Transition_Shards_Funcs[gTasks[taskID].tState](&gTasks[taskID])); } -static bool8 Phase2_Transition11_Func1(struct Task* task) +static bool8 Phase2_Transition_Shards_Func1(struct Task* task) { u16 i; @@ -2173,13 +2173,13 @@ static bool8 Phase2_Transition11_Func1(struct Task* task) } CpuSet(gUnknown_03004DE0[0], gUnknown_03004DE0[1], 0xA0); - SetVBlankCallback(VBlankCB_Phase2_Transition11); + SetVBlankCallback(VBlankCB_Phase2_Transition_Shards); task->tState++; return TRUE; } -static bool8 Phase2_Transition11_Func2(struct Task* task) +static bool8 Phase2_Transition_Shards_Func2(struct Task* task) { sub_811D8FC(TRANSITION_STRUCT.data, sUnknown_083FD8F4[task->data[1]][0], @@ -2192,7 +2192,7 @@ static bool8 Phase2_Transition11_Func2(struct Task* task) return TRUE; } -static bool8 Phase2_Transition11_Func3(struct Task* task) +static bool8 Phase2_Transition_Shards_Func3(struct Task* task) { s16 i; bool8 nextFunc; @@ -2231,7 +2231,7 @@ static bool8 Phase2_Transition11_Func3(struct Task* task) return FALSE; } -static bool8 Phase2_Transition11_Func4(struct Task* task) +static bool8 Phase2_Transition_Shards_Func4(struct Task* task) { if (++task->data[1] < 7) { @@ -2243,12 +2243,12 @@ static bool8 Phase2_Transition11_Func4(struct Task* task) { DmaStop(0); sub_811D6D4(); - DestroyTask(FindTaskIdByFunc(Phase2Task_Transition11)); + DestroyTask(FindTaskIdByFunc(Phase2Task_Transition_Shards)); return FALSE; } } -static bool8 Phase2_Transition11_Func5(struct Task* task) +static bool8 Phase2_Transition_Shards_Func5(struct Task* task) { if (--task->data[3] == 0) { @@ -2259,7 +2259,7 @@ static bool8 Phase2_Transition11_Func5(struct Task* task) return FALSE; } -static void VBlankCB_Phase2_Transition11(void) +static void VBlankCB_Phase2_Transition_Shards(void) { DmaStop(0); VBlankCB_BattleTransition(); -- cgit v1.2.3 From 9ac913c5270c7cc5fc245c2cce6b9e64e848f7e9 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 23 Aug 2017 19:36:25 +0200 Subject: start working on reshow battle screen --- src/battle_10.c | 6 +- src/battle_6.c | 16 +-- src/battle_7.c | 132 +++++++++++------------ src/battle_8.c | 6 +- src/battle_811DA74.c | 12 +-- src/battle_anim_8137220.c | 6 +- src/reshow_battle_screen.c | 262 +++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 351 insertions(+), 89 deletions(-) create mode 100644 src/reshow_battle_screen.c (limited to 'src') diff --git a/src/battle_10.c b/src/battle_10.c index 0237bab4b..c2053a5d1 100644 --- a/src/battle_10.c +++ b/src/battle_10.c @@ -52,7 +52,7 @@ extern u8 gUnknown_0300434C[]; extern u8 sub_8077F68(); extern u8 sub_8079E90(); extern u8 GetBankIdentity(u8); -extern void sub_8031794(struct Pokemon *, u8); +extern void BattleLoadOpponentMonSprite(struct Pokemon *, u8); extern void sub_8037A74(void); extern void sub_8032984(u8, u16); extern void sub_8037E30(void); @@ -696,7 +696,7 @@ void sub_8039294(void) { u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -726,7 +726,7 @@ void sub_8039430(u8 a, u8 b) gBattlePartyID[a] = gBattleBufferA[a][1]; species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); gObjectBankIDs[a] = CreateSprite( &gUnknown_02024E8C, diff --git a/src/battle_6.c b/src/battle_6.c index c833aef5e..6fa0e3948 100644 --- a/src/battle_6.c +++ b/src/battle_6.c @@ -98,7 +98,7 @@ extern void sub_80E43C0(); extern void oamt_add_pos2_onto_pos1(); extern void sub_8078B34(struct Sprite *); extern void oamt_set_x3A_32(); -extern void sub_80318FC(); +extern void BattleLoadPlayerMonSprite(); extern bool8 IsDoubleBattle(void); extern void sub_802D500(void); extern void dp11b_obj_free(); @@ -121,7 +121,7 @@ extern void sub_80105EC(struct Sprite *); extern void sub_802D274(void); extern void sub_802D23C(void); extern u8 GetBankIdentity(u8); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern void sub_80313A0(struct Sprite *); extern void sub_802D204(void); extern u8 sub_8079E90(); @@ -739,7 +739,7 @@ void sub_802F7CC(void) void PlayerHandleLoadPokeSprite(void) { - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; gBattleBankFunc[gActiveBank] = bx_0802E404; } @@ -748,7 +748,7 @@ void PlayerHandleSendOutPoke(void) { sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); gActionSelectionCursor[gActiveBank] = 0; gMoveSelectionCursor[gActiveBank] = 0; sub_802F934(gActiveBank, gBattleBufferA[gActiveBank][2]); @@ -829,7 +829,7 @@ void PlayerHandleTrainerThrow(void) { r7 = 0; } - sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -845,7 +845,7 @@ void PlayerHandleTrainerThrow(void) void PlayerHandleTrainerSlide(void) { - sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1357,7 +1357,7 @@ void sub_8030E38(struct Sprite *sprite) FreeSpriteOamMatrix(sprite); FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); DestroySprite(sprite); - sub_80318FC(&gPlayerParty[gBattlePartyID[r4]], r4); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[r4]], r4); StartSpriteAnim(&gSprites[gObjectBankIDs[r4]], 0); } @@ -1383,7 +1383,7 @@ void task05_08033660(u8 taskId) sub_802F934(gActiveBank, 0); gActiveBank ^= 2; gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_802F934(gActiveBank, 0); gActiveBank ^= 2; } diff --git a/src/battle_7.c b/src/battle_7.c index f2838467e..8c5f5f45d 100644 --- a/src/battle_7.c +++ b/src/battle_7.c @@ -182,9 +182,9 @@ bool8 move_anim_start_t3(u8 a, u8 b, u8 c, u8 d, u16 e) gBattleMonForms[a] = e & 0x7F; return TRUE; } - if (ewram17800[a].unk0_2 && sub_803163C(d) == 0) + if (ewram17800[a].substituteSprite && sub_803163C(d) == 0) return TRUE; - if (ewram17800[a].unk0_2 && d == 2 && gSprites[gObjectBankIDs[a]].invisible) + if (ewram17800[a].substituteSprite && d == 2 && gSprites[gObjectBankIDs[a]].invisible) { refresh_graphics_maybe(a, 1, gObjectBankIDs[a]); sub_80324E0(a); @@ -273,29 +273,29 @@ bool8 mplay_80342A4(u8 a) return TRUE; } -void sub_8031794(struct Pokemon *pkmn, u8 b) +void BattleLoadOpponentMonSprite(struct Pokemon *pkmn, u8 bank) { u32 personalityValue; u16 species; - u32 r7; + u32 transformPersonality; u32 otId; u8 var; u16 paletteOffset; const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[b].unk2 == 0) + if (ewram17800[bank].transformedSpecies == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); - r7 = personalityValue; + transformPersonality = personalityValue; } else { - species = ewram17800[b].unk2; - r7 = gPID_perBank[b]; + species = ewram17800[bank].transformedSpecies; + transformPersonality = gPID_perBank[bank]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); - var = GetBankIdentity(b); + var = GetBankIdentity(bank); HandleLoadSpecialPokePic( &gMonFrontPicTable[species], gMonFrontPicCoords[species].coords, @@ -303,29 +303,29 @@ void sub_8031794(struct Pokemon *pkmn, u8 b) 0x02000000, gUnknown_081FAF4C[var], species, - r7); - paletteOffset = 0x100 + b * 16; - if (ewram17800[b].unk2 == 0) + transformPersonality); + paletteOffset = 0x100 + bank * 16; + if (ewram17800[bank].transformedSpecies == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 0x20); - LoadPalette(ewram, 0x80 + b * 16, 0x20); + LoadPalette(ewram, 0x80 + bank * 16, 0x20); if (species == SPECIES_CASTFORM) { - paletteOffset = 0x100 + b * 16; + paletteOffset = 0x100 + bank * 16; sub_800D238(lzPaletteData, ewram + 0x16400); - LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); + LoadPalette(ewram + 0x16400 + gBattleMonForms[bank] * 32, paletteOffset, 0x20); } - if (ewram17800[b].unk2 != 0) + if (ewram17800[bank].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); } } -void sub_80318FC(struct Pokemon *pkmn, u8 b) +void BattleLoadPlayerMonSprite(struct Pokemon *pkmn, u8 bank) { u32 personalityValue; u16 species; @@ -336,18 +336,18 @@ void sub_80318FC(struct Pokemon *pkmn, u8 b) const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[b].unk2 == 0) + if (ewram17800[bank].transformedSpecies == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); r7 = personalityValue; } else { - species = ewram17800[b].unk2; - r7 = gPID_perBank[b]; + species = ewram17800[bank].transformedSpecies; + r7 = gPID_perBank[bank]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); - var = GetBankIdentity(b); + var = GetBankIdentity(bank); HandleLoadSpecialPokePic( &gMonBackPicTable[species], gMonBackPicCoords[species].coords, @@ -356,21 +356,21 @@ void sub_80318FC(struct Pokemon *pkmn, u8 b) gUnknown_081FAF4C[var], species, r7); - paletteOffset = 0x100 + b * 16; - if (ewram17800[b].unk2 == 0) + paletteOffset = 0x100 + bank * 16; + if (ewram17800[bank].transformedSpecies == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 0x20); - LoadPalette(ewram, 0x80 + b * 16, 0x20); + LoadPalette(ewram, 0x80 + bank * 16, 0x20); if (species == SPECIES_CASTFORM) { - paletteOffset = 0x100 + b * 16; + paletteOffset = 0x100 + bank * 16; sub_800D238(lzPaletteData, ewram + 0x16400); - LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); + LoadPalette(ewram + 0x16400 + gBattleMonForms[bank] * 32, paletteOffset, 0x20); } - if (ewram17800[b].unk2 != 0) + if (ewram17800[bank].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); @@ -405,11 +405,11 @@ void sub_8031A6C(u16 a, u8 b) LoadCompressedObjectPalette(&gTrainerFrontPicPaletteTable[a]); } -void sub_8031AF4(u16 a, u8 b) +void LoadPlayerTrainerBankSprite(u16 a, u8 bank) { u8 status; - status = GetBankIdentity(b); + status = GetBankIdentity(bank); DecompressPicFromTable_2( &gTrainerBackPicTable[a], gTrainerBackPicCoords[a].coords, @@ -417,7 +417,7 @@ void sub_8031AF4(u16 a, u8 b) (void *)0x02000000, gUnknown_081FAF4C[status], 0); - LoadCompressedPalette(gTrainerBackPicPaletteTable[a].data, 0x100 + b * 16, 32); + LoadCompressedPalette(gTrainerBackPicPaletteTable[a].data, 0x100 + bank * 16, 32); } void nullsub_10(int unused) @@ -615,7 +615,7 @@ void sub_8031F88(u8 a) ewram17800[a].unk0_0 = gSprites[gObjectBankIDs[a]].invisible; } -void sub_8031FC4(u8 a, u8 b, bool8 c) +void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) { u16 paletteOffset; u16 species; @@ -626,16 +626,16 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) if (c) { - StartSpriteAnim(&gSprites[gObjectBankIDs[a]], ewram17840.unk0); - paletteOffset = 0x100 + a * 16; + StartSpriteAnim(&gSprites[gObjectBankIDs[bank1]], ewram17840.unk0); + paletteOffset = 0x100 + bank1 * 16; LoadPalette(ewram + 0x16400 + ewram17840.unk0 * 32, paletteOffset, 32); - gBattleMonForms[a] = ewram17840.unk0; - if (ewram17800[a].unk2 != 0) + gBattleMonForms[bank1] = ewram17840.unk0; + if (ewram17800[bank1].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); } - gSprites[gObjectBankIDs[a]].pos1.y = sub_8077F68(a); + gSprites[gObjectBankIDs[bank1]].pos1.y = sub_8077F68(bank1); } else { @@ -659,15 +659,15 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) } else { - r10 = GetBankIdentity(a); - if (GetBankSide(b) == 1) - species = GetMonData(&gEnemyParty[gBattlePartyID[b]], MON_DATA_SPECIES); + r10 = GetBankIdentity(bank1); + if (GetBankSide(bank2) == 1) + species = GetMonData(&gEnemyParty[gBattlePartyID[bank2]], MON_DATA_SPECIES); else - species = GetMonData(&gPlayerParty[gBattlePartyID[b]], MON_DATA_SPECIES); - if (GetBankSide(a) == 0) + species = GetMonData(&gPlayerParty[gBattlePartyID[bank2]], MON_DATA_SPECIES); + if (GetBankSide(bank1) == 0) { - personalityValue = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_OT_ID); + personalityValue = GetMonData(&gPlayerParty[gBattlePartyID[bank1]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlePartyID[bank1]], MON_DATA_OT_ID); HandleLoadSpecialPokePic( &gMonBackPicTable[species], gMonBackPicCoords[species].coords, @@ -675,12 +675,12 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) 0x02000000, gUnknown_081FAF4C[r10], species, - gPID_perBank[a]); + gPID_perBank[bank1]); } else { - personalityValue = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_OT_ID); + personalityValue = GetMonData(&gEnemyParty[gBattlePartyID[bank1]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlePartyID[bank1]], MON_DATA_OT_ID); HandleLoadSpecialPokePic( &gMonFrontPicTable[species], gMonFrontPicCoords[species].coords, @@ -688,13 +688,13 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) 0x02000000, gUnknown_081FAF4C[r10], species, - gPID_perBank[a]); + gPID_perBank[bank1]); } } src = gUnknown_081FAF4C[r10]; - dst = (void *)(VRAM + 0x10000 + gSprites[gObjectBankIDs[a]].oam.tileNum * 32); + dst = (void *)(VRAM + 0x10000 + gSprites[gObjectBankIDs[bank1]].oam.tileNum * 32); DmaCopy32(3, src, dst, 0x800); - paletteOffset = 0x100 + a * 16; + paletteOffset = 0x100 + bank1 * 16; lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 32); @@ -703,21 +703,21 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) u16 *paletteSrc = (u16 *)(ewram + 0x16400); sub_800D238(lzPaletteData, paletteSrc); - LoadPalette(paletteSrc + gBattleMonForms[b] * 16, paletteOffset, 32); + LoadPalette(paletteSrc + gBattleMonForms[bank2] * 16, paletteOffset, 32); } BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); if (!IsContest()) { - ewram17800[a].unk2 = species; - gBattleMonForms[a] = gBattleMonForms[b]; + ewram17800[bank1].transformedSpecies = species; + gBattleMonForms[bank1] = gBattleMonForms[bank2]; } - gSprites[gObjectBankIDs[a]].pos1.y = sub_8077F68(a); - StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); + gSprites[gObjectBankIDs[bank1]].pos1.y = sub_8077F68(bank1); + StartSpriteAnim(&gSprites[gObjectBankIDs[bank1]], gBattleMonForms[bank1]); } } -void sub_8032350(u8 a, u8 b) +void BattleLoadSubstituteSprite(u8 a, u8 b) { u8 r4; u16 foo; @@ -750,16 +750,16 @@ void sub_8032350(u8 a, u8 b) if (!IsContest()) { if (GetBankSide(a) != 0) - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); else - sub_80318FC(&gPlayerParty[gBattlePartyID[a]], a); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[a]], a); } } } void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) { - sub_8032350(a, b); + BattleLoadSubstituteSprite(a, b); StartSpriteAnim(&gSprites[spriteId], gBattleMonForms[a]); if (b == 0) gSprites[spriteId].pos1.y = sub_8077F7C(a); @@ -770,12 +770,12 @@ void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) void sub_80324BC(u8 a, u16 b) { if (b == 0xA4) - ewram17800[a].unk0_2 = 1; + ewram17800[a].substituteSprite = 1; } void sub_80324E0(u8 a) { - ewram17800[a].unk0_2 = 0; + ewram17800[a].substituteSprite = 0; } void sub_80324F8(struct Pokemon *pkmn, u8 b) @@ -896,9 +896,9 @@ void sub_80328A4(struct Sprite *sprite) } if (gAnimScriptActive || r7->invisible) invisible = TRUE; - else if (ewram17800[r4].unk2 != 0 && gEnemyMonElevation[ewram17800[r4].unk2] == 0) + else if (ewram17800[r4].transformedSpecies != 0 && gEnemyMonElevation[ewram17800[r4].transformedSpecies] == 0) invisible = TRUE; - if (ewram17800[r4].unk0_2) + if (ewram17800[r4].substituteSprite) invisible = TRUE; sprite->pos1.x = r7->pos1.x; sprite->pos2.x = r7->pos2.x; @@ -914,8 +914,8 @@ void sub_8032984(u8 a, u16 b) { if (GetBankSide(a) != 0) { - if (ewram17800[a].unk2 != 0) - b = ewram17800[a].unk2; + if (ewram17800[a].transformedSpecies != 0) + b = ewram17800[a].transformedSpecies; if (gEnemyMonElevation[b] != 0) gSprites[ewram17810[a].unk7].callback = sub_80328A4; else @@ -953,7 +953,7 @@ void sub_8032A38(void) void sub_8032AA8(u8 a, u8 b) { - ewram17800[a].unk2 = 0; + ewram17800[a].transformedSpecies = 0; gBattleMonForms[a] = 0; if (b == 0) sub_80324E0(a); @@ -1168,7 +1168,7 @@ void sub_8033264(void) { if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_80332D0; } diff --git a/src/battle_8.c b/src/battle_8.c index 75f10c4b1..6d17ecd28 100644 --- a/src/battle_8.c +++ b/src/battle_8.c @@ -58,7 +58,7 @@ extern u8 sub_8077ABC(); extern u8 sub_8077F68(); extern u8 sub_8079E90(); extern void sub_8033018(void); -extern void sub_8031794(); +extern void BattleLoadOpponentMonSprite(); extern u8 GetBankIdentity(u8); extern void sub_8032984(u8, u16); extern void sub_80333D4(void); @@ -714,7 +714,7 @@ void OpponentHandleLoadPokeSprite(void) { u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -746,7 +746,7 @@ void sub_803495C(u8 a, u8 b) gBattlePartyID[a] = gBattleBufferA[a][1]; species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); gObjectBankIDs[a] = CreateSprite( &gUnknown_02024E8C, diff --git a/src/battle_811DA74.c b/src/battle_811DA74.c index 36a287efc..47ae8246f 100644 --- a/src/battle_811DA74.c +++ b/src/battle_811DA74.c @@ -87,12 +87,12 @@ extern void oamt_set_x3A_32(); extern void sub_8078B34(struct Sprite *); extern void sub_80105EC(struct Sprite *); extern s32 sub_803FC34(u16); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern void sub_80313A0(struct Sprite *); extern u8 sub_8046400(); extern void sub_80312F0(struct Sprite *); extern u8 CreateInvisibleSpriteWithCallback(); -extern void sub_80318FC(); +extern void BattleLoadPlayerMonSprite(); extern u8 sub_8077ABC(); extern u8 sub_8077F68(); extern u8 sub_8079E90(); @@ -989,7 +989,7 @@ void sub_811F664(void) void sub_811F6D8(void) { - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C( GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), GetBankIdentity(gActiveBank)); @@ -1009,7 +1009,7 @@ void sub_811F7F4(void) { sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_811F864(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattleBankFunc[gActiveBank] = sub_811E1BC; } @@ -1092,7 +1092,7 @@ void sub_811FAE4(void) xOffset = 0; gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; } - sub_8031AF4(gender, gActiveBank); + LoadPlayerTrainerBankSprite(gender, gActiveBank); GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1508,7 +1508,7 @@ void sub_812071C(u8 taskId) sub_811F864(gActiveBank, 0); gActiveBank ^= 2; gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_811F864(gActiveBank, 0); gActiveBank ^= 2; } diff --git a/src/battle_anim_8137220.c b/src/battle_anim_8137220.c index bb181d5fb..8d323736a 100644 --- a/src/battle_anim_8137220.c +++ b/src/battle_anim_8137220.c @@ -73,7 +73,7 @@ extern void sub_8043DFC(); extern bool8 IsDoubleBattle(void); extern void c3_0802FDF4(u8); extern void sub_802ECF0(void); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern u8 GetBankIdentity(u8); extern void sub_80313A0(struct Sprite *); extern u8 GetBankByPlayerAI(u8); @@ -981,7 +981,7 @@ void sub_8138CB4(void) void sub_8138D38(void) { - sub_8031AF4(2, gActiveBank); + LoadPlayerTrainerBankSprite(2, gActiveBank); GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -996,7 +996,7 @@ void sub_8138D38(void) void sub_8138E04(void) { - sub_8031AF4(2, gActiveBank); + LoadPlayerTrainerBankSprite(2, gActiveBank); GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c new file mode 100644 index 000000000..6643ba4b2 --- /dev/null +++ b/src/reshow_battle_screen.c @@ -0,0 +1,262 @@ +#include "global.h" +#include "battle.h" +#include "palette.h" +#include "main.h" +#include "unknown_task.h" +#include "text.h" +#include "rom_8077ABC.h" + +extern struct Window gUnknown_03004210; +extern u16 gUnknown_03004280; +extern u16 gUnknown_03004288; +extern u16 gUnknown_030042A4; +extern u16 gUnknown_030042C0; +extern u16 gUnknown_030041B0; +extern u16 gUnknown_030041B4; +extern u16 gUnknown_030041B8; +extern u16 gUnknown_030042A0; +extern u8 gReservedSpritePaletteCount; +extern u8 gActionSelectionCursor[4]; +extern u8 gBankInMenu; +extern u16 gBattlePartyID[4]; +extern u8 gNoOfAllBanks; +extern u16 gBattleTypeFlags; +extern u8 gObjectBankIDs[4]; + +bool8 sub_800E414(u8 a0); +bool8 sub_8031C30(u8 a0); +void sub_8031EE8(void); +void sub_80327CC(void); +void sub_8032984(u8 a, u16 b); +void sub_800FCD4(void); +void BattleLoadOpponentMonSprite(struct Pokemon *, u8 bank); +void BattleLoadPlayerMonSprite(struct Pokemon *, u8 bank); +void BattleLoadSubstituteSprite(u8 bank, u8 b); +void LoadPlayerTrainerBankSprite(u16 a0, u8 bank); +u8 sub_8077F7C(u8 bank); +u8 sub_8077F68(u8 bank); + +// this file's functions +static void CB2_ReshowBattleScreenAfterMenu(void); +static bool8 LoadAppropiateBankSprite(u8 bank); +void sub_807B184(u8 bank); +void sub_807B508(u8 bank); +void sub_807B06C(void); + +#define RESHOW_STATE 0x1FFFF +#define HELPER_STATE 0x1FFFE + +struct BGCNT +{ + u16 priority : 2; + u16 charBaseBlock : 2; + u16 reserved : 2; + u16 mosaic : 1; + u16 colors : 1; + u16 screenBaseBlock : 5; + u16 screenSize : 2; +}; + +void nullsub_14(void) +{ + +} + +void ReshowBattleScreenAfterMenu(void) +{ + gPaletteFade.bufferTransferDisabled = 1; + SetHBlankCallback(0); + SetVBlankCallback(0); + REG_MOSAIC = 0; + ewram[RESHOW_STATE] = 0; + ewram[HELPER_STATE] = 0; + SetMainCallback2(CB2_ReshowBattleScreenAfterMenu); +} + +static void CB2_ReshowBattleScreenAfterMenu(void) +{ + switch (ewram[RESHOW_STATE]) + { + case 0: + dp12_8087EA4(); + SetUpWindowConfig(&gWindowConfig_81E6C58); + ResetPaletteFade(); + InitWindowFromConfig(&gUnknown_03004210, &gWindowConfig_81E6C58); + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + gUnknown_030042C0 = 0; + gUnknown_030041B4 = 0; + gUnknown_03004288 = 0; + gUnknown_03004280 = 0; + gUnknown_030041B0 = 0; + gUnknown_030041B8 = 0; + break; + case 1: + { + const u32 zero = 0; + CpuFastSet(&zero, (void*) VRAM, 0x1006000); + } + break; + case 2: + if (!sub_800E414(ewram[HELPER_STATE])) + { + ewram[HELPER_STATE]++; + ewram[RESHOW_STATE]--; + } + else + ewram[HELPER_STATE] = 0; + break; + case 3: + ResetSpriteData(); + break; + case 4: + FreeAllSpritePalettes(); + gReservedSpritePaletteCount = 4; + break; + case 5: + sub_8031EE8(); + break; + case 6: + if (sub_8031C30(ewram[HELPER_STATE])) + ewram[HELPER_STATE] = 0; + else + { + ewram[HELPER_STATE]++; + ewram[RESHOW_STATE]--; + } + break; + case 7: + if (!LoadAppropiateBankSprite(0)) + ewram[RESHOW_STATE]--; + break; + case 8: + if (!LoadAppropiateBankSprite(1)) + ewram[RESHOW_STATE]--; + break; + case 9: + if (!LoadAppropiateBankSprite(2)) + ewram[RESHOW_STATE]--; + break; + case 10: + if (!LoadAppropiateBankSprite(3)) + ewram[RESHOW_STATE]--; + break; + case 11: + sub_807B184(0); + break; + case 12: + sub_807B184(1); + break; + case 13: + sub_807B184(2); + break; + case 14: + sub_807B184(3); + break; + case 15: + sub_807B508(0); + break; + case 16: + sub_807B508(1); + break; + case 17: + sub_807B508(2); + break; + case 18: + sub_807B508(3); + break; + case 19: + { + u8 opponentBank; + u16 species; + + sub_80327CC(); + + opponentBank = GetBankByPlayerAI(1); + species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES); + sub_8032984(opponentBank, species); + + if (IsDoubleBattle()) + { + opponentBank = GetBankByPlayerAI(3); + species = GetMonData(&gEnemyParty[gBattlePartyID[opponentBank]], MON_DATA_SPECIES); + sub_8032984(opponentBank, species); + } + sub_802E3E4(gActionSelectionCursor[gBankInMenu], 0); + } + break; + default: + SetHBlankCallback(sub_800FCD4); + SetVBlankCallback(sub_800FCFC); + sub_807B06C(); + BeginHardwarePaletteFade(0xFF, 0, 0x10, 0, 1); + gPaletteFade.bufferTransferDisabled = 0; + SetMainCallback2(sub_800F808); + break; + } + ewram[RESHOW_STATE]++; +} + +void sub_807B06C(void) +{ + struct BGCNT *regBgcnt1, *regBgcnt2; + + sub_800D6D4(); + + regBgcnt1 = (void*)(®_BG1CNT); + regBgcnt1->charBaseBlock = 0; + + regBgcnt2 = (void*)(®_BG2CNT); + regBgcnt2->charBaseBlock = 0; +} + +static bool8 LoadAppropiateBankSprite(u8 bank) +{ + if (bank < gNoOfAllBanks) + { + if (GetBankSide(bank)) + { + if (!ewram17800[bank].substituteSprite) + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[bank]], bank); + else + BattleLoadSubstituteSprite(bank, 0); + } + else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0) + LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, 0); + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0) + LoadPlayerTrainerBankSprite(2, 0); + else if (!ewram17800[bank].substituteSprite) + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[bank]], bank); + else + BattleLoadSubstituteSprite(bank, 0); + + ewram[HELPER_STATE] = 0; + } + return 1; +} + +void sub_807B184(u8 bank) +{ + if (bank < gNoOfAllBanks) + { + u16 species; + s16 posX, posY; + u8 subpriority; + + if (ewram17800[bank].substituteSprite) + posY = sub_8077F7C(); + else + posY = sub_8077F68(); + if (GetBankSide(bank)) + { + if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP)) + { + species = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); + posX = sub_8077ABC(bank); + subpriority = sub_8079E90(bank); + gObjectBankIDs[] = todo; + } + } + } +} -- cgit v1.2.3 From 78027fb38d7a9cd25bbbb765b88915d7b63f4839 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 23 Aug 2017 23:04:00 +0200 Subject: reshow battle screen is decompiled --- src/battle_10.c | 8 ++-- src/battle_2.c | 4 +- src/battle_6.c | 8 ++-- src/battle_7.c | 4 +- src/battle_8.c | 8 ++-- src/battle_811DA74.c | 10 ++--- src/battle_anim_8137220.c | 6 +-- src/reshow_battle_screen.c | 106 +++++++++++++++++++++++++++++++++++++++------ 8 files changed, 117 insertions(+), 37 deletions(-) (limited to 'src') diff --git a/src/battle_10.c b/src/battle_10.c index c2053a5d1..1a01e5383 100644 --- a/src/battle_10.c +++ b/src/battle_10.c @@ -765,7 +765,7 @@ void sub_8039648(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -834,7 +834,7 @@ void sub_803995C(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -909,7 +909,7 @@ void sub_8039B64(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -929,7 +929,7 @@ void sub_8039B64(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_2.c b/src/battle_2.c index 7772444d7..bdd908ea5 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -1347,8 +1347,8 @@ void sub_8010384(struct Sprite *sprite) u16 species; u8 yOffset; - if (ewram17800[r6].unk2 != 0) - species = ewram17800[r6].unk2; + if (ewram17800[r6].transformedSpecies != 0) + species = ewram17800[r6].transformedSpecies; else species = sprite->data2; diff --git a/src/battle_6.c b/src/battle_6.c index 6fa0e3948..e7f152a4b 100644 --- a/src/battle_6.c +++ b/src/battle_6.c @@ -800,7 +800,7 @@ void sub_802FB2C(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -875,7 +875,7 @@ void sub_802FE7C(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -963,7 +963,7 @@ void sub_8030190(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 == 1 && ewram17800[gActiveBank].unk0_3 == 0) + if (ewram17800[gActiveBank].substituteSprite == 1 && ewram17800[gActiveBank].unk0_3 == 0) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -983,7 +983,7 @@ void sub_8030190(void) if (!gAnimScriptActive) { sub_80326EC(1); - if (ewram17800[gActiveBank].unk0_2 == 1 && r7 < 2) + if (ewram17800[gActiveBank].substituteSprite == 1 && r7 < 2) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_7.c b/src/battle_7.c index 8c5f5f45d..0c4b118b4 100644 --- a/src/battle_7.c +++ b/src/battle_7.c @@ -607,12 +607,12 @@ void sub_8031F24(void) s32 i; for (i = 0; i < gNoOfAllBanks; i++) - ewram17800[i].unk0_0 = gSprites[gObjectBankIDs[i]].invisible; + ewram17800[i].invisible = gSprites[gObjectBankIDs[i]].invisible; } void sub_8031F88(u8 a) { - ewram17800[a].unk0_0 = gSprites[gObjectBankIDs[a]].invisible; + ewram17800[a].invisible = gSprites[gObjectBankIDs[a]].invisible; } void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) diff --git a/src/battle_8.c b/src/battle_8.c index 6d17ecd28..44e42d0d6 100644 --- a/src/battle_8.c +++ b/src/battle_8.c @@ -785,7 +785,7 @@ void sub_8034B74(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -876,7 +876,7 @@ void sub_8035030(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -951,7 +951,7 @@ void sub_8035238(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -971,7 +971,7 @@ void sub_8035238(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_811DA74.c b/src/battle_811DA74.c index 47ae8246f..14f547b82 100644 --- a/src/battle_811DA74.c +++ b/src/battle_811DA74.c @@ -298,7 +298,7 @@ void sub_811E034(void) { if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_811E0A0; } @@ -1059,7 +1059,7 @@ void sub_811FA5C(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -1125,7 +1125,7 @@ void sub_811FCE8(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -1200,7 +1200,7 @@ void sub_811FF30(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -1220,7 +1220,7 @@ void sub_811FF30(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_anim_8137220.c b/src/battle_anim_8137220.c index 8d323736a..af2b86c17 100644 --- a/src/battle_anim_8137220.c +++ b/src/battle_anim_8137220.c @@ -1081,7 +1081,7 @@ void sub_81390D0(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 == 1) + if (ewram17800[gActiveBank].substituteSprite == 1) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -1098,7 +1098,7 @@ void sub_81390D0(void) if (!gAnimScriptActive) { sub_80326EC(1); - if (ewram17800[gActiveBank].unk0_2 == 1) + if (ewram17800[gActiveBank].substituteSprite == 1) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17810[gActiveBank].unk4 = 3; } @@ -1382,7 +1382,7 @@ void sub_81398BC(u8 bank) { u16 species; - ewram17800[bank].unk2 = 0; + ewram17800[bank].transformedSpecies = 0; gBattlePartyID[bank] = gBattleBufferA[bank][1]; species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c index 6643ba4b2..1ed5da7d3 100644 --- a/src/reshow_battle_screen.c +++ b/src/reshow_battle_screen.c @@ -5,7 +5,9 @@ #include "unknown_task.h" #include "text.h" #include "rom_8077ABC.h" +#include "data2.h" +extern struct SpriteTemplate gUnknown_02024E8C; extern struct Window gUnknown_03004210; extern u16 gUnknown_03004280; extern u16 gUnknown_03004288; @@ -22,6 +24,8 @@ extern u16 gBattlePartyID[4]; extern u8 gNoOfAllBanks; extern u16 gBattleTypeFlags; extern u8 gObjectBankIDs[4]; +extern u8 gBattleMonForms[4]; +extern u8 gHealthboxIDs[4]; bool8 sub_800E414(u8 a0); bool8 sub_8031C30(u8 a0); @@ -35,6 +39,13 @@ void BattleLoadSubstituteSprite(u8 bank, u8 b); void LoadPlayerTrainerBankSprite(u16 a0, u8 bank); u8 sub_8077F7C(u8 bank); u8 sub_8077F68(u8 bank); +void nullsub_11(u8 healthboxID, u8 a1); +void sub_8043DB0(u8 bank); +u8 battle_make_oam_normal_battle(u8 bank); +u8 battle_make_oam_safari_battle(void); +void sub_8045A5C(u8 healthboxID, struct Pokemon*, u8); +void sub_8043F44(u8 bank); +void sub_8043DFC(u8 healthboxID); // this file's functions static void CB2_ReshowBattleScreenAfterMenu(void); @@ -239,24 +250,93 @@ void sub_807B184(u8 bank) { if (bank < gNoOfAllBanks) { - u16 species; - s16 posX, posY; - u8 subpriority; + u8 posY; if (ewram17800[bank].substituteSprite) - posY = sub_8077F7C(); + posY = sub_8077F7C(bank); else - posY = sub_8077F68(); + posY = sub_8077F68(bank); if (GetBankSide(bank)) { - if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP)) - { - species = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); - posX = sub_8077ABC(bank); - subpriority = sub_8079E90(bank); - gObjectBankIDs[] = todo; - } + if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0) + return; + GetMonSpriteTemplate_803C56C(GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank)); + gObjectBankIDs[bank] = CreateSprite(&gUnknown_02024E8C, sub_8077ABC(bank, 2), posY, sub_8079E90(bank)); + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gObjectBankIDs[bank]].data0 = bank; + gSprites[gObjectBankIDs[bank]].data2 = GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); + } + else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0) + { + GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(0)); + gObjectBankIDs[bank] = CreateSprite(&gUnknown_02024E8C, 0x50, + (8 - gTrainerBackPicCoords[gSaveBlock2.playerGender].coords) * 4 + 80, + sub_8079E90(0)); + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gObjectBankIDs[bank]].data0 = bank; + } + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0) + { + GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(0)); + gObjectBankIDs[bank] = CreateSprite(&gUnknown_02024E8C, 0x50, + (8 - gTrainerBackPicCoords[2].coords) * 4 + 80, + sub_8079E90(0)); + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gObjectBankIDs[bank]].data0 = bank; + } + else + { + if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0) + return; + GetMonSpriteTemplate_803C56C(GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES), GetBankIdentity(bank)); + gObjectBankIDs[bank] = CreateSprite(&gUnknown_02024E8C, sub_8077ABC(bank, 2), posY, sub_8079E90(bank)); + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gObjectBankIDs[bank]].data0 = bank; + gSprites[gObjectBankIDs[bank]].data2 = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); + } + gSprites[gObjectBankIDs[bank]].invisible = ewram17800[bank].invisible; + } +} + +void sub_807B508(u8 bank) +{ + if (bank < gNoOfAllBanks) + { + u8 healthboxID; + if (gBattleTypeFlags & BATTLE_TYPE_SAFARI && bank == 0) + healthboxID = battle_make_oam_safari_battle(); + else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL && bank == 0) + return; + else + healthboxID = battle_make_oam_normal_battle(bank); + gHealthboxIDs[bank] = healthboxID; + sub_8043F44(bank); + sub_8043DFC(healthboxID); + if (GetBankSide(bank)) + sub_8045A5C(gHealthboxIDs[bank], &gEnemyParty[gBattlePartyID[bank]], 0); + else if (gBattleTypeFlags & BATTLE_TYPE_SAFARI) + sub_8045A5C(gHealthboxIDs[bank], &gPlayerParty[gBattlePartyID[bank]], 10); + else + sub_8045A5C(gHealthboxIDs[bank], &gPlayerParty[gBattlePartyID[bank]], 0); + if (GetBankIdentity(bank) == 3 || GetBankIdentity(bank) == 2) + nullsub_11(gHealthboxIDs[bank], 1); + else + nullsub_11(gHealthboxIDs[bank], 0); + if (GetBankSide(bank)) + { + if (GetMonData(&gEnemyParty[gBattlePartyID[bank]], MON_DATA_HP) == 0) + sub_8043DB0(healthboxID); + } + else if (!(gBattleTypeFlags & BATTLE_TYPE_SAFARI)) + { + if (GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_HP) == 0) + sub_8043DB0(healthboxID); } } } -- cgit v1.2.3 From 79ae2bac1e970ddc5828092f7f9ffee094b50220 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Wed, 23 Aug 2017 23:23:06 +0200 Subject: reuse struct, static and make it compile --- src/battle_5.c | 2 +- src/reshow_battle_screen.c | 26 ++++++++------------------ 2 files changed, 9 insertions(+), 19 deletions(-) (limited to 'src') diff --git a/src/battle_5.c b/src/battle_5.c index c54caae92..5972c0cb1 100644 --- a/src/battle_5.c +++ b/src/battle_5.c @@ -943,7 +943,7 @@ void sub_802D680(void) ewram17810[gActiveBank].unk1_0 = 0; FreeSpriteTilesByTag(0x27F9); FreeSpritePaletteByTag(0x27F9); - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_802D730; } diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c index 1ed5da7d3..202431ae9 100644 --- a/src/reshow_battle_screen.c +++ b/src/reshow_battle_screen.c @@ -1,5 +1,6 @@ #include "global.h" #include "battle.h" +#include "battle_anim.h" #include "palette.h" #include "main.h" #include "unknown_task.h" @@ -50,24 +51,13 @@ void sub_8043DFC(u8 healthboxID); // this file's functions static void CB2_ReshowBattleScreenAfterMenu(void); static bool8 LoadAppropiateBankSprite(u8 bank); -void sub_807B184(u8 bank); -void sub_807B508(u8 bank); -void sub_807B06C(void); +static void sub_807B184(u8 bank); +static void sub_807B508(u8 bank); +static void sub_807B06C(void); #define RESHOW_STATE 0x1FFFF #define HELPER_STATE 0x1FFFE -struct BGCNT -{ - u16 priority : 2; - u16 charBaseBlock : 2; - u16 reserved : 2; - u16 mosaic : 1; - u16 colors : 1; - u16 screenBaseBlock : 5; - u16 screenSize : 2; -}; - void nullsub_14(void) { @@ -208,9 +198,9 @@ static void CB2_ReshowBattleScreenAfterMenu(void) ewram[RESHOW_STATE]++; } -void sub_807B06C(void) +static void sub_807B06C(void) { - struct BGCNT *regBgcnt1, *regBgcnt2; + struct BGCntrlBitfield *regBgcnt1, *regBgcnt2; sub_800D6D4(); @@ -246,7 +236,7 @@ static bool8 LoadAppropiateBankSprite(u8 bank) return 1; } -void sub_807B184(u8 bank) +static void sub_807B184(u8 bank) { if (bank < gNoOfAllBanks) { @@ -304,7 +294,7 @@ void sub_807B184(u8 bank) } } -void sub_807B508(u8 bank) +static void sub_807B508(u8 bank) { if (bank < gNoOfAllBanks) { -- cgit v1.2.3 From f325f2d9ca2c40ed5a728fa4bea585e3bd71ca81 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Thu, 24 Aug 2017 02:13:07 -0400 Subject: decompile up to sub_80B3A70 --- src/money.c | 2 +- src/shop.c | 179 ++++++++++++++++++++++++++++++++++++++++++++++-------------- 2 files changed, 140 insertions(+), 41 deletions(-) (limited to 'src') diff --git a/src/money.c b/src/money.c index 5d9d0b689..67b7eb03f 100644 --- a/src/money.c +++ b/src/money.c @@ -148,7 +148,7 @@ void sub_80B7AEC(u32 arg0, u8 left, u8 top) } __attribute__((naked)) -void sub_80B7B34(void) +void sub_80B7B34(u8 var1, u8 var2, int var3) { asm(".syntax unified\n\ push {r4-r7,lr}\n\ diff --git a/src/shop.c b/src/shop.c index aca48cc2e..91d84363e 100644 --- a/src/shop.c +++ b/src/shop.c @@ -20,23 +20,27 @@ #include "field_player_avatar.h" #include "fieldmap.h" #include "item.h" +#include "decoration.h" -extern void sub_80B39D0(int, int, int); -extern void sub_80B3A70(void); +enum +{ + MART_TYPE_0, // normal mart + MART_TYPE_1, + MART_TYPE_2, +}; -struct UnknownShopStruct +struct MartInfo { /* 0x0 */ void (* callback) (void); /* 0x4 */ u16 *itemList; /* 0x8 */ u8 itemCount; /* 0x9 */ u8 cursor; - /* 0xA */ u8 unkA; - /* 0xB */ u8 unkB; - /* 0xC */ bool8 unkC; - // unknown size + /* 0xA */ u8 numChoices; + /* 0xB */ u8 choicesAbove; + /* 0xC */ u8 martType; }; -extern struct UnknownShopStruct gUnknown_03000708; +extern struct MartInfo gMartInfo; extern struct MenuAction gUnknown_083CC6D0[]; extern u8 ewram[]; @@ -63,44 +67,47 @@ extern u16 gBuyMenuFrame_Tilemap[]; extern u16 gMenuMoneyPal[16]; extern u16 gUnknown_083CC710[2]; -u8 CreateShopMenu(bool8 var) +void sub_80B39D0(int var1, int var2, bool32 hasControlCode); +void sub_80B3A70(void); + +u8 CreateShopMenu(u8 martType) { ScriptContext2_Enable(); - gUnknown_03000708.unkC = var; - gUnknown_03000708.cursor = 0; + gMartInfo.martType = martType; + gMartInfo.cursor = 0; - if(var == FALSE) + if(martType == MART_TYPE_0) { - gUnknown_03000708.unkA = 2; + gMartInfo.numChoices = 2; MenuDrawTextWindow(0, 0, 10, 7); PrintMenuItemsReordered(1, 1, 3, gUnknown_083CC6D0, (u8 *)gUnknown_083CC6E8); } else { - gUnknown_03000708.unkA = 1; + gMartInfo.numChoices = 1; MenuDrawTextWindow(0, 0, 10, 5); PrintMenuItemsReordered(1, 1, 2, gUnknown_083CC6D0, (u8 *)gUnknown_083CC6EB); } - InitMenu(0, 1, 1, gUnknown_03000708.unkA + 1, 0, 9); + InitMenu(0, 1, 1, gMartInfo.numChoices + 1, 0, 9); // add 1 for cancel return CreateTask(sub_80B2E38, 8); } void SetShopMenuCallback(void *callbackPtr) { - gUnknown_03000708.callback = callbackPtr; + gMartInfo.callback = callbackPtr; } void SetShopItemsForSale(u16 *items) { u16 i = 0; - gUnknown_03000708.itemList = items; - gUnknown_03000708.itemCount = 0; + gMartInfo.itemList = items; + gMartInfo.itemCount = 0; - while (gUnknown_03000708.itemList[i]) + while (gMartInfo.itemList[i]) { - gUnknown_03000708.itemCount++; + gMartInfo.itemCount++; i++; } } @@ -111,30 +118,30 @@ void sub_80B2E38(u8 var) if(gMain.newAndRepeatedKeys & DPAD_UP) { - if(gUnknown_03000708.cursor) // can move cursor up? + if(gMartInfo.cursor) // can move cursor up? { PlaySE(0x5); - gUnknown_03000708.cursor = MoveMenuCursor(-1); + gMartInfo.cursor = MoveMenuCursor(-1); } } else if(gMain.newAndRepeatedKeys & DPAD_DOWN) { - if(gUnknown_03000708.cursor != gUnknown_03000708.unkA) // can move cursor down? + if(gMartInfo.cursor != gMartInfo.numChoices) // can move cursor down? { PlaySE(0x5); - gUnknown_03000708.cursor = MoveMenuCursor(1); + gMartInfo.cursor = MoveMenuCursor(1); } } else if (gMain.newKeys & A_BUTTON) { PlaySE(0x5); - if(!gUnknown_03000708.unkC) + if(gMartInfo.martType == MART_TYPE_0) { - gUnknown_083CC6D0[gUnknown_083CC6E8[gUnknown_03000708.cursor]].func(local); + gUnknown_083CC6D0[gUnknown_083CC6E8[gMartInfo.cursor]].func(local); } else { - gUnknown_083CC6D0[gUnknown_083CC6EB[gUnknown_03000708.cursor]].func(local); + gUnknown_083CC6D0[gUnknown_083CC6EB[gMartInfo.cursor]].func(local); } } else if(gMain.newKeys & B_BUTTON) @@ -164,12 +171,12 @@ void HandleShopMenuQuit(u8 taskId) { HandleDestroyMenuCursors(); MenuZeroFillWindowRect(0, 0, 11, 8); - sub_80BE3BC(); // in tv.s? + sub_80BE3BC(); ScriptContext2_Disable(); DestroyTask(taskId); - if(gUnknown_03000708.callback) - gUnknown_03000708.callback(); // run the callback if it exists. + if(gMartInfo.callback) + gMartInfo.callback(); // run the callback if it exists. } void sub_80B2FA0(u8 taskId) @@ -183,7 +190,7 @@ void sub_80B2FA0(u8 taskId) void ReturnToShopMenuAfterExitingSellMenu(u8 taskId) { - CreateShopMenu(gUnknown_03000708.unkC); + CreateShopMenu(gMartInfo.martType); DestroyTask(taskId); } @@ -191,7 +198,7 @@ void Task_ExitSellMenu(u8 taskId) { if(sub_807D770() == 1) { - if(gUnknown_03000708.unkC == 2) + if(gMartInfo.martType == MART_TYPE_2) DisplayItemMessageOnField(taskId, gOtherText_CanIHelpYou, ReturnToShopMenuAfterExitingSellMenu, 0); else DisplayItemMessageOnField(taskId, gOtherText_AnythingElse, ReturnToShopMenuAfterExitingSellMenu, 0); @@ -276,8 +283,8 @@ void BuyMenuDrawGraphics(void) SetUpWindowConfig(&gWindowConfig_81E6DFC); InitMenuWindow(&gWindowConfig_81E6DFC); BuyMenuDrawMapGraphics(); - gUnknown_03000708.cursor = zero; - gUnknown_03000708.unkB = zero2; + gMartInfo.cursor = zero; + gMartInfo.choicesAbove = zero2; MenuZeroFillWindowRect(0, 0, 0x20, 0x20); sub_80B7C14(gSaveBlock1.money, 0, 0); sub_80B3764(0, 7); @@ -306,7 +313,7 @@ void sub_80B3270(void) { sub_80F944C(); - if(gUnknown_03000708.itemCount > 7) + if(gMartInfo.itemCount > 7) { CreateVerticalScrollIndicators(0, 172, 12); CreateVerticalScrollIndicators(1, 172, 148); @@ -316,12 +323,12 @@ void sub_80B3270(void) void sub_80B32A4(void) { - if(gUnknown_03000708.unkB == 0) + if(gMartInfo.choicesAbove == 0) sub_80F979C(0, 1); else sub_80F979C(0, 0); - if(gUnknown_03000708.unkB + 7 >= gUnknown_03000708.itemCount) + if(gMartInfo.choicesAbove + 7 >= gMartInfo.itemCount) sub_80F979C(1, 1); else sub_80F979C(1, 0); @@ -493,7 +500,7 @@ void sub_80B3764(int var1, int var2) { sub_80B3720(); sub_80B39D0(var1, var2, 0); - InitMenu(0, 0xE, 0x2, 0x8, gUnknown_03000708.cursor, 0xF); + InitMenu(0, 0xE, 0x2, 0x8, gMartInfo.cursor, 0xF); } void sub_80B379C(void) @@ -512,8 +519,8 @@ void sub_80B37EC(void) void sub_80B37F8(u8 taskId) { - u16 itemListIndex = gUnknown_03000708.unkB + gUnknown_03000708.cursor; - u16 itemId = *(gUnknown_03000708.itemList + itemListIndex); + u16 itemListIndex = gMartInfo.choicesAbove + gMartInfo.cursor; + u16 itemId = *(gMartInfo.itemList + itemListIndex); u32 price = (ItemId_GetPrice(itemId) >> GetPriceReduction(1)); sub_80B7A94(gTasks[taskId].data[1] * price, 6, 6, 11); @@ -524,3 +531,95 @@ void sub_80B37F8(u8 taskId) MenuPrint(gOtherText_xString1, 1, 11); sub_80A3FA0(gBGTilemapBuffers[1], 1, 11, 12, 2, 0xC3E1); } + +void sub_80B389C(u16 itemId, u8 var2, bool32 hasControlCode) +{ + u8 *stringPtr = gStringVar1; + + if(hasControlCode != FALSE) + { + stringPtr[0] = EXT_CTRL_CODE_BEGIN; + stringPtr[1] = 0x1; + stringPtr[2] = 0x2; + stringPtr += 3; + } + + CopyItemName(itemId, stringPtr); + + sub_8072A18(&gStringVar1[0], 0x70, var2 << 3, 0x58, 0x1); + stringPtr = gStringVar1; + + if(hasControlCode != FALSE) + stringPtr = &gStringVar1[3]; + + sub_80B79F8(stringPtr, (ItemId_GetPrice(itemId) >> GetPriceReduction(1)), 0x4); + MenuPrint_PixelCoords(&gStringVar1[0], 0xCA, var2 << 3, 1); +} + +void sub_80B3930(u16 itemId, u8 var2, bool32 hasControlCode) +{ + u8 *stringPtr = gStringVar1; + + if(hasControlCode != FALSE) + { + stringPtr[0] = EXT_CTRL_CODE_BEGIN; + stringPtr[1] = 0x1; + stringPtr[2] = 0x2; + stringPtr += 3; + } + + StringCopy(stringPtr, gDecorations[itemId].name); + sub_8072A18(&gStringVar1[0], 0x70, var2 << 3, 0x58, 0x1); + stringPtr = gStringVar1; + + if(hasControlCode != FALSE) + stringPtr = &gStringVar1[3]; + + if(gDecorations[itemId].price == 10000) + { + sub_80B7B34(0x19, var2, hasControlCode); // huh??? + } + else + { + sub_80B79F8(stringPtr, gDecorations[itemId].price, 0x4); + MenuPrint_PixelCoords(&gStringVar1[0], 0xCA, var2 << 3, 0x1); + } +} + +void sub_80B39D0(int var1, int var2, bool32 hasControlCode) +{ + u8 i; + + for(i = var1; i <= var2 && gMartInfo.choicesAbove + i < gMartInfo.itemCount; i++) + { + if(gMartInfo.martType == MART_TYPE_0) + sub_80B389C(gMartInfo.itemList[gMartInfo.choicesAbove + i], (i << 1) + 2, hasControlCode); + else + sub_80B3930(gMartInfo.itemList[gMartInfo.choicesAbove + i], (i << 1) + 2, hasControlCode); + } + + if(i != 8 && gMartInfo.choicesAbove + i == gMartInfo.itemCount) + { + MenuFillWindowRectWithBlankTile(0xE, (i << 1) + 2, 0x1C, (i << 1) + 3); + MenuPrint(gOtherText_CancelNoTerminator, 0xE, (i << 1) + 2); + } +} + +void sub_80B3A70(void) +{ + if(gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) + { + if(gMartInfo.martType == MART_TYPE_0) + { + sub_8072AB0(ItemId_GetDescription(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]), + 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); + } + else + sub_8072AB0(gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].description, // doesn't consider choicesAbove? + 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); // huh?? + } + else + { + sub_8072AB0(gOtherText_QuitShopping, 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); + } +} -- cgit v1.2.3 From a8432ea708c0e2cf5443ba4286ddece562999ebb Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Thu, 24 Aug 2017 02:25:21 -0400 Subject: whatever cam --- src/shop.c | 62 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 31 insertions(+), 31 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 91d84363e..17cebfee6 100644 --- a/src/shop.c +++ b/src/shop.c @@ -76,7 +76,7 @@ u8 CreateShopMenu(u8 martType) gMartInfo.martType = martType; gMartInfo.cursor = 0; - if(martType == MART_TYPE_0) + if (martType == MART_TYPE_0) { gMartInfo.numChoices = 2; MenuDrawTextWindow(0, 0, 10, 7); @@ -116,17 +116,17 @@ void sub_80B2E38(u8 var) { const u8 local = var; - if(gMain.newAndRepeatedKeys & DPAD_UP) + if (gMain.newAndRepeatedKeys & DPAD_UP) { - if(gMartInfo.cursor) // can move cursor up? + if (gMartInfo.cursor) // can move cursor up? { PlaySE(0x5); gMartInfo.cursor = MoveMenuCursor(-1); } } - else if(gMain.newAndRepeatedKeys & DPAD_DOWN) + else if (gMain.newAndRepeatedKeys & DPAD_DOWN) { - if(gMartInfo.cursor != gMartInfo.numChoices) // can move cursor down? + if (gMartInfo.cursor != gMartInfo.numChoices) // can move cursor down? { PlaySE(0x5); gMartInfo.cursor = MoveMenuCursor(1); @@ -135,7 +135,7 @@ void sub_80B2E38(u8 var) else if (gMain.newKeys & A_BUTTON) { PlaySE(0x5); - if(gMartInfo.martType == MART_TYPE_0) + if (gMartInfo.martType == MART_TYPE_0) { gUnknown_083CC6D0[gUnknown_083CC6E8[gMartInfo.cursor]].func(local); } @@ -144,7 +144,7 @@ void sub_80B2E38(u8 var) gUnknown_083CC6D0[gUnknown_083CC6EB[gMartInfo.cursor]].func(local); } } - else if(gMain.newKeys & B_BUTTON) + else if (gMain.newKeys & B_BUTTON) { PlaySE(0x5); HandleShopMenuQuit(local); @@ -175,13 +175,13 @@ void HandleShopMenuQuit(u8 taskId) ScriptContext2_Disable(); DestroyTask(taskId); - if(gMartInfo.callback) + if (gMartInfo.callback) gMartInfo.callback(); // run the callback if it exists. } void sub_80B2FA0(u8 taskId) { - if(!gPaletteFade.active) + if (!gPaletteFade.active) { SetMainCallback2((void *)((u16)gTasks[taskId].data[8] << 16 | (u16)gTasks[taskId].data[9])); DestroyTask(taskId); @@ -196,9 +196,9 @@ void ReturnToShopMenuAfterExitingSellMenu(u8 taskId) void Task_ExitSellMenu(u8 taskId) { - if(sub_807D770() == 1) + if (sub_807D770() == 1) { - if(gMartInfo.martType == MART_TYPE_2) + if (gMartInfo.martType == MART_TYPE_2) DisplayItemMessageOnField(taskId, gOtherText_CanIHelpYou, ReturnToShopMenuAfterExitingSellMenu, 0); else DisplayItemMessageOnField(taskId, gOtherText_AnythingElse, ReturnToShopMenuAfterExitingSellMenu, 0); @@ -313,7 +313,7 @@ void sub_80B3270(void) { sub_80F944C(); - if(gMartInfo.itemCount > 7) + if (gMartInfo.itemCount > 7) { CreateVerticalScrollIndicators(0, 172, 12); CreateVerticalScrollIndicators(1, 172, 148); @@ -323,12 +323,12 @@ void sub_80B3270(void) void sub_80B32A4(void) { - if(gMartInfo.choicesAbove == 0) + if (gMartInfo.choicesAbove == 0) sub_80F979C(0, 1); else sub_80F979C(0, 0); - if(gMartInfo.choicesAbove + 7 >= gMartInfo.itemCount) + if (gMartInfo.choicesAbove + 7 >= gMartInfo.itemCount) sub_80F979C(1, 1); else sub_80F979C(1, 0); @@ -354,7 +354,7 @@ void BuyMenuDrawMapMetatile(int var1, int var2, u16 *var3, s32 var4) s16 offset1 = var1 * 2; s16 offset2 = (var2 * 0x40) + 0x40; - switch(tempVar4) + switch (tempVar4) { case 0: // _080B335C BuyMenuDrawMapMetatileLayer(gBGTilemapBuffers[2], offset1, offset2, var3); @@ -470,9 +470,9 @@ void sub_80B368C(void) { u8 i; - for(i = 0; i < 16; i++) // max objects? + for (i = 0; i < 16; i++) // max objects? { - if(gUnknown_020386A4[i][MAP_OBJ_ID] == 16) + if (gUnknown_020386A4[i][MAP_OBJ_ID] == 16) continue; StartSpriteAnim(&gSprites[AddPseudoFieldObject( @@ -507,8 +507,8 @@ void sub_80B379C(void) { u16 i, j; - for(i = 0; i < 8; i++) - for(j = 0; j < 14; j++) + for (i = 0; i < 8; i++) + for (j = 0; j < 14; j++) gBGTilemapBuffers[1][32 * (i + 12) + j] = ewram18300[32 * i + j] + 0xC3E0; } @@ -536,7 +536,7 @@ void sub_80B389C(u16 itemId, u8 var2, bool32 hasControlCode) { u8 *stringPtr = gStringVar1; - if(hasControlCode != FALSE) + if (hasControlCode != FALSE) { stringPtr[0] = EXT_CTRL_CODE_BEGIN; stringPtr[1] = 0x1; @@ -549,7 +549,7 @@ void sub_80B389C(u16 itemId, u8 var2, bool32 hasControlCode) sub_8072A18(&gStringVar1[0], 0x70, var2 << 3, 0x58, 0x1); stringPtr = gStringVar1; - if(hasControlCode != FALSE) + if (hasControlCode != FALSE) stringPtr = &gStringVar1[3]; sub_80B79F8(stringPtr, (ItemId_GetPrice(itemId) >> GetPriceReduction(1)), 0x4); @@ -560,7 +560,7 @@ void sub_80B3930(u16 itemId, u8 var2, bool32 hasControlCode) { u8 *stringPtr = gStringVar1; - if(hasControlCode != FALSE) + if (hasControlCode != FALSE) { stringPtr[0] = EXT_CTRL_CODE_BEGIN; stringPtr[1] = 0x1; @@ -572,10 +572,10 @@ void sub_80B3930(u16 itemId, u8 var2, bool32 hasControlCode) sub_8072A18(&gStringVar1[0], 0x70, var2 << 3, 0x58, 0x1); stringPtr = gStringVar1; - if(hasControlCode != FALSE) + if (hasControlCode != FALSE) stringPtr = &gStringVar1[3]; - if(gDecorations[itemId].price == 10000) + if (gDecorations[itemId].price == 10000) { sub_80B7B34(0x19, var2, hasControlCode); // huh??? } @@ -590,15 +590,15 @@ void sub_80B39D0(int var1, int var2, bool32 hasControlCode) { u8 i; - for(i = var1; i <= var2 && gMartInfo.choicesAbove + i < gMartInfo.itemCount; i++) + for (i = var1; i <= var2 && gMartInfo.choicesAbove + i < gMartInfo.itemCount; i++) { - if(gMartInfo.martType == MART_TYPE_0) + if (gMartInfo.martType == MART_TYPE_0) sub_80B389C(gMartInfo.itemList[gMartInfo.choicesAbove + i], (i << 1) + 2, hasControlCode); else sub_80B3930(gMartInfo.itemList[gMartInfo.choicesAbove + i], (i << 1) + 2, hasControlCode); } - if(i != 8 && gMartInfo.choicesAbove + i == gMartInfo.itemCount) + if (i != 8 && gMartInfo.choicesAbove + i == gMartInfo.itemCount) { MenuFillWindowRectWithBlankTile(0xE, (i << 1) + 2, 0x1C, (i << 1) + 3); MenuPrint(gOtherText_CancelNoTerminator, 0xE, (i << 1) + 2); @@ -607,16 +607,16 @@ void sub_80B39D0(int var1, int var2, bool32 hasControlCode) void sub_80B3A70(void) { - if(gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) + if (gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) { - if(gMartInfo.martType == MART_TYPE_0) + if (gMartInfo.martType == MART_TYPE_0) { sub_8072AB0(ItemId_GetDescription(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]), 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); } else - sub_8072AB0(gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].description, // doesn't consider choicesAbove? - 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); // huh?? + sub_8072AB0(gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].description, + 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); // huh?? if mart type isnt 0, why assume it? } else { -- cgit v1.2.3 From d87b8b03f19002705e27e08dfcbd1beaed0cb005 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Thu, 24 Aug 2017 10:48:29 +0200 Subject: change ewram defines --- src/reshow_battle_screen.c | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) (limited to 'src') diff --git a/src/reshow_battle_screen.c b/src/reshow_battle_screen.c index 202431ae9..343c8f183 100644 --- a/src/reshow_battle_screen.c +++ b/src/reshow_battle_screen.c @@ -55,8 +55,8 @@ static void sub_807B184(u8 bank); static void sub_807B508(u8 bank); static void sub_807B06C(void); -#define RESHOW_STATE 0x1FFFF -#define HELPER_STATE 0x1FFFE +#define gReshowState ewram[0x1FFFF] +#define gHelperState ewram[0x1FFFE] void nullsub_14(void) { @@ -69,14 +69,14 @@ void ReshowBattleScreenAfterMenu(void) SetHBlankCallback(0); SetVBlankCallback(0); REG_MOSAIC = 0; - ewram[RESHOW_STATE] = 0; - ewram[HELPER_STATE] = 0; + gReshowState = 0; + gHelperState = 0; SetMainCallback2(CB2_ReshowBattleScreenAfterMenu); } static void CB2_ReshowBattleScreenAfterMenu(void) { - switch (ewram[RESHOW_STATE]) + switch (gReshowState) { case 0: dp12_8087EA4(); @@ -99,13 +99,13 @@ static void CB2_ReshowBattleScreenAfterMenu(void) } break; case 2: - if (!sub_800E414(ewram[HELPER_STATE])) + if (!sub_800E414(gHelperState)) { - ewram[HELPER_STATE]++; - ewram[RESHOW_STATE]--; + gHelperState++; + gReshowState--; } else - ewram[HELPER_STATE] = 0; + gHelperState = 0; break; case 3: ResetSpriteData(); @@ -118,29 +118,29 @@ static void CB2_ReshowBattleScreenAfterMenu(void) sub_8031EE8(); break; case 6: - if (sub_8031C30(ewram[HELPER_STATE])) - ewram[HELPER_STATE] = 0; + if (sub_8031C30(gHelperState)) + gHelperState = 0; else { - ewram[HELPER_STATE]++; - ewram[RESHOW_STATE]--; + gHelperState++; + gReshowState--; } break; case 7: if (!LoadAppropiateBankSprite(0)) - ewram[RESHOW_STATE]--; + gReshowState--; break; case 8: if (!LoadAppropiateBankSprite(1)) - ewram[RESHOW_STATE]--; + gReshowState--; break; case 9: if (!LoadAppropiateBankSprite(2)) - ewram[RESHOW_STATE]--; + gReshowState--; break; case 10: if (!LoadAppropiateBankSprite(3)) - ewram[RESHOW_STATE]--; + gReshowState--; break; case 11: sub_807B184(0); @@ -195,7 +195,7 @@ static void CB2_ReshowBattleScreenAfterMenu(void) SetMainCallback2(sub_800F808); break; } - ewram[RESHOW_STATE]++; + gReshowState++; } static void sub_807B06C(void) @@ -231,7 +231,7 @@ static bool8 LoadAppropiateBankSprite(u8 bank) else BattleLoadSubstituteSprite(bank, 0); - ewram[HELPER_STATE] = 0; + gHelperState = 0; } return 1; } -- cgit v1.2.3 From 8bd3b74b8dcce8b18a3310f61a07ecd4d98ec0a5 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Thu, 24 Aug 2017 21:40:41 +0200 Subject: code review changes --- src/battle_transition.c | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) (limited to 'src') diff --git a/src/battle_transition.c b/src/battle_transition.c index 35f001bc7..395a38df1 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -243,11 +243,11 @@ static const TransitionState sPhase2_Transition_Shuffle_Funcs[] = static const TransitionState sPhase2_Transition_BigPokeball_Funcs[] = { Phase2_Transition_BigPokeball_Func1, - Phase2_Transition_BigPokeball_Func2, - Phase2_Transition_BigPokeball_Func3, - Phase2_Transition_BigPokeball_Func4, - Phase2_Transition_BigPokeball_Func5, - Phase2_Transition_BigPokeball_Func6 + Phase2_Transition_BigPokeball_Func2, + Phase2_Transition_BigPokeball_Func3, + Phase2_Transition_BigPokeball_Func4, + Phase2_Transition_BigPokeball_Func5, + Phase2_Transition_BigPokeball_Func6 }; static const TransitionState sPhase2_Transition_PokeballsTrail_Funcs[] = @@ -571,7 +571,7 @@ static void Task_BattleTransitionMain(u8 taskID) static bool8 Transition_Phase1(struct Task* task) { sub_807DE10(); - CpuSet(gPlttBufferFaded, gPlttBufferUnfaded, 0x4000100); + CpuCopy32(gPlttBufferFaded, gPlttBufferUnfaded, 0x400); if (sPhase1_Tasks[task->tTransitionID] != NULL) { CreateTask(sPhase1_Tasks[task->tTransitionID], 4); @@ -630,9 +630,9 @@ static void Phase2Task_Transition_Blur(u8 taskID) static bool8 Phase2_Transition_Blur_Func1(struct Task* task) { REG_MOSAIC = 0; - REG_BG1CNT |= 0x40; - REG_BG2CNT |= 0x40; - REG_BG3CNT |= 0x40; + REG_BG1CNT |= BGCNT_MOSAIC; + REG_BG2CNT |= BGCNT_MOSAIC; + REG_BG3CNT |= BGCNT_MOSAIC; task->tState++; return TRUE; } @@ -682,9 +682,9 @@ static bool8 Phase2_Transition_Swirl_Func1(struct Task* task) savedIME = REG_IME; REG_IME = 0; - REG_IE |= 3; + REG_IE |= (INTR_FLAG_VBLANK | INTR_FLAG_HBLANK); REG_IME = savedIME; - REG_DISPSTAT |= 0x18; + REG_DISPSTAT |= (DISPSTAT_VBLANK_INTR | DISPSTAT_HBLANK_INTR); task->tState++; return FALSE; @@ -743,9 +743,9 @@ static bool8 Phase2_Transition_Shuffle_Func1(struct Task* task) savedIME = REG_IME; REG_IME = 0; - REG_IE |= 3; + REG_IE |= (INTR_FLAG_VBLANK | INTR_FLAG_HBLANK); REG_IME = savedIME; - REG_DISPSTAT |= 0x18; + REG_DISPSTAT |= (DISPSTAT_VBLANK_INTR | DISPSTAT_HBLANK_INTR); task->tState++; return FALSE; @@ -1282,8 +1282,8 @@ static bool8 Phase2_Transition_Ripple_Func1(struct Task* task) SetVBlankCallback(VBlankCB_Phase2_Transition_Ripple); SetHBlankCallback(HBlankCB_Phase2_Transition_Ripple); - REG_IE |= 2; - REG_DISPSTAT |= 0x10; + REG_IE |= INTR_FLAG_HBLANK; + REG_DISPSTAT |= DISPSTAT_HBLANK_INTR; task->tState++; return TRUE; @@ -1504,8 +1504,8 @@ static bool8 Phase2_Mugshot_Func2(struct Task* task) } } - REG_IE |= 2; - REG_DISPSTAT |= 0x10; + REG_IE |= INTR_FLAG_HBLANK; + REG_DISPSTAT |= DISPSTAT_HBLANK_INTR; SetHBlankCallback(HBlankCB_Phase2_Mugshots); task->tState++; return FALSE; @@ -1861,8 +1861,8 @@ static bool8 Phase2_Transition_Slice_Func1(struct Task* task) gUnknown_03004DE0[1][160 + i] = 0xF0; } - REG_IE |= 2; - REG_DISPSTAT |= 0x10; + REG_IE |= INTR_FLAG_HBLANK; + REG_DISPSTAT |= DISPSTAT_HBLANK_INTR; SetVBlankCallback(VBlankCB_Phase2_Transition_Slice); SetHBlankCallback(HBlankCB_Phase2_Transition_Slice); @@ -1960,8 +1960,8 @@ static bool8 Phase2_Transition_WhiteFade_Func1(struct Task* task) gUnknown_03004DE0[1][i + 160] = 0xF0; } - REG_IE |= 2; - REG_DISPSTAT |= 0x10; + REG_IE |= INTR_FLAG_HBLANK; + REG_DISPSTAT |= DISPSTAT_HBLANK_INTR; SetHBlankCallback(HBlankCB_Phase2_Transition_WhiteFade); SetVBlankCallback(VBlankCB0_Phase2_Transition_WhiteFade); -- cgit v1.2.3 From e427c657f2f44f06a0dd085a79d2e91c4045f0f0 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Thu, 24 Aug 2017 17:30:42 -0400 Subject: decompile up to sub_80B3BF4 --- src/shop.c | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 17cebfee6..6150d1b78 100644 --- a/src/shop.c +++ b/src/shop.c @@ -21,6 +21,13 @@ #include "fieldmap.h" #include "item.h" #include "decoration.h" +#include "items.h" +#include "songs.h" +#include "rom4.h" +#include "decoration_inventory.h" + +extern void sub_80B4378(u8); +extern void sub_80B4470(u8); enum { @@ -43,6 +50,8 @@ struct MartInfo extern struct MartInfo gMartInfo; extern struct MenuAction gUnknown_083CC6D0[]; +extern u32 gMartTotalCost; // the total cost of a purchase before checking out. + extern u8 ewram[]; extern u8 gUnknown_083CC6E8[]; @@ -623,3 +632,71 @@ void sub_80B3A70(void) sub_8072AB0(gOtherText_QuitShopping, 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); } } + +void sub_80B3AEC(u8 taskId) +{ + if(gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + { + sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); // huh??? + PlaySE(SE_SELECT); + + if(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] == ITEM_POKE_BALL && gTasks[taskId].data[1] >= 10 && AddBagItem(ITEM_PREMIER_BALL, 1) == TRUE) + DisplayItemMessageOnField(taskId, gOtherText_FreePremierBall, sub_80B4378, 0xC3E1); + else + sub_80B4378(taskId); + } +} + +void sub_80B3B80(u8 taskId) +{ + IncrementGameStat(0x26); + sub_80B79E0(&gSaveBlock1.money, gMartTotalCost); + PlaySE(0x5F); + sub_80B7BEC(gSaveBlock1.money, 0, 0); + gTasks[taskId].func = sub_80B3AEC; +} + +void sub_80B3BD0(u8 taskId) +{ + sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); // same thing as above? + sub_80B4378(taskId); +} + +void sub_80B3BF4(u8 taskId) +{ + MenuZeroFillWindowRect(0x7, 0x8, 0xD, 0xD); + sub_80A3FA0(gBGTilemapBuffers[1], 8, 9, 4, 4, 0); + sub_80B379C(); + sub_80B3420(); + + if(IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + { + if(gMartInfo.martType == MART_TYPE_0) + { + if(AddBagItem(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor], gTasks[taskId].data[1])) + { + DisplayItemMessageOnField(taskId, gOtherText_HereYouGo, sub_80B3B80, 0xC3E1); + sub_80B4470(taskId); + } + else + DisplayItemMessageOnField(taskId, gOtherText_NoRoomFor, sub_80B3BD0, 0xC3E1); + } + else // a normal mart is only type 0, so types 1 and 2 are decoration marts. + { + if(IsThereStorageSpaceForDecoration(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor])) + { + if(gMartInfo.martType == MART_TYPE_1) + DisplayItemMessageOnField(taskId, gOtherText_HereYouGo2, sub_80B3B80, 0xC3E1); + else + DisplayItemMessageOnField(taskId, gOtherText_HereYouGo3, sub_80B3B80, 0xC3E1); + } + else + { + StringExpandPlaceholders(gStringVar4, gOtherText_SpaceForIsFull); + DisplayItemMessageOnField(taskId, gStringVar4, sub_80B3BD0, 0xC3E1); + } + } + } + else + DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); +} -- cgit v1.2.3 From 8eb47079f9c339f43f4b7d8dee494b495f799de1 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 25 Aug 2017 00:38:49 +0200 Subject: code review changes --- src/pokeblock_feed.c | 121 ++++++++++++++++++++++++++------------------------- 1 file changed, 62 insertions(+), 59 deletions(-) (limited to 'src') diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 69917bf5d..8dc2f47de 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -92,30 +92,30 @@ s16 gUnknown_03005FA0[24]; static const u8 sNatureToMonPokeblockAnim[][2] = { { 0, 0 }, // HARDY - { 3, 0 }, // LONELY - { 4, 1 }, // BRAVE - { 5, 0 }, // ADAMANT - { 10, 0 }, // NAUGHTY - { 13, 0 }, // BOLD - { 15, 0 }, // DOCILE - { 16, 2 }, // RELAXED - { 18, 0 }, // IMPISH - { 19, 0 }, // LAX - { 20, 0 }, // TIMID - { 25, 0 }, // HASTY - { 27, 3 }, // SERIOUS - { 28, 0 }, // JOLLY - { 29, 0 }, // NAIVE - { 33, 4 }, // MODEST - { 36, 0 }, // MILD - { 37, 0 }, // QUIET - { 39, 0 }, // BASHFUL - { 42, 0 }, // RASH - { 45, 0 }, // CALM - { 46, 5 }, // GENTLE - { 47, 6 }, // SASSY - { 48, 0 }, // CAREFUL - { 53, 0 }, // QUIRKY + { 3, 0 }, // LONELY + { 4, 1 }, // BRAVE + { 5, 0 }, // ADAMANT + { 10, 0 }, // NAUGHTY + { 13, 0 }, // BOLD + { 15, 0 }, // DOCILE + { 16, 2 }, // RELAXED + { 18, 0 }, // IMPISH + { 19, 0 }, // LAX + { 20, 0 }, // TIMID + { 25, 0 }, // HASTY + { 27, 3 }, // SERIOUS + { 28, 0 }, // JOLLY + { 29, 0 }, // NAIVE + { 33, 4 }, // MODEST + { 36, 0 }, // MILD + { 37, 0 }, // QUIET + { 39, 0 }, // BASHFUL + { 42, 0 }, // RASH + { 45, 0 }, // CALM + { 46, 5 }, // GENTLE + { 47, 6 }, // SASSY + { 48, 0 }, // CAREFUL + { 53, 0 }, // QUIRKY }; static const s16 sMonPokeblockAnims[][10] = @@ -228,7 +228,7 @@ static const s16 sMonPokeblockAnims[][10] = static const union AffineAnimCmd sSpriteAffineAnim_8411E90[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; @@ -242,7 +242,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411EA0[] = static const union AffineAnimCmd sSpriteAffineAnim_8411EC0[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0, 0, 12, 1), AFFINEANIMCMD_FRAME(0, 0, 0, 28), AFFINEANIMCMD_FRAME(0, 0, -4, 3), @@ -259,7 +259,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411EE8[] = static const union AffineAnimCmd sSpriteAffineAnim_8411F08[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), @@ -276,7 +276,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411F30[] = static const union AffineAnimCmd sSpriteAffineAnim_8411F50[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), @@ -293,7 +293,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411F78[] = static const union AffineAnimCmd sSpriteAffineAnim_8411F98[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), @@ -310,7 +310,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411FC0[] = static const union AffineAnimCmd sSpriteAffineAnim_8411FE0[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), @@ -327,7 +327,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8412008[] = static const union AffineAnimCmd sSpriteAffineAnim_8412028[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), @@ -379,7 +379,7 @@ static const u8* const sPokeblocksPals[] = static const union AffineAnimCmd sSpriteAffineAnim_84120DC[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; @@ -390,7 +390,7 @@ static const union AffineAnimCmd *const sSpriteAffineAnimTable_84120EC[] = static const union AffineAnimCmd sSpriteAffineAnim_84120F0[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), @@ -399,13 +399,13 @@ static const union AffineAnimCmd sSpriteAffineAnim_84120F0[] = AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8412148[] = { - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), @@ -414,7 +414,7 @@ static const union AffineAnimCmd sSpriteAffineAnim_8412148[] = AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), - AFFINEANIMCMD_FRAME(0xFF00, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), AFFINEANIMCMD_END }; @@ -464,7 +464,7 @@ static const union AnimCmd *const sThrownPokeblockAnimTable[] = static const union AffineAnimCmd sSpriteAffineAnim_84121C0[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0xFFF8, 0xFFF8, 0, 1), + AFFINEANIMCMD_FRAME(-8, -8, 0, 1), AFFINEANIMCMD_JUMP(1) }; @@ -582,9 +582,9 @@ static bool8 TransitionToPokeblockFeedScene(void) BeginNormalPaletteFade(-1, 0, 0x10, 0, 0); gPaletteFade.bufferTransferDisabled = 0; SetMainCallback2(CB2_PokeblockFeed); - return 1; + return TRUE; } - return 0; + return FALSE; } void CB2_PreparePokeblockFeedScene(void) @@ -660,9 +660,9 @@ static bool8 sub_8147B20(struct Pokemon* mon) case 8: LoadCompressedPalette(gBattleTerrainPalette_BattleTower, 0x20, 0x60); ewram[0x1FFFF] = 0; - return 1; + return TRUE; } - return 0; + return FALSE; } static void SetPokeblockFeedSpritePal(u8 pkbID) @@ -912,7 +912,7 @@ static bool8 sub_8148540(void) for (i = 0; i < 10; i++) gUnknown_03005FA0[i] = sMonPokeblockAnims[gUnknown_03005F40][i]; if (gUnknown_03005FA0[4] == 0) - return 1; + return TRUE; else { gUnknown_03005FA0[10] = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2]); @@ -924,27 +924,30 @@ static bool8 sub_8148540(void) gUnknown_03005FA0[4] = gUnknown_03005FA0[12]; sub_814862C(); gUnknown_03005FA0[4] = gUnknown_03005FA0[12]; - return 0; + return FALSE; } } +#define ewram1D000 ((u16 *)(ewram + 0x1D000)) +#define ewram1D400 ((u16 *)(ewram + 0x1D400)) + static bool8 sub_81485CC(void) { u16 var = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; - gPokeblockFeedPokeSprite->pos2.x = (*((u16*)(&ewram[0x1D000]) + var)); - gPokeblockFeedPokeSprite->pos2.y = (*((u16*)(&ewram[0x1D400]) + var)); + gPokeblockFeedPokeSprite->pos2.x = ewram1D000[var]; + gPokeblockFeedPokeSprite->pos2.y = ewram1D400[var]; if (--gUnknown_03005FA0[4] == 0) - return 1; + return TRUE; else - return 0; + return FALSE; } static bool8 FreePokeSpriteMatrix(void) { FreeSpriteOamMatrix(gPokeblockFeedPokeSprite); - return 0; + return FALSE; } static void sub_814862C(void) @@ -957,23 +960,23 @@ static void sub_814862C(void) for (i = 0; i < r7 - 1; i++) { - s16* r3 = (((u16*)(&ewram[0x1D000]) + (r8 + i))); + s16* r3 = &ewram1D000[r8 + i]; s16 r1 = *r3 - (var3); - s16* r5 = (((u16*)(&ewram[0x1D400]) + (r8 + i))); + s16* r5 = &ewram1D400[r8 + i]; s16 r4 = *r5 - r9; *r3 -= r1 * (i + 1) / r7; *r5 -= r4 * (i + 1) / r7; } - *((u16*)(&ewram[0x1CFFE]) + (r8 + r7)) = var3; - *((u16*)(&ewram[0x1D3FE]) + (r8 + r7)) = r9; + ewram1D000[(r8 + r7) - 1] = var3; + ewram1D400[(r8 + r7) - 1] = r9; } void sub_8148710(void) { - bool8 var_24 = 0; + bool8 var_24 = FALSE; s16 r8 = gUnknown_03005FA0[13] - gUnknown_03005FA0[10]; s16 r7 = gUnknown_03005FA0[14] - gUnknown_03005FA0[11]; while (1) @@ -987,22 +990,22 @@ void sub_8148710(void) gUnknown_03005FA0[3] = r5; if (gUnknown_03005FA0[2] < 0) - var_24 = 1; + var_24 = TRUE; r4 = gUnknown_03005FA0[12] - gUnknown_03005FA0[4]; if (gUnknown_03005FA0[4] == 0) break; - if (var_24 == 0) + if (!var_24) { - *((u16*)(&ewram[0x1D000]) + r4) = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] + r5 / 256) + r8; - *((u16*)(&ewram[0x1D400]) + r4) = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] + r5 / 256) + r7; + ewram1D000[r4] = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] + r5 / 256) + r8; + ewram1D400[r4] = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] + r5 / 256) + r7; } else { - *((u16*)(&ewram[0x1D000]) + r4) = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] - r5 / 256) + r8; - *((u16*)(&ewram[0x1D400]) + r4) = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] - r5 / 256) + r7; + ewram1D000[r4] = Sin(gUnknown_03005FA0[0], gUnknown_03005FA0[2] - r5 / 256) + r8; + ewram1D400[r4] = Cos(gUnknown_03005FA0[0], gUnknown_03005FA0[3] - r5 / 256) + r7; } gUnknown_03005FA0[0] += gUnknown_03005FA0[1]; -- cgit v1.2.3 From 28836dd9b7f1f38ba1d065e2c336d32628fb7cca Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Fri, 25 Aug 2017 00:14:33 -0400 Subject: decompile up to sub_80B3EFC --- src/shop.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 6150d1b78..0ce14c004 100644 --- a/src/shop.c +++ b/src/shop.c @@ -28,6 +28,7 @@ extern void sub_80B4378(u8); extern void sub_80B4470(u8); +extern bool8 sub_80A52C4(u8, u8); enum { @@ -45,10 +46,12 @@ struct MartInfo /* 0xA */ u8 numChoices; /* 0xB */ u8 choicesAbove; /* 0xC */ u8 martType; + /* 0xD */ u8 unkD; }; extern struct MartInfo gMartInfo; extern struct MenuAction gUnknown_083CC6D0[]; +extern struct YesNoFuncTable gUnknown_083CC708[]; extern u32 gMartTotalCost; // the total cost of a purchase before checking out. @@ -700,3 +703,60 @@ void sub_80B3BF4(u8 taskId) else DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); } + +void sub_80B3D38(u8 taskId) +{ + DisplayYesNoMenu(7, 8, 1); + sub_80A3FA0(gBGTilemapBuffers[1], 8, 9, 4, 4, 0xC3E1); + DoYesNoFuncWithChoice(taskId, gUnknown_083CC708); +} + +void sub_80B3D7C(u8 taskId) +{ + sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); + MenuZeroFillWindowRect(0x7, 0x8, 0xD, 0xD); + sub_80A3FA0(gBGTilemapBuffers[1], 0x8, 0x9, 0x4, 0x4, 0); + sub_80B4378(taskId); +} + +void sub_80B3DC8(u8 taskId) +{ + if(sub_80A52C4(taskId, gMartInfo.unkD) == TRUE) + sub_80B37F8(taskId); + + if(gMain.newKeys & A_BUTTON) + { + gMartTotalCost = (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)) * gTasks[taskId].data[1]; // set total cost of your purchase. + MenuZeroFillWindowRect(0, 0xA, 0xD, 0xD); + sub_80A3FA0(gBGTilemapBuffers[1], 0x1, 0xB, 0xC, 0x2, 0); + sub_80B379C(); + sub_80B3420(); + CopyItemName(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor], gStringVar1); + ConvertIntToDecimalStringN(gStringVar2, gTasks[taskId].data[1], 0, 0x2); + ConvertIntToDecimalStringN(gStringVar3, gMartTotalCost, 0, 0x8); + StringExpandPlaceholders(gStringVar4, gOtherText_ThatWillBe); + DisplayItemMessageOnField(taskId, gStringVar4, sub_80B3D38, 0xC3E1); + } + else if(gMain.newKeys & B_BUTTON) + { + sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); + sub_80B4378(taskId); + } +} + +void sub_80B3EFC(u8 taskId) +{ + u16 var; + + gTasks[taskId].data[1] = 1; + MenuDrawTextWindow(0, 0xA, 0xD, 0xD); + sub_80B37F8(taskId); + + var = gSaveBlock1.money / (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)); + if(var > 99) + gMartInfo.unkD = 99; + else + gMartInfo.unkD = var; + + gTasks[taskId].func = sub_80B3DC8; +} -- cgit v1.2.3 From d5b9456949371bf73ca93dc13202ab4dbf2387d1 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 25 Aug 2017 20:07:39 +0200 Subject: start decompiling evo graphics --- src/evolution_graphics.c | 404 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 404 insertions(+) create mode 100644 src/evolution_graphics.c (limited to 'src') diff --git a/src/evolution_graphics.c b/src/evolution_graphics.c new file mode 100644 index 000000000..ed7296a8e --- /dev/null +++ b/src/evolution_graphics.c @@ -0,0 +1,404 @@ +#include "global.h" +#include "sprite.h" +#include "trig.h" +#include "rng.h" +#include "decompress.h" +#include "task.h" +#include "sound.h" +#include "songs.h" +#include "palette.h" + +// this file's functions +static void EvoTask_BeginPreSet1_FadeAndPlaySE(u8 taskID); +static void EvoTask_CreatePreEvoSparkleSet1(u8 taskID); +static void EvoTask_WaitForPre1SparklesToGoUp(u8 taskID); +static void EvoTask_BeginPreSparklesSet2(u8 taskID); +static void EvoTask_CreatePreEvoSparklesSet2(u8 taskID); +static void EvoTask_DestroyPreSet2Task(u8 taskID); +static void EvoTask_BeginPostSparklesSet1(u8 taskID); +static void EvoTask_CreatePostEvoSparklesSet1(u8 taskID); +static void EvoTask_DestroyPostSet1Task(u8 taskID); + +static void EvoTask_BeginPostSparklesSet2_AndFlash(u8 taskID); +static void EvoTask_CreatePostEvoSparklesSet2_AndFlash(u8 taskID); +static void EvoTask_BeginPostSparklesSet2_AndFlash_Trade(u8 taskID); +static void EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade(u8 taskID); +static void EvoTask_DestroyPostSet2AndFlashTask(u8 taskID); + +extern const s16 gUnknown_08416ED0[]; +extern const struct SpriteTemplate gSpriteTemplate_8416EB8; +extern const struct CompressedSpriteSheet gUnknown_08416E84; +extern const struct SpritePalette gUnknown_08416E94[]; + +void nullsub_84(struct Sprite* sprite) +{ + +} + +static void sub_8149520(void) +{ + u16 i; + for (i = 0; i < 12; i++) + { + SetOamMatrix(20 + i, gUnknown_08416ED0[i], 0, 0, gUnknown_08416ED0[i]); + } +} + +static void SpriteCB_PreEvoSparkleSet1(struct Sprite* sprite) +{ + if (sprite->pos1.y > 8) + { + u8 matrixNum; + + sprite->pos1.y = 88 - (sprite->data7 * sprite->data7) / 80; + sprite->pos2.y = Sin((u8)(sprite->data6), sprite->data5) / 4; + sprite->pos2.x = Cos((u8)(sprite->data6), sprite->data5); + sprite->data6 += 4; + if (sprite->data7 & 1) + sprite->data5--; + sprite->data7++; + if (sprite->pos2.y > 0) + sprite->subpriority = 1; + else + sprite->subpriority = 20; + matrixNum = sprite->data5 / 4 + 20; + if (matrixNum > 31) + matrixNum = 31; + sprite->oam.matrixNum = matrixNum; + } + else + DestroySprite(sprite); +} + +static void CreatePreEvoSparkleSet1(u8 arg0) +{ + u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 88, 0); + if (spriteID != MAX_SPRITES) + { + gSprites[spriteID].data5 = 48; + gSprites[spriteID].data6 = arg0; + gSprites[spriteID].data7 = 0; + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].oam.matrixNum = 31; + gSprites[spriteID].callback = SpriteCB_PreEvoSparkleSet1; + } +} + +static void SpriteCB_PreEvoSparkleSet2(struct Sprite* sprite) +{ + if (sprite->pos1.y < 88) + { + sprite->pos1.y = 8 + (sprite->data7 * sprite->data7) / 5; + sprite->pos2.y = Sin((u8)(sprite->data6), sprite->data5) / 4; + sprite->pos2.x = Cos((u8)(sprite->data6), sprite->data5); + sprite->data5 = 8 + Sin((u8)(sprite->data7 * 4), 40); + sprite->data7++; + } + else + DestroySprite(sprite); +} + +static void CreatePreEvoSparkleSet2(u8 arg0) +{ + u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 8, 0); + if (spriteID != MAX_SPRITES) + { + gSprites[spriteID].data5 = 8; + gSprites[spriteID].data6 = arg0; + gSprites[spriteID].data7 = 0; + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].oam.matrixNum = 25; + gSprites[spriteID].subpriority = 1; + gSprites[spriteID].callback = SpriteCB_PreEvoSparkleSet2; + } +} + +static void SpriteCB_PostEvoSparkleSet1(struct Sprite* sprite) +{ + if (sprite->data5 > 8) + { + sprite->pos2.y = Sin((u8)(sprite->data6), sprite->data5); + sprite->pos2.x = Cos((u8)(sprite->data6), sprite->data5); + sprite->data5 -= sprite->data3; + sprite->data6 += 4; + } + else + DestroySprite(sprite); +} + +static void CreatePostEvoSparkleSet1(u8 arg0, u8 arg1) +{ + u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 56, 0); + if (spriteID != MAX_SPRITES) + { + gSprites[spriteID].data3 = arg1; + gSprites[spriteID].data5 = 120; + gSprites[spriteID].data6 = arg0; + gSprites[spriteID].data7 = 0; + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].oam.matrixNum = 31; + gSprites[spriteID].subpriority = 1; + gSprites[spriteID].callback = SpriteCB_PostEvoSparkleSet1; + } +} + +static void SpriteCB_PostEvoSparkleSet2(struct Sprite* sprite) +{ + if (!(sprite->data7 & 3)) + sprite->pos1.y++; + if (sprite->data6 < 128) + { + u8 matrixNum; + + sprite->pos2.y = -Sin((u8)(sprite->data6), sprite->data5); + sprite->pos1.x = 120 + (sprite->data3 * sprite->data7) / 3; + sprite->data6++; + matrixNum = 31 - (sprite->data6 * 12 / 128); + if (sprite->data6 > 64) + sprite->subpriority = 1; + else + { + sprite->invisible = 0; + sprite->subpriority = 20; + if (sprite->data6 > 112 && sprite->data6 & 1) + sprite->invisible = 1; + } + if (matrixNum < 20) + matrixNum = 20; + sprite->oam.matrixNum = matrixNum; + sprite->data7++; + } + else + DestroySprite(sprite); +} + +void CreatePostEvoSparkleSet2(u8 arg0) +{ + u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 56, 0); + if (spriteID != MAX_SPRITES) + { + gSprites[spriteID].data3 = 3 - (Random() % 7); + gSprites[spriteID].data5 = 48 + (Random() & 0x3F); + gSprites[spriteID].data7 = 0; + gSprites[spriteID].oam.affineMode = 1; + gSprites[spriteID].oam.matrixNum = 31; + gSprites[spriteID].subpriority = 20; + gSprites[spriteID].callback = SpriteCB_PostEvoSparkleSet2; + } +} + +void sub_8149954(void) +{ + LoadCompressedObjectPic(&gUnknown_08416E84); + LoadSpritePalettes(gUnknown_08416E94); +} + +u8 LaunchTask_PreEvoSparklesSet1(u16 arg0) +{ + u8 taskID = CreateTask(EvoTask_BeginPreSet1_FadeAndPlaySE, 0); + gTasks[taskID].data[1] = arg0; + return taskID; +} + +#define tFrameCounter data[15] + +static void EvoTask_BeginPreSet1_FadeAndPlaySE(u8 taskID) +{ + sub_8149520(); + gTasks[taskID].tFrameCounter = 0; + BeginNormalPaletteFade(3 << gTasks[taskID].data[1], 0xA, 0, 0x10, 0x7FFF); + gTasks[taskID].func = EvoTask_CreatePreEvoSparkleSet1; + PlaySE(SE_W025); +} + +static void EvoTask_CreatePreEvoSparkleSet1(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter < 64) + { + if (!(gTasks[taskID].tFrameCounter & 7)) + { + u8 i; + for (i = 0; i < 4; i++) + CreatePreEvoSparkleSet1((0x78 & gTasks[taskID].tFrameCounter) * 2 + i * 64); + } + gTasks[taskID].tFrameCounter++; + } + else + { + gTasks[taskID].tFrameCounter = 96; + gTasks[taskID].func = EvoTask_WaitForPre1SparklesToGoUp; + } +} + +static void EvoTask_WaitForPre1SparklesToGoUp(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter != 0) + gTasks[taskID].tFrameCounter--; + else + DestroyTask(taskID); +} + +u8 LaunchTask_PreEvoSparklesSet2(void) +{ + return CreateTask(EvoTask_BeginPreSparklesSet2, 0); +} + +static void EvoTask_BeginPreSparklesSet2(u8 taskID) +{ + sub_8149520(); + gTasks[taskID].tFrameCounter = 0; + gTasks[taskID].func = EvoTask_CreatePreEvoSparklesSet2; + PlaySE(SE_W062B); +} + +static void EvoTask_CreatePreEvoSparklesSet2(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter < 96) + { + if (gTasks[taskID].tFrameCounter < 6) + { + u8 i; + for (i = 0; i < 9; i++) + CreatePreEvoSparkleSet2(i * 16); + } + gTasks[taskID].tFrameCounter++; + } + else + gTasks[taskID].func = EvoTask_DestroyPreSet2Task; +} + +static void EvoTask_DestroyPreSet2Task(u8 taskID) +{ + DestroyTask(taskID); +} + +u8 LaunchTask_PostEvoSparklesSet1(void) +{ + return CreateTask(EvoTask_BeginPostSparklesSet1, 0); +} + +static void EvoTask_BeginPostSparklesSet1(u8 taskID) +{ + sub_8149520(); + gTasks[taskID].tFrameCounter = 0; + gTasks[taskID].func = EvoTask_CreatePostEvoSparklesSet1; + PlaySE(SE_REAPOKE); +} + +static void EvoTask_CreatePostEvoSparklesSet1(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter < 48) + { + if (gTasks[taskID].tFrameCounter == 0) + { + u8 i; + for (i = 0; i < 16; i++) + CreatePostEvoSparkleSet1(i * 16, 4); + } + if (gTasks[taskID].tFrameCounter == 32) + { + u8 i; + for (i = 0; i < 16; i++) + CreatePostEvoSparkleSet1(i * 16, 8); + } + gTasks[taskID].tFrameCounter++; + } + else + gTasks[taskID].func = EvoTask_DestroyPostSet1Task; +} + +static void EvoTask_DestroyPostSet1Task(u8 taskID) +{ + DestroyTask(taskID); +} + +u8 LaunchTask_PostEvoSparklesSet2AndFlash(u16 arg0) +{ + u8 taskID = CreateTask(EvoTask_BeginPostSparklesSet2_AndFlash, 0); + gTasks[taskID].data[2] = arg0; + return taskID; +} + +static void EvoTask_BeginPostSparklesSet2_AndFlash(u8 taskID) +{ + sub_8149520(); + gTasks[taskID].tFrameCounter = 0; + CpuSet(&gPlttBufferFaded[0x20], &gPlttBufferUnfaded[0x20], 0x30); + BeginNormalPaletteFade(0xFFF9001C, 0, 0, 0x10, 0x7FFF); + gTasks[taskID].func = EvoTask_CreatePostEvoSparklesSet2_AndFlash; + PlaySE(SE_W080); +} + +static void EvoTask_CreatePostEvoSparklesSet2_AndFlash(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter < 128) + { + u8 i; + switch (gTasks[taskID].tFrameCounter) + { + default: + if (gTasks[taskID].tFrameCounter < 50) + CreatePostEvoSparkleSet2(Random() & 7); + break; + case 0: + for (i = 0; i < 8; i++) + CreatePostEvoSparkleSet2(i); + break; + case 32: + BeginNormalPaletteFade(0xFFFF001C, 0x10, 0x10, 0, 0x7FFF); + break; + } + gTasks[taskID].tFrameCounter++; + } + else + gTasks[taskID].func = EvoTask_DestroyPostSet2AndFlashTask; +} + +static void EvoTask_DestroyPostSet2AndFlashTask(u8 taskID) +{ + if (!gPaletteFade.active) + DestroyTask(taskID); +} + +u8 LaunchTask_PostEvoSparklesSet2AndFlash_Trade(u16 arg0) +{ + u8 taskID = CreateTask(EvoTask_BeginPostSparklesSet2_AndFlash_Trade, 0); + gTasks[taskID].data[2] = arg0; + return taskID; +} + +static void EvoTask_BeginPostSparklesSet2_AndFlash_Trade(u8 taskID) +{ + sub_8149520(); + gTasks[taskID].tFrameCounter = 0; + CpuSet(&gPlttBufferFaded[0x20], &gPlttBufferUnfaded[0x20], 0x30); + BeginNormalPaletteFade(0xFFF90001, 0, 0, 0x10, 0x7FFF); + gTasks[taskID].func = EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade; + PlaySE(SE_W080); +} + +static void EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade(u8 taskID) +{ + if (gTasks[taskID].tFrameCounter < 128) + { + u8 i; + switch (gTasks[taskID].tFrameCounter) + { + default: + if (gTasks[taskID].tFrameCounter < 50) + CreatePostEvoSparkleSet2(Random() & 7); + break; + case 0: + for (i = 0; i < 8; i++) + CreatePostEvoSparkleSet2(i); + break; + case 32: + BeginNormalPaletteFade(0xFFFF0001, 0x10, 0x10, 0, 0x7FFF); + break; + } + gTasks[taskID].tFrameCounter++; + } + else + gTasks[taskID].func = EvoTask_DestroyPostSet2AndFlashTask; +} + -- cgit v1.2.3 From b4f9fe17d766c5713875701c3ed8b2a0a6af8ce8 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 25 Aug 2017 20:55:08 +0200 Subject: move evo graphics data to C --- src/evolution_graphics.c | 98 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 78 insertions(+), 20 deletions(-) (limited to 'src') diff --git a/src/evolution_graphics.c b/src/evolution_graphics.c index ed7296a8e..45f60c614 100644 --- a/src/evolution_graphics.c +++ b/src/evolution_graphics.c @@ -9,6 +9,7 @@ #include "palette.h" // this file's functions +static void EvoSparkle_DummySpriteCb(struct Sprite* sprite); static void EvoTask_BeginPreSet1_FadeAndPlaySE(u8 taskID); static void EvoTask_CreatePreEvoSparkleSet1(u8 taskID); static void EvoTask_WaitForPre1SparklesToGoUp(u8 taskID); @@ -18,29 +19,86 @@ static void EvoTask_DestroyPreSet2Task(u8 taskID); static void EvoTask_BeginPostSparklesSet1(u8 taskID); static void EvoTask_CreatePostEvoSparklesSet1(u8 taskID); static void EvoTask_DestroyPostSet1Task(u8 taskID); - static void EvoTask_BeginPostSparklesSet2_AndFlash(u8 taskID); static void EvoTask_CreatePostEvoSparklesSet2_AndFlash(u8 taskID); static void EvoTask_BeginPostSparklesSet2_AndFlash_Trade(u8 taskID); static void EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade(u8 taskID); static void EvoTask_DestroyPostSet2AndFlashTask(u8 taskID); -extern const s16 gUnknown_08416ED0[]; -extern const struct SpriteTemplate gSpriteTemplate_8416EB8; -extern const struct CompressedSpriteSheet gUnknown_08416E84; -extern const struct SpritePalette gUnknown_08416E94[]; +// const data +static const u16 sEvoSparklePalette[] = INCBIN_U16("graphics/misc/evo_sparkle.gbapal"); +static const u8 sEvoSparkleTiles[] = INCBIN_U8("graphics/misc/evo_sparkle.4bpp.lz"); + +static const struct CompressedSpriteSheet sEvoSparkleSpriteSheets[] = +{ + {sEvoSparkleTiles, 0x20, 1001}, + {NULL, 0, 0} +}; +static const struct SpritePalette sEvoSparkleSpritePals[] = +{ + {sEvoSparklePalette, 1001}, + {NULL, 0} +}; + +static const struct OamData sOamData_EvoSparkle = +{ + .y = 160, + .affineMode = 0, + .objMode = 0, + .mosaic = 0, + .bpp = 0, + .shape = 0, + .x = 0, + .matrixNum = 0, + .size = 0, + .tileNum = 0, + .priority = 1, + .paletteNum = 0, + .affineParam = 0, +}; + +static const union AnimCmd sSpriteAnim_EvoSparkle[] = +{ + ANIMCMD_FRAME(0, 8), + ANIMCMD_END +}; + +static const union AnimCmd *const sSpriteAnimTable_EvoSparkle[] = +{ + sSpriteAnim_EvoSparkle, +}; + +static const struct SpriteTemplate sEvoSparkleSpriteTemplate = +{ + .tileTag = 1001, + .paletteTag = 1001, + .oam = &sOamData_EvoSparkle, + .anims = sSpriteAnimTable_EvoSparkle, + .images = NULL, + .affineAnims = gDummySpriteAffineAnimTable, + .callback = EvoSparkle_DummySpriteCb +}; + +static const s16 sEvoSparkleMatricies[] = +{ + 0x3C0, 0x380, 0x340, 0x300, 0x2C0, 0x280, 0x240, 0x200, 0x1C0, + 0x180, 0x140, 0x100, -4, 0x10, -3, 0x30, -2, 0x50, + -1, 0x70, 0x1, 0x70, 0x2, 0x50, 0x3, 0x30, 0x4, 0x10 +}; + +// code -void nullsub_84(struct Sprite* sprite) +static void EvoSparkle_DummySpriteCb(struct Sprite* sprite) { } -static void sub_8149520(void) +static void SetEvoSparklesMatrices(void) { u16 i; for (i = 0; i < 12; i++) { - SetOamMatrix(20 + i, gUnknown_08416ED0[i], 0, 0, gUnknown_08416ED0[i]); + SetOamMatrix(20 + i, sEvoSparkleMatricies[i], 0, 0, sEvoSparkleMatricies[i]); } } @@ -72,7 +130,7 @@ static void SpriteCB_PreEvoSparkleSet1(struct Sprite* sprite) static void CreatePreEvoSparkleSet1(u8 arg0) { - u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 88, 0); + u8 spriteID = CreateSprite(&sEvoSparkleSpriteTemplate, 120, 88, 0); if (spriteID != MAX_SPRITES) { gSprites[spriteID].data5 = 48; @@ -100,7 +158,7 @@ static void SpriteCB_PreEvoSparkleSet2(struct Sprite* sprite) static void CreatePreEvoSparkleSet2(u8 arg0) { - u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 8, 0); + u8 spriteID = CreateSprite(&sEvoSparkleSpriteTemplate, 120, 8, 0); if (spriteID != MAX_SPRITES) { gSprites[spriteID].data5 = 8; @@ -128,7 +186,7 @@ static void SpriteCB_PostEvoSparkleSet1(struct Sprite* sprite) static void CreatePostEvoSparkleSet1(u8 arg0, u8 arg1) { - u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 56, 0); + u8 spriteID = CreateSprite(&sEvoSparkleSpriteTemplate, 120, 56, 0); if (spriteID != MAX_SPRITES) { gSprites[spriteID].data3 = arg1; @@ -174,7 +232,7 @@ static void SpriteCB_PostEvoSparkleSet2(struct Sprite* sprite) void CreatePostEvoSparkleSet2(u8 arg0) { - u8 spriteID = CreateSprite(&gSpriteTemplate_8416EB8, 120, 56, 0); + u8 spriteID = CreateSprite(&sEvoSparkleSpriteTemplate, 120, 56, 0); if (spriteID != MAX_SPRITES) { gSprites[spriteID].data3 = 3 - (Random() % 7); @@ -187,10 +245,10 @@ void CreatePostEvoSparkleSet2(u8 arg0) } } -void sub_8149954(void) +void LoadEvoSparkleSpriteAndPal(void) { - LoadCompressedObjectPic(&gUnknown_08416E84); - LoadSpritePalettes(gUnknown_08416E94); + LoadCompressedObjectPic(&sEvoSparkleSpriteSheets[0]); + LoadSpritePalettes(sEvoSparkleSpritePals); } u8 LaunchTask_PreEvoSparklesSet1(u16 arg0) @@ -204,7 +262,7 @@ u8 LaunchTask_PreEvoSparklesSet1(u16 arg0) static void EvoTask_BeginPreSet1_FadeAndPlaySE(u8 taskID) { - sub_8149520(); + SetEvoSparklesMatrices(); gTasks[taskID].tFrameCounter = 0; BeginNormalPaletteFade(3 << gTasks[taskID].data[1], 0xA, 0, 0x10, 0x7FFF); gTasks[taskID].func = EvoTask_CreatePreEvoSparkleSet1; @@ -245,7 +303,7 @@ u8 LaunchTask_PreEvoSparklesSet2(void) static void EvoTask_BeginPreSparklesSet2(u8 taskID) { - sub_8149520(); + SetEvoSparklesMatrices(); gTasks[taskID].tFrameCounter = 0; gTasks[taskID].func = EvoTask_CreatePreEvoSparklesSet2; PlaySE(SE_W062B); @@ -279,7 +337,7 @@ u8 LaunchTask_PostEvoSparklesSet1(void) static void EvoTask_BeginPostSparklesSet1(u8 taskID) { - sub_8149520(); + SetEvoSparklesMatrices(); gTasks[taskID].tFrameCounter = 0; gTasks[taskID].func = EvoTask_CreatePostEvoSparklesSet1; PlaySE(SE_REAPOKE); @@ -321,7 +379,7 @@ u8 LaunchTask_PostEvoSparklesSet2AndFlash(u16 arg0) static void EvoTask_BeginPostSparklesSet2_AndFlash(u8 taskID) { - sub_8149520(); + SetEvoSparklesMatrices(); gTasks[taskID].tFrameCounter = 0; CpuSet(&gPlttBufferFaded[0x20], &gPlttBufferUnfaded[0x20], 0x30); BeginNormalPaletteFade(0xFFF9001C, 0, 0, 0x10, 0x7FFF); @@ -369,7 +427,7 @@ u8 LaunchTask_PostEvoSparklesSet2AndFlash_Trade(u16 arg0) static void EvoTask_BeginPostSparklesSet2_AndFlash_Trade(u8 taskID) { - sub_8149520(); + SetEvoSparklesMatrices(); gTasks[taskID].tFrameCounter = 0; CpuSet(&gPlttBufferFaded[0x20], &gPlttBufferUnfaded[0x20], 0x30); BeginNormalPaletteFade(0xFFF90001, 0, 0, 0x10, 0x7FFF); -- cgit v1.2.3 From 7a26678cc022f466cbee26ae8a9e7011f01b7fb3 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Fri, 25 Aug 2017 15:10:50 -0400 Subject: decompile up to sub_80B40E8 --- src/shop.c | 300 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 299 insertions(+), 1 deletion(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 0ce14c004..110b5cdea 100644 --- a/src/shop.c +++ b/src/shop.c @@ -27,6 +27,7 @@ #include "decoration_inventory.h" extern void sub_80B4378(u8); +extern void sub_80B43F0(u8); extern void sub_80B4470(u8); extern bool8 sub_80A52C4(u8, u8); @@ -42,7 +43,7 @@ struct MartInfo /* 0x0 */ void (* callback) (void); /* 0x4 */ u16 *itemList; /* 0x8 */ u8 itemCount; - /* 0x9 */ u8 cursor; + /* 0x9 */ u8 cursor; // this shows the on-screen true index of the cursor and not the current item selected. /* 0xA */ u8 numChoices; /* 0xB */ u8 choicesAbove; /* 0xC */ u8 martType; @@ -760,3 +761,300 @@ void sub_80B3EFC(u8 taskId) gTasks[taskId].func = sub_80B3DC8; } + +// the next two functions are strange gMenuWindow functions that manually acccess gMenuWindow.tilemap and do weird pointer arithmetic. i'd rather not deal with these right now. +__attribute__((naked)) +void sub_80B3F88(void) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x4\n\ + ldr r0, _080B4020 @ =gMenuWindow\n\ + mov r8, r0\n\ + ldr r1, [r0, 0x28]\n\ + ldr r3, _080B4024 @ =0x000003de\n\ + adds r1, r3\n\ + adds r2, r1, 0\n\ + adds r2, 0x80\n\ + ldr r7, [r0, 0x24]\n\ + mov r10, r7\n\ + ldr r0, _080B4028 @ =0x000003ff\n\ + mov r9, r0\n\ + movs r6, 0xD\n\ +_080B3FAC:\n\ + adds r3, r2, 0\n\ + subs r3, 0x40\n\ + str r3, [sp]\n\ + movs r7, 0x40\n\ + negs r7, r7\n\ + adds r7, r1\n\ + mov r12, r7\n\ + adds r3, r2, 0\n\ + adds r4, r1, 0\n\ + movs r5, 0xE\n\ +_080B3FC0:\n\ + ldrh r2, [r4]\n\ + mov r1, r9\n\ + ands r1, r2\n\ + mov r7, r8\n\ + ldrh r0, [r7, 0x1A]\n\ + adds r0, 0x1\n\ + cmp r1, r0\n\ + ble _080B3FD4\n\ + adds r0, r2, 0\n\ + adds r0, 0x3C\n\ +_080B3FD4:\n\ + strh r0, [r3]\n\ + adds r3, 0x2\n\ + adds r4, 0x2\n\ + subs r5, 0x1\n\ + cmp r5, 0\n\ + bge _080B3FC0\n\ + ldr r2, [sp]\n\ + mov r1, r12\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080B3FAC\n\ + ldr r1, _080B402C @ =0x00003a20\n\ + add r1, r10\n\ + movs r0, 0xF0\n\ + lsls r0, 3\n\ + adds r2, r1, r0\n\ + ldr r3, _080B4030 @ =0x040000d4\n\ + ldr r5, _080B4034 @ =0x800000f0\n\ + ldr r4, _080B4038 @ =0xfffffc40\n\ + movs r6, 0xD\n\ +_080B3FFC:\n\ + str r1, [r3]\n\ + str r2, [r3, 0x4]\n\ + str r5, [r3, 0x8]\n\ + ldr r0, [r3, 0x8]\n\ + adds r2, r4\n\ + adds r1, r4\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080B3FFC\n\ + add sp, 0x4\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_080B4020: .4byte gMenuWindow\n\ +_080B4024: .4byte 0x000003de\n\ +_080B4028: .4byte 0x000003ff\n\ +_080B402C: .4byte 0x00003a20\n\ +_080B4030: .4byte 0x040000d4\n\ +_080B4034: .4byte 0x800000f0\n\ +_080B4038: .4byte 0xfffffc40\n\ + .syntax divided"); +} + +__attribute__((naked)) +void sub_80B403C(void) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x4\n\ + ldr r0, _080B40D8 @ =gMenuWindow\n\ + mov r8, r0\n\ + ldr r2, [r0, 0x28]\n\ + adds r1, r2, 0\n\ + adds r1, 0x9E\n\ + adds r2, r1, 0\n\ + adds r1, 0x80\n\ + ldr r3, [r0, 0x24]\n\ + mov r10, r3\n\ + ldr r7, _080B40DC @ =0x000003ff\n\ + mov r9, r7\n\ + movs r6, 0xD\n\ +_080B4060:\n\ + adds r0, r2, 0\n\ + adds r0, 0x40\n\ + str r0, [sp]\n\ + movs r3, 0x40\n\ + adds r3, r1\n\ + mov r12, r3\n\ + adds r3, r2, 0\n\ + adds r4, r1, 0\n\ + movs r5, 0xE\n\ +_080B4072:\n\ + ldrh r2, [r4]\n\ + mov r1, r9\n\ + ands r1, r2\n\ + mov r7, r8\n\ + ldrh r0, [r7, 0x1A]\n\ + adds r0, 0x1\n\ + cmp r1, r0\n\ + ble _080B4086\n\ + adds r0, r2, 0\n\ + subs r0, 0x3C\n\ +_080B4086:\n\ + strh r0, [r3]\n\ + adds r3, 0x2\n\ + adds r4, 0x2\n\ + subs r5, 0x1\n\ + cmp r5, 0\n\ + bge _080B4072\n\ + ldr r2, [sp]\n\ + mov r1, r12\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080B4060\n\ + movs r1, 0x96\n\ + lsls r1, 4\n\ + add r1, r10\n\ + adds r2, r1, 0\n\ + movs r0, 0xF0\n\ + lsls r0, 3\n\ + adds r1, r0\n\ + ldr r3, _080B40E0 @ =0x040000d4\n\ + ldr r5, _080B40E4 @ =0x800000f0\n\ + movs r4, 0xF0\n\ + lsls r4, 2\n\ + movs r6, 0xD\n\ +_080B40B4:\n\ + str r1, [r3]\n\ + str r2, [r3, 0x4]\n\ + str r5, [r3, 0x8]\n\ + ldr r0, [r3, 0x8]\n\ + adds r2, r4\n\ + adds r1, r4\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080B40B4\n\ + add sp, 0x4\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_080B40D8: .4byte gMenuWindow\n\ +_080B40DC: .4byte 0x000003ff\n\ +_080B40E0: .4byte 0x040000d4\n\ +_080B40E4: .4byte 0x800000f0\n\ + .syntax divided"); +} + +void sub_80B40E8(u8 taskId) // Mart_DoCursorAction +{ + if(!gPaletteFade.active) + { + if((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_UP) // only up can be pressed + { + if(gMartInfo.cursor == 0) + { + if(gMartInfo.choicesAbove == 0) // if there are no choices above, dont bother + return; + + PlaySE(SE_SELECT); + gMartInfo.choicesAbove--; // since cursor is at the top and there are choices above the top, scroll the menu up by updating choicesAbove. + sub_80B3F88(); + sub_80B39D0(0, 0, 0); + sub_80B3A70(); + sub_80B32A4(); + } + else // if the cursor is not 0, choicesAbove cannot be updated yet since the cursor is at the top of the menu, so update cursor. + { + PlaySE(SE_SELECT); + gMartInfo.cursor = MoveMenuCursor(-1); // move cursor up + sub_80B3A70(); + } + } + else if((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_DOWN) // only down can be pressed + { + if(gMartInfo.cursor == 7) // are you at the bottom of the menu? + { + if(gMartInfo.choicesAbove + gMartInfo.cursor == gMartInfo.itemCount) // are you at cancel? + return; + + PlaySE(SE_SELECT); + gMartInfo.choicesAbove++; + sub_80B403C(); + sub_80B39D0(7, 7, 0); + sub_80B3A70(); + sub_80B32A4(); + } + else if(gMartInfo.cursor != gMartInfo.itemCount) + { + PlaySE(SE_SELECT); + gMartInfo.cursor = MoveMenuCursor(1); + sub_80B3A70(); + } + } + else if(gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + + if(gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) // did you not hit CANCEL? + { + PauseVerticalScrollIndicator(0); + PauseVerticalScrollIndicator(1); + sub_80F979C(1, 1); + sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 1); + HandleDestroyMenuCursors(); + MenuZeroFillWindowRect(0, 0xC, 0xD, 0x13); + + if(gMartInfo.martType == MART_TYPE_0) + { + gMartTotalCost = (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)); // set 1x price + if(!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + { + DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); // tail merge + } + else // _080B42BA + { + CopyItemName(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor], gStringVar1); + StringExpandPlaceholders(gStringVar4, gOtherText_HowManyYouWant); + DisplayItemMessageOnField(taskId, gStringVar4, sub_80B3EFC, 0xC3E1); + } + } + else // _080B428C + { + gMartTotalCost = gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].price; + + if(!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + { + DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); // tail merge + } + else + { + StringCopy(gStringVar1, gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].name); + ConvertIntToDecimalStringN(gStringVar2, gMartTotalCost, 0, 0x8); + + if(gMartInfo.martType == MART_TYPE_1) + { + StringExpandPlaceholders(gStringVar4, gOtherText_ThatWillBe2); + } + else + { + StringExpandPlaceholders(gStringVar4, gOtherText_ThatWillBe3); + } + DisplayItemMessageOnField(taskId, gStringVar4, sub_80B3D38, 0xC3E1); + } + } + } + else + sub_80B43F0(taskId); + } + else if(gMain.newKeys & B_BUTTON) // go back to buy/sell/exit menu + { + PlaySE(SE_SELECT); + sub_80B43F0(taskId); + } + } +} -- cgit v1.2.3 From 80d2e6efe070007d3f8d6fe183bc9928cf731175 Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Fri, 25 Aug 2017 22:38:22 +0200 Subject: evolution graphics file is done --- src/evolution_graphics.c | 157 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 154 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/evolution_graphics.c b/src/evolution_graphics.c index 45f60c614..9fd2d7b7a 100644 --- a/src/evolution_graphics.c +++ b/src/evolution_graphics.c @@ -25,6 +25,12 @@ static void EvoTask_BeginPostSparklesSet2_AndFlash_Trade(u8 taskID); static void EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade(u8 taskID); static void EvoTask_DestroyPostSet2AndFlashTask(u8 taskID); +static void sub_8149FC8(u8 taskID); +static void sub_8149FEC(u8 taskID); +static void PreEvoVisible_PostEvoInvisible_KillTask(u8 taskID); +static void PreEvoInVisible_PostEvoVisible_KillTask(u8 taskID); +static void sub_814A03C(u8 taskID); + // const data static const u16 sEvoSparklePalette[] = INCBIN_U16("graphics/misc/evo_sparkle.gbapal"); static const u8 sEvoSparkleTiles[] = INCBIN_U8("graphics/misc/evo_sparkle.4bpp.lz"); @@ -230,7 +236,7 @@ static void SpriteCB_PostEvoSparkleSet2(struct Sprite* sprite) DestroySprite(sprite); } -void CreatePostEvoSparkleSet2(u8 arg0) +static void CreatePostEvoSparkleSet2(u8 arg0) { u8 spriteID = CreateSprite(&sEvoSparkleSpriteTemplate, 120, 56, 0); if (spriteID != MAX_SPRITES) @@ -251,6 +257,8 @@ void LoadEvoSparkleSpriteAndPal(void) LoadSpritePalettes(sEvoSparkleSpritePals); } +#define tFrameCounter data[15] + u8 LaunchTask_PreEvoSparklesSet1(u16 arg0) { u8 taskID = CreateTask(EvoTask_BeginPreSet1_FadeAndPlaySE, 0); @@ -258,8 +266,6 @@ u8 LaunchTask_PreEvoSparklesSet1(u16 arg0) return taskID; } -#define tFrameCounter data[15] - static void EvoTask_BeginPreSet1_FadeAndPlaySE(u8 taskID) { SetEvoSparklesMatrices(); @@ -460,3 +466,148 @@ static void EvoTask_CreatePostEvoSparklesSet2_AndFlash_Trade(u8 taskID) gTasks[taskID].func = EvoTask_DestroyPostSet2AndFlashTask; } +#undef tFrameCounter + +static void PokeEvoSprite_DummySpriteCB(struct Sprite* sprite) +{ + +} + +#define tPreEvoSpriteID data[1] +#define tPostEvoSpriteID data[2] +#define tEvoStopped data[8] + +u8 sub_8149E7C(u8 preEvoSpriteID, u8 postEvoSpriteID) +{ + u16 i; + u16 stack[16]; + u8 taskID; + s32 toDiv; + + for (i = 0; i < 16; i++) + stack[i] = 0x7FFF; + + taskID = CreateTask(sub_8149FC8, 0); + gTasks[taskID].tPreEvoSpriteID = preEvoSpriteID; + gTasks[taskID].tPostEvoSpriteID = postEvoSpriteID; + gTasks[taskID].data[3] = 256; + gTasks[taskID].data[4] = 16; + + toDiv = 65536; + SetOamMatrix(30, 256, 0, 0, 256); + SetOamMatrix(31, toDiv / gTasks[taskID].data[4], 0, 0, toDiv / gTasks[taskID].data[4]); + + gSprites[preEvoSpriteID].callback = PokeEvoSprite_DummySpriteCB; + gSprites[preEvoSpriteID].oam.affineMode = 1; + gSprites[preEvoSpriteID].oam.matrixNum = 30; + gSprites[preEvoSpriteID].invisible = 0; + CpuSet(stack, &gPlttBufferFaded[0x100 + (gSprites[preEvoSpriteID].oam.paletteNum * 16)], 16); + + gSprites[postEvoSpriteID].callback = PokeEvoSprite_DummySpriteCB; + gSprites[postEvoSpriteID].oam.affineMode = 1; + gSprites[postEvoSpriteID].oam.matrixNum = 31; + gSprites[postEvoSpriteID].invisible = 0; + CpuSet(stack, &gPlttBufferFaded[0x100 + (gSprites[postEvoSpriteID].oam.paletteNum * 16)], 16); + + gTasks[taskID].tEvoStopped = FALSE; + return taskID; +} + +static void sub_8149FC8(u8 taskID) +{ + gTasks[taskID].data[5] = 0; + gTasks[taskID].data[6] = 8; + gTasks[taskID].func = sub_8149FEC; +} + +static void sub_8149FEC(u8 taskID) +{ + if (gTasks[taskID].tEvoStopped) + PreEvoVisible_PostEvoInvisible_KillTask(taskID); + else if (gTasks[taskID].data[6] == 128) + PreEvoInVisible_PostEvoVisible_KillTask(taskID); + else + { + gTasks[taskID].data[6] += 2; + gTasks[taskID].data[5] ^= 1; + gTasks[taskID].func = sub_814A03C; + } +} + +static void sub_814A03C(u8 taskID) +{ + if (gTasks[taskID].data[tEvoStopped]) + gTasks[taskID].func = PreEvoVisible_PostEvoInvisible_KillTask; + else + { + u16 oamMatrixArg; + u8 r6 = 0; + if (gTasks[taskID].data[5] == 0) + { + if (gTasks[taskID].data[3] < 256 - gTasks[taskID].data[6]) + gTasks[taskID].data[3] += gTasks[taskID].data[6]; + else + { + gTasks[taskID].data[3] = 256; + r6++; + } + if (gTasks[taskID].data[4] > 16 + gTasks[taskID].data[6]) + gTasks[taskID].data[4] -= gTasks[taskID].data[6]; + else + { + gTasks[taskID].data[4] = 16; + r6++; + } + } + else + { + if (gTasks[taskID].data[4] < 256 - gTasks[taskID].data[6]) + gTasks[taskID].data[4] += gTasks[taskID].data[6]; + else + { + gTasks[taskID].data[4] = 256; + r6++; + } + if (gTasks[taskID].data[3] > 16 + gTasks[taskID].data[6]) + gTasks[taskID].data[3] -= gTasks[taskID].data[6]; + else + { + gTasks[taskID].data[3] = 16; + r6++; + } + } + oamMatrixArg = 65536 / gTasks[taskID].data[3]; + SetOamMatrix(30, oamMatrixArg, 0, 0, oamMatrixArg); + + oamMatrixArg = 65536 / gTasks[taskID].data[4]; + SetOamMatrix(31, oamMatrixArg, 0, 0, oamMatrixArg); + if (r6 == 2) + gTasks[taskID].func = sub_8149FEC; + } +} + +static void PreEvoInVisible_PostEvoVisible_KillTask(u8 taskID) +{ + gSprites[gTasks[taskID].tPreEvoSpriteID].oam.affineMode = 0; + gSprites[gTasks[taskID].tPreEvoSpriteID].oam.matrixNum = 0; + gSprites[gTasks[taskID].tPreEvoSpriteID].invisible = 1; + + gSprites[gTasks[taskID].tPostEvoSpriteID].oam.affineMode = 0; + gSprites[gTasks[taskID].tPostEvoSpriteID].oam.matrixNum = 0; + gSprites[gTasks[taskID].tPostEvoSpriteID].invisible = 0; + + DestroyTask(taskID); +} + +static void PreEvoVisible_PostEvoInvisible_KillTask(u8 taskID) +{ + gSprites[gTasks[taskID].tPreEvoSpriteID].oam.affineMode = 0; + gSprites[gTasks[taskID].tPreEvoSpriteID].oam.matrixNum = 0; + gSprites[gTasks[taskID].tPreEvoSpriteID].invisible = 0; + + gSprites[gTasks[taskID].tPostEvoSpriteID].oam.affineMode = 0; + gSprites[gTasks[taskID].tPostEvoSpriteID].oam.matrixNum = 0; + gSprites[gTasks[taskID].tPostEvoSpriteID].invisible = 1; + + DestroyTask(taskID); +} -- cgit v1.2.3 From e394b1e04bf3ac5ab9fc7bb7f80e8d349603acdd Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sat, 26 Aug 2017 00:01:25 +0200 Subject: i need sleep --- src/evolution_graphics.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/evolution_graphics.c b/src/evolution_graphics.c index 9fd2d7b7a..a47e63a59 100644 --- a/src/evolution_graphics.c +++ b/src/evolution_graphics.c @@ -536,7 +536,7 @@ static void sub_8149FEC(u8 taskID) static void sub_814A03C(u8 taskID) { - if (gTasks[taskID].data[tEvoStopped]) + if (gTasks[taskID].tEvoStopped) gTasks[taskID].func = PreEvoVisible_PostEvoInvisible_KillTask; else { -- cgit v1.2.3 From 1ab4ed75e7daae4b17cfca2970e935f653236014 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Fri, 25 Aug 2017 19:09:46 -0400 Subject: decompile up to nonmatching sub_80B4470 --- src/shop.c | 174 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 171 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 110b5cdea..b053e3f2e 100644 --- a/src/shop.c +++ b/src/shop.c @@ -26,9 +26,6 @@ #include "rom4.h" #include "decoration_inventory.h" -extern void sub_80B4378(u8); -extern void sub_80B43F0(u8); -extern void sub_80B4470(u8); extern bool8 sub_80A52C4(u8, u8); enum @@ -53,6 +50,7 @@ struct MartInfo extern struct MartInfo gMartInfo; extern struct MenuAction gUnknown_083CC6D0[]; extern struct YesNoFuncTable gUnknown_083CC708[]; +extern struct ItemSlot gUnknown_02038724[3]; extern u32 gMartTotalCost; // the total cost of a purchase before checking out. @@ -74,6 +72,8 @@ enum ANIM_NUM }; +extern u8 gUnknown_02038730; + extern s16 gUnknown_020386A4[][4]; // game freak barely uses 2d arrays wtf? extern u16 gBuyMenuFrame_Tilemap[]; @@ -82,6 +82,10 @@ extern u16 gUnknown_083CC710[2]; void sub_80B39D0(int var1, int var2, bool32 hasControlCode); void sub_80B3A70(void); +void sub_80B4378(u8); +void sub_80B43F0(u8); +void Task_ExitBuyMenu(u8); +void sub_80B4470(u8); u8 CreateShopMenu(u8 martType) { @@ -1058,3 +1062,167 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction } } } + +void sub_80B4378(u8 taskId) +{ + MenuZeroFillWindowRect(0, 0xE, 0x1D, 0x13); + MenuZeroFillWindowRect(0, 0xA, 0xD, 0xD); + sub_80A3FA0(gBGTilemapBuffers[1], 0x1, 0xB, 0xC, 0x2, 0); + sub_80B3420(); + sub_80B3764(6, 7); + sub_80B37EC(); + StartVerticalScrollIndicators(0); + StartVerticalScrollIndicators(1); + sub_80B32A4(); + gTasks[taskId].func = sub_80B40E8; +} + +void sub_80B43F0(u8 taskId) +{ + gFieldCallback = sub_80B3050; + BeginNormalPaletteFade(-1, 0, 0, 0x10, 0); + gTasks[taskId].func = Task_ExitBuyMenu; +} + +void Task_ExitBuyMenu(u8 taskId) +{ + if(!gPaletteFade.active) + { + RemoveMoneyLabelObject(0, 0); + BuyMenuFreeMemory(); + SetMainCallback2(c2_exit_to_overworld_2_switch); + DestroyTask(taskId); + } +} + +// in the for loop, the loop prologue is not correct and loads choicesabove + cursor immediately instead of setting up the gUnknown_02038724 struct. +#ifdef NONMATCHING +void sub_80B4470(u8 taskId) +{ + u16 i; + + for(i = 0; i < 3; i++) + { + if(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] != gUnknown_02038724[i].itemId || gUnknown_02038724[i].quantity == 0) + continue; + + if(gTasks[taskId].data[1] + gUnknown_02038724[i].quantity > 255) + gUnknown_02038724[i].quantity = 255; + else + gUnknown_02038724[i].quantity += gTasks[taskId].data[1]; + return; + } + + if(gUnknown_02038730 < 3) + { + gUnknown_02038724[gUnknown_02038730].itemId = gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]; + gUnknown_02038724[gUnknown_02038730].quantity = gTasks[taskId].data[1]; + gUnknown_02038730++; + } +} +#else +__attribute__((naked)) +void sub_80B4470(u8 taskId) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r9\n\ + mov r6, r8\n\ + push {r6,r7}\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + movs r2, 0\n\ + ldr r0, _080B44C8 @ =gUnknown_02038724\n\ + mov r12, r0\n\ + ldr r6, _080B44CC @ =gMartInfo\n\ + mov r8, r12\n\ + adds r4, r6, 0\n\ + ldr r1, _080B44D0 @ =gTasks\n\ + mov r9, r1\n\ + lsls r0, r5, 2\n\ + adds r0, r5\n\ + lsls r7, r0, 3\n\ +_080B4492:\n\ + lsls r0, r2, 2\n\ + mov r1, r8\n\ + adds r3, r0, r1\n\ + ldrb r0, [r4, 0xB]\n\ + ldrb r1, [r4, 0x9]\n\ + adds r0, r1\n\ + ldr r1, [r4, 0x4]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r1, [r3]\n\ + ldrh r0, [r0]\n\ + cmp r1, r0\n\ + bne _080B44DC\n\ + ldrh r0, [r3, 0x2]\n\ + cmp r0, 0\n\ + beq _080B44DC\n\ + adds r2, r0, 0\n\ + mov r4, r9\n\ + adds r1, r7, r4\n\ + movs r4, 0xA\n\ + ldrsh r0, [r1, r4]\n\ + adds r0, r2, r0\n\ + cmp r0, 0xFF\n\ + ble _080B44D4\n\ + movs r0, 0xFF\n\ + strh r0, [r3, 0x2]\n\ + b _080B451E\n\ + .align 2, 0\n\ +_080B44C8: .4byte gUnknown_02038724\n\ +_080B44CC: .4byte gMartInfo\n\ +_080B44D0: .4byte gTasks\n\ +_080B44D4:\n\ + ldrh r0, [r1, 0xA]\n\ + adds r0, r2, r0\n\ + strh r0, [r3, 0x2]\n\ + b _080B451E\n\ +_080B44DC:\n\ + adds r0, r2, 0x1\n\ + lsls r0, 16\n\ + lsrs r2, r0, 16\n\ + cmp r2, 0x2\n\ + bls _080B4492\n\ + ldr r3, _080B452C @ =gUnknown_02038730\n\ + ldrb r0, [r3]\n\ + cmp r0, 0x2\n\ + bhi _080B451E\n\ + adds r2, r0, 0\n\ + lsls r2, 2\n\ + add r2, r12\n\ + ldrb r0, [r6, 0xB]\n\ + ldrb r1, [r6, 0x9]\n\ + adds r0, r1\n\ + ldr r1, [r6, 0x4]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r0, [r0]\n\ + strh r0, [r2]\n\ + ldrb r1, [r3]\n\ + lsls r1, 2\n\ + add r1, r12\n\ + ldr r2, _080B4530 @ =gTasks\n\ + lsls r0, r5, 2\n\ + adds r0, r5\n\ + lsls r0, 3\n\ + adds r0, r2\n\ + ldrh r0, [r0, 0xA]\n\ + strh r0, [r1, 0x2]\n\ + ldrb r0, [r3]\n\ + adds r0, 0x1\n\ + strb r0, [r3]\n\ +_080B451E:\n\ + pop {r3,r4}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_080B452C: .4byte gUnknown_02038730\n\ +_080B4530: .4byte gTasks\n\ + .syntax divided"); +} +#endif -- cgit v1.2.3 From efd3e208f10ed2db25871bab49b9462ab7efb903 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Fri, 25 Aug 2017 20:30:35 -0400 Subject: finish decompiling shop.c except for a few indented functions --- src/shop.c | 295 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 295 insertions(+) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index b053e3f2e..737d0e2bd 100644 --- a/src/shop.c +++ b/src/shop.c @@ -25,6 +25,7 @@ #include "songs.h" #include "rom4.h" #include "decoration_inventory.h" +#include "field_camera.h" extern bool8 sub_80A52C4(u8, u8); @@ -73,6 +74,7 @@ enum }; extern u8 gUnknown_02038730; +extern u8 gUnknown_02038731; extern s16 gUnknown_020386A4[][4]; // game freak barely uses 2d arrays wtf? @@ -1226,3 +1228,296 @@ _080B4530: .4byte gTasks\n\ .syntax divided"); } #endif + +void ClearItemPurchases(void) +{ + gUnknown_02038730 = 0; + ClearItemSlots(gUnknown_02038724, 3); +} + +void CreatePokemartMenu(u16 *itemList) +{ + CreateShopMenu(MART_TYPE_0); + SetShopItemsForSale(itemList); + ClearItemPurchases(); + SetShopMenuCallback(EnableBothScriptContexts); +} + +void CreateDecorationShop1Menu(u16 *itemList) +{ + CreateShopMenu(MART_TYPE_1); + SetShopItemsForSale(itemList); + SetShopMenuCallback(EnableBothScriptContexts); +} + +void CreateDecorationShop2Menu(u16 *itemList) +{ + CreateShopMenu(MART_TYPE_2); + SetShopItemsForSale(itemList); + SetShopMenuCallback(EnableBothScriptContexts); +} + +// no. +__attribute__((naked)) +void sub_80B45B4(u8 taskId, u16 *list, int var3) +{ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x10\n\ + mov r9, r1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + lsls r2, 16\n\ + lsrs r2, 16\n\ + mov r10, r2\n\ + ldr r2, _080B4648 @ =gTasks\n\ + lsls r1, r0, 2\n\ + adds r1, r0\n\ + lsls r1, 3\n\ + adds r1, r2\n\ + ldrh r0, [r1, 0x10]\n\ + subs r0, 0x1\n\ + lsls r0, 16\n\ + lsrs r5, r0, 16\n\ + ldrh r0, [r1, 0x12]\n\ + subs r0, 0x1\n\ + lsls r0, 16\n\ + lsrs r3, r0, 16\n\ + ldrh r4, [r1, 0xA]\n\ + movs r2, 0xC\n\ + ldrsh r0, [r1, r2]\n\ + cmp r0, 0\n\ + bne _080B4678\n\ + movs r2, 0\n\ + lsls r5, 16\n\ + str r5, [sp, 0xC]\n\ + lsls r0, r3, 16\n\ + lsls r1, r4, 16\n\ + asrs r0, 16\n\ + str r0, [sp]\n\ + asrs r1, 16\n\ + str r1, [sp, 0x4]\n\ + lsls r0, r1, 1\n\ + mov r1, r9\n\ + adds r7, r0, r1\n\ +_080B4608:\n\ + movs r4, 0\n\ + lsls r2, 16\n\ + mov r8, r2\n\ + asrs r0, r2, 16\n\ + ldr r2, [sp]\n\ + adds r6, r2, r0\n\ +_080B4614:\n\ + ldr r0, [sp, 0xC]\n\ + asrs r1, r0, 16\n\ + lsls r4, 16\n\ + asrs r0, r4, 16\n\ + adds r5, r1, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridGetMetatileIdAt\n\ + movs r2, 0\n\ + ldrsh r1, [r7, r2]\n\ + lsls r0, 16\n\ + asrs r0, 16\n\ + cmp r1, r0\n\ + bne _080B465C\n\ + ldr r0, [sp, 0x4]\n\ + cmp r0, 0x2\n\ + beq _080B464C\n\ + ldrh r0, [r7, 0x2]\n\ + mov r2, r10\n\ + orrs r2, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridSetMetatileIdAt\n\ + b _080B465C\n\ + .align 2, 0\n\ +_080B4648: .4byte gTasks\n\ +_080B464C:\n\ + mov r1, r9\n\ + ldrh r0, [r1]\n\ + mov r2, r10\n\ + orrs r2, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridSetMetatileIdAt\n\ +_080B465C:\n\ + movs r2, 0x80\n\ + lsls r2, 9\n\ + adds r0, r4, r2\n\ + lsrs r4, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x2\n\ + ble _080B4614\n\ + adds r0, r2, 0\n\ + add r0, r8\n\ + lsrs r2, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x2\n\ + ble _080B4608\n\ + b _080B4700\n\ +_080B4678:\n\ + movs r2, 0\n\ + lsls r5, 16\n\ + str r5, [sp, 0xC]\n\ + lsls r0, r3, 16\n\ + lsls r1, r4, 16\n\ + asrs r0, 16\n\ + str r0, [sp, 0x8]\n\ + asrs r7, r1, 16\n\ +_080B4688:\n\ + movs r4, 0\n\ + lsls r2, 16\n\ + mov r8, r2\n\ + asrs r0, r2, 16\n\ + ldr r1, [sp, 0x8]\n\ + adds r6, r1, r0\n\ +_080B4694:\n\ + ldr r2, [sp, 0xC]\n\ + asrs r1, r2, 16\n\ + lsls r4, 16\n\ + asrs r0, r4, 16\n\ + adds r5, r1, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridGetMetatileIdAt\n\ + movs r1, 0x2\n\ + subs r1, r7\n\ + lsls r1, 1\n\ + add r1, r9\n\ + movs r2, 0\n\ + ldrsh r1, [r1, r2]\n\ + lsls r0, 16\n\ + asrs r0, 16\n\ + cmp r1, r0\n\ + bne _080B46E6\n\ + cmp r7, 0x2\n\ + beq _080B46D6\n\ + movs r0, 0x1\n\ + subs r0, r7\n\ + lsls r0, 1\n\ + add r0, r9\n\ + ldrh r0, [r0]\n\ + mov r2, r10\n\ + orrs r2, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridSetMetatileIdAt\n\ + b _080B46E6\n\ +_080B46D6:\n\ + mov r1, r9\n\ + ldrh r0, [r1, 0x4]\n\ + mov r2, r10\n\ + orrs r2, r0\n\ + adds r0, r5, 0\n\ + adds r1, r6, 0\n\ + bl MapGridSetMetatileIdAt\n\ +_080B46E6:\n\ + movs r2, 0x80\n\ + lsls r2, 9\n\ + adds r0, r4, r2\n\ + lsrs r4, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x2\n\ + ble _080B4694\n\ + adds r0, r2, 0\n\ + add r0, r8\n\ + lsrs r2, r0, 16\n\ + asrs r0, 16\n\ + cmp r0, 0x2\n\ + ble _080B4688\n\ +_080B4700:\n\ + add sp, 0x10\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .syntax divided"); +} + +extern u16 gUnknown_083CC714[]; +extern u16 gUnknown_083CC71A[]; +extern u16 gUnknown_083CC720[]; +extern u16 gUnknown_083CC726[]; +extern u16 gUnknown_083CC72C[]; +extern u16 gUnknown_083CC732[]; +extern u16 gUnknown_083CC738[]; + +void sub_80B4710(u8 taskId) +{ + s16 *data = gTasks[taskId].data; + + data[3] = 1; + + switch(data[0]) + { + case 0: + sub_80B45B4(taskId, gUnknown_083CC714, 0); + break; + case 1: + sub_80B45B4(taskId, gUnknown_083CC71A, 0); + break; + case 2: + sub_80B45B4(taskId, gUnknown_083CC720, 0xC00); + break; + case 3: + sub_80B45B4(taskId, gUnknown_083CC726, 0); + break; + case 4: + sub_80B45B4(taskId, gUnknown_083CC72C, 0xC00); + break; + case 5: + sub_80B45B4(taskId, gUnknown_083CC732, 0); + break; + case 6: + sub_80B45B4(taskId, gUnknown_083CC738, 0); + break; + } + + data[0] = (data[0] + 1) & 7; + if(!data[0]) + { + DrawWholeMapView(); + data[1] = (data[1] + 1) % 3; + data[3] = 0; + } +} + +u8 sub_80B47D8(u16 var) +{ + u8 taskId = CreateTask(sub_80B4710, 0); + s16 *data = gTasks[taskId].data; + + PlayerGetDestCoords(&data[4], &data[5]); + data[0] = 0; + data[1] = 0; + data[2] = var; + sub_80B4710(taskId); + return taskId; +} + +void sub_80B4824(u8 var) +{ + gUnknown_02038731 = sub_80B47D8(var); +} + +void sub_80B483C(void) +{ + DestroyTask(gUnknown_02038731); +} + +bool8 sub_80B4850(void) +{ + if(gTasks[gUnknown_02038731].data[3] == 0 && gTasks[gUnknown_02038731].data[1] == 2) + return FALSE; + else + return TRUE; +} -- cgit v1.2.3 From e9037c7861b70d39686608b3eace9e9443c18c44 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Fri, 25 Aug 2017 23:38:46 -0400 Subject: move data to C --- src/shop.c | 85 ++++++++++++++++++++++++++++---------------------------------- 1 file changed, 38 insertions(+), 47 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 737d0e2bd..ca7609e72 100644 --- a/src/shop.c +++ b/src/shop.c @@ -27,52 +27,20 @@ #include "decoration_inventory.h" #include "field_camera.h" -extern bool8 sub_80A52C4(u8, u8); - -enum -{ - MART_TYPE_0, // normal mart - MART_TYPE_1, - MART_TYPE_2, -}; +#define ewram18000 ((u16 *)(ewram + 0x18000)) +#define ewram18300 ((u16 *)(ewram + 0x18300)) -struct MartInfo -{ - /* 0x0 */ void (* callback) (void); - /* 0x4 */ u16 *itemList; - /* 0x8 */ u8 itemCount; - /* 0x9 */ u8 cursor; // this shows the on-screen true index of the cursor and not the current item selected. - /* 0xA */ u8 numChoices; - /* 0xB */ u8 choicesAbove; - /* 0xC */ u8 martType; - /* 0xD */ u8 unkD; -}; +extern bool8 sub_80A52C4(u8, u8); extern struct MartInfo gMartInfo; -extern struct MenuAction gUnknown_083CC6D0[]; -extern struct YesNoFuncTable gUnknown_083CC708[]; extern struct ItemSlot gUnknown_02038724[3]; extern u32 gMartTotalCost; // the total cost of a purchase before checking out. extern u8 ewram[]; -extern u8 gUnknown_083CC6E8[]; -extern u8 gUnknown_083CC6EB[]; extern u8 gBuyMenuFrame_Gfx[]; -#define ewram18000 ((u16 *)(ewram + 0x18000)) -#define ewram18300 ((u16 *)(ewram + 0x18300)) - -// shop view window NPC info enum -enum -{ - MAP_OBJ_ID, - X_COORD, - Y_COORD, - ANIM_NUM -}; - extern u8 gUnknown_02038730; extern u8 gUnknown_02038731; @@ -80,7 +48,6 @@ extern s16 gUnknown_020386A4[][4]; // game freak barely uses 2d arrays wtf? extern u16 gBuyMenuFrame_Tilemap[]; extern u16 gMenuMoneyPal[16]; -extern u16 gUnknown_083CC710[2]; void sub_80B39D0(int var1, int var2, bool32 hasControlCode); void sub_80B3A70(void); @@ -88,6 +55,38 @@ void sub_80B4378(u8); void sub_80B43F0(u8); void Task_ExitBuyMenu(u8); void sub_80B4470(u8); +void sub_80B2EFC(u8 taskId); +void sub_80B2F30(u8 taskId); +void HandleShopMenuQuit(u8 taskId); +void sub_80B3BF4(u8 taskId); +void sub_80B3D7C(u8 taskId); + +static const struct MenuAction2 gUnknown_083CC6D0[] = +{ + { MartText_Buy, sub_80B2EFC }, + { MartText_Sell, sub_80B2F30 }, + { MartText_Quit2, HandleShopMenuQuit }, +}; + +static const u8 gUnknown_083CC6E8[] = {0, 1, 2}; // BUY SELL EXIT +static const u8 gUnknown_083CC6EB[] = {0, 2}; // BUY EXIT + +static const u16 gUnusedMartArray[] = {0x2, 0x3, 0x4, 0xD, 0x121, 0xE, 0xE, 0xE, 0xE, 0xE, 0xE, 0x0, 0x0}; + +static const struct YesNoFuncTable gUnknown_083CC708[] = +{ + sub_80B3BF4, + sub_80B3D7C +}; + +static const u16 gUnknown_083CC710[] = {0x41EE, 0x7FFF}; +static const u16 gUnknown_083CC714[] = {0x284, 0x282, 0x280}; +static const u16 gUnknown_083CC71A[] = {0x285, 0x283, 0x281}; +static const u16 gUnknown_083CC720[] = {0x28C, 0x28A, 0x288}; +static const u16 gUnknown_083CC726[] = {0x28D, 0x28B, 0x289}; +static const u16 gUnknown_083CC72C[] = {0x2A0, 0x2A2, 0x2A4}; +static const u16 gUnknown_083CC732[] = {0x2A1, 0x2A3, 0x2A5}; +static const u16 gUnknown_083CC738[] = {0x2A8, 0x2AA, 0x2AC}; u8 CreateShopMenu(u8 martType) { @@ -99,13 +98,13 @@ u8 CreateShopMenu(u8 martType) { gMartInfo.numChoices = 2; MenuDrawTextWindow(0, 0, 10, 7); - PrintMenuItemsReordered(1, 1, 3, gUnknown_083CC6D0, (u8 *)gUnknown_083CC6E8); + PrintMenuItemsReordered(1, 1, 3, (struct MenuAction *)gUnknown_083CC6D0, (u8 *)gUnknown_083CC6E8); } else { gMartInfo.numChoices = 1; MenuDrawTextWindow(0, 0, 10, 5); - PrintMenuItemsReordered(1, 1, 2, gUnknown_083CC6D0, (u8 *)gUnknown_083CC6EB); + PrintMenuItemsReordered(1, 1, 2, (struct MenuAction *)gUnknown_083CC6D0, (u8 *)gUnknown_083CC6EB); } InitMenu(0, 1, 1, gMartInfo.numChoices + 1, 0, 9); // add 1 for cancel @@ -1259,7 +1258,7 @@ void CreateDecorationShop2Menu(u16 *itemList) // no. __attribute__((naked)) -void sub_80B45B4(u8 taskId, u16 *list, int var3) +void sub_80B45B4(u8 taskId, const u16 *list, int var3) { asm(".syntax unified\n\ push {r4-r7,lr}\n\ @@ -1443,14 +1442,6 @@ _080B4700:\n\ .syntax divided"); } -extern u16 gUnknown_083CC714[]; -extern u16 gUnknown_083CC71A[]; -extern u16 gUnknown_083CC720[]; -extern u16 gUnknown_083CC726[]; -extern u16 gUnknown_083CC72C[]; -extern u16 gUnknown_083CC732[]; -extern u16 gUnknown_083CC738[]; - void sub_80B4710(u8 taskId) { s16 *data = gTasks[taskId].data; -- cgit v1.2.3 From 5c7f78d8bc897f5bf4d9d18352bc81626ee09437 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 00:03:29 -0400 Subject: iwram and ewram data --- src/shop.c | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index ca7609e72..060e84693 100644 --- a/src/shop.c +++ b/src/shop.c @@ -32,20 +32,8 @@ extern bool8 sub_80A52C4(u8, u8); -extern struct MartInfo gMartInfo; -extern struct ItemSlot gUnknown_02038724[3]; - -extern u32 gMartTotalCost; // the total cost of a purchase before checking out. - extern u8 ewram[]; - extern u8 gBuyMenuFrame_Gfx[]; - -extern u8 gUnknown_02038730; -extern u8 gUnknown_02038731; - -extern s16 gUnknown_020386A4[][4]; // game freak barely uses 2d arrays wtf? - extern u16 gBuyMenuFrame_Tilemap[]; extern u16 gMenuMoneyPal[16]; @@ -61,6 +49,17 @@ void HandleShopMenuQuit(u8 taskId); void sub_80B3BF4(u8 taskId); void sub_80B3D7C(u8 taskId); +// iwram +static struct MartInfo gMartInfo; + +// ewram +EWRAM_DATA u32 gMartTotalCost = 0; +EWRAM_DATA s16 gUnknown_020386A4[16][4] = {0}; // game freak barely uses 2d arrays wtf? +EWRAM_DATA struct ItemSlot gUnknown_02038724[3] = {0}; // tv.c uses this, so it cant be static +EWRAM_DATA u8 gUnknown_02038730 = 0; +EWRAM_DATA u8 gUnknown_02038731 = 0; + +// rodata static const struct MenuAction2 gUnknown_083CC6D0[] = { { MartText_Buy, sub_80B2EFC }, -- cgit v1.2.3 From 027dc5448e9a5cc90ca6fa4e37d9b73ec342cfe5 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 00:25:28 -0400 Subject: formatting --- src/shop.c | 68 +++++++++++++++++++++++++++++++------------------------------- 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 060e84693..e523f927c 100644 --- a/src/shop.c +++ b/src/shop.c @@ -643,12 +643,12 @@ void sub_80B3A70(void) void sub_80B3AEC(u8 taskId) { - if(gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) + if (gMain.newKeys & A_BUTTON || gMain.newKeys & B_BUTTON) { sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); // huh??? PlaySE(SE_SELECT); - if(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] == ITEM_POKE_BALL && gTasks[taskId].data[1] >= 10 && AddBagItem(ITEM_PREMIER_BALL, 1) == TRUE) + if (gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] == ITEM_POKE_BALL && gTasks[taskId].data[1] >= 10 && AddBagItem(ITEM_PREMIER_BALL, 1) == TRUE) DisplayItemMessageOnField(taskId, gOtherText_FreePremierBall, sub_80B4378, 0xC3E1); else sub_80B4378(taskId); @@ -677,11 +677,11 @@ void sub_80B3BF4(u8 taskId) sub_80B379C(); sub_80B3420(); - if(IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + if (IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) { - if(gMartInfo.martType == MART_TYPE_0) + if (gMartInfo.martType == MART_TYPE_0) { - if(AddBagItem(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor], gTasks[taskId].data[1])) + if (AddBagItem(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor], gTasks[taskId].data[1])) { DisplayItemMessageOnField(taskId, gOtherText_HereYouGo, sub_80B3B80, 0xC3E1); sub_80B4470(taskId); @@ -691,9 +691,9 @@ void sub_80B3BF4(u8 taskId) } else // a normal mart is only type 0, so types 1 and 2 are decoration marts. { - if(IsThereStorageSpaceForDecoration(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor])) + if (IsThereStorageSpaceForDecoration(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor])) { - if(gMartInfo.martType == MART_TYPE_1) + if (gMartInfo.martType == MART_TYPE_1) DisplayItemMessageOnField(taskId, gOtherText_HereYouGo2, sub_80B3B80, 0xC3E1); else DisplayItemMessageOnField(taskId, gOtherText_HereYouGo3, sub_80B3B80, 0xC3E1); @@ -726,10 +726,10 @@ void sub_80B3D7C(u8 taskId) void sub_80B3DC8(u8 taskId) { - if(sub_80A52C4(taskId, gMartInfo.unkD) == TRUE) + if (sub_80A52C4(taskId, gMartInfo.unkD) == TRUE) sub_80B37F8(taskId); - if(gMain.newKeys & A_BUTTON) + if (gMain.newKeys & A_BUTTON) { gMartTotalCost = (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)) * gTasks[taskId].data[1]; // set total cost of your purchase. MenuZeroFillWindowRect(0, 0xA, 0xD, 0xD); @@ -742,7 +742,7 @@ void sub_80B3DC8(u8 taskId) StringExpandPlaceholders(gStringVar4, gOtherText_ThatWillBe); DisplayItemMessageOnField(taskId, gStringVar4, sub_80B3D38, 0xC3E1); } - else if(gMain.newKeys & B_BUTTON) + else if (gMain.newKeys & B_BUTTON) { sub_80B39D0(gMartInfo.cursor, gMartInfo.cursor, 0); sub_80B4378(taskId); @@ -758,7 +758,7 @@ void sub_80B3EFC(u8 taskId) sub_80B37F8(taskId); var = gSaveBlock1.money / (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)); - if(var > 99) + if (var > 99) gMartInfo.unkD = 99; else gMartInfo.unkD = var; @@ -956,13 +956,13 @@ _080B40E4: .4byte 0x800000f0\n\ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction { - if(!gPaletteFade.active) + if (!gPaletteFade.active) { - if((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_UP) // only up can be pressed + if ((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_UP) // only up can be pressed { - if(gMartInfo.cursor == 0) + if (gMartInfo.cursor == 0) { - if(gMartInfo.choicesAbove == 0) // if there are no choices above, dont bother + if (gMartInfo.choicesAbove == 0) // if there are no choices above, dont bother return; PlaySE(SE_SELECT); @@ -979,11 +979,11 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction sub_80B3A70(); } } - else if((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_DOWN) // only down can be pressed + else if ((gMain.newAndRepeatedKeys & DPAD_ANY) == DPAD_DOWN) // only down can be pressed { - if(gMartInfo.cursor == 7) // are you at the bottom of the menu? + if (gMartInfo.cursor == 7) // are you at the bottom of the menu? { - if(gMartInfo.choicesAbove + gMartInfo.cursor == gMartInfo.itemCount) // are you at cancel? + if (gMartInfo.choicesAbove + gMartInfo.cursor == gMartInfo.itemCount) // are you at cancel? return; PlaySE(SE_SELECT); @@ -993,18 +993,18 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction sub_80B3A70(); sub_80B32A4(); } - else if(gMartInfo.cursor != gMartInfo.itemCount) + else if (gMartInfo.cursor != gMartInfo.itemCount) { PlaySE(SE_SELECT); gMartInfo.cursor = MoveMenuCursor(1); sub_80B3A70(); } } - else if(gMain.newKeys & A_BUTTON) + else if (gMain.newKeys & A_BUTTON) { PlaySE(SE_SELECT); - if(gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) // did you not hit CANCEL? + if (gMartInfo.choicesAbove + gMartInfo.cursor != gMartInfo.itemCount) // did you not hit CANCEL? { PauseVerticalScrollIndicator(0); PauseVerticalScrollIndicator(1); @@ -1013,10 +1013,10 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction HandleDestroyMenuCursors(); MenuZeroFillWindowRect(0, 0xC, 0xD, 0x13); - if(gMartInfo.martType == MART_TYPE_0) + if (gMartInfo.martType == MART_TYPE_0) { gMartTotalCost = (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)); // set 1x price - if(!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + if (!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) { DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); // tail merge } @@ -1031,7 +1031,7 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction { gMartTotalCost = gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].price; - if(!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) + if (!IsEnoughMoney(gSaveBlock1.money, gMartTotalCost)) { DisplayItemMessageOnField(taskId, gOtherText_NotEnoughMoney, sub_80B3BD0, 0xC3E1); // tail merge } @@ -1040,7 +1040,7 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction StringCopy(gStringVar1, gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].name); ConvertIntToDecimalStringN(gStringVar2, gMartTotalCost, 0, 0x8); - if(gMartInfo.martType == MART_TYPE_1) + if (gMartInfo.martType == MART_TYPE_1) { StringExpandPlaceholders(gStringVar4, gOtherText_ThatWillBe2); } @@ -1055,7 +1055,7 @@ void sub_80B40E8(u8 taskId) // Mart_DoCursorAction else sub_80B43F0(taskId); } - else if(gMain.newKeys & B_BUTTON) // go back to buy/sell/exit menu + else if (gMain.newKeys & B_BUTTON) // go back to buy/sell/exit menu { PlaySE(SE_SELECT); sub_80B43F0(taskId); @@ -1086,7 +1086,7 @@ void sub_80B43F0(u8 taskId) void Task_ExitBuyMenu(u8 taskId) { - if(!gPaletteFade.active) + if (!gPaletteFade.active) { RemoveMoneyLabelObject(0, 0); BuyMenuFreeMemory(); @@ -1101,19 +1101,19 @@ void sub_80B4470(u8 taskId) { u16 i; - for(i = 0; i < 3; i++) + for (i = 0; i < 3; i++) { - if(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] != gUnknown_02038724[i].itemId || gUnknown_02038724[i].quantity == 0) + if (gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] != gUnknown_02038724[i].itemId || gUnknown_02038724[i].quantity == 0) continue; - if(gTasks[taskId].data[1] + gUnknown_02038724[i].quantity > 255) + if (gTasks[taskId].data[1] + gUnknown_02038724[i].quantity > 255) gUnknown_02038724[i].quantity = 255; else gUnknown_02038724[i].quantity += gTasks[taskId].data[1]; return; } - if(gUnknown_02038730 < 3) + if (gUnknown_02038730 < 3) { gUnknown_02038724[gUnknown_02038730].itemId = gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]; gUnknown_02038724[gUnknown_02038730].quantity = gTasks[taskId].data[1]; @@ -1447,7 +1447,7 @@ void sub_80B4710(u8 taskId) data[3] = 1; - switch(data[0]) + switch (data[0]) { case 0: sub_80B45B4(taskId, gUnknown_083CC714, 0); @@ -1473,7 +1473,7 @@ void sub_80B4710(u8 taskId) } data[0] = (data[0] + 1) & 7; - if(!data[0]) + if (!data[0]) { DrawWholeMapView(); data[1] = (data[1] + 1) % 3; @@ -1506,7 +1506,7 @@ void sub_80B483C(void) bool8 sub_80B4850(void) { - if(gTasks[gUnknown_02038731].data[3] == 0 && gTasks[gUnknown_02038731].data[1] == 2) + if (gTasks[gUnknown_02038731].data[3] == 0 && gTasks[gUnknown_02038731].data[1] == 2) return FALSE; else return TRUE; -- cgit v1.2.3 From 0c3a2fb275129567b23ef0ed520c04aece90079f Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 14:10:07 -0400 Subject: matching sub_80B4470 and nonmatching sub_80B3F88 and sub_80B403C --- src/shop.c | 446 ++++++++++++++++++++----------------------------------------- 1 file changed, 143 insertions(+), 303 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index e523f927c..30f23e10f 100644 --- a/src/shop.c +++ b/src/shop.c @@ -726,7 +726,7 @@ void sub_80B3D7C(u8 taskId) void sub_80B3DC8(u8 taskId) { - if (sub_80A52C4(taskId, gMartInfo.unkD) == TRUE) + if (sub_80A52C4(taskId, gMartInfo.curItemCount) == TRUE) sub_80B37F8(taskId); if (gMain.newKeys & A_BUTTON) @@ -759,14 +759,55 @@ void sub_80B3EFC(u8 taskId) var = gSaveBlock1.money / (ItemId_GetPrice(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]) >> GetPriceReduction(1)); if (var > 99) - gMartInfo.unkD = 99; + gMartInfo.curItemCount = 99; else - gMartInfo.unkD = var; + gMartInfo.curItemCount = var; gTasks[taskId].func = sub_80B3DC8; } -// the next two functions are strange gMenuWindow functions that manually acccess gMenuWindow.tilemap and do weird pointer arithmetic. i'd rather not deal with these right now. +#ifdef NONMATCHING +void sub_80B3F88(void) +{ + u16 *r1; + u16 *r2; + register u8 *r10 asm("r10"); + s32 i; + s32 j; + struct Window *r8 = &gMenuWindow; + + r1 = r8->tilemap; + r1 += 0x1EF; + r2 = r1; + r2 += 64; + r10 = r8->tileData; + + for (i = 0; i < 14; i++) + { + for (j = 0; j < 15; j++) + { + if ((r1[j] & 0x3FF) <= r8->tileDataStartOffset + 1) + r2[j] = r8->tileDataStartOffset + 1; + else + r2[j] = r1[j] + 0x3C; + } + + r1 -= 32; + r2 -= 32; + } + + { + u8 *r1 = r10 + 0x3A20; + u8 *r2 = r1 + 0x780; + for (i = 0; i < 14; i++) + { + DmaCopy16(3, r1, r2, 0x1E0); + r2 -= 0x3C0; + r1 -= 0x3C0; + } + } +} +#else __attribute__((naked)) void sub_80B3F88(void) { @@ -860,7 +901,52 @@ _080B4034: .4byte 0x800000f0\n\ _080B4038: .4byte 0xfffffc40\n\ .syntax divided"); } +#endif +#ifdef NONMATCHING +void sub_80B403C(void) +{ + u16 *r1; + u16 *r2; + u8 *r10; + s32 i; + s32 j; + struct Window *r8 = &gMenuWindow; + + r1 = r8->tilemap; + r1 += 0x4F; + r2 = r1; + r2 += 64; + r10 = r8->tileData; + + for (i = 0; i < 14; i++) + { + for (j = 0; j < 15; j++) + { + if ((r1[j] & 0x3FF) <= r8->tileDataStartOffset + 1) + r2[j] = r8->tileDataStartOffset + 1; + else + r2[j] = r1[j] + 0x3C; + } + + r1 += 32; + r2 += 32; + } + + { + register u8 *r1 asm("r1") = r10 + 0x960; + register u8 *r2 asm("r2") = r1; + + r1 += 0x780; + for (i = 0; i < 14; i++) + { + DmaCopy16(3, r1, r2, 0x1E0); + r1 += 0x3C0; + r2 += 0x3C0; + } + } +} +#else __attribute__((naked)) void sub_80B403C(void) { @@ -953,6 +1039,7 @@ _080B40E0: .4byte 0x040000d4\n\ _080B40E4: .4byte 0x800000f0\n\ .syntax divided"); } +#endif void sub_80B40E8(u8 taskId) // Mart_DoCursorAction { @@ -1095,22 +1182,21 @@ void Task_ExitBuyMenu(u8 taskId) } } -// in the for loop, the loop prologue is not correct and loads choicesabove + cursor immediately instead of setting up the gUnknown_02038724 struct. -#ifdef NONMATCHING void sub_80B4470(u8 taskId) { u16 i; for (i = 0; i < 3; i++) { - if (gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] != gUnknown_02038724[i].itemId || gUnknown_02038724[i].quantity == 0) - continue; - - if (gTasks[taskId].data[1] + gUnknown_02038724[i].quantity > 255) - gUnknown_02038724[i].quantity = 255; - else - gUnknown_02038724[i].quantity += gTasks[taskId].data[1]; - return; + if (gUnknown_02038724[i].itemId == gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor] + && gUnknown_02038724[i].quantity != 0) + { + if (gUnknown_02038724[i].quantity + gTasks[taskId].data[1] > 255) + gUnknown_02038724[i].quantity = 255; + else + gUnknown_02038724[i].quantity += gTasks[taskId].data[1]; + return; + } } if (gUnknown_02038730 < 3) @@ -1120,112 +1206,6 @@ void sub_80B4470(u8 taskId) gUnknown_02038730++; } } -#else -__attribute__((naked)) -void sub_80B4470(u8 taskId) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r9\n\ - mov r6, r8\n\ - push {r6,r7}\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - movs r2, 0\n\ - ldr r0, _080B44C8 @ =gUnknown_02038724\n\ - mov r12, r0\n\ - ldr r6, _080B44CC @ =gMartInfo\n\ - mov r8, r12\n\ - adds r4, r6, 0\n\ - ldr r1, _080B44D0 @ =gTasks\n\ - mov r9, r1\n\ - lsls r0, r5, 2\n\ - adds r0, r5\n\ - lsls r7, r0, 3\n\ -_080B4492:\n\ - lsls r0, r2, 2\n\ - mov r1, r8\n\ - adds r3, r0, r1\n\ - ldrb r0, [r4, 0xB]\n\ - ldrb r1, [r4, 0x9]\n\ - adds r0, r1\n\ - ldr r1, [r4, 0x4]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r1, [r3]\n\ - ldrh r0, [r0]\n\ - cmp r1, r0\n\ - bne _080B44DC\n\ - ldrh r0, [r3, 0x2]\n\ - cmp r0, 0\n\ - beq _080B44DC\n\ - adds r2, r0, 0\n\ - mov r4, r9\n\ - adds r1, r7, r4\n\ - movs r4, 0xA\n\ - ldrsh r0, [r1, r4]\n\ - adds r0, r2, r0\n\ - cmp r0, 0xFF\n\ - ble _080B44D4\n\ - movs r0, 0xFF\n\ - strh r0, [r3, 0x2]\n\ - b _080B451E\n\ - .align 2, 0\n\ -_080B44C8: .4byte gUnknown_02038724\n\ -_080B44CC: .4byte gMartInfo\n\ -_080B44D0: .4byte gTasks\n\ -_080B44D4:\n\ - ldrh r0, [r1, 0xA]\n\ - adds r0, r2, r0\n\ - strh r0, [r3, 0x2]\n\ - b _080B451E\n\ -_080B44DC:\n\ - adds r0, r2, 0x1\n\ - lsls r0, 16\n\ - lsrs r2, r0, 16\n\ - cmp r2, 0x2\n\ - bls _080B4492\n\ - ldr r3, _080B452C @ =gUnknown_02038730\n\ - ldrb r0, [r3]\n\ - cmp r0, 0x2\n\ - bhi _080B451E\n\ - adds r2, r0, 0\n\ - lsls r2, 2\n\ - add r2, r12\n\ - ldrb r0, [r6, 0xB]\n\ - ldrb r1, [r6, 0x9]\n\ - adds r0, r1\n\ - ldr r1, [r6, 0x4]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r0, [r0]\n\ - strh r0, [r2]\n\ - ldrb r1, [r3]\n\ - lsls r1, 2\n\ - add r1, r12\n\ - ldr r2, _080B4530 @ =gTasks\n\ - lsls r0, r5, 2\n\ - adds r0, r5\n\ - lsls r0, 3\n\ - adds r0, r2\n\ - ldrh r0, [r0, 0xA]\n\ - strh r0, [r1, 0x2]\n\ - ldrb r0, [r3]\n\ - adds r0, 0x1\n\ - strb r0, [r3]\n\ -_080B451E:\n\ - pop {r3,r4}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_080B452C: .4byte gUnknown_02038730\n\ -_080B4530: .4byte gTasks\n\ - .syntax divided"); -} -#endif void ClearItemPurchases(void) { @@ -1255,190 +1235,50 @@ void CreateDecorationShop2Menu(u16 *itemList) SetShopMenuCallback(EnableBothScriptContexts); } -// no. -__attribute__((naked)) -void sub_80B45B4(u8 taskId, const u16 *list, int var3) +void sub_80B45B4(u8 taskId, const s16 *list, u16 c) { - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x10\n\ - mov r9, r1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - lsls r2, 16\n\ - lsrs r2, 16\n\ - mov r10, r2\n\ - ldr r2, _080B4648 @ =gTasks\n\ - lsls r1, r0, 2\n\ - adds r1, r0\n\ - lsls r1, 3\n\ - adds r1, r2\n\ - ldrh r0, [r1, 0x10]\n\ - subs r0, 0x1\n\ - lsls r0, 16\n\ - lsrs r5, r0, 16\n\ - ldrh r0, [r1, 0x12]\n\ - subs r0, 0x1\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - ldrh r4, [r1, 0xA]\n\ - movs r2, 0xC\n\ - ldrsh r0, [r1, r2]\n\ - cmp r0, 0\n\ - bne _080B4678\n\ - movs r2, 0\n\ - lsls r5, 16\n\ - str r5, [sp, 0xC]\n\ - lsls r0, r3, 16\n\ - lsls r1, r4, 16\n\ - asrs r0, 16\n\ - str r0, [sp]\n\ - asrs r1, 16\n\ - str r1, [sp, 0x4]\n\ - lsls r0, r1, 1\n\ - mov r1, r9\n\ - adds r7, r0, r1\n\ -_080B4608:\n\ - movs r4, 0\n\ - lsls r2, 16\n\ - mov r8, r2\n\ - asrs r0, r2, 16\n\ - ldr r2, [sp]\n\ - adds r6, r2, r0\n\ -_080B4614:\n\ - ldr r0, [sp, 0xC]\n\ - asrs r1, r0, 16\n\ - lsls r4, 16\n\ - asrs r0, r4, 16\n\ - adds r5, r1, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridGetMetatileIdAt\n\ - movs r2, 0\n\ - ldrsh r1, [r7, r2]\n\ - lsls r0, 16\n\ - asrs r0, 16\n\ - cmp r1, r0\n\ - bne _080B465C\n\ - ldr r0, [sp, 0x4]\n\ - cmp r0, 0x2\n\ - beq _080B464C\n\ - ldrh r0, [r7, 0x2]\n\ - mov r2, r10\n\ - orrs r2, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridSetMetatileIdAt\n\ - b _080B465C\n\ - .align 2, 0\n\ -_080B4648: .4byte gTasks\n\ -_080B464C:\n\ - mov r1, r9\n\ - ldrh r0, [r1]\n\ - mov r2, r10\n\ - orrs r2, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridSetMetatileIdAt\n\ -_080B465C:\n\ - movs r2, 0x80\n\ - lsls r2, 9\n\ - adds r0, r4, r2\n\ - lsrs r4, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x2\n\ - ble _080B4614\n\ - adds r0, r2, 0\n\ - add r0, r8\n\ - lsrs r2, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x2\n\ - ble _080B4608\n\ - b _080B4700\n\ -_080B4678:\n\ - movs r2, 0\n\ - lsls r5, 16\n\ - str r5, [sp, 0xC]\n\ - lsls r0, r3, 16\n\ - lsls r1, r4, 16\n\ - asrs r0, 16\n\ - str r0, [sp, 0x8]\n\ - asrs r7, r1, 16\n\ -_080B4688:\n\ - movs r4, 0\n\ - lsls r2, 16\n\ - mov r8, r2\n\ - asrs r0, r2, 16\n\ - ldr r1, [sp, 0x8]\n\ - adds r6, r1, r0\n\ -_080B4694:\n\ - ldr r2, [sp, 0xC]\n\ - asrs r1, r2, 16\n\ - lsls r4, 16\n\ - asrs r0, r4, 16\n\ - adds r5, r1, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridGetMetatileIdAt\n\ - movs r1, 0x2\n\ - subs r1, r7\n\ - lsls r1, 1\n\ - add r1, r9\n\ - movs r2, 0\n\ - ldrsh r1, [r1, r2]\n\ - lsls r0, 16\n\ - asrs r0, 16\n\ - cmp r1, r0\n\ - bne _080B46E6\n\ - cmp r7, 0x2\n\ - beq _080B46D6\n\ - movs r0, 0x1\n\ - subs r0, r7\n\ - lsls r0, 1\n\ - add r0, r9\n\ - ldrh r0, [r0]\n\ - mov r2, r10\n\ - orrs r2, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridSetMetatileIdAt\n\ - b _080B46E6\n\ -_080B46D6:\n\ - mov r1, r9\n\ - ldrh r0, [r1, 0x4]\n\ - mov r2, r10\n\ - orrs r2, r0\n\ - adds r0, r5, 0\n\ - adds r1, r6, 0\n\ - bl MapGridSetMetatileIdAt\n\ -_080B46E6:\n\ - movs r2, 0x80\n\ - lsls r2, 9\n\ - adds r0, r4, r2\n\ - lsrs r4, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x2\n\ - ble _080B4694\n\ - adds r0, r2, 0\n\ - add r0, r8\n\ - lsrs r2, r0, 16\n\ - asrs r0, 16\n\ - cmp r0, 0x2\n\ - ble _080B4688\n\ -_080B4700:\n\ - add sp, 0x10\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .syntax divided"); + s16 r5 = gTasks[taskId].data[4] - 1; + s16 r3 = gTasks[taskId].data[5] - 1; + s16 r4 = gTasks[taskId].data[1]; + s16 y; + s16 x; + + if (gTasks[taskId].data[2] == 0) + { + for (y = 0; y < 3; y++) + { + for (x = 0; x < 3; x++) + { + s16 metatileId = MapGridGetMetatileIdAt(r5 + x, r3 + y); + + if (list[r4] == metatileId) + { + if (r4 != 2) + MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[r4 + 1]); + else + MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[0]); + } + } + } + } + else + { + for (y = 0; y < 3; y++) + { + for (x = 0; x < 3; x++) + { + s16 metatileId = MapGridGetMetatileIdAt(r5 + x, r3 + y); + + if (list[2 - r4] == metatileId) + { + if (r4 != 2) + MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[1 - r4]); + else + MapGridSetMetatileIdAt(r5 + x, r3 + y, c | list[2]); + } + } + } + } } void sub_80B4710(u8 taskId) -- cgit v1.2.3 From 989215ace2d94d9b11462c8db9e4acebc76ca5b1 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 14:20:10 -0400 Subject: get rid of memcpy --- src/shop.c | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 30f23e10f..8bca7adc9 100644 --- a/src/shop.c +++ b/src/shop.c @@ -78,15 +78,6 @@ static const struct YesNoFuncTable gUnknown_083CC708[] = sub_80B3D7C }; -static const u16 gUnknown_083CC710[] = {0x41EE, 0x7FFF}; -static const u16 gUnknown_083CC714[] = {0x284, 0x282, 0x280}; -static const u16 gUnknown_083CC71A[] = {0x285, 0x283, 0x281}; -static const u16 gUnknown_083CC720[] = {0x28C, 0x28A, 0x288}; -static const u16 gUnknown_083CC726[] = {0x28D, 0x28B, 0x289}; -static const u16 gUnknown_083CC72C[] = {0x2A0, 0x2A2, 0x2A4}; -static const u16 gUnknown_083CC732[] = {0x2A1, 0x2A3, 0x2A5}; -static const u16 gUnknown_083CC738[] = {0x2A8, 0x2AA, 0x2AC}; - u8 CreateShopMenu(u8 martType) { ScriptContext2_Enable(); @@ -319,9 +310,8 @@ void BuyMenuDrawGraphics(void) void sub_80B3240(void) { - u16 tempArr[2]; + u16 tempArr[2] = {0x41EE, 0x7FFF}; - memcpy(tempArr, gUnknown_083CC710, sizeof(tempArr)); LoadPalette(&tempArr[1], 0xD1, 2); LoadPalette(&tempArr[0], 0xD8, 2); } @@ -629,15 +619,15 @@ void sub_80B3A70(void) if (gMartInfo.martType == MART_TYPE_0) { sub_8072AB0(ItemId_GetDescription(gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]), - 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); + 0x4, 0x68, 0x68, 0x30, 0); } else sub_8072AB0(gDecorations[gMartInfo.itemList[gMartInfo.choicesAbove + gMartInfo.cursor]].description, - 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); // huh?? if mart type isnt 0, why assume it? + 0x4, 0x68, 0x68, 0x30, 0); } else { - sub_8072AB0(gOtherText_QuitShopping, 0x4, 0x68, 0x68, 0x30, MART_TYPE_0); + sub_8072AB0(gOtherText_QuitShopping, 0x4, 0x68, 0x68, 0x30, 0); } } @@ -1281,6 +1271,14 @@ void sub_80B45B4(u8 taskId, const s16 *list, u16 c) } } +static const u16 gUnknown_083CC714[] = {0x284, 0x282, 0x280}; +static const u16 gUnknown_083CC71A[] = {0x285, 0x283, 0x281}; +static const u16 gUnknown_083CC720[] = {0x28C, 0x28A, 0x288}; +static const u16 gUnknown_083CC726[] = {0x28D, 0x28B, 0x289}; +static const u16 gUnknown_083CC72C[] = {0x2A0, 0x2A2, 0x2A4}; +static const u16 gUnknown_083CC732[] = {0x2A1, 0x2A3, 0x2A5}; +static const u16 gUnknown_083CC738[] = {0x2A8, 0x2AA, 0x2AC}; + void sub_80B4710(u8 taskId) { s16 *data = gTasks[taskId].data; -- cgit v1.2.3 From a2087a9caf534be0889cf54a8202f3a88ccc09ea Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 14:23:43 -0400 Subject: use PlaySE constants --- src/shop.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index 8bca7adc9..fa9d8c30d 100644 --- a/src/shop.c +++ b/src/shop.c @@ -128,7 +128,7 @@ void sub_80B2E38(u8 var) { if (gMartInfo.cursor) // can move cursor up? { - PlaySE(0x5); + PlaySE(SE_SELECT); gMartInfo.cursor = MoveMenuCursor(-1); } } @@ -136,13 +136,13 @@ void sub_80B2E38(u8 var) { if (gMartInfo.cursor != gMartInfo.numChoices) // can move cursor down? { - PlaySE(0x5); + PlaySE(SE_SELECT); gMartInfo.cursor = MoveMenuCursor(1); } } else if (gMain.newKeys & A_BUTTON) { - PlaySE(0x5); + PlaySE(SE_SELECT); if (gMartInfo.martType == MART_TYPE_0) { gUnknown_083CC6D0[gUnknown_083CC6E8[gMartInfo.cursor]].func(local); @@ -154,7 +154,7 @@ void sub_80B2E38(u8 var) } else if (gMain.newKeys & B_BUTTON) { - PlaySE(0x5); + PlaySE(SE_SELECT); HandleShopMenuQuit(local); } } @@ -649,7 +649,7 @@ void sub_80B3B80(u8 taskId) { IncrementGameStat(0x26); sub_80B79E0(&gSaveBlock1.money, gMartTotalCost); - PlaySE(0x5F); + PlaySE(SE_REGI); sub_80B7BEC(gSaveBlock1.money, 0, 0); gTasks[taskId].func = sub_80B3AEC; } -- cgit v1.2.3 From 6f360947a67c4fb8c0b32b07dc74bb28ff0f08a0 Mon Sep 17 00:00:00 2001 From: ProjectRevoTPP Date: Sat, 26 Aug 2017 14:27:10 -0400 Subject: correct itemId access --- src/shop.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/shop.c b/src/shop.c index fa9d8c30d..6a88f1394 100644 --- a/src/shop.c +++ b/src/shop.c @@ -527,7 +527,7 @@ void sub_80B37EC(void) void sub_80B37F8(u8 taskId) { u16 itemListIndex = gMartInfo.choicesAbove + gMartInfo.cursor; - u16 itemId = *(gMartInfo.itemList + itemListIndex); + u16 itemId = gMartInfo.itemList[itemListIndex]; u32 price = (ItemId_GetPrice(itemId) >> GetPriceReduction(1)); sub_80B7A94(gTasks[taskId].data[1] * price, 6, 6, 11); -- cgit v1.2.3 From 991cbbffbcdbba6ba71ea9a08a7a28a29377f976 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 26 Aug 2017 19:45:45 -0500 Subject: import DizzyEggg's battle controller changes --- src/battle_10.c | 1323 -------------- src/battle_2.c | 30 +- src/battle_4.c | 36 +- src/battle_5.c | 1579 ----------------- src/battle_6.c | 1507 ---------------- src/battle_7.c | 414 +---- src/battle_anim_81258BC.c | 50 - src/battle_anim_8137220.c | 1486 ---------------- src/battle_controller_linkopponent2.c | 1449 ++++++++++++++++ src/battle_controller_linkpartner.c | 1728 +++++++++++++++++++ src/battle_controller_opponent.c | 2055 ++++++++++++++++++++++ src/battle_controller_player.c | 3066 +++++++++++++++++++++++++++++++++ src/battle_controller_safari.c | 173 ++ src/battle_controller_wally.c | 1611 +++++++++++++++++ src/rom3.c | 74 +- 15 files changed, 10219 insertions(+), 6362 deletions(-) delete mode 100644 src/battle_10.c delete mode 100644 src/battle_5.c delete mode 100644 src/battle_6.c delete mode 100644 src/battle_anim_81258BC.c delete mode 100644 src/battle_anim_8137220.c create mode 100644 src/battle_controller_linkopponent2.c create mode 100644 src/battle_controller_linkpartner.c create mode 100644 src/battle_controller_opponent.c create mode 100644 src/battle_controller_player.c create mode 100644 src/battle_controller_safari.c create mode 100644 src/battle_controller_wally.c (limited to 'src') diff --git a/src/battle_10.c b/src/battle_10.c deleted file mode 100644 index 1a01e5383..000000000 --- a/src/battle_10.c +++ /dev/null @@ -1,1323 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_interface.h" -#include "data2.h" -#include "link.h" -#include "palette.h" -#include "rom_8077ABC.h" -#include "rom3.h" -#include "songs.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -struct UnknownStruct3 -{ - u16 moves[4]; - u8 pp[4]; - u8 ppBonuses; -}; - -extern u8 gActiveBank; -extern u8 gBattleBufferA[][0x200]; -extern u8 gObjectBankIDs[]; -extern u16 gBattlePartyID[]; -extern u8 gHealthboxIDs[]; -extern u16 gBattleTypeFlags; -extern u8 gBattleMonForms[]; -extern void (*gBattleBankFunc[])(void); -extern u32 *gDisableStructMoveAnim; -extern u32 gMoveDmgMoveAnim; -extern u16 gMovePowerMoveAnim; -extern u8 gHappinessMoveAnim; -extern u16 gWeatherMoveAnim; -extern u32 gPID_perBank[]; -extern u8 gAnimScriptActive; -extern void (*gAnimScriptCallback)(void); -extern u8 gDisplayedStringBattle[]; -extern bool8 gDoingBattleAnim; -extern u8 gBattleOutcome; -extern u16 gUnknown_02024DE8; -extern u8 gUnknown_02024E68[]; -extern struct SpriteTemplate gUnknown_02024E8C; -extern u8 gUnknown_0202F7C4; -extern struct Window gUnknown_03004210; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; -extern u8 gUnknown_0300434C[]; - -extern u8 sub_8077F68(); -extern u8 sub_8079E90(); -extern u8 GetBankIdentity(u8); -extern void BattleLoadOpponentMonSprite(struct Pokemon *, u8); -extern void sub_8037A74(void); -extern void sub_8032984(u8, u16); -extern void sub_8037E30(void); -extern void sub_80312F0(struct Sprite *); -extern u8 sub_8046400(); -extern void sub_8032A08(); -extern void sub_8043DB0(); -extern void sub_8037BBC(void); -extern s32 sub_803FC34(u16); -extern void sub_8031A6C(u16, u8); -extern void sub_80313A0(struct Sprite *); -extern void sub_803757C(void); -extern void oamt_add_pos2_onto_pos1(); -extern void oamt_set_x3A_32(); -extern void sub_8078B34(struct Sprite *); -extern void sub_80375B4(void); -extern void sub_8010384(struct Sprite *); -extern void sub_8037B78(void); -extern u8 sub_8031720(); -extern bool8 mplay_80342A4(u8); -extern void ExecuteMoveAnim(); -extern void sub_80326EC(); -extern void sub_8031F24(void); -extern void sub_80324BC(); -extern void BufferStringBattle(); -extern void sub_8037C2C(void); -extern void sub_8043D84(); -extern void sub_8037B24(void); -extern void sub_8045A5C(); -extern void sub_8037FAC(void); -extern void move_anim_start_t2_for_situation(); -extern void dp01t_0F_4_move_anim(void); -extern void sub_8047858(); -extern u8 GetBankSide(u8); -extern void sub_80E43C0(); -extern void sub_803A3A8(struct Sprite *); -extern void sub_8044CA0(u8); -extern void nullsub_47(void); -extern bool8 IsDoubleBattle(void); -extern void sub_8037840(void); -extern void sub_8031B74(); -extern u8 sub_8078874(); -extern u8 move_anim_start_t3(); -extern void sub_8037FD8(void); -extern void sub_8037F34(void); -extern void dp01_tbl4_exec_completed(void); - -u32 dp01_getattr_by_ch1_for_player_pokemon__(u8, u8 *); -void sub_8038900(u8); -void sub_8039430(u8, u8); -void sub_8039648(void); -void sub_8039B64(void); -void sub_803A2C4(u8); -void sub_803A4E0(void); - -void LinkOpponentHandleGetAttributes(void) -{ - u8 buffer[0x100]; - u32 r6 = 0; - u8 r4; - s32 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - r6 = dp01_getattr_by_ch1_for_player_pokemon__(gBattlePartyID[gActiveBank], buffer); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - r6 += dp01_getattr_by_ch1_for_player_pokemon__(i, buffer + r6); - r4 >>= 1; - } - } - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, r6, buffer); - dp01_tbl4_exec_completed(); -} - -u32 dp01_getattr_by_ch1_for_player_pokemon__(u8 a, u8 *buffer) -{ - struct BattlePokemon battlePokemon; - struct UnknownStruct3 moveData; - u8 nickname[20]; - u8 *src; - s16 data16; - u32 data32; - s32 size = 0; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - battlePokemon.species = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); - battlePokemon.item = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); - for (size = 0; size < 4; size++) - { - battlePokemon.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); - battlePokemon.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - } - battlePokemon.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - battlePokemon.friendship = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); - battlePokemon.experience = GetMonData(&gEnemyParty[a], MON_DATA_EXP); - battlePokemon.hpIV = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - battlePokemon.attackIV = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - battlePokemon.defenseIV = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - battlePokemon.speedIV = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - battlePokemon.spAttackIV = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - battlePokemon.spDefenseIV = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - battlePokemon.personality = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); - battlePokemon.status1 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); - battlePokemon.level = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); - battlePokemon.hp = GetMonData(&gEnemyParty[a], MON_DATA_HP); - battlePokemon.maxHP = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); - battlePokemon.attack = GetMonData(&gEnemyParty[a], MON_DATA_ATK); - battlePokemon.defense = GetMonData(&gEnemyParty[a], MON_DATA_DEF); - battlePokemon.speed = GetMonData(&gEnemyParty[a], MON_DATA_SPD); - battlePokemon.spAttack = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); - battlePokemon.spDefense = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); - battlePokemon.isEgg = GetMonData(&gEnemyParty[a], MON_DATA_IS_EGG); - battlePokemon.altAbility = GetMonData(&gEnemyParty[a], MON_DATA_ALT_ABILITY); - battlePokemon.otId = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); - GetMonData(&gEnemyParty[a], MON_DATA_NICKNAME, nickname); - StringCopy10(battlePokemon.nickname, nickname); - GetMonData(&gEnemyParty[a], MON_DATA_OT_NAME, battlePokemon.otName); - src = (u8 *)&battlePokemon; - for (size = 0; size < sizeof(battlePokemon); size++) - buffer[size] = src[size]; - break; - case 1: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 2: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 3: - for (size = 0; size < 4; size++) - { - moveData.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); - moveData.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - } - moveData.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - src = (u8 *)&moveData; - for (size = 0; size < sizeof(moveData); size++) - buffer[size] = src[size]; - break; - case 4: - case 5: - case 6: - case 7: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 8: - for (size = 0; size < 4; size++) - buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - size++; - break; - case 9: - case 10: - case 11: - case 12: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); - size = 1; - break; - case 17: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 18: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_EXP); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 19: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_EV); - size = 1; - break; - case 20: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_EV); - size = 1; - break; - case 21: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_EV); - size = 1; - break; - case 22: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_EV); - size = 1; - break; - case 23: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV); - size = 1; - break; - case 24: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV); - size = 1; - break; - case 25: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); - size = 1; - break; - case 26: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKERUS); - size = 1; - break; - case 27: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION); - size = 1; - break; - case 28: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL); - size = 1; - break; - case 29: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_GAME); - size = 1; - break; - case 30: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKEBALL); - size = 1; - break; - case 31: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - buffer[1] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - buffer[2] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - buffer[3] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - buffer[4] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - buffer[5] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - size = 6; - break; - case 32: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - size = 1; - break; - case 33: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - size = 1; - break; - case 34: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - size = 1; - break; - case 35: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - size = 1; - break; - case 36: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - size = 1; - break; - case 37: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - size = 1; - break; - case 38: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 39: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 40: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 41: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); - size = 1; - break; - case 42: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 43: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 44: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_ATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 45: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_DEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 46: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPD); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 47: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 48: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 49: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL); - size = 1; - break; - case 50: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY); - size = 1; - break; - case 51: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE); - size = 1; - break; - case 52: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART); - size = 1; - break; - case 53: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH); - size = 1; - break; - case 54: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SHEEN); - size = 1; - break; - case 55: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON); - size = 1; - break; - case 56: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON); - size = 1; - break; - case 57: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON); - size = 1; - break; - case 58: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON); - size = 1; - break; - case 59: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON); - size = 1; - break; - } - return size; -} - -void sub_803889C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_80388A8(void) -{ - u8 i; - u8 r4; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - sub_8038900(gBattlePartyID[gActiveBank]); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - sub_8038900(i); - r4 >>= 1; - } - } - dp01_tbl4_exec_completed(); -} - -void sub_8038900(u8 a) -{ - struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; - struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; - s32 i; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - { - u8 iv; - - SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); - SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); - for (i = 0; i < 4; i++) - { - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); - } - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); - SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); - SetMonData(&gEnemyParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); - iv = battlePokemon->hpIV; - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, (u8 *)&iv); - iv = battlePokemon->attackIV; - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, (u8 *)&iv); - iv = battlePokemon->defenseIV; - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, (u8 *)&iv); - iv = battlePokemon->speedIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, (u8 *)&iv); - iv = battlePokemon->spAttackIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); - iv = battlePokemon->spDefenseIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); - SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); - SetMonData(&gEnemyParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); - SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); - SetMonData(&gEnemyParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); - SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); - SetMonData(&gEnemyParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); - SetMonData(&gEnemyParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); - SetMonData(&gEnemyParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); - SetMonData(&gEnemyParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); - } - break; - case 1: - SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); - break; - case 2: - SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); - break; - case 3: - for (i = 0; i < 4; i++) - { - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); - } - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); - break; - case 4: - case 5: - case 6: - case 7: - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); - break; - case 8: - SetMonData(&gEnemyParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gEnemyParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gEnemyParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gEnemyParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); - break; - case 9: - case 10: - case 11: - case 12: - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); - break; - case 17: - SetMonData(&gEnemyParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); - break; - case 18: - SetMonData(&gEnemyParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); - break; - case 19: - SetMonData(&gEnemyParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 20: - SetMonData(&gEnemyParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 21: - SetMonData(&gEnemyParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 22: - SetMonData(&gEnemyParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 23: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 24: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 25: - SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); - break; - case 26: - SetMonData(&gEnemyParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); - break; - case 27: - SetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); - break; - case 28: - SetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 29: - SetMonData(&gEnemyParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); - break; - case 30: - SetMonData(&gEnemyParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); - break; - case 31: - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); - break; - case 32: - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 33: - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 34: - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 35: - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 36: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 37: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 38: - SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); - break; - case 39: - SetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); - break; - case 40: - SetMonData(&gEnemyParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); - break; - case 41: - SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 42: - SetMonData(&gEnemyParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 43: - SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 44: - SetMonData(&gEnemyParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); - break; - case 45: - SetMonData(&gEnemyParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); - break; - case 46: - SetMonData(&gEnemyParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); - break; - case 47: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); - break; - case 48: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); - break; - case 49: - SetMonData(&gEnemyParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); - break; - case 50: - SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); - break; - case 51: - SetMonData(&gEnemyParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); - break; - case 52: - SetMonData(&gEnemyParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); - break; - case 53: - SetMonData(&gEnemyParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); - break; - case 54: - SetMonData(&gEnemyParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); - break; - case 55: - SetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 56: - SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 57: - SetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 58: - SetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 59: - SetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - } -} - -void sub_8039220(void) -{ - u8 *dst; - u8 i; - - dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = gBattleBufferA[gActiveBank][3 + i]; - dp01_tbl4_exec_completed(); -} - -void sub_8039294(void) -{ - u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - - BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(gActiveBank, 2), - sub_8077F68(gActiveBank), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); - sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); - gBattleBankFunc[gActiveBank] = sub_8037A74; -} - -void sub_80393E4(void) -{ - gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - sub_8039430(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattleBankFunc[gActiveBank] = sub_8037E30; -} - -void sub_8039430(u8 a, u8 b) -{ - u16 species; - - sub_8032AA8(a, b); - gBattlePartyID[a] = gBattleBufferA[a][1]; - species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); - gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); - gObjectBankIDs[a] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(a, 2), - sub_8077F68(a), - sub_8079E90(a)); - gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; - gSprites[gObjectBankIDs[a]].data0 = a; - gSprites[gObjectBankIDs[a]].data2 = species; - gSprites[gObjectBankIDs[a]].oam.paletteNum = a; - StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); - gSprites[gObjectBankIDs[a]].invisible = TRUE; - gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; - gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFE); -} - -void sub_80395B4(void) -{ - if (gBattleBufferA[gActiveBank][1] == 0) - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_8039648; - } - else - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8032A08(gActiveBank); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - dp01_tbl4_exec_completed(); - } -} - -void sub_8039648(void) -{ - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 2); - gBattleBankFunc[gActiveBank] = sub_8037BBC; - } - break; - } -} - -void sub_80396D0(void) -{ - s16 xOffset; - u32 gender; - - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - { - if (GetBankIdentity(gActiveBank) & 2) - xOffset = -16; - else - xOffset = 16; - gender = gLinkPlayers[sub_803FC34(gActiveBank)].gender; - } - else - { - xOffset = 0; - gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; - } - sub_8031A6C(gender, gActiveBank); - GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 176 + xOffset, 40 + 4 * (8 - gTrainerFrontPicCoords[gender].coords), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[gender].tag); - gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; - gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[gender].tag); - gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = gender; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_803757C; -} - -void sub_80398A4(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_80398B0(void) -{ - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); - gBattleBankFunc[gActiveBank] = sub_80375B4; -} - -void sub_803995C(void) -{ - if (ewram17810[gActiveBank].unk4 == 0) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4++; - } - else if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - PlaySE12WithPanning(SE_POKE_DEAD, 63); - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8010384; - gBattleBankFunc[gActiveBank] = sub_8037B78; - } -} - -void sub_8039A00(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039A0C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039A18(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039A24(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039A30(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - u32 r0 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - - gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; - gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] - | (gBattleBufferA[gActiveBank][5] << 8); - gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] - | (gBattleBufferA[gActiveBank][7] << 8) - | (gBattleBufferA[gActiveBank][8] << 16) - | (gBattleBufferA[gActiveBank][9] << 24); - gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; - gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] - | (gBattleBufferA[gActiveBank][13] << 8); - gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; - gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; - - // Dead code. sub_8031720 always returns 0. - if (sub_8031720(r0, gUnknown_0202F7C4) != 0) - { - dp01_tbl4_exec_completed(); - } - else - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_8039B64; - } - } -} - -void sub_8039B64(void) -{ - u16 r4 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - u8 r7 = gBattleBufferA[gActiveBank][11]; - - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) - { - ewram17800[gActiveBank].unk0_3 = 1; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - } - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_80326EC(0); - ExecuteMoveAnim(r4); - ewram17810[gActiveBank].unk4 = 2; - } - break; - case 2: - gAnimScriptCallback(); - if (!gAnimScriptActive) - { - sub_80326EC(1); - if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) - { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - ewram17800[gActiveBank].unk0_3 = 0; - } - ewram17810[gActiveBank].unk4 = 3; - } - break; - case 3: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_8031F24(); - sub_80324BC( - gActiveBank, - gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - ewram17810[gActiveBank].unk4 = 0; - dp01_tbl4_exec_completed(); - } - break; - } -} - -void sub_8039CC8(void) -{ - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); - sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); - gBattleBankFunc[gActiveBank] = sub_8037C2C; -} - -void sub_8039D2C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D38(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D44(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D50(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D5C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D68(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D74(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039D80(void) -{ - s16 r7; - - load_gfxc_health_bar(0); - r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - if (r7 != 0x7FFF) - { - u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - u32 hp = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); - } - else - { - u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); - } - gBattleBankFunc[gActiveBank] = sub_8037B24; -} - -void sub_8039E70(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039E7C(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - sub_8045A5C(gHealthboxIDs[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], 9); - ewram17810[gActiveBank].unk0_4 = 0; - gBattleBankFunc[gActiveBank] = sub_8037FAC; - } -} - -void sub_8039EF0(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - move_anim_start_t2_for_situation( - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2] - | (gBattleBufferA[gActiveBank][3] << 8) - | (gBattleBufferA[gActiveBank][4] << 16) - | (gBattleBufferA[gActiveBank][5] << 24)); - gBattleBankFunc[gActiveBank] = sub_8037FAC; - } -} - -void sub_8039F58(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039F64(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039F70(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039F7C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039F88(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039F94(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039FA0(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039FAC(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039FB8(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_8039FC4(void) -{ - gUnknown_020238C8.unk0_0 = 0; - dp01_tbl4_exec_completed(); -} - -void sub_8039FE0(void) -{ - gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; - dp01_tbl4_exec_completed(); -} - -void sub_803A018(void) -{ - gUnknown_020238C8.unk0_7 = 0; - dp01_tbl4_exec_completed(); -} - -void sub_803A030(void) -{ - gUnknown_020238C8.unk0_7 ^= 1; - dp01_tbl4_exec_completed(); -} - -void dp01t_29_4_blink(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) - { - dp01_tbl4_exec_completed(); - } - else - { - gDoingBattleAnim = TRUE; - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - sub_8047858(gActiveBank); - gBattleBankFunc[gActiveBank] = dp01t_0F_4_move_anim; - } -} - -void sub_803A0C8(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_803A0D4(void) -{ - s8 pan; - - if (GetBankSide(gActiveBank) == 0) - pan = -64; - else - pan = 63; - PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); - dp01_tbl4_exec_completed(); -} - -void sub_803A118(void) -{ - PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - dp01_tbl4_exec_completed(); -} - -void sub_803A148(void) -{ - PlayCry3( - GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), - 25, 5); - dp01_tbl4_exec_completed(); -} - -void dp01t_2E_4_battle_intro(void) -{ - sub_80E43C0(gBattleBufferA[gActiveBank][1]); - gUnknown_02024DE8 |= 1; - dp01_tbl4_exec_completed(); -} - -void sub_803A1B8(void) -{ - u8 taskId; - - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_803A3A8); - taskId = CreateTask(sub_803A2C4, 5); - gTasks[taskId].data[0] = gActiveBank; - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - ewram17840.unk9_0 = 1; - gBattleBankFunc[gActiveBank] = nullsub_47; -} - -void sub_803A2C4(u8 taskId) -{ - u8 r9; - - r9 = gActiveBank; - gActiveBank = gTasks[taskId].data[0]; - if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_8039430(gActiveBank, 0); - } - else - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_8039430(gActiveBank, 0); - gActiveBank ^= 2; - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_8039430(gActiveBank, 0); - gActiveBank ^= 2; - } - gBattleBankFunc[gActiveBank] = sub_8037840; - gActiveBank = r9; - DestroyTask(taskId); -} - -void sub_803A3A8(struct Sprite *sprite) -{ - sub_8031B74(sprite->oam.affineParam); - sprite->oam.tileNum = sprite->data5; - FreeSpriteOamMatrix(sprite); - DestroySprite(sprite); -} - -void sub_803A3DC(void) -{ - if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) - { - dp01_tbl4_exec_completed(); - return; - } - - ewram17810[gActiveBank].unk0_0 = 1; - if (gBattleBufferA[gActiveBank][2] != 0) - { - if (ewram17810[gActiveBank].unk1_1 < 2) - { - ewram17810[gActiveBank].unk1_1++; - return; - } - else - { - ewram17810[gActiveBank].unk1_1 = 0; - } - } - gUnknown_02024E68[gActiveBank] = sub_8044804( - gActiveBank, - (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2]); - ewram17810[gActiveBank].unk5 = 0; - if (gBattleBufferA[gActiveBank][2] != 0) - ewram17810[gActiveBank].unk5 = 0x5D; - gBattleBankFunc[gActiveBank] = sub_803A4E0; -} - -void sub_803A4E0(void) -{ - if (ewram17810[gActiveBank].unk5++ >= 93) - { - ewram17810[gActiveBank].unk5 = 0; - dp01_tbl4_exec_completed(); - } -} - -void sub_803A520(void) -{ - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - dp01_tbl4_exec_completed(); -} - -void sub_803A56C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_803A578(void) -{ - if (sub_8078874(gActiveBank) != 0) - { - gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - sub_8031F88(gActiveBank); - } - dp01_tbl4_exec_completed(); -} - -void bx_exec_buffer_A_ch0_tbl4(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - u8 r3 = gBattleBufferA[gActiveBank][1]; - u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) - dp01_tbl4_exec_completed(); - else - gBattleBankFunc[gActiveBank] = sub_8037FD8; - } -} - -void sub_803A640(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_803A64C(void) -{ - dp01_tbl4_exec_completed(); -} - -void sub_803A658(void) -{ - if (gBattleBufferA[gActiveBank][1] == 3) - gBattleOutcome = gBattleBufferA[gActiveBank][1]; - else - gBattleOutcome = gBattleBufferA[gActiveBank][1] ^ 3; - FadeOutMapMusic(5); - BeginFastPaletteFade(3); - dp01_tbl4_exec_completed(); - gBattleBankFunc[gActiveBank] = sub_8037F34; -} - -void nullsub_48(void) -{ -} diff --git a/src/battle_2.c b/src/battle_2.c index bdd908ea5..06e20bb06 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -1347,8 +1347,8 @@ void sub_8010384(struct Sprite *sprite) u16 species; u8 yOffset; - if (ewram17800[r6].transformedSpecies != 0) - species = ewram17800[r6].transformedSpecies; + if (ewram17800[r6].unk2 != 0) + species = ewram17800[r6].unk2; else species = sprite->data2; @@ -1866,7 +1866,7 @@ static void BattlePrepIntroSlide(void) if (gBattleExecBuffer == 0) { gActiveBank = GetBankByPlayerAI(0); - EmitBattleIntroSlide(0, gBattleTerrain); + EmitIntroSlide(0, gBattleTerrain); MarkBufferBankForExecution(gActiveBank); gBattleMainFunc = sub_8011384; gBattleCommunication[0] = 0; @@ -1910,7 +1910,7 @@ void sub_8011384(void) if (GetBankIdentity(gActiveBank) == 0) { - dp01_build_cmdbuf_x07_7_7_7(0); + EmitTrainerThrow(0); MarkBufferBankForExecution(gActiveBank); } @@ -1918,7 +1918,7 @@ void sub_8011384(void) { if (GetBankIdentity(gActiveBank) == 1) { - dp01_build_cmdbuf_x07_7_7_7(0); + EmitTrainerThrow(0); MarkBufferBankForExecution(gActiveBank); } if (GetBankSide(gActiveBank) == 1 @@ -1931,7 +1931,7 @@ void sub_8011384(void) && !(gBattleTypeFlags & (BATTLE_TYPE_EREADER_TRAINER | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_LINK))) { GetNationalPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBank].species), 2); - dp01_build_cmdbuf_x04_4_4_4(0); + EmitLoadPokeSprite(0); MarkBufferBankForExecution(gActiveBank); } } @@ -1941,7 +1941,7 @@ void sub_8011384(void) if (GetBankIdentity(gActiveBank) == 2 || GetBankIdentity(gActiveBank) == 3) { - dp01_build_cmdbuf_x07_7_7_7(0); + EmitTrainerThrow(0); MarkBufferBankForExecution(gActiveBank); } } @@ -1979,7 +1979,7 @@ void bc_801333C(void) } } gActiveBank = GetBankByPlayerAI(1); - dp01_build_cmdbuf_x30_TODO(0, (u8 *)sp0, 0x80); + Emitcmd48(0, (u8 *)sp0, 0x80); MarkBufferBankForExecution(gActiveBank); for (i = 0; i < 6; i++) @@ -1997,7 +1997,7 @@ void bc_801333C(void) } } gActiveBank = GetBankByPlayerAI(0); - dp01_build_cmdbuf_x30_TODO(0, (u8 *)sp0, 0x80); + Emitcmd48(0, (u8 *)sp0, 0x80); MarkBufferBankForExecution(gActiveBank); gBattleMainFunc = bc_battle_begin_message; @@ -2063,13 +2063,13 @@ void sub_8011834(void) { if (GetBankIdentity(gActiveBank) == 1) { - dp01_build_cmdbuf_x2F_2F_2F_2F(0); + EmitTrainerBallThrow(0); MarkBufferBankForExecution(gActiveBank); } if ((gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBankIdentity(gActiveBank) == 3) { - dp01_build_cmdbuf_x2F_2F_2F_2F(0); + EmitTrainerBallThrow(0); MarkBufferBankForExecution(gActiveBank); } } @@ -2115,13 +2115,13 @@ void sub_80119B4(void) { if (GetBankIdentity(gActiveBank) == 0) { - dp01_build_cmdbuf_x2F_2F_2F_2F(0); + EmitTrainerBallThrow(0); MarkBufferBankForExecution(gActiveBank); } if ((gBattleTypeFlags & BATTLE_TYPE_MULTI) && GetBankIdentity(gActiveBank) == 2) { - dp01_build_cmdbuf_x2F_2F_2F_2F(0); + EmitTrainerBallThrow(0); MarkBufferBankForExecution(gActiveBank); } } @@ -2140,7 +2140,7 @@ void unref_sub_8011A68(void) { if (GetBankSide(gActiveBank) == 0) { - EmitSwitchInAnim(0, gBattlePartyID[gActiveBank], 0); + EmitSendOutPoke(0, gBattlePartyID[gActiveBank], 0); MarkBufferBankForExecution(gActiveBank); } } @@ -2429,7 +2429,7 @@ void sub_8012324(void) } else { - dp01_build_cmdbuf_x12_a_bb(0, gActionForBanks[0], gBattleBufferB[0][1] | (gBattleBufferB[0][2] << 8)); + Emitcmd18(0, gActionForBanks[0], gBattleBufferB[0][1] | (gBattleBufferB[0][2] << 8)); MarkBufferBankForExecution(gActiveBank); gBattleCommunication[gActiveBank]++; } diff --git a/src/battle_4.c b/src/battle_4.c index 6dd5d7df6..a3cfbc2de 100644 --- a/src/battle_4.c +++ b/src/battle_4.c @@ -5634,7 +5634,7 @@ static void atk1A_faint_animation(void) if (gBattleExecBuffer == 0) { gActiveBank = GetBattleBank(BSScriptRead8(gBattlescriptCurrInstr + 1)); - EmitFaintAnimation(0); + Emitcmd10(0); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 2; } @@ -10125,7 +10125,7 @@ static void atk4E_switchin_anim(void) GetNationalPokedexFlag(SpeciesToNationalPokedexNum(gBattleMons[gActiveBank].species), 2); } gAbsentBankFlags &= ~(gBitTable[gActiveBank]); - EmitSwitchInAnim(0, gBattlePartyID[gActiveBank], BSScriptRead8(gBattlescriptCurrInstr + 2)); + EmitSendOutPoke(0, gBattlePartyID[gActiveBank], BSScriptRead8(gBattlescriptCurrInstr + 2)); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 3; } @@ -10205,7 +10205,7 @@ void sub_8022A3C(u8 unkown) { //BATTLE_STRUCT->unk16064[gActiveBank] = gBattlePartyID[gActiveBank]; ewram[gActiveBank + 0x16064] = gBattlePartyID[gActiveBank]; - EmitChoosePokemon(0, 1, unkown, 0, BATTLE_STRUCT->unk1606C[gActiveBank]); + Emitcmd22(0, 1, unkown, 0, BATTLE_STRUCT->unk1606C[gActiveBank]); MarkBufferBankForExecution(gActiveBank); } @@ -10446,7 +10446,7 @@ _08022BC4:\n\ bics r0, r1\n\ str r0, [r2]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ b _08022C7E\n\ @@ -10531,7 +10531,7 @@ _08022C7E:\n\ bics r0, r1\n\ str r0, [r2]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ b _08022D40\n\ @@ -10615,7 +10615,7 @@ _08022D40:\n\ bics r0, r1\n\ str r0, [r2]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ b _08022DF6\n\ @@ -10702,7 +10702,7 @@ _08022DF6:\n\ bics r0, r1\n\ str r0, [r2]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ b _08022EB8\n\ @@ -10900,7 +10900,7 @@ _08022F92:\n\ bics r0, r1\n\ str r0, [r7]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r6]\n\ bl MarkBufferBankForExecution\n\ b _0802303A\n\ @@ -10977,7 +10977,7 @@ _0802303A:\n\ bics r0, r1\n\ str r0, [r2]\n\ movs r0, 0\n\ - bl dp01_build_cmdbuf_x2A_2A_2A_2A\n\ + bl Emitcmd42\n\ ldrb r0, [r5]\n\ bl MarkBufferBankForExecution\n\ b _080230EE\n\ @@ -11173,7 +11173,7 @@ _080231F8:\n\ movs r0, 0\n\ adds r1, r5, 0\n\ movs r3, 0\n\ - bl EmitChoosePokemon\n\ + bl Emitcmd22\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ ldr r0, [r6]\n\ @@ -11426,7 +11426,7 @@ static void atk54_effectiveness_sound(void) static void atk55_play_sound(void) { gActiveBank = gBankAttacker; - EmitPlaySound(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1)); + Emitcmd44(0, BS2ScriptRead16(gBattlescriptCurrInstr + 1)); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 3; } @@ -11442,7 +11442,7 @@ static void atk56_fainting_cry(void) static void atk57(void) { gActiveBank = GetBankByPlayerAI(0); - dp01_build_cmdbuf_x37_a(0, gBattleOutcome); + Emitcmd55(0, gBattleOutcome); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 1; } @@ -12011,7 +12011,7 @@ static void atk61_8025BA4(void) hpStatus[i].status = GetMonData(&party[i], MON_DATA_STATUS); } } - dp01_build_cmdbuf_x30_TODO(0, (u8*)(hpStatus), 1); + Emitcmd48(0, (u8*)(hpStatus), 1); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 2; } @@ -12019,7 +12019,7 @@ static void atk61_8025BA4(void) static void atk62_08025C6C(void) { gActiveBank = GetBattleBank(BSScriptRead8(gBattlescriptCurrInstr + 1)); - dp01_build_cmdbuf_x31_31_31_31(0); + Emitcmd49(0); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr += 2; } @@ -17789,13 +17789,13 @@ void atkEF_pokeball_catch_calculation(void) gBankTarget = gBankAttacker ^ 1; if (gBattleTypeFlags & BATTLE_TYPE_TRAINER) { - EmitBallThrowAnim(0, 5); + EmitBallThrow(0, 5); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_TrainerBallBlock; } else if (gBattleTypeFlags & BATTLE_TYPE_WALLY_TUTORIAL) { - EmitBallThrowAnim(0, 4); + EmitBallThrow(0, 4); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_WallyBallThrow; } @@ -17873,7 +17873,7 @@ void atkEF_pokeball_catch_calculation(void) } if (odds > 254) //poke caught { - EmitBallThrowAnim(0, 4); + EmitBallThrow(0, 4); MarkBufferBankForExecution(gActiveBank); gBattlescriptCurrInstr = BattleScript_SuccessBallThrow; SetMonData(&gEnemyParty[gBattlePartyID[gBankTarget]], MON_DATA_POKEBALL, (const void*) &gLastUsedItem); @@ -17890,7 +17890,7 @@ void atkEF_pokeball_catch_calculation(void) for (shakes = 0; shakes < 4 && Random() < odds; shakes++) {} if (gLastUsedItem == ITEM_MASTER_BALL) shakes = 4; //why calculate the shakes before that check? - EmitBallThrowAnim(0, shakes); + EmitBallThrow(0, shakes); MarkBufferBankForExecution(gActiveBank); if (shakes == 4) //poke caught, copy of the code above { diff --git a/src/battle_5.c b/src/battle_5.c deleted file mode 100644 index 5972c0cb1..000000000 --- a/src/battle_5.c +++ /dev/null @@ -1,1579 +0,0 @@ -#include "global.h" -#include "data2.h" -#include "battle.h" -#include "battle_interface.h" -#include "item.h" -#include "items.h" -#include "link.h" -#include "m4a.h" -#include "main.h" -#include "menu_cursor.h" -#include "moves.h" -#include "palette.h" -#include "pokemon.h" -#include "rom3.h" -#include "songs.h" -#include "sound.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -extern u8 gActiveBank; -extern void (*gBattleBankFunc[])(void); -extern bool8 gDoingBattleAnim; -extern u16 gBattleTypeFlags; -extern u32 gBattleExecBuffer; -extern u8 gBattleBufferA[][0x200]; -extern u8 gObjectBankIDs[]; -extern u8 gActionSelectionCursor[]; -extern u8 gMoveSelectionCursor[]; -extern u8 gAbsentBankFlags; -extern u8 gUnknown_03004344; -extern u8 gNoOfAllBanks; -extern u16 gBattlePartyID[]; -//extern const struct BattleMove gBattleMoves[]; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; -extern struct Window gUnknown_03004210; -extern const u8 gUnknown_08400D89[]; -extern u8 gUnknown_03004348; -extern struct BattlePokemon gBattleMons[]; -extern MainCallback gPreBattleCallback1; -extern u8 gHealthboxIDs[]; -extern struct MusicPlayerInfo gMPlay_BGM; -extern u8 gUnknown_0300434C[]; -extern u8 gUnknown_0202E8F4; -extern u8 gUnknown_0202E8F5; -extern u8 gUnknown_02038470[]; -extern u16 gScriptItemId; -extern u8 gDisplayedStringBattle[]; -extern const u8 gUnknown_08400CE0[]; - -extern void dp11b_obj_instanciate(u8, u8, s8, s8); -extern u8 GetBankIdentity(u8); -extern u8 GetBankByPlayerAI(u8); -extern void dp11b_obj_free(u8, u8); -extern void sub_8010520(struct Sprite *); -extern void sub_8010574(struct Sprite *); -extern bool8 IsDoubleBattle(); -extern void sub_804777C(); -extern void sub_8141828(); -extern void sub_8094E20(u8); -extern void nullsub_14(void); -extern void sub_80A6DCC(void); -extern void ReshowBattleScreenAfterMenu(void); - -void PlayerHandleGetAttributes(void); -void sub_802ECF0(void); -void PlayerHandleSetAttributes(void); -void sub_802F7CC(void); -void PlayerHandleLoadPokeSprite(void); -void PlayerHandleSendOutPoke(void); -void PlayerHandleReturnPokeToBall(void); -void PlayerHandleTrainerThrow(void); -void PlayerHandleTrainerSlide(void); -void PlayerHandleTrainerSlideBack(void); -void sub_802FE7C(void); -void sub_802FF60(void); -void sub_802FF80(void); -void PlayerHandleBallThrow(void); -void PlayerHandlePuase(void); -void PlayerHandleMoveAnimation(void); -void PlayerHandlePrintString(void); -void PlayerHandlePrintStringPlayerOnly(void); -void sub_803037C(void); -void nullsub_42(void); -void sub_8030468(void); -void PlayerHandleOpenBag(void); -void sub_8030594(void); -void sub_8030674(void); -void PlayerHandleHealthBarUpdate(void); -void PlayerHandleExpBarUpdate(void); -void PlayerHandleStatusIconUpdate(void); -void PlayerHandleStatusAnimation(void); -void PlayerHandleStatusXor(void); -void sub_803097C(void); -void PlayerHandleDMATransfer(void); -void sub_8030A3C(void); -void sub_8030A6C(void); -void sub_8030A78(void); -void sub_8030A8C(void); -void sub_8030AA0(void); -void sub_8030AB4(void); -void sub_8030AC8(void); -void sub_8030AE4(void); -void sub_8030B1C(void); -void sub_8030B34(void); -void PlayerHandleHitAnimation(void); -void sub_8030BCC(void); -void PlayerHandleEffectivenessSound(void); -void sub_8030C1C(void); -void PlayerHandleFaintingCry(void); -void PlayerHandleIntroSlide(void); -void PlayerHandleTrainerBallThrow(void); -void sub_8030FAC(void); -void sub_80310A4(void); -void sub_80310F0(void); -void PlayerHandleSpriteInvisibility(void); -void PlayerHandleBattleAnimation(void); -void PlayerHandleLinkStandbyMsg(void); -void PlayerHandleResetActionMoveSelection(void); -void sub_80312A0(void); -void nullsub_43(void); - -const u8 gString_TurnJP[] = _("ターン"); - -void (*const gPlayerBufferCommands[])(void) = -{ - PlayerHandleGetAttributes, - sub_802ECF0, - PlayerHandleSetAttributes, - sub_802F7CC, - PlayerHandleLoadPokeSprite, - PlayerHandleSendOutPoke, - PlayerHandleReturnPokeToBall, - PlayerHandleTrainerThrow, - PlayerHandleTrainerSlide, - PlayerHandleTrainerSlideBack, - sub_802FE7C, - sub_802FF60, - sub_802FF80, - PlayerHandleBallThrow, - PlayerHandlePuase, - PlayerHandleMoveAnimation, - PlayerHandlePrintString, - PlayerHandlePrintStringPlayerOnly, - sub_803037C, - nullsub_42, - sub_8030468, - PlayerHandleOpenBag, - sub_8030594, - sub_8030674, - PlayerHandleHealthBarUpdate, - PlayerHandleExpBarUpdate, - PlayerHandleStatusIconUpdate, - PlayerHandleStatusAnimation, - PlayerHandleStatusXor, - sub_803097C, - PlayerHandleDMATransfer, - sub_8030A3C, - sub_8030A6C, - sub_8030A78, - sub_8030A8C, - sub_8030AA0, - sub_8030AB4, - sub_8030AC8, - sub_8030AE4, - sub_8030B1C, - sub_8030B34, - PlayerHandleHitAnimation, - sub_8030BCC, - PlayerHandleEffectivenessSound, - sub_8030C1C, - PlayerHandleFaintingCry, - PlayerHandleIntroSlide, - PlayerHandleTrainerBallThrow, - sub_8030FAC, - sub_80310A4, - sub_80310F0, - PlayerHandleSpriteInvisibility, - PlayerHandleBattleAnimation, - PlayerHandleLinkStandbyMsg, - PlayerHandleResetActionMoveSelection, - sub_80312A0, - nullsub_43, -}; - -void PlayerBufferRunCommand(void); -void sub_802C2EC(void); -void sub_802C68C(void); -void sub_802CA60(void); -void sub_802D730(void); -void sub_802DA9C(u8); -void sub_802DB6C(u8); -void sub_802DCB0(u8); -void sub_802DD10(u8); -void sub_802DDC4(u8); -void sub_802DF88(void); -void sub_802E03C(void); -void sub_802E12C(s32, const u8 *); -void sub_802E1B0(void); -void sub_802E220(void); -void sub_802E2D4(void); -void sub_802E3B4(u8, int); -void nullsub_7(u8); -void b_link_standby_message(void); - -void nullsub_91(void) -{ -} - -void SetBankFuncToPlayerBufferRunCommand(void) -{ - gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; - gDoingBattleAnim = FALSE; -} - -void PlayerBufferExecCompleted(void) -{ - gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; - if (gBattleTypeFlags & BATTLE_TYPE_LINK) - { - u8 playerId = GetMultiplayerId(); - - dp01_prepare_buffer_wireless_probably(2, 4, &playerId); - gBattleBufferA[gActiveBank][0] = 0x38; - } - else - { - gBattleExecBuffer &= ~gBitTable[gActiveBank]; - } -} - -void PlayerBufferRunCommand(void) -{ - if (gBattleExecBuffer & gBitTable[gActiveBank]) - { - if (gBattleBufferA[gActiveBank][0] < 0x39) - gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); - else - PlayerBufferExecCompleted(); - } -} - -void bx_0802E404(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) - PlayerBufferExecCompleted(); -} - -void sub_802C098(void) -{ - u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - dp11b_obj_instanciate(gActiveBank, 1, 7, 1); - dp11b_obj_instanciate(gActiveBank, 0, 7, 1); - if (gMain.newKeys & A_BUTTON) - { - PlaySE(SE_SELECT); - DestroyMenuCursor(); - - // Useless switch statement. - switch (gActionSelectionCursor[gActiveBank]) - { - case 0: - dp01_build_cmdbuf_x21_a_bb(1, 0, 0); - break; - case 1: - dp01_build_cmdbuf_x21_a_bb(1, 1, 0); - break; - case 2: - dp01_build_cmdbuf_x21_a_bb(1, 2, 0); - break; - case 3: - dp01_build_cmdbuf_x21_a_bb(1, 3, 0); - break; - } - PlayerBufferExecCompleted(); - } - else if (gMain.newKeys & DPAD_LEFT) - { - if (gActionSelectionCursor[gActiveBank] & 1) - { - PlaySE(SE_SELECT); - nullsub_8(gActionSelectionCursor[gActiveBank]); - gActionSelectionCursor[gActiveBank] ^= 1; - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - } - } - else if (gMain.newKeys & DPAD_RIGHT) - { - if (!(gActionSelectionCursor[gActiveBank] & 1)) - { - PlaySE(SE_SELECT); - nullsub_8(gActionSelectionCursor[gActiveBank]); - gActionSelectionCursor[gActiveBank] ^= 1; - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - } - } - else if (gMain.newKeys & DPAD_UP) - { - if (gActionSelectionCursor[gActiveBank] & 2) - { - PlaySE(SE_SELECT); - nullsub_8(gActionSelectionCursor[gActiveBank]); - gActionSelectionCursor[gActiveBank] ^= 2; - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - } - } - else if (gMain.newKeys & DPAD_DOWN) - { - if (!(gActionSelectionCursor[gActiveBank] & 2)) - { - PlaySE(SE_SELECT); - nullsub_8(gActionSelectionCursor[gActiveBank]); - gActionSelectionCursor[gActiveBank] ^= 2; - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - } - } - else if (gMain.newKeys & B_BUTTON) - { - if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) - && GetBankIdentity(gActiveBank) == 2 - && !(gAbsentBankFlags & gBitTable[GetBankByPlayerAI(0)]) - && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - if (gBattleBufferA[gActiveBank][1] == 1) - { - // Add item to bag if it is a ball - if (itemId <= ITEM_PREMIER_BALL) - AddBagItem(itemId, 1); - else - return; - } - PlaySE(SE_SELECT); - dp01_build_cmdbuf_x21_a_bb(1, 12, 0); - PlayerBufferExecCompleted(); - DestroyMenuCursor(); - } - } - else if (gMain.newKeys & START_BUTTON) - { - sub_804454C(); - } -} - -void unref_sub_802C2B8(void) -{ - dp11b_obj_free(gActiveBank, 1); - dp11b_obj_free(gActiveBank, 0); - gBattleBankFunc[gActiveBank] = sub_802C2EC; -} - -// TODO: fix this function -void sub_802C2EC(void) -{ - u8 arr[4] = {0, 2, 3, 1}; - s32 i; - - dp11b_obj_instanciate(gUnknown_03004344, 1, 15, 1); - i = 0; - if (gNoOfAllBanks != 0) - { - do - { - if (i != gUnknown_03004344) - dp11b_obj_free(i, 1); - i++; - } while (i < gNoOfAllBanks); - } - if (gMain.newKeys & A_BUTTON) - { - DestroyMenuCursor(); - PlaySE(SE_SELECT); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; - dp01_build_cmdbuf_x21_a_bb(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); - dp11b_obj_free(gUnknown_03004344, 1); - PlayerBufferExecCompleted(); - } - //_0802C3A8 - else if (gMain.newKeys & B_BUTTON) - { - PlaySE(SE_SELECT); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; - gBattleBankFunc[gActiveBank] = sub_802C68C; - dp11b_obj_instanciate(gActiveBank, 1, 7, 1); - dp11b_obj_instanciate(gActiveBank, 0, 7, 1); - dp11b_obj_free(gUnknown_03004344, 1); - } - else if (gMain.newKeys & 0x60) - { - PlaySE(SE_SELECT); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; - do - { - u8 var = GetBankIdentity(gUnknown_03004344); - - for (i = 0; i < 4; i++) - { - if (var == arr[i]) - break; - } - do - { - i--; - if (i < 0) - i = 3; - gUnknown_03004344 = GetBankByPlayerAI(arr[i]); - } while(gUnknown_03004344 == gNoOfAllBanks); - i = 0; - switch (GetBankIdentity(gUnknown_03004344)) - { - case 0: - case 2: - if (gActiveBank == gUnknown_03004344) - { - u32 moveId; - - asm("":::"memory"); - moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); - if (!(gBattleMoves[moveId].target & 2)) - break; - } - i++; - break; - case 1: - case 3: - i++; - } - //_0802C500 - if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) - i = 0; - } while (i == 0); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; - } - //_0802C540 - else if (gMain.newKeys & 0x90) - { - PlaySE(SE_SELECT); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; - do - { - u8 var = GetBankIdentity(gUnknown_03004344); - - for (i = 0; i < 4; i++) - { - if (var == arr[i]) - break; - } - do - { - i++; - if (i > 3) - i = 0; - gUnknown_03004344 = GetBankByPlayerAI(arr[i]); - } while (gUnknown_03004344 == gNoOfAllBanks); - i = 0; - switch (GetBankIdentity(gUnknown_03004344)) - { - case 0: - case 2: - if (gActiveBank == gUnknown_03004344) - { - u32 moveId; - - asm("":::"memory"); - moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); - if (!(gBattleMoves[moveId].target & 2)) - break; - } - i++; - break; - case 1: - case 3: - i++; - } - if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) - i = 0; - } while (i == 0); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; - } -} - -struct UnknownStruct1 -{ - u16 moves[4]; - u8 pp[4]; - u8 unkC[0x12-0xC]; - u8 unk12; - u8 unk13; - u8 filler14[0x20-0x14]; -}; - -const u8 gUnknown_081FAE80[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW WHITE LIGHT_BLUE WHITE2}"); - -void sub_802C68C(void) -{ - u32 r8 = 0; - struct UnknownStruct1 *r6 = (struct UnknownStruct1 *)(gBattleBufferA[gActiveBank] + 4); - - if (gMain.newKeys & A_BUTTON) - { - u32 r4; - - PlaySE(SE_SELECT); - - if (r6->moves[gMoveSelectionCursor[gActiveBank]] == MOVE_CURSE) - r4 = (r6->unk12 != TYPE_GHOST && (r6->unk13 ^ 7)) ? 0x10 : 0; - else - r4 = gBattleMoves[r6->moves[gMoveSelectionCursor[gActiveBank]]].target; - - if (r4 & 0x10) - gUnknown_03004344 = gActiveBank; - else - gUnknown_03004344 = GetBankByPlayerAI((GetBankIdentity(gActiveBank) & 1) ^ 1); - - if (gBattleBufferA[gActiveBank][1] == 0) - { - if ((r4 & 2) && gBattleBufferA[gActiveBank][2] == 0) - r8++; - } - else - { - if (!(r4 & 0x7D)) - r8++; - if (r6->pp[gMoveSelectionCursor[gActiveBank]] == 0) - { - r8 = 0; - } - else if (!(r4 & 0x12) && CountAliveMons(0) <= 1) - { - gUnknown_03004344 = sub_803C434(gActiveBank); - r8 = 0; - } - } - if (r8 == 0) - { - DestroyMenuCursor(); - dp01_build_cmdbuf_x21_a_bb(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); - PlayerBufferExecCompleted(); - } - else - { - gBattleBankFunc[gActiveBank] = sub_802C2EC; - if (r4 & 0x12) - gUnknown_03004344 = gActiveBank; - else if (gAbsentBankFlags & gBitTable[GetBankByPlayerAI(1)]) - gUnknown_03004344 = GetBankByPlayerAI(3); - else - gUnknown_03004344 = GetBankByPlayerAI(1); - gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; - } - } - else if (gMain.newKeys & B_BUTTON) - { - DestroyMenuCursor(); - PlaySE(SE_SELECT); - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 320; - dp01_build_cmdbuf_x21_a_bb(1, 10, 0xFFFF); - PlayerBufferExecCompleted(); - } - else if (gMain.newKeys & DPAD_LEFT) - { - if (gMoveSelectionCursor[gActiveBank] & 1) - { - nullsub_7(gMoveSelectionCursor[gActiveBank]); - gMoveSelectionCursor[gActiveBank] ^= 1; - PlaySE(SE_SELECT); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E220(); - sub_802E2D4(); - } - } - else if (gMain.newKeys & DPAD_RIGHT) - { - if (!(gMoveSelectionCursor[gActiveBank] & 1) - && (gMoveSelectionCursor[gActiveBank] ^ 1) < gUnknown_03004348) - { - nullsub_7(gMoveSelectionCursor[gActiveBank]); - gMoveSelectionCursor[gActiveBank] ^= 1; - PlaySE(SE_SELECT); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E220(); - sub_802E2D4(); - } - } - else if (gMain.newKeys & DPAD_UP) - { - if (gMoveSelectionCursor[gActiveBank] & 2) - { - nullsub_7(gMoveSelectionCursor[gActiveBank]); - gMoveSelectionCursor[gActiveBank] ^= 2; - PlaySE(SE_SELECT); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E220(); - sub_802E2D4(); - } - } - else if (gMain.newKeys & DPAD_DOWN) - { - if (!(gMoveSelectionCursor[gActiveBank] & 2) - && (gMoveSelectionCursor[gActiveBank] ^ 2) < gUnknown_03004348) - { - nullsub_7(gMoveSelectionCursor[gActiveBank]); - gMoveSelectionCursor[gActiveBank] ^= 2; - PlaySE(SE_SELECT); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E220(); - sub_802E2D4(); - } - } - else if (gMain.newKeys & SELECT_BUTTON) - { - if (gUnknown_03004348 > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) - { - sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_081FAE80); - if (gMoveSelectionCursor[gActiveBank] != 0) - gUnknown_03004344 = 0; - else - gUnknown_03004344 = gMoveSelectionCursor[gActiveBank] + 1; - sub_802E3B4(gUnknown_03004344, 27); - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D89, 0x290, 0x17, 0x37); - sub_8002F44(&gUnknown_03004210); - gBattleBankFunc[gActiveBank] = sub_802CA60; - } - } -} - -extern const u8 gUnknown_08400D49[]; -extern const u8 gUnknown_08400D38[]; - -void sub_802CA60(void) -{ - u8 perMovePPBonuses[4]; - struct - { - u16 moves[4]; - u8 pp[4]; - u8 filler18[8]; // what is this? - } sp0; - //struct UnknownStruct1 sp0; - u8 totalPPBonuses; - - if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) - { - PlaySE(SE_SELECT); - if (gMoveSelectionCursor[gActiveBank] != gUnknown_03004344) - { - struct UnknownStruct1 *r9 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - s32 i; - - i = r9->moves[gMoveSelectionCursor[gActiveBank]]; - r9->moves[gMoveSelectionCursor[gActiveBank]] = r9->moves[gUnknown_03004344]; - r9->moves[gUnknown_03004344] = i; - - i = r9->pp[gMoveSelectionCursor[gActiveBank]]; - r9->pp[gMoveSelectionCursor[gActiveBank]] = r9->pp[gUnknown_03004344]; - r9->pp[gUnknown_03004344] = i; - - i = r9->unkC[gMoveSelectionCursor[gActiveBank]]; - r9->unkC[gMoveSelectionCursor[gActiveBank]] = r9->unkC[gUnknown_03004344]; - r9->unkC[gUnknown_03004344] = i; - - if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) - { - gDisableStructs[gActiveBank].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBank]]; - gDisableStructs[gActiveBank].unk18_b |= gBitTable[gUnknown_03004344]; - } - - sub_802E1B0(); - - for (i = 0; i < 4; i++) - perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; - perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; - - totalPPBonuses = 0; - for (i = 0; i < 4; i++) - totalPPBonuses |= perMovePPBonuses[i] << (i * 2); - gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; - - for (i = 0; i < 4; i++) - { - gBattleMons[gActiveBank].moves[i] = r9->moves[i]; - gBattleMons[gActiveBank].pp[i] = r9->pp[i]; - } - if (!(gBattleMons[gActiveBank].status2 & 0x200000)) - { - for (i = 0; i < 4; i++) - { - sp0.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); - sp0.pp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); - } - - totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); - for (i = 0; i < 4; i++) - perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); - - i = sp0.moves[gMoveSelectionCursor[gActiveBank]]; - sp0.moves[gMoveSelectionCursor[gActiveBank]] = sp0.moves[gUnknown_03004344]; - sp0.moves[gUnknown_03004344] = i; - - i = sp0.pp[gMoveSelectionCursor[gActiveBank]]; - sp0.pp[gMoveSelectionCursor[gActiveBank]] = sp0.pp[gUnknown_03004344]; - sp0.pp[gUnknown_03004344] = i; - - totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; - perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; - perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; - - totalPPBonuses = 0; - for (i = 0; i < 4; i++) - totalPPBonuses |= perMovePPBonuses[i] << (i * 2); - - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, (u8 *)&sp0.moves[i]); - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &sp0.pp[i]); - } - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); - } - } - else - { - sub_802E12C(gUnknown_03004344, gUnknown_08400D49); - } - gBattleBankFunc[gActiveBank] = sub_802C68C; - gMoveSelectionCursor[gActiveBank] = gUnknown_03004344; - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); - sub_8002F44(&gUnknown_03004210); - sub_802E220(); - sub_802E2D4(); - } - if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) - { - PlaySE(SE_SELECT); - nullsub_7(gUnknown_03004344); - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_08400D49); - gBattleBankFunc[gActiveBank] = sub_802C68C; - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); - sub_8002F44(&gUnknown_03004210); - sub_802E220(); - sub_802E2D4(); - } - if ((gMain.newKeys & DPAD_LEFT) && (gUnknown_03004344 & 1)) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 1; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_RIGHT) && !(gUnknown_03004344 & 1) && (gUnknown_03004344 ^ 1) < gUnknown_03004348) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 1; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_UP) && (gUnknown_03004344 & 2)) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 2; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } - if ((gMain.newKeys & DPAD_DOWN) && !(gUnknown_03004344 & 2) && (gUnknown_03004344 ^ 2) < gUnknown_03004348) - { - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); - else - nullsub_7(gUnknown_03004344); - gUnknown_03004344 ^= 2; - PlaySE(SE_SELECT); - if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) - sub_802E3B4(gUnknown_03004344, 0); - else - sub_802E3B4(gUnknown_03004344, 0x1B); - } -} - -void sub_802D148(void) -{ - if (gReceivedRemoteLinkPlayers == 0) - { - m4aSongNumStop(SE_HINSI); - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(c2_8011A1C); - } -} - -void sub_802D18C(void) -{ - if (!gPaletteFade.active) - { - if (gBattleTypeFlags & BATTLE_TYPE_LINK) - { - sub_800832C(); - gBattleBankFunc[gActiveBank] = sub_802D148; - } - else - { - m4aSongNumStop(SE_HINSI); - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(gMain.savedCallback); - } - } -} - -void sub_802D204(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - PlayerBufferExecCompleted(); -} - -// duplicate of sub_802D204 -void sub_802D23C(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - PlayerBufferExecCompleted(); -} - -void sub_802D274(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - { - nullsub_10(gSaveBlock2.playerGender); - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - PlayerBufferExecCompleted(); - } -} - -void sub_802D2E0(void) -{ - if (--ewram17810[gActiveBank].unk9 == 0xFF) - { - ewram17810[gActiveBank].unk9 = 0; - PlayerBufferExecCompleted(); - } -} - -void sub_802D31C(void) -{ - bool8 r6 = FALSE; - - if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - else - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy - && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - if (IsCryPlayingOrClearCrySongs()) - r6 = FALSE; - - if (r6 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - ewram17810[gActiveBank ^ 2].unk0_7 = 0; - ewram17810[gActiveBank ^ 2].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - m4aMPlayContinue(&gMPlay_BGM); - else - m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256); - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - if (IsDoubleBattle()) - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], gActiveBank ^ 2); - ewram17810[gActiveBank].unk9 = 3; - gBattleBankFunc[gActiveBank] = sub_802D2E0; - } -} - -void sub_802D500(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); - if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) - sub_8141828(gActiveBank ^ 2, &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]]); - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) - { - if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); - sub_8045A5C( - gHealthboxIDs[gActiveBank ^ 2], - &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], - 0); - sub_804777C(gActiveBank ^ 2); - sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); - } - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8045A5C( - gHealthboxIDs[gActiveBank], - &gPlayerParty[gBattlePartyID[gActiveBank]], - 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - ewram17840.unk9_0 = 0; - gBattleBankFunc[gActiveBank] = sub_802D31C; - } -} - -void sub_802D680(void) -{ - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy - && ewram17810[gActiveBank].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - gBattleBankFunc[gActiveBank] = sub_802D730; - } -} - -void sub_802D730(void) -{ - if (!ewram17810[gActiveBank].unk0_6 && !IsCryPlayingOrClearCrySongs()) - { - m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlayerBufferExecCompleted(); - } -} - -void sub_802D798(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); - if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy - && !ewram17810[gActiveBank].unk0_3) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - sub_8031F88(gActiveBank); - gBattleBankFunc[gActiveBank] = sub_802D680; - } -} - -void c3_0802FDF4(u8 taskId) -{ - if (!IsCryPlayingOrClearCrySongs()) - { - m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); - DestroyTask(taskId); - } -} - -void bx_t1_healthbar_update(void) -{ - s16 r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); - - sub_8043DFC(gHealthboxIDs[gActiveBank]); - if (r4 != -1) - { - sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); - } - else - { - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlayerBufferExecCompleted(); - } -} - -void sub_802D90C(void) -{ - if (gUnknown_03004210.state == 0) - PlayerBufferExecCompleted(); -} - -// Rare Candy usage, maybe? -void sub_802D924(u8 taskId) -{ - u32 pkmnIndex = (u8)gTasks[taskId].data[0]; - u8 bank = gTasks[taskId].data[2]; - s16 gainedExp = gTasks[taskId].data[1]; - - if (IsDoubleBattle() == TRUE || pkmnIndex != gBattlePartyID[bank]) - { - struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; - u16 species = GetMonData(pkmn, MON_DATA_SPECIES); - u8 level = GetMonData(pkmn, MON_DATA_LEVEL); - u32 currExp = GetMonData(pkmn, MON_DATA_EXP); - u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1]; - - if (currExp + gainedExp >= nextLvlExp) - { - u8 savedActiveBank; - - SetMonData(pkmn, MON_DATA_EXP, (u8 *)&nextLvlExp); - CalculateMonStats(pkmn); - gainedExp -= nextLvlExp - currExp; - savedActiveBank = gActiveBank; - gActiveBank = bank; - dp01_build_cmdbuf_x21_a_bb(1, 11, gainedExp); - gActiveBank = savedActiveBank; - - if (IsDoubleBattle() == TRUE - && ((u16)pkmnIndex == gBattlePartyID[bank] || (u16)pkmnIndex == gBattlePartyID[bank ^ 2])) - gTasks[taskId].func = sub_802DCB0; - else - gTasks[taskId].func = sub_802DDC4; - } - else - { - currExp += gainedExp; - SetMonData(pkmn, MON_DATA_EXP, (u8 *)&currExp); - gBattleBankFunc[bank] = sub_802D90C; - DestroyTask(taskId); - } - } - else - { - gTasks[taskId].func = sub_802DA9C; - } -} - -void sub_802DA9C(u8 taskId) -{ - u8 pkmnIndex = gTasks[taskId].data[0]; - s32 r9 = gTasks[taskId].data[1]; - u8 bank = gTasks[taskId].data[2]; - struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; - u8 level = GetMonData(pkmn, MON_DATA_LEVEL); - u16 species = GetMonData(pkmn, MON_DATA_SPECIES); - u32 exp = GetMonData(pkmn, MON_DATA_EXP); - u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level]; - u32 expToNextLvl; - - exp -= currLvlExp; - expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp; - sub_8043D84(bank, gHealthboxIDs[bank], expToNextLvl, exp, -r9); - PlaySE(SE_EXP); - gTasks[taskId].func = sub_802DB6C; -} - -#ifdef NONMATCHING -void sub_802DB6C(u8 taskId) -{ - if (gTasks[taskId].data[10] < 13) - { - gTasks[taskId].data[10]++; - } - else - { - u8 r9 = gTasks[taskId].data[0]; - s32 r10 = gTasks[taskId].data[1]; //s16? - u8 r7 = gTasks[taskId].data[2]; - s16 r4; - - r4 = sub_8045C78(r7, gHealthboxIDs[r7], 1, 0); - sub_8043DFC(gHealthboxIDs[r7]); - if (r4 == -1) - { - struct Pokemon *pkmn; - u8 r4; - u32 sp4; - u16 r0; - u32 sp0; - - m4aSongNumStop(SE_EXP); - pkmn = &gPlayerParty[r9]; - r4 = GetMonData(pkmn, MON_DATA_LEVEL); - sp4 = GetMonData(pkmn, MON_DATA_EXP); - r0 = GetMonData(pkmn, MON_DATA_SPECIES); - sp0 = gExperienceTables[gBaseStats[r0].growthRate][r4 + 1]; - if (sp4 + r10 >= sp0) - { - u8 r5; - u32 asdf; - - SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp0); - CalculateMonStats(pkmn); - //r10 -= sp0 - sp4; - asdf = sp0 - sp4; - //asdf = r10 - (sp0 - sp4); - r10 -= asdf; - r5 = gActiveBank; - gActiveBank = r7; - dp01_build_cmdbuf_x21_a_bb(1, 11, r10); - gActiveBank = r5; - gTasks[taskId].func = sub_802DCB0; - } - else - { - //u32 asdf = sp4 + r10; - sp4 += r10; - SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp4); - gBattleBankFunc[r7] = sub_802D90C; - DestroyTask(taskId); - } - } - } -} -#else -__attribute__((naked)) -void sub_802DB6C(u8 taskId) -{ - asm_unified("push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x8\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r8, r0\n\ - ldr r1, _0802DB98 @ =gTasks\n\ - lsls r0, 2\n\ - add r0, r8\n\ - lsls r0, 3\n\ - adds r6, r0, r1\n\ - ldrh r1, [r6, 0x1C]\n\ - movs r2, 0x1C\n\ - ldrsh r0, [r6, r2]\n\ - cmp r0, 0xC\n\ - bgt _0802DB9C\n\ - adds r0, r1, 0x1\n\ - strh r0, [r6, 0x1C]\n\ - b _0802DC98\n\ - .align 2, 0\n\ -_0802DB98: .4byte gTasks\n\ -_0802DB9C:\n\ - ldrb r0, [r6, 0x8]\n\ - mov r9, r0\n\ - ldrh r2, [r6, 0xA]\n\ - mov r10, r2\n\ - ldrb r7, [r6, 0xC]\n\ - ldr r5, _0802DC64 @ =gHealthboxIDs\n\ - adds r5, r7, r5\n\ - ldrb r1, [r5]\n\ - adds r0, r7, 0\n\ - movs r2, 0x1\n\ - movs r3, 0\n\ - bl sub_8045C78\n\ - adds r4, r0, 0\n\ - lsls r4, 16\n\ - lsrs r4, 16\n\ - ldrb r0, [r5]\n\ - bl sub_8043DFC\n\ - lsls r4, 16\n\ - asrs r4, 16\n\ - movs r0, 0x1\n\ - negs r0, r0\n\ - cmp r4, r0\n\ - bne _0802DC98\n\ - movs r0, 0x21\n\ - bl m4aSongNumStop\n\ - movs r0, 0x64\n\ - mov r1, r9\n\ - muls r1, r0\n\ - ldr r0, _0802DC68 @ =gPlayerParty\n\ - adds r5, r1, r0\n\ - adds r0, r5, 0\n\ - movs r1, 0x38\n\ - bl GetMonData\n\ - adds r4, r0, 0\n\ - lsls r4, 24\n\ - lsrs r4, 24\n\ - adds r0, r5, 0\n\ - movs r1, 0x19\n\ - bl GetMonData\n\ - str r0, [sp, 0x4]\n\ - adds r0, r5, 0\n\ - movs r1, 0xB\n\ - bl GetMonData\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - ldr r3, _0802DC6C @ =gExperienceTables\n\ - adds r4, 0x1\n\ - lsls r4, 2\n\ - ldr r2, _0802DC70 @ =gBaseStats\n\ - lsls r1, r0, 3\n\ - subs r1, r0\n\ - lsls r1, 2\n\ - adds r1, r2\n\ - ldrb r1, [r1, 0x13]\n\ - movs r0, 0xCA\n\ - lsls r0, 1\n\ - muls r0, r1\n\ - adds r4, r0\n\ - adds r4, r3\n\ - ldr r1, [r4]\n\ - str r1, [sp]\n\ - mov r2, r10\n\ - lsls r0, r2, 16\n\ - asrs r4, r0, 16\n\ - ldr r0, [sp, 0x4]\n\ - adds r0, r4\n\ - cmp r0, r1\n\ - blt _0802DC7C\n\ - adds r0, r5, 0\n\ - movs r1, 0x19\n\ - mov r2, sp\n\ - bl SetMonData\n\ - adds r0, r5, 0\n\ - bl CalculateMonStats\n\ - ldr r2, [sp]\n\ - add r0, sp, 0x4\n\ - ldrh r0, [r0]\n\ - subs r2, r0\n\ - subs r2, r4, r2\n\ - ldr r4, _0802DC74 @ =gActiveBank\n\ - ldrb r5, [r4]\n\ - strb r7, [r4]\n\ - lsls r2, 16\n\ - lsrs r2, 16\n\ - movs r0, 0x1\n\ - movs r1, 0xB\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ - strb r5, [r4]\n\ - ldr r0, _0802DC78 @ =sub_802DCB0\n\ - str r0, [r6]\n\ - b _0802DC98\n\ - .align 2, 0\n\ -_0802DC64: .4byte gHealthboxIDs\n\ -_0802DC68: .4byte gPlayerParty\n\ -_0802DC6C: .4byte gExperienceTables\n\ -_0802DC70: .4byte gBaseStats\n\ -_0802DC74: .4byte gActiveBank\n\ -_0802DC78: .4byte sub_802DCB0\n\ -_0802DC7C:\n\ - str r0, [sp, 0x4]\n\ - add r2, sp, 0x4\n\ - adds r0, r5, 0\n\ - movs r1, 0x19\n\ - bl SetMonData\n\ - ldr r1, _0802DCA8 @ =gBattleBankFunc\n\ - lsls r0, r7, 2\n\ - adds r0, r1\n\ - ldr r1, _0802DCAC @ =sub_802D90C\n\ - str r1, [r0]\n\ - mov r0, r8\n\ - bl DestroyTask\n\ -_0802DC98:\n\ - add sp, 0x8\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_0802DCA8: .4byte gBattleBankFunc\n\ -_0802DCAC: .4byte sub_802D90C\n"); -} -#endif - -void sub_802DCB0(u8 taskId) -{ - u8 bank = gTasks[taskId].data[2]; - u8 pkmnIndex = gTasks[taskId].data[0]; - - if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) - bank ^= 2; - move_anim_start_t4(bank, bank, bank, 0); - gTasks[taskId].func = sub_802DD10; -} - -void sub_802DD10(u8 taskId) -{ - u8 bank = gTasks[taskId].data[2]; - - if (!ewram17810[bank].unk0_6) - { - u8 pkmnIndex = gTasks[taskId].data[0]; - - GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value - if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) - sub_8045A5C(gHealthboxIDs[bank ^ 2], &gPlayerParty[pkmnIndex], 0); - else - sub_8045A5C(gHealthboxIDs[bank], &gPlayerParty[pkmnIndex], 0); - gTasks[taskId].func = sub_802DDC4; - } -} - -void sub_802DDC4(u8 taskId) -{ - u8 pkmnIndex; - u8 bank; - - pkmnIndex = gTasks[taskId].data[0]; - GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value - bank = gTasks[taskId].data[2]; - gBattleBankFunc[bank] = sub_802D90C; - DestroyTask(taskId); -} - -void sub_802DE10(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > DISPLAY_HEIGHT) - { - u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - - nullsub_9(species); - FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - PlayerBufferExecCompleted(); - } -} - -void sub_802DEAC(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - PlayerBufferExecCompleted(); - } -} - -// Duplicate of sub_802D90C -void sub_802DF18(void) -{ - if (gUnknown_03004210.state == 0) - PlayerBufferExecCompleted(); -} - -void sub_802DF30(void) -{ - if (!gPaletteFade.active) - { - u8 r4; - - gBattleBankFunc[gActiveBank] = sub_802DF88; - r4 = gTasks[gUnknown_0300434C[gActiveBank]].data[0]; - DestroyTask(gUnknown_0300434C[gActiveBank]); - sub_8094E20(r4); - } -} - -void sub_802DF88(void) -{ - if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) - { - if (gUnknown_0202E8F4 == 1) - dp01_build_cmdbuf_x22_a_three_bytes(1, gUnknown_0202E8F5, gUnknown_02038470); - else - dp01_build_cmdbuf_x22_a_three_bytes(1, 6, NULL); - if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1) - b_link_standby_message(); - PlayerBufferExecCompleted(); - } -} - -void sub_802E004(void) -{ - if (!gPaletteFade.active) - { - gBattleBankFunc[gActiveBank] = sub_802E03C; - nullsub_14(); - sub_80A6DCC(); - } -} - -void sub_802E03C(void) -{ - if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) - { - dp01_build_cmdbuf_x23_aa_0(1, gScriptItemId); - PlayerBufferExecCompleted(); - } -} - -void bx_wait_t1(void) -{ - if (!gDoingBattleAnim || !ewram17810[gActiveBank].unk0_6) - PlayerBufferExecCompleted(); -} - -void bx_blink_t1(void) -{ - u8 spriteId = gObjectBankIDs[gActiveBank]; - - if (gSprites[spriteId].data1 == 32) - { - gSprites[spriteId].data1 = 0; - gSprites[spriteId].invisible = FALSE; - gDoingBattleAnim = 0; - PlayerBufferExecCompleted(); - } - else - { - if (((u16)gSprites[spriteId].data1 % 4) == 0) - gSprites[spriteId].invisible ^= 1; - gSprites[spriteId].data1++; - } -} - -void sub_802E12C(s32 a, const u8 *b) -{ - struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - - StringCopy(gDisplayedStringBattle, b); - StringAppend(gDisplayedStringBattle, gMoveNames[r4->moves[a]]); - InitWindow( - &gUnknown_03004210, - gDisplayedStringBattle, - 0x300 + a * 20, - (a & 1) ? 11 : 1, - (a < 2) ? 0x37 : 0x39); - sub_8002F44(&gUnknown_03004210); -} - -void sub_802E1B0(void) -{ - struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - s32 i; - - gUnknown_03004348 = 0; - FillWindowRect(&gUnknown_03004210, 0x1016, 1, 0x37, 0x14, 0x3A); - for (i = 0; i < 4; i++) - { - nullsub_7(i); - sub_802E12C(i, gUnknown_08400D49); - if (r4->moves[i] != 0) - gUnknown_03004348++; - } -} - -void sub_802E220(void) -{ - if (gBattleBufferA[gActiveBank][2] != 1) - { - struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - u8 *str = gDisplayedStringBattle; - - str = StringCopy(str, gUnknown_08400D49); - str[0] = EXT_CTRL_CODE_BEGIN; - str[1] = 0x11; - str[2] = 2; - str += 3; - str[0] = EXT_CTRL_CODE_BEGIN; - str[1] = 0x14; - str[2] = 6; - str += 3; - str = ConvertIntToDecimalStringN(str, r4->pp[gMoveSelectionCursor[gActiveBank]], 1, 2); - *str++ = CHAR_SLASH; - ConvertIntToDecimalStringN(str, r4->unkC[gMoveSelectionCursor[gActiveBank]], 1, 2); - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2A2, 0x19, 0x37); - sub_8002F44(&gUnknown_03004210); - } -} - -extern const u8 gUnknown_08400D52[]; -extern const u8 gTypeNames[][7]; - -void sub_802E2D4(void) -{ - if (gBattleBufferA[gActiveBank][2] == 1) - { - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gUnknown_08400D52, 0x290, 0x13, 0x37); - } - else - { - struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; - u8 *str = gDisplayedStringBattle; - - str = StringCopy(str, gUnknown_08400D49); - StringCopy(str, gTypeNames[gBattleMoves[r4->moves[gMoveSelectionCursor[gActiveBank]]].type]); - FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x39, 0x1C, 0x3A); - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2C0, 0x17, 0x39); - } - sub_8002F44(&gUnknown_03004210); -} - -const u8 gUnknown_081FAE89[][2] = -{ - { 8, 120}, - {88, 120}, - { 8, 136}, - {88, 136}, -}; - -const u8 gUnknown_081FAE91[][2] = -{ - {144, 120}, - {190, 120}, - {144, 136}, - {190, 136}, - { 72, 72}, - { 32, 90}, - { 80, 80}, - { 80, 88}, -}; - -void sub_802E3B4(u8 a, int unused) -{ - sub_814A958(0x48); - sub_814A880(gUnknown_081FAE89[a][0], gUnknown_081FAE89[a][1]); -} - -void nullsub_7(u8 a) -{ -} - -void sub_802E3E4(u8 a, int unused) -{ - sub_814A958(0x2A); - sub_814A880(gUnknown_081FAE91[a][0], gUnknown_081FAE91[a][1]); -} - -void nullsub_8(u8 a) -{ -} - -void sub_802E414(void) -{ - SetMainCallback2(ReshowBattleScreenAfterMenu); -} - -void sub_802E424(void) -{ - SetMainCallback2(ReshowBattleScreenAfterMenu); -} - -void sub_802E434(void) -{ - if (!ewram17810[gActiveBank].unk0_4) - PlayerBufferExecCompleted(); -} - -void sub_802E460(void) -{ - if (!ewram17810[gActiveBank].unk0_5) - PlayerBufferExecCompleted(); -} - -void b_link_standby_message(void) -{ - if (gBattleTypeFlags & BATTLE_TYPE_LINK) - { - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - sub_8002EB0(&gUnknown_03004210, gUnknown_08400CE0, 0x90, 2, 15); - } -} diff --git a/src/battle_6.c b/src/battle_6.c deleted file mode 100644 index e7f152a4b..000000000 --- a/src/battle_6.c +++ /dev/null @@ -1,1507 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_interface.h" -#include "battle_message.h" -#include "data2.h" -#include "menu_cursor.h" -#include "palette.h" -#include "pokemon.h" -#include "rom3.h" -#include "songs.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -//Possibly PokemonSubstruct1 -struct UnknownStruct3 -{ - u16 moves[4]; - u8 pp[4]; - u8 ppBonuses; -}; - -extern u16 gUnknown_030042A4; -extern u16 gUnknown_030042A0; - -extern struct Window gUnknown_03004210; - -extern void (*gBattleBankFunc[])(void); - -extern u8 gActiveBank; -extern u8 gActionSelectionCursor[]; -extern u8 gDisplayedStringBattle[]; -extern u8 gMoveSelectionCursor[]; -extern u8 gBattleBufferA[][0x200]; -extern u8 gBankInMenu; -extern u16 gBattlePartyID[]; -extern u8 gHealthboxIDs[]; -extern u8 gDoingBattleAnim; -extern u8 gObjectBankIDs[]; -extern u16 gBattleTypeFlags; -extern u8 gBattleOutcome; -extern void (*gAnimScriptCallback)(void); -extern bool8 gAnimScriptActive; -extern u16 gMovePowerMoveAnim; -extern u32 gMoveDmgMoveAnim; -extern u8 gHappinessMoveAnim; -extern u16 gWeatherMoveAnim; -extern u32 *gDisableStructMoveAnim; -extern u32 gPID_perBank[]; -extern u8 gBattleMonForms[]; -extern u16 gUnknown_02024DE8; -extern u8 gUnknown_02024E68[]; -extern struct SpriteTemplate gUnknown_02024E8C; -extern u8 gUnknown_0202F7C4; -extern u8 gUnknown_02038470[]; -extern u16 gUnknown_030041B0; -extern u16 gUnknown_030041B4; -extern u16 gUnknown_030041B8; -extern u16 gUnknown_03004280; -extern u16 gUnknown_03004288; -extern u16 gUnknown_030042A4; -extern u16 gUnknown_030042C0; -extern u8 gUnknown_03004344; -extern u8 gUnknown_0300434C[]; - -extern const u8 gUnknown_08400CA8[]; -extern const u8 gUnknown_08400CF3[]; -extern const u8 gUnknown_08400D38[]; - -#if ENGLISH -#define SUB_803037C_TILE_DATA_OFFSET 440 -#elif GERMAN -#define SUB_803037C_TILE_DATA_OFFSET 444 -#endif - -extern void sub_802C68C(void); -extern void sub_802E1B0(void); -extern void sub_802E3B4(); -extern void sub_802E220(); -extern void sub_802E2D4(); -extern void sub_802E004(void); -extern void sub_802DF30(void); -extern void BattleMusicStop(void); -extern void PlayerBufferExecCompleted(void); -extern void bx_t1_healthbar_update(void); -extern void nullsub_91(void); -extern void sub_802D924(u8); -extern void sub_802E434(void); -extern bool8 mplay_80342A4(u8); -extern void move_anim_start_t2_for_situation(); -extern void bx_blink_t1(void); -extern void sub_8047858(); -extern u8 GetBankSide(u8); -extern void sub_80E43C0(); -extern void oamt_add_pos2_onto_pos1(); -extern void sub_8078B34(struct Sprite *); -extern void oamt_set_x3A_32(); -extern void BattleLoadPlayerMonSprite(); -extern bool8 IsDoubleBattle(void); -extern void sub_802D500(void); -extern void dp11b_obj_free(); -extern bool8 sub_8078874(u8); -extern bool8 move_anim_start_t3(); -extern void sub_802E460(void); -extern void b_link_standby_message(void); -extern void sub_802D18C(void); -extern void sub_802DF18(void); -extern void BufferStringBattle(); -extern void sub_80326EC(); -extern void ExecuteMoveAnim(); -extern void sub_8031F24(void); -extern void sub_80324BC(); -extern u8 sub_8031720(); -extern void bx_wait_t1(void); -extern u8 GetBankByPlayerAI(u8); -extern void sub_802DE10(void); -extern void sub_80105EC(struct Sprite *); -extern void sub_802D274(void); -extern void sub_802D23C(void); -extern u8 GetBankIdentity(u8); -extern void LoadPlayerTrainerBankSprite(); -extern void sub_80313A0(struct Sprite *); -extern void sub_802D204(void); -extern u8 sub_8079E90(); -extern void sub_802DEAC(void); -extern void sub_80312F0(struct Sprite *); -extern u8 sub_8077ABC(); -extern u8 sub_8077F68(); -extern u8 sub_8046400(); -extern void sub_802D798(void); -extern void bx_0802E404(void); - -u32 dp01_getattr_by_ch1_for_player_pokemon_(u8, u8 *); -void dp01_setattr_by_ch1_for_player_pokemon(u8); -void sub_802F934(u8, u8); -void sub_802FB2C(void); -void sub_8030190(void); -void sub_80304A8(void); -void sub_8030E38(struct Sprite *); -void task05_08033660(u8); -void sub_8031064(void); - -void PlayerHandleGetAttributes(void) -{ - u8 unkData[0x100]; - u32 offset = 0; - u8 r4; - s32 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - offset += dp01_getattr_by_ch1_for_player_pokemon_(gBattlePartyID[gActiveBank], unkData); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - offset += dp01_getattr_by_ch1_for_player_pokemon_(i, unkData + offset); - r4 >>= 1; - } - } - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, offset, unkData); - PlayerBufferExecCompleted(); -} - -// Duplicate of dp01_getattr_by_ch1_for_player_pokemon -u32 dp01_getattr_by_ch1_for_player_pokemon_(u8 a, u8 *buffer) -{ - struct BattlePokemon battlePokemon; - struct UnknownStruct3 moveData; - u8 nickname[20]; - u8 *src; - s16 data16; - u32 data32; - s32 size = 0; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - for (size = 0; size < 4; size++) - { - battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); - battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); - battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); - battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); - StringCopy10(battlePokemon.nickname, nickname); - GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); - src = (u8 *)&battlePokemon; - for (size = 0; size < sizeof(battlePokemon); size++) - buffer[size] = src[size]; - break; - case 1: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 2: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 3: - for (size = 0; size < 4; size++) - { - moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - src = (u8 *)&moveData; - for (size = 0; size < sizeof(moveData); size++) - buffer[size] = src[size]; - break; - case 4: - case 5: - case 6: - case 7: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 8: - for (size = 0; size < 4; size++) - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - size++; - break; - case 9: - case 10: - case 11: - case 12: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); - size = 1; - break; - case 17: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 18: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 19: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); - size = 1; - break; - case 20: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); - size = 1; - break; - case 21: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); - size = 1; - break; - case 22: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); - size = 1; - break; - case 23: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); - size = 1; - break; - case 24: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); - size = 1; - break; - case 25: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - size = 1; - break; - case 26: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); - size = 1; - break; - case 27: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); - size = 1; - break; - case 28: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); - size = 1; - break; - case 29: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); - size = 1; - break; - case 30: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); - size = 1; - break; - case 31: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 6; - break; - case 32: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - size = 1; - break; - case 33: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - size = 1; - break; - case 34: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - size = 1; - break; - case 35: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - size = 1; - break; - case 36: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - size = 1; - break; - case 37: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 1; - break; - case 38: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 39: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 40: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 41: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - size = 1; - break; - case 42: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 43: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 44: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 45: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 46: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 47: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 48: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 49: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); - size = 1; - break; - case 50: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); - size = 1; - break; - case 51: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); - size = 1; - break; - case 52: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); - size = 1; - break; - case 53: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); - size = 1; - break; - case 54: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); - size = 1; - break; - case 55: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); - size = 1; - break; - case 56: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); - size = 1; - break; - case 57: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); - size = 1; - break; - case 58: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); - size = 1; - break; - case 59: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); - size = 1; - break; - } - return size; -} - -void sub_802ECF0(void) -{ - struct BattlePokemon battleMon; // I think this is a BattlePokemon - u8 *src = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBank][1]; - u8 i; - - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = src[i]; - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, gBattleBufferA[gActiveBank][2], dst); - PlayerBufferExecCompleted(); -} - -void PlayerHandleSetAttributes(void) -{ - u8 r4; - u8 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - dp01_setattr_by_ch1_for_player_pokemon(gBattlePartyID[gActiveBank]); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - dp01_setattr_by_ch1_for_player_pokemon(i); - r4 >>= 1; - } - } - PlayerBufferExecCompleted(); -} - -// Duplicate of sub_811EC68 -void dp01_setattr_by_ch1_for_player_pokemon(u8 a) -{ - struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; - struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; - s32 i; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - { - u8 iv; - - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); - SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); - iv = battlePokemon->hpIV; - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); - iv = battlePokemon->attackIV; - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); - iv = battlePokemon->defenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); - iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); - iv = battlePokemon->spAttackIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); - iv = battlePokemon->spDefenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); - SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); - SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); - SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); - SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); - } - break; - case 1: - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); - break; - case 2: - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); - break; - case 3: - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); - break; - case 4: - case 5: - case 6: - case 7: - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); - break; - case 8: - SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); - break; - case 9: - case 10: - case 11: - case 12: - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); - break; - case 17: - SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); - break; - case 18: - SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); - break; - case 19: - SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 20: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 21: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 22: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 23: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 24: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 25: - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); - break; - case 26: - SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); - break; - case 27: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); - break; - case 28: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 29: - SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); - break; - case 30: - SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); - break; - case 31: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); - break; - case 32: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 33: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 34: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 35: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 36: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 37: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 38: - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); - break; - case 39: - SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); - break; - case 40: - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); - break; - case 41: - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 42: - SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 43: - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 44: - SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); - break; - case 45: - SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); - break; - case 46: - SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); - break; - case 47: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); - break; - case 48: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); - break; - case 49: - SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); - break; - case 50: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); - break; - case 51: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); - break; - case 52: - SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); - break; - case 53: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); - break; - case 54: - SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); - break; - case 55: - SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 56: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 57: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 58: - SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 59: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - } - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); -} - -void sub_802F7CC(void) -{ - u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - u8 i; - - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = gBattleBufferA[gActiveBank][3 + i]; - PlayerBufferExecCompleted(); -} - -void PlayerHandleLoadPokeSprite(void) -{ - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gBattleBankFunc[gActiveBank] = bx_0802E404; -} - -void PlayerHandleSendOutPoke(void) -{ - sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - gActionSelectionCursor[gActiveBank] = 0; - gMoveSelectionCursor[gActiveBank] = 0; - sub_802F934(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattleBankFunc[gActiveBank] = sub_802D798; -} - -void sub_802F934(u8 bank, u8 b) -{ - u16 species; - - sub_8032AA8(bank, b); - gBattlePartyID[bank] = gBattleBufferA[bank][1]; - species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); - gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); - gObjectBankIDs[bank] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(bank, 2), - sub_8077F68(bank), - sub_8079E90(bank)); - gSprites[gUnknown_0300434C[bank]].data1 = gObjectBankIDs[bank]; - gSprites[gObjectBankIDs[bank]].data0 = bank; - gSprites[gObjectBankIDs[bank]].data2 = species; - gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; - StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); - gSprites[gObjectBankIDs[bank]].invisible = TRUE; - gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; - gSprites[gUnknown_0300434C[bank]].data0 = sub_8046400(0, 0xFF); -} - -void PlayerHandleReturnPokeToBall(void) -{ - if (gBattleBufferA[gActiveBank][1] == 0) - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_802FB2C; - } - else - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - PlayerBufferExecCompleted(); - } -} - -void sub_802FB2C(void) -{ - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); - gBattleBankFunc[gActiveBank] = sub_802DEAC; - } - } -} - -void PlayerHandleTrainerThrow(void) -{ - s16 r7; - - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - { - if (GetBankIdentity(gActiveBank) & 2) - r7 = 16; - else - r7 = -16; - } - else - { - r7 = 0; - } - LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); - GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - r7 + 80, - (8 - gTrainerBackPicCoords[gSaveBlock2.playerGender].coords) * 4 + 80, - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_802D204; -} - -void PlayerHandleTrainerSlide(void) -{ - LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); - GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 80, - (8 - gTrainerBackPicCoords[gSaveBlock2.playerGender].coords) * 4 + 80, - 30); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -96; - gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_802D23C; -} - -void PlayerHandleTrainerSlideBack(void) -{ - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; - gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); - gBattleBankFunc[gActiveBank] = sub_802D274; -} - -void sub_802FE7C(void) -{ - if (ewram17810[gActiveBank].unk4 == 0) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4++; - } - else - { - if (ewram17810[gActiveBank].unk0_6 == 0) - { - ewram17810[gActiveBank].unk4 = 0; - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlaySE12WithPanning(SE_POKE_DEAD, -64); - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 5; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80105EC; - gBattleBankFunc[gActiveBank] = sub_802DE10; - } - } -} - -void sub_802FF60(void) -{ - BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, 0); - PlayerBufferExecCompleted(); -} - -void sub_802FF80(void) -{ - ewram17840.unk8 = 4; - gDoingBattleAnim = 1; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 3); - gBattleBankFunc[gActiveBank] = bx_wait_t1; -} - -void PlayerHandleBallThrow(void) -{ - u8 var = gBattleBufferA[gActiveBank][1]; - - ewram17840.unk8 = var; - gDoingBattleAnim = 1; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 3); - gBattleBankFunc[gActiveBank] = bx_wait_t1; -} - -void PlayerHandlePuase(void) -{ - u8 var = gBattleBufferA[gActiveBank][1]; - - // WTF is this?? - while (var != 0) - var--; - - PlayerBufferExecCompleted(); -} - -void PlayerHandleMoveAnimation(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - u16 r0 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); - - gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; - gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); - gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); - gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; - gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); - gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; - gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; - if (sub_8031720(r0, gUnknown_0202F7C4) != 0) - { - // Dead code. sub_8031720 always returns 0. - PlayerBufferExecCompleted(); - } - else - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_8030190; - } - } -} - -void sub_8030190(void) -{ - u16 r4 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); - u8 r7 = gBattleBufferA[gActiveBank][11]; - - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite == 1 && ewram17800[gActiveBank].unk0_3 == 0) - { - ewram17800[gActiveBank].unk0_3 = 1; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - } - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (ewram17810[gActiveBank].unk0_6 == 0) - { - sub_80326EC(0); - ExecuteMoveAnim(r4); - ewram17810[gActiveBank].unk4 = 2; - } - break; - case 2: - gAnimScriptCallback(); - if (!gAnimScriptActive) - { - sub_80326EC(1); - if (ewram17800[gActiveBank].substituteSprite == 1 && r7 < 2) - { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - ewram17800[gActiveBank].unk0_3 = 0; - } - ewram17810[gActiveBank].unk4 = 3; - } - break; - case 3: - if (ewram17810[gActiveBank].unk0_6 == 0) - { - sub_8031F24(); - sub_80324BC(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - ewram17810[gActiveBank].unk4 = 0; - PlayerBufferExecCompleted(); - } - break; - } -} - -void PlayerHandlePrintString(void) -{ - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); - sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 0x90, 2, 15); - gBattleBankFunc[gActiveBank] = sub_802DF18; -} - -void PlayerHandlePrintStringPlayerOnly(void) -{ - if (GetBankSide(gActiveBank) == 0) - PlayerHandlePrintString(); - else - PlayerBufferExecCompleted(); -} - -void sub_803037C(void) -{ - int r4; - - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 160; - FillWindowRect(&gUnknown_03004210, 10, 2, 15, 27, 18); - FillWindowRect(&gUnknown_03004210, 10, 2, 35, 16, 38); - - gBattleBankFunc[gActiveBank] = sub_802C098; - - InitWindow(&gUnknown_03004210, gUnknown_08400CF3, 400, 18, 35); - sub_8002F44(&gUnknown_03004210); - sub_814A5C0(0, 0xFFFF, 12, 11679, 0); - - for (r4 = 0; r4 < 4; r4++) - nullsub_8(r4); - - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - - StrCpyDecodeToDisplayedStringBattle((u8 *) gUnknown_08400CA8); - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, SUB_803037C_TILE_DATA_OFFSET, 2, 35); - sub_8002F44(&gUnknown_03004210); -} - -void nullsub_42() -{ -} - -void sub_8030468(void) -{ - sub_814A5C0(0, 0xFFFF, 12, 0x2D9F, 0); - sub_80304A8(); - gBattleBankFunc[gActiveBank] = sub_802C68C; -} - -void sub_80304A8(void) -{ - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 320; - sub_802E1B0(); - gUnknown_03004344 = 0xFF; - sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); - if (gBattleBufferA[gActiveBank][2] != 1) - { - InitWindow(&gUnknown_03004210, gUnknown_08400D38, 656, 23, 55); - sub_8002F44(&gUnknown_03004210); - } - sub_802E220(); - sub_802E2D4(); -} - -void PlayerHandleOpenBag(void) -{ - s32 i; - - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - gBattleBankFunc[gActiveBank] = sub_802E004; - gBankInMenu = gActiveBank; - for (i = 0; i < 3; i++) - gUnknown_02038470[i] = gBattleBufferA[gActiveBank][1 + i]; -} - -void sub_8030594(void) -{ - s32 i; - - gUnknown_0300434C[gActiveBank] = CreateTask(TaskDummy, 0xFF); - gTasks[gUnknown_0300434C[gActiveBank]].data[0] = gBattleBufferA[gActiveBank][1] & 0xF; - ewram[0x16054] = gBattleBufferA[gActiveBank][1] >> 4; - ewram[0x1609D] = gBattleBufferA[gActiveBank][2]; - ewram[0x160C0] = gBattleBufferA[gActiveBank][3]; - for (i = 0; i < 3; i++) - gUnknown_02038470[i] = gBattleBufferA[gActiveBank][4 + i]; - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - gBattleBankFunc[gActiveBank] = sub_802DF30; - gBankInMenu = gActiveBank; -} - -void sub_8030674(void) -{ - BattleMusicStop(); - BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, 0); - PlayerBufferExecCompleted(); -} - -void PlayerHandleHealthBarUpdate(void) -{ - s16 r7; - - load_gfxc_health_bar(0); - r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - if (r7 != 0x7FFF) - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, curHP, r7); - } - else - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); - sub_80440EC(gHealthboxIDs[gActiveBank], 0, 0); - } - gBattleBankFunc[gActiveBank] = bx_t1_healthbar_update; -} - -void PlayerHandleExpBarUpdate(void) -{ - u8 r7 = gBattleBufferA[gActiveBank][1]; - - if (GetMonData(&gPlayerParty[r7], MON_DATA_LEVEL) >= 100) - { - PlayerBufferExecCompleted(); - } - else - { - u16 r4; - u8 taskId; - - load_gfxc_health_bar(1); - GetMonData(&gPlayerParty[r7], MON_DATA_SPECIES); // unused return value - r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - taskId = CreateTask(sub_802D924, 10); - gTasks[taskId].data[0] = r7; - gTasks[taskId].data[1] = r4; - gTasks[taskId].data[2] = gActiveBank; - gBattleBankFunc[gActiveBank] = nullsub_91; - } -} - -void PlayerHandleStatusIconUpdate(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 9); - ewram17810[gActiveBank].unk0_4 = 0; - gBattleBankFunc[gActiveBank] = sub_802E434; - } -} - -void PlayerHandleStatusAnimation(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - move_anim_start_t2_for_situation( - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); - gBattleBankFunc[gActiveBank] = sub_802E434; - } -} - -void PlayerHandleStatusXor(void) -{ - u8 val = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS) ^ gBattleBufferA[gActiveBank][1]; - - SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS, &val); - PlayerBufferExecCompleted(); -} - -void sub_803097C(void) -{ - PlayerBufferExecCompleted(); -} - -void PlayerHandleDMATransfer(void) -{ - u32 val1 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8) - | (gBattleBufferA[gActiveBank][3] << 16) - | (gBattleBufferA[gActiveBank][4] << 24); - u16 val2 = gBattleBufferA[gActiveBank][5] | (gBattleBufferA[gActiveBank][6] << 8); - - const u8 *src = &gBattleBufferA[gActiveBank][7]; - u8 *dst = (u8 *)val1; - u32 size = val2; - - while (1) - { - if (size <= 0x1000) - { - DmaCopy16(3, src, dst, size); - break; - } - DmaCopy16(3, src, dst, 0x1000); - src += 0x1000; - dst += 0x1000; - size -= 0x1000; - } - PlayerBufferExecCompleted(); -} - -void sub_8030A3C(void) -{ - PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - PlayerBufferExecCompleted(); -} - -void sub_8030A6C(void) -{ - PlayerBufferExecCompleted(); -} - -void sub_8030A78(void) -{ - dp01_build_cmdbuf_x21_a_bb(1, 0, 0); - PlayerBufferExecCompleted(); -} - -void sub_8030A8C(void) -{ - dp01_build_cmdbuf_x22_a_three_bytes(1, 0, 0); - PlayerBufferExecCompleted(); -} - -void sub_8030AA0(void) -{ - dp01_build_cmdbuf_x23_aa_0(1, 0); - PlayerBufferExecCompleted(); -} - -void sub_8030AB4(void) -{ - dp01_build_cmdbuf_x24_aa_0(1, 0); - PlayerBufferExecCompleted(); -} - -void sub_8030AC8(void) -{ - gUnknown_020238C8.unk0_0 = 0; - PlayerBufferExecCompleted(); -} - -void sub_8030AE4(void) -{ - gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; - PlayerBufferExecCompleted(); -} - -void sub_8030B1C(void) -{ - gUnknown_020238C8.unk0_7 = 0; - PlayerBufferExecCompleted(); -} - -void sub_8030B34(void) -{ - gUnknown_020238C8.unk0_7 ^= 1; - PlayerBufferExecCompleted(); -} - -void PlayerHandleHitAnimation(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) - { - PlayerBufferExecCompleted(); - } - else - { - gDoingBattleAnim = 1; - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - sub_8047858(gActiveBank); - gBattleBankFunc[gActiveBank] = bx_blink_t1; - } -} - -void sub_8030BCC(void) -{ - PlayerBufferExecCompleted(); -} - -void PlayerHandleEffectivenessSound(void) -{ - s8 pan; - - if (GetBankSide(gActiveBank) == 0) - pan = -64; - else - pan = 63; - PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); - PlayerBufferExecCompleted(); -} - -void sub_8030C1C(void) -{ - PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - PlayerBufferExecCompleted(); -} - -void PlayerHandleFaintingCry(void) -{ - u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - - PlayCry3(species, -25, 5); - PlayerBufferExecCompleted(); -} - -void PlayerHandleIntroSlide(void) -{ - sub_80E43C0(gBattleBufferA[gActiveBank][1]); - gUnknown_02024DE8 |= 1; - PlayerBufferExecCompleted(); -} - -void PlayerHandleTrainerBallThrow(void) -{ - u8 paletteNum; - u8 taskId; - - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; - gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); - paletteNum = AllocSpritePalette(0xD6F8); - LoadCompressedPalette(gTrainerBackPicPaletteTable[gSaveBlock2.playerGender].data, 0x100 + paletteNum * 16, 32); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = paletteNum; - taskId = CreateTask(task05_08033660, 5); - gTasks[taskId].data[0] = gActiveBank; - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - ewram17810[4].unk9 |= 1; - gBattleBankFunc[gActiveBank] = nullsub_91; -} - -void sub_8030E38(struct Sprite *sprite) -{ - u8 r4 = sprite->data5; - - FreeSpriteOamMatrix(sprite); - FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); - DestroySprite(sprite); - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[r4]], r4); - StartSpriteAnim(&gSprites[gObjectBankIDs[r4]], 0); -} - -void task05_08033660(u8 taskId) -{ - if (gTasks[taskId].data[1] < 31) - { - gTasks[taskId].data[1]++; - } - else - { - u8 savedActiveBank = gActiveBank; - - gActiveBank = gTasks[taskId].data[0]; - if (!IsDoubleBattle() || (gBattleTypeFlags & 0x40)) - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_802F934(gActiveBank, 0); - } - else - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_802F934(gActiveBank, 0); - gActiveBank ^= 2; - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - sub_802F934(gActiveBank, 0); - gActiveBank ^= 2; - } - gBattleBankFunc[gActiveBank] = sub_802D500; - gActiveBank = savedActiveBank; - DestroyTask(taskId); - } -} - -void sub_8030FAC(void) -{ - if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) - { - PlayerBufferExecCompleted(); - } - else - { - ewram17810[gActiveBank].unk0_0 = 1; - gUnknown_02024E68[gActiveBank] = sub_8044804(gActiveBank, (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); - ewram17810[gActiveBank].unk5 = 0; - if (gBattleBufferA[gActiveBank][2] != 0) - ewram17810[gActiveBank].unk5 = 0x5D; - gBattleBankFunc[gActiveBank] = sub_8031064; - } -} - -void sub_8031064(void) -{ - if (ewram17810[gActiveBank].unk5++ > 0x5C) - { - ewram17810[gActiveBank].unk5 = 0; - PlayerBufferExecCompleted(); - } -} - -void sub_80310A4(void) -{ - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - PlayerBufferExecCompleted(); -} - -void sub_80310F0(void) -{ - dp11b_obj_free(gActiveBank, 1); - dp11b_obj_free(gActiveBank, 0); - PlayerBufferExecCompleted(); -} - -void PlayerHandleSpriteInvisibility(void) -{ - if (sub_8078874(gActiveBank)) - { - gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - sub_8031F88(gActiveBank); - } - PlayerBufferExecCompleted(); -} - -void PlayerHandleBattleAnimation(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - u8 val2 = gBattleBufferA[gActiveBank][1]; - u16 val = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, val2, val)) - PlayerBufferExecCompleted(); - else - gBattleBankFunc[gActiveBank] = sub_802E460; - } -} - -void PlayerHandleLinkStandbyMsg(void) -{ - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - b_link_standby_message(); - // fall through - case 1: - dp11b_obj_free(gActiveBank, 1); - dp11b_obj_free(gActiveBank, 0); - break; - case 2: - b_link_standby_message(); - break; - } - PlayerBufferExecCompleted(); -} - -void PlayerHandleResetActionMoveSelection(void) -{ - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - gActionSelectionCursor[gActiveBank] = 0; - gMoveSelectionCursor[gActiveBank] = 0; - break; - case 1: - gActionSelectionCursor[gActiveBank] = 0; - break; - case 2: - gMoveSelectionCursor[gActiveBank] = 0; - break; - } - PlayerBufferExecCompleted(); -} - -void sub_80312A0(void) -{ - gBattleOutcome = gBattleBufferA[gActiveBank][1]; - FadeOutMapMusic(5); - BeginFastPaletteFade(3); - PlayerBufferExecCompleted(); - gBattleBankFunc[gActiveBank] = sub_802D18C; -} - -void nullsub_43(void) -{ -} diff --git a/src/battle_7.c b/src/battle_7.c index 0c4b118b4..4ae220f6c 100644 --- a/src/battle_7.c +++ b/src/battle_7.c @@ -31,7 +31,6 @@ struct Struct2019348 extern u8 gBattleBufferA[][0x200]; extern u8 gActiveBank; -extern u32 gBattleExecBuffer; extern u8 gNoOfAllBanks; extern u16 gBattlePartyID[]; extern u8 gBanksBySide[]; @@ -63,7 +62,6 @@ extern const u8 gSubstituteDollGfx[]; extern const u8 gSubstituteDollPal[]; extern const struct CompressedSpriteSheet gUnknown_081FAF24; extern const struct SpriteTemplate gSpriteTemplate_81FAF34; -extern void (*const gOpponentBufferCommands[])(void); extern const struct CompressedSpriteSheet gUnknown_0820A47C; extern const struct CompressedSpriteSheet gUnknown_0820A484; extern const struct CompressedSpriteSheet gUnknown_0820A48C[]; @@ -96,9 +94,6 @@ void sub_80324E0(u8 a); void sub_80327CC(void); void sub_8032978(struct Sprite *); void sub_80328A4(struct Sprite *); -void OpponentBufferRunCommand(void); -void sub_80332D0(void); -void OpponentBufferExecCompleted(void); void sub_80312F0(struct Sprite *sprite) { @@ -182,9 +177,9 @@ bool8 move_anim_start_t3(u8 a, u8 b, u8 c, u8 d, u16 e) gBattleMonForms[a] = e & 0x7F; return TRUE; } - if (ewram17800[a].substituteSprite && sub_803163C(d) == 0) + if (ewram17800[a].unk0_2 && sub_803163C(d) == 0) return TRUE; - if (ewram17800[a].substituteSprite && d == 2 && gSprites[gObjectBankIDs[a]].invisible) + if (ewram17800[a].unk0_2 && d == 2 && gSprites[gObjectBankIDs[a]].invisible) { refresh_graphics_maybe(a, 1, gObjectBankIDs[a]); sub_80324E0(a); @@ -273,29 +268,29 @@ bool8 mplay_80342A4(u8 a) return TRUE; } -void BattleLoadOpponentMonSprite(struct Pokemon *pkmn, u8 bank) +void sub_8031794(struct Pokemon *pkmn, u8 b) { u32 personalityValue; u16 species; - u32 transformPersonality; + u32 r7; u32 otId; u8 var; u16 paletteOffset; const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[bank].transformedSpecies == 0) + if (ewram17800[b].unk2 == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); - transformPersonality = personalityValue; + r7 = personalityValue; } else { - species = ewram17800[bank].transformedSpecies; - transformPersonality = gPID_perBank[bank]; + species = ewram17800[b].unk2; + r7 = gPID_perBank[b]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); - var = GetBankIdentity(bank); + var = GetBankIdentity(b); HandleLoadSpecialPokePic( &gMonFrontPicTable[species], gMonFrontPicCoords[species].coords, @@ -303,29 +298,29 @@ void BattleLoadOpponentMonSprite(struct Pokemon *pkmn, u8 bank) 0x02000000, gUnknown_081FAF4C[var], species, - transformPersonality); - paletteOffset = 0x100 + bank * 16; - if (ewram17800[bank].transformedSpecies == 0) + r7); + paletteOffset = 0x100 + b * 16; + if (ewram17800[b].unk2 == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 0x20); - LoadPalette(ewram, 0x80 + bank * 16, 0x20); + LoadPalette(ewram, 0x80 + b * 16, 0x20); if (species == SPECIES_CASTFORM) { - paletteOffset = 0x100 + bank * 16; + paletteOffset = 0x100 + b * 16; sub_800D238(lzPaletteData, ewram + 0x16400); - LoadPalette(ewram + 0x16400 + gBattleMonForms[bank] * 32, paletteOffset, 0x20); + LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); } - if (ewram17800[bank].transformedSpecies != 0) + if (ewram17800[b].unk2 != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); } } -void BattleLoadPlayerMonSprite(struct Pokemon *pkmn, u8 bank) +void sub_80318FC(struct Pokemon *pkmn, u8 b) { u32 personalityValue; u16 species; @@ -336,18 +331,18 @@ void BattleLoadPlayerMonSprite(struct Pokemon *pkmn, u8 bank) const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[bank].transformedSpecies == 0) + if (ewram17800[b].unk2 == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); r7 = personalityValue; } else { - species = ewram17800[bank].transformedSpecies; - r7 = gPID_perBank[bank]; + species = ewram17800[b].unk2; + r7 = gPID_perBank[b]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); - var = GetBankIdentity(bank); + var = GetBankIdentity(b); HandleLoadSpecialPokePic( &gMonBackPicTable[species], gMonBackPicCoords[species].coords, @@ -356,21 +351,21 @@ void BattleLoadPlayerMonSprite(struct Pokemon *pkmn, u8 bank) gUnknown_081FAF4C[var], species, r7); - paletteOffset = 0x100 + bank * 16; - if (ewram17800[bank].transformedSpecies == 0) + paletteOffset = 0x100 + b * 16; + if (ewram17800[b].unk2 == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 0x20); - LoadPalette(ewram, 0x80 + bank * 16, 0x20); + LoadPalette(ewram, 0x80 + b * 16, 0x20); if (species == SPECIES_CASTFORM) { - paletteOffset = 0x100 + bank * 16; + paletteOffset = 0x100 + b * 16; sub_800D238(lzPaletteData, ewram + 0x16400); - LoadPalette(ewram + 0x16400 + gBattleMonForms[bank] * 32, paletteOffset, 0x20); + LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); } - if (ewram17800[bank].transformedSpecies != 0) + if (ewram17800[b].unk2 != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); @@ -405,11 +400,11 @@ void sub_8031A6C(u16 a, u8 b) LoadCompressedObjectPalette(&gTrainerFrontPicPaletteTable[a]); } -void LoadPlayerTrainerBankSprite(u16 a, u8 bank) +void sub_8031AF4(u16 a, u8 b) { u8 status; - status = GetBankIdentity(bank); + status = GetBankIdentity(b); DecompressPicFromTable_2( &gTrainerBackPicTable[a], gTrainerBackPicCoords[a].coords, @@ -417,7 +412,7 @@ void LoadPlayerTrainerBankSprite(u16 a, u8 bank) (void *)0x02000000, gUnknown_081FAF4C[status], 0); - LoadCompressedPalette(gTrainerBackPicPaletteTable[a].data, 0x100 + bank * 16, 32); + LoadCompressedPalette(gTrainerBackPicPaletteTable[a].data, 0x100 + b * 16, 32); } void nullsub_10(int unused) @@ -607,15 +602,15 @@ void sub_8031F24(void) s32 i; for (i = 0; i < gNoOfAllBanks; i++) - ewram17800[i].invisible = gSprites[gObjectBankIDs[i]].invisible; + ewram17800[i].unk0_0 = gSprites[gObjectBankIDs[i]].invisible; } void sub_8031F88(u8 a) { - ewram17800[a].invisible = gSprites[gObjectBankIDs[a]].invisible; + ewram17800[a].unk0_0 = gSprites[gObjectBankIDs[a]].invisible; } -void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) +void sub_8031FC4(u8 a, u8 b, bool8 c) { u16 paletteOffset; u16 species; @@ -626,16 +621,16 @@ void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) if (c) { - StartSpriteAnim(&gSprites[gObjectBankIDs[bank1]], ewram17840.unk0); - paletteOffset = 0x100 + bank1 * 16; + StartSpriteAnim(&gSprites[gObjectBankIDs[a]], ewram17840.unk0); + paletteOffset = 0x100 + a * 16; LoadPalette(ewram + 0x16400 + ewram17840.unk0 * 32, paletteOffset, 32); - gBattleMonForms[bank1] = ewram17840.unk0; - if (ewram17800[bank1].transformedSpecies != 0) + gBattleMonForms[a] = ewram17840.unk0; + if (ewram17800[a].unk2 != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); } - gSprites[gObjectBankIDs[bank1]].pos1.y = sub_8077F68(bank1); + gSprites[gObjectBankIDs[a]].pos1.y = sub_8077F68(a); } else { @@ -659,15 +654,15 @@ void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) } else { - r10 = GetBankIdentity(bank1); - if (GetBankSide(bank2) == 1) - species = GetMonData(&gEnemyParty[gBattlePartyID[bank2]], MON_DATA_SPECIES); + r10 = GetBankIdentity(a); + if (GetBankSide(b) == 1) + species = GetMonData(&gEnemyParty[gBattlePartyID[b]], MON_DATA_SPECIES); else - species = GetMonData(&gPlayerParty[gBattlePartyID[bank2]], MON_DATA_SPECIES); - if (GetBankSide(bank1) == 0) + species = GetMonData(&gPlayerParty[gBattlePartyID[b]], MON_DATA_SPECIES); + if (GetBankSide(a) == 0) { - personalityValue = GetMonData(&gPlayerParty[gBattlePartyID[bank1]], MON_DATA_PERSONALITY); - otId = GetMonData(&gPlayerParty[gBattlePartyID[bank1]], MON_DATA_OT_ID); + personalityValue = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_PERSONALITY); + otId = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_OT_ID); HandleLoadSpecialPokePic( &gMonBackPicTable[species], gMonBackPicCoords[species].coords, @@ -675,12 +670,12 @@ void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) 0x02000000, gUnknown_081FAF4C[r10], species, - gPID_perBank[bank1]); + gPID_perBank[a]); } else { - personalityValue = GetMonData(&gEnemyParty[gBattlePartyID[bank1]], MON_DATA_PERSONALITY); - otId = GetMonData(&gEnemyParty[gBattlePartyID[bank1]], MON_DATA_OT_ID); + personalityValue = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_PERSONALITY); + otId = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_OT_ID); HandleLoadSpecialPokePic( &gMonFrontPicTable[species], gMonFrontPicCoords[species].coords, @@ -688,13 +683,13 @@ void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) 0x02000000, gUnknown_081FAF4C[r10], species, - gPID_perBank[bank1]); + gPID_perBank[a]); } } src = gUnknown_081FAF4C[r10]; - dst = (void *)(VRAM + 0x10000 + gSprites[gObjectBankIDs[bank1]].oam.tileNum * 32); + dst = (void *)(VRAM + 0x10000 + gSprites[gObjectBankIDs[a]].oam.tileNum * 32); DmaCopy32(3, src, dst, 0x800); - paletteOffset = 0x100 + bank1 * 16; + paletteOffset = 0x100 + a * 16; lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); sub_800D238(lzPaletteData, ewram); LoadPalette(ewram, paletteOffset, 32); @@ -703,21 +698,21 @@ void sub_8031FC4(u8 bank1, u8 bank2, bool8 c) u16 *paletteSrc = (u16 *)(ewram + 0x16400); sub_800D238(lzPaletteData, paletteSrc); - LoadPalette(paletteSrc + gBattleMonForms[bank2] * 16, paletteOffset, 32); + LoadPalette(paletteSrc + gBattleMonForms[b] * 16, paletteOffset, 32); } BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); if (!IsContest()) { - ewram17800[bank1].transformedSpecies = species; - gBattleMonForms[bank1] = gBattleMonForms[bank2]; + ewram17800[a].unk2 = species; + gBattleMonForms[a] = gBattleMonForms[b]; } - gSprites[gObjectBankIDs[bank1]].pos1.y = sub_8077F68(bank1); - StartSpriteAnim(&gSprites[gObjectBankIDs[bank1]], gBattleMonForms[bank1]); + gSprites[gObjectBankIDs[a]].pos1.y = sub_8077F68(a); + StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); } } -void BattleLoadSubstituteSprite(u8 a, u8 b) +void sub_8032350(u8 a, u8 b) { u8 r4; u16 foo; @@ -750,16 +745,16 @@ void BattleLoadSubstituteSprite(u8 a, u8 b) if (!IsContest()) { if (GetBankSide(a) != 0) - BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); + sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); else - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[a]], a); + sub_80318FC(&gPlayerParty[gBattlePartyID[a]], a); } } } void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) { - BattleLoadSubstituteSprite(a, b); + sub_8032350(a, b); StartSpriteAnim(&gSprites[spriteId], gBattleMonForms[a]); if (b == 0) gSprites[spriteId].pos1.y = sub_8077F7C(a); @@ -770,12 +765,12 @@ void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) void sub_80324BC(u8 a, u16 b) { if (b == 0xA4) - ewram17800[a].substituteSprite = 1; + ewram17800[a].unk0_2 = 1; } void sub_80324E0(u8 a) { - ewram17800[a].substituteSprite = 0; + ewram17800[a].unk0_2 = 0; } void sub_80324F8(struct Pokemon *pkmn, u8 b) @@ -896,9 +891,9 @@ void sub_80328A4(struct Sprite *sprite) } if (gAnimScriptActive || r7->invisible) invisible = TRUE; - else if (ewram17800[r4].transformedSpecies != 0 && gEnemyMonElevation[ewram17800[r4].transformedSpecies] == 0) + else if (ewram17800[r4].unk2 != 0 && gEnemyMonElevation[ewram17800[r4].unk2] == 0) invisible = TRUE; - if (ewram17800[r4].substituteSprite) + if (ewram17800[r4].unk0_2) invisible = TRUE; sprite->pos1.x = r7->pos1.x; sprite->pos2.x = r7->pos2.x; @@ -914,8 +909,8 @@ void sub_8032984(u8 a, u16 b) { if (GetBankSide(a) != 0) { - if (ewram17800[a].transformedSpecies != 0) - b = ewram17800[a].transformedSpecies; + if (ewram17800[a].unk2 != 0) + b = ewram17800[a].unk2; if (gEnemyMonElevation[b] != 0) gSprites[ewram17810[a].unk7].callback = sub_80328A4; else @@ -953,283 +948,8 @@ void sub_8032A38(void) void sub_8032AA8(u8 a, u8 b) { - ewram17800[a].transformedSpecies = 0; + ewram17800[a].unk2 = 0; gBattleMonForms[a] = 0; if (b == 0) sub_80324E0(a); } - -void nullsub_45(void) -{ -} - -void SetBankFuncToOpponentBufferRunCommand(void) -{ - gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; -} - -void OpponentBufferRunCommand(void) -{ - if (gBattleExecBuffer & gBitTable[gActiveBank]) - { - if (gBattleBufferA[gActiveBank][0] <= 0x38) - gOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); - else - OpponentBufferExecCompleted(); - } -} - -void sub_8032B4C(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - OpponentBufferExecCompleted(); -} - -// Duplicate of sub_8032B4C -void sub_8032B84(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - OpponentBufferExecCompleted(); -} - -void sub_8032BBC(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - { - sub_8031B74(gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam); - gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = gSprites[gObjectBankIDs[gActiveBank]].data5; - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - OpponentBufferExecCompleted(); - } -} - -void sub_8032C4C(void) -{ - if ((--ewram17810[gActiveBank].unk9) == 0xFF) - { - ewram17810[gActiveBank].unk9 = 0; - OpponentBufferExecCompleted(); - } -} - -void sub_8032C88(void) -{ - bool8 r6 = FALSE; - - if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - else - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy - && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - if (IsCryPlayingOrClearCrySongs()) - r6 = FALSE; - - if (r6 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - ewram17810[gActiveBank ^ 2].unk0_7 = 0; - ewram17810[gActiveBank ^ 2].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - m4aMPlayContinue(&gMPlay_BGM); - else - m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256); - ewram17810[gActiveBank].unk9 = 3; - gBattleBankFunc[gActiveBank] = sub_8032C4C; - } -} - -void sub_8032E2C(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); - if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) - sub_8141828(gActiveBank ^ 2, &gEnemyParty[gBattlePartyID[gActiveBank ^ 2]]); - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) - { - if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); - sub_8045A5C( - gHealthboxIDs[gActiveBank ^ 2], - &gEnemyParty[gBattlePartyID[gActiveBank ^ 2]], - 0); - sub_804777C(gActiveBank ^ 2); - sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); - sub_8032984( - gActiveBank ^ 2, - GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank ^ 2]], MON_DATA_SPECIES)); - } - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8045A5C( - gHealthboxIDs[gActiveBank], - &gEnemyParty[gBattlePartyID[gActiveBank]], - 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - sub_8032984( - gActiveBank, - GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); - - ewram17840.unk9_0 = 0; - gBattleBankFunc[gActiveBank] = sub_8032C88; - } -} - -void sub_8033018(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].animEnded == TRUE - && gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) - { - if (!ewram17810[gActiveBank].unk0_7) - { - sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); - return; - } - if (ewram17810[gActiveBank].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - OpponentBufferExecCompleted(); - return; - } - } -} - -void sub_80330C8(void) -{ - s16 r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); - - sub_8043DFC(gHealthboxIDs[gActiveBank]); - if (r4 != -1) - sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); - else - OpponentBufferExecCompleted(); -} - -void sub_803311C(void) -{ - if (!gSprites[gObjectBankIDs[gActiveBank]].inUse) - { - sub_8043DB0(gHealthboxIDs[gActiveBank]); - OpponentBufferExecCompleted(); - } -} - -void sub_8033160(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8032A08(gActiveBank); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - OpponentBufferExecCompleted(); - } -} - -void sub_80331D0(void) -{ - if (gUnknown_03004210.state == 0) - OpponentBufferExecCompleted(); -} - -void bx_blink_t7(void) -{ - u8 spriteId = gObjectBankIDs[gActiveBank]; - - if (gSprites[spriteId].data1 == 32) - { - gSprites[spriteId].data1 = 0; - gSprites[spriteId].invisible = FALSE; - gDoingBattleAnim = 0; - OpponentBufferExecCompleted(); - } - else - { - if (((u16)gSprites[spriteId].data1 % 4) == 0) - gSprites[spriteId].invisible ^= 1; - gSprites[spriteId].data1++; - } -} - -void sub_8033264(void) -{ - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - gBattleBankFunc[gActiveBank] = sub_80332D0; - } -} - -void sub_80332D0(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - { - CreateTask(c3_0802FDF4, 10); - OpponentBufferExecCompleted(); - } -} - -void sub_8033308(void) -{ - if (ewram17810[gActiveBank].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 0); - sub_8045A5C( - gHealthboxIDs[gActiveBank], - &gEnemyParty[gBattlePartyID[gActiveBank]], - 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - sub_8031F88(gActiveBank); - gBattleBankFunc[gActiveBank] = sub_8033264; - } -} - -void sub_80333D4(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); - if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy - && !ewram17810[gActiveBank].unk0_3) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); - gBattleBankFunc[gActiveBank] = sub_8033308; - } -} - -void sub_8033494(void) -{ - if (!ewram17810[gActiveBank].unk0_4) - OpponentBufferExecCompleted(); -} - -void sub_80334C0(void) -{ - if (!ewram17810[gActiveBank].unk0_5) - OpponentBufferExecCompleted(); -} - -void OpponentBufferExecCompleted(void) -{ - gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; - gBattleExecBuffer &= ~gBitTable[gActiveBank]; -} diff --git a/src/battle_anim_81258BC.c b/src/battle_anim_81258BC.c deleted file mode 100644 index 5bdbb4946..000000000 --- a/src/battle_anim_81258BC.c +++ /dev/null @@ -1,50 +0,0 @@ -#include "global.h" -#include "battle_anim_81258BC.h" -#include "battle.h" -#include "battle_message.h" -#include "menu_cursor.h" -#include "text.h" - -extern struct Window gUnknown_03004210; -extern u8 gDisplayedStringBattle[]; -extern u8 gActionSelectionCursor[]; - -extern const u8 gUnknown_08400CBB[]; -extern u8 gActiveBank; -extern const u8 gUnknown_08400D15[]; - -extern void *gBattleBankFunc[]; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; - -#if ENGLISH -#define SUB_812BB10_TILE_DATA_OFFSET 440 -#elif GERMAN -#define SUB_812BB10_TILE_DATA_OFFSET 444 -#endif - -void sub_812BB10(void) { - int i; - - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 160; - gUnknown_03004210.paletteNum = 0; - FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 15, 27, 18); - FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 35, 16, 36); - gBattleBankFunc[gActiveBank] = bx_battle_menu_t6_2; - - InitWindow(&gUnknown_03004210, gUnknown_08400D15, 400, 18, 35); - sub_8002F44(&gUnknown_03004210); - sub_814A5C0(0, 0xFFFF, 12, 11679, 0); - - for (i = 0; i < 4; i++) - { - nullsub_8(i); - } - - sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); - StrCpyDecodeToDisplayedStringBattle((u8 *) gUnknown_08400CBB); - - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, SUB_812BB10_TILE_DATA_OFFSET, 2, 35); - sub_8002F44(&gUnknown_03004210); -} \ No newline at end of file diff --git a/src/battle_anim_8137220.c b/src/battle_anim_8137220.c deleted file mode 100644 index af2b86c17..000000000 --- a/src/battle_anim_8137220.c +++ /dev/null @@ -1,1486 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_interface.h" -#include "battle_message.h" -#include "data2.h" -#include "link.h" -#include "main.h" -#include "menu_cursor.h" -#include "palette.h" -#include "pokemon.h" -#include "rom3.h" -#include "songs.h" -#include "sound.h" -#include "sprite.h" -#include "item_use.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -//Possibly PokemonSubstruct1 -struct UnknownStruct3 -{ - u16 moves[4]; - u8 pp[4]; - u8 ppBonuses; -}; - -extern u8 gActiveBank; -extern void (*gBattleBankFunc[])(void); -extern u32 gBattleExecBuffer; -extern void (*gWallyBufferCommands[])(void); -extern u8 gBattleBufferA[][0x200]; -extern u8 gObjectBankIDs[]; -extern MainCallback gPreBattleCallback1; -extern bool8 gDoingBattleAnim; -extern u16 gBattlePartyID[]; -extern u8 gHealthboxIDs[]; -extern u16 gBattleTypeFlags; -extern u16 gMovePowerMoveAnim; -extern u32 gMoveDmgMoveAnim; -extern u8 gHappinessMoveAnim; -extern u16 gWeatherMoveAnim; -extern u32 *gDisableStructMoveAnim; -extern u32 gPID_perBank[]; -extern void (*gAnimScriptCallback)(void); -extern bool8 gAnimScriptActive; -extern u8 gDisplayedStringBattle[]; -extern u8 gBankInMenu; -extern u8 gBattleMonForms[]; -extern u8 gBattleOutcome; -extern u16 gUnknown_02024DE8; -extern u8 gUnknown_02024E68[]; -extern struct SpriteTemplate gUnknown_02024E8C; -extern u8 gUnknown_0202F7C4; -extern struct Window gUnknown_03004210; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; -extern u8 gUnknown_0300434C[]; -extern const u8 gUnknown_08400CCC[]; -extern const u8 gUnknown_08400CF3[]; - -// TODO: include rom3.h when my other PR gets merged -extern void dp01_build_cmdbuf_x21_a_bb(u8, u8, u16); -extern void dp01_build_cmdbuf_x23_aa_0(u8, u16); - -extern void nullsub_14(void); -extern void PrepareBagForWallyTutorial(void); -extern void sub_8141828(); -extern void sub_8045A5C(); -extern void sub_804777C(); -extern void sub_8043DFC(); -extern bool8 IsDoubleBattle(void); -extern void c3_0802FDF4(u8); -extern void sub_802ECF0(void); -extern void LoadPlayerTrainerBankSprite(); -extern u8 GetBankIdentity(u8); -extern void sub_80313A0(struct Sprite *); -extern u8 GetBankByPlayerAI(u8); -extern u8 sub_8031720(); -extern void ExecuteMoveAnim(); -extern void sub_80326EC(); -extern void sub_8031F24(void); -extern void sub_80324BC(); -extern void BufferStringBattle(); -extern u8 GetBankSide(u8); -extern void sub_80304A8(void); -extern void sub_8047858(); -extern void sub_80E43C0(); -extern void oamt_add_pos2_onto_pos1(); -extern void sub_8078B34(struct Sprite *); -extern void sub_8030E38(struct Sprite *); -extern void oamt_set_x3A_32(); -extern u8 sub_8046400(); -extern u8 sub_8077ABC(); -extern u8 sub_8077F68(); -extern u8 sub_8079E90(); -extern void sub_80312F0(struct Sprite *); -extern bool8 move_anim_start_t3(); - -void WallyBufferRunCommand(void); -void sub_81374FC(void); -void sub_81376B8(void); -void WallyBufferExecCompleted(void); -u32 sub_8137A84(u8, u8 *); -void sub_8138294(u8); -void sub_81390D0(void); -void sub_8139A2C(u8); - -void unref_sub_8137220(void) -{ -} - -void SetBankFuncToWallyBufferRunCommand(void) -{ - gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; - ewram[0x160A8] = 0; - ewram[0x160A9] = 0; - ewram[0x160AA] = 0; - ewram[0x160AB] = 0; -} - -void WallyBufferRunCommand(void) -{ - if (gBattleExecBuffer & gBitTable[gActiveBank]) - { - if (gBattleBufferA[gActiveBank][0] < 0x39) - gWallyBufferCommands[gBattleBufferA[gActiveBank][0]](); - else - WallyBufferExecCompleted(); - } -} - -void sub_81372BC(void) -{ - u8 r4; - - switch (ewram[0x160A8]) - { - case 0: - ewram[0x160AA] = 64; - ewram[0x160A8]++; - // fall through - case 1: - r4 = --ewram[0x160AA]; - if (r4 == 0) - { - PlaySE(SE_SELECT); - dp01_build_cmdbuf_x21_a_bb(1, 0, 0); - WallyBufferExecCompleted(); - ewram[0x160A8]++; - ewram[0x160A9] = r4; - ewram[0x160AA] = 64; - } - break; - case 2: - r4 = --ewram[0x160AA]; - if (r4 == 0) - { - PlaySE(SE_SELECT); - dp01_build_cmdbuf_x21_a_bb(1, 0, 0); - WallyBufferExecCompleted(); - ewram[0x160A8]++; - ewram[0x160A9] = r4; - ewram[0x160AA] = 64; - } - break; - case 3: - r4 = --ewram[0x160AA]; - if (r4 == 0) - { - dp01_build_cmdbuf_x21_a_bb(1, 9, 0); - WallyBufferExecCompleted(); - ewram[0x160A8]++; - ewram[0x160A9] = r4; - ewram[0x160AA] = 64; - } - break; - case 4: - if (--ewram[0x160AA] == 0) - { - PlaySE(SE_SELECT); - nullsub_8(0); - sub_802E3E4(1, 0); - ewram[0x160AA] = 64; - ewram[0x160A8]++; - } - break; - case 5: - if (--ewram[0x160AA] == 0) - { - PlaySE(SE_SELECT); - DestroyMenuCursor(); - dp01_build_cmdbuf_x21_a_bb(1, 1, 0); - WallyBufferExecCompleted(); - } - break; - } -} - -void sub_813741C(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - WallyBufferExecCompleted(); -} - -void sub_8137454(void) -{ - if (gUnknown_03004210.state == 0) - WallyBufferExecCompleted(); -} - -void sub_813746C(void) -{ - if (!gPaletteFade.active) - { - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(gMain.savedCallback); - } -} - -void bx_wait_t5(void) -{ - if (!gDoingBattleAnim) - WallyBufferExecCompleted(); -} - -void sub_81374C4(void) -{ - if (!gPaletteFade.active) - { - gBattleBankFunc[gActiveBank] = sub_81374FC; - nullsub_14(); - PrepareBagForWallyTutorial(); - } -} - -void sub_81374FC(void) -{ - if (gMain.callback2 == sub_800F808 - && !gPaletteFade.active) - { - dp01_build_cmdbuf_x23_aa_0(1, gScriptItemId); - WallyBufferExecCompleted(); - } -} - -void sub_8137538(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); - - if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) - sub_8141828(gActiveBank ^ 2, &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]]); - - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) - { - if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); - sub_8045A5C(gHealthboxIDs[gActiveBank ^ 2], &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], 0); - sub_804777C(gActiveBank ^ 2); - sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); - } - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - ewram17840.unk9_0 = 0; - gBattleBankFunc[gActiveBank] = sub_81376B8; - } -} - -void sub_81376B8(void) -{ - bool8 r4 = FALSE; - - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - r4 = TRUE; - if (r4 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - ewram17810[gActiveBank ^ 2].unk0_7 = 0; - ewram17810[gActiveBank ^ 2].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - CreateTask(c3_0802FDF4, 10); - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - WallyBufferExecCompleted(); - } -} - -void sub_81377B0(void) -{ - s16 r4; - - r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - if (r4 != -1) - { - sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); - } - else - { - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - WallyBufferExecCompleted(); - } -} - -void bx_blink_t5(void) -{ - u8 spriteId = gObjectBankIDs[gActiveBank]; - - if (gSprites[spriteId].data1 == 32) - { - gSprites[spriteId].data1 = 0; - gSprites[spriteId].invisible = FALSE; - gDoingBattleAnim = FALSE; - WallyBufferExecCompleted(); - } - else - { - if (((u16)gSprites[spriteId].data1 % 4) == 0) - gSprites[spriteId].invisible ^= 1; - gSprites[spriteId].data1++; - } -} - -void sub_813789C(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - WallyBufferExecCompleted(); - } -} - -// Duplicate of sub_813741C -void sub_8137908(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - WallyBufferExecCompleted(); -} - -void sub_8137940(void) -{ - if (!ewram17810[gActiveBank].unk0_5) - WallyBufferExecCompleted(); -} - -void WallyBufferExecCompleted(void) -{ - gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; - if (gBattleTypeFlags & BATTLE_TYPE_LINK) - { - u8 multiplayerId = GetMultiplayerId(); - - dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); - gBattleBufferA[gActiveBank][0] = 0x38; - } - else - { - gBattleExecBuffer &= ~gBitTable[gActiveBank]; - } -} - -void unref_sub_81379E4(void) -{ - if (!ewram17810[gActiveBank].unk0_4) - WallyBufferExecCompleted(); -} - -void dp01t_00_5_getattr(void) -{ - u8 arr[0x100]; - u32 r6 = 0; - u8 r4; - s32 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - r6 = sub_8137A84(gBattlePartyID[gActiveBank], arr); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - r6 += sub_8137A84(i, arr + r6); - r4 >>= 1; - } - } - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, r6, arr); - WallyBufferExecCompleted(); -} - -u32 sub_8137A84(u8 a, u8 *buffer) -{ - struct BattlePokemon battlePokemon; - struct UnknownStruct3 moveData; - u8 nickname[20]; - u8 *src; - s16 data16; - u32 data32; - s32 size = 0; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - for (size = 0; size < 4; size++) - { - battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); - battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); - battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); - battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); - StringCopy10(battlePokemon.nickname, nickname); - GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); - src = (u8 *)&battlePokemon; - for (size = 0; size < sizeof(battlePokemon); size++) - buffer[size] = src[size]; - break; - case 1: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 2: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 3: - for (size = 0; size < 4; size++) - { - moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - src = (u8 *)&moveData; - for (size = 0; size < sizeof(moveData); size++) - buffer[size] = src[size]; - break; - case 4: - case 5: - case 6: - case 7: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 8: - for (size = 0; size < 4; size++) - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - size++; - break; - case 9: - case 10: - case 11: - case 12: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); - size = 1; - break; - case 17: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 18: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 19: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); - size = 1; - break; - case 20: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); - size = 1; - break; - case 21: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); - size = 1; - break; - case 22: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); - size = 1; - break; - case 23: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); - size = 1; - break; - case 24: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); - size = 1; - break; - case 25: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - size = 1; - break; - case 26: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); - size = 1; - break; - case 27: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); - size = 1; - break; - case 28: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); - size = 1; - break; - case 29: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); - size = 1; - break; - case 30: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); - size = 1; - break; - case 31: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 6; - break; - case 32: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - size = 1; - break; - case 33: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - size = 1; - break; - case 34: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - size = 1; - break; - case 35: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - size = 1; - break; - case 36: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - size = 1; - break; - case 37: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 1; - break; - case 38: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 39: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 40: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 41: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - size = 1; - break; - case 42: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 43: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 44: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 45: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 46: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 47: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 48: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 49: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); - size = 1; - break; - case 50: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); - size = 1; - break; - case 51: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); - size = 1; - break; - case 52: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); - size = 1; - break; - case 53: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); - size = 1; - break; - case 54: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); - size = 1; - break; - case 55: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); - size = 1; - break; - case 56: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); - size = 1; - break; - case 57: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); - size = 1; - break; - case 58: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); - size = 1; - break; - case 59: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); - size = 1; - break; - } - return size; -} - -void sub_8138230(void) -{ - sub_802ECF0(); -} - -void sub_813823C(void) -{ - u8 r4; - u8 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - sub_8138294(gBattlePartyID[gActiveBank]); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - sub_8138294(i); - r4 >>= 1; - } - } - WallyBufferExecCompleted(); -} - -void sub_8138294(u8 a) -{ - struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; - struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; - s32 i; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - { - u8 iv; - - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); - SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); - iv = battlePokemon->hpIV; - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); - iv = battlePokemon->attackIV; - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); - iv = battlePokemon->defenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); - iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); - iv = battlePokemon->spAttackIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); - iv = battlePokemon->spDefenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); - SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); - SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); - SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); - SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); - } - break; - case 1: - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); - break; - case 2: - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); - break; - case 3: - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); - break; - case 4: - case 5: - case 6: - case 7: - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); - break; - case 8: - SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); - break; - case 9: - case 10: - case 11: - case 12: - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); - break; - case 17: - SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); - break; - case 18: - SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); - break; - case 19: - SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 20: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 21: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 22: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 23: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 24: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 25: - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); - break; - case 26: - SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); - break; - case 27: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); - break; - case 28: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 29: - SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); - break; - case 30: - SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); - break; - case 31: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); - break; - case 32: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 33: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 34: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 35: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 36: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 37: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 38: - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); - break; - case 39: - SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); - break; - case 40: - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); - break; - case 41: - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 42: - SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 43: - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 44: - SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); - break; - case 45: - SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); - break; - case 46: - SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); - break; - case 47: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); - break; - case 48: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); - break; - case 49: - SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); - break; - case 50: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); - break; - case 51: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); - break; - case 52: - SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); - break; - case 53: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); - break; - case 54: - SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); - break; - case 55: - SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 56: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 57: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 58: - SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 59: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - } - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); -} - -void sub_8138C90(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138C9C(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138CA8(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138CB4(void) -{ - if (gBattleBufferA[gActiveBank][1] == 0) - { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); - gBattleBankFunc[gActiveBank] = sub_813789C; - } - else - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - WallyBufferExecCompleted(); - } -} - -void sub_8138D38(void) -{ - LoadPlayerTrainerBankSprite(2, gActiveBank); - GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords), - 30); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_813741C; -} - -void sub_8138E04(void) -{ - LoadPlayerTrainerBankSprite(2, gActiveBank); - GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords), - 30); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -96; - gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_8137908; -} - -void sub_8138ED0(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138EDC(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138EE8(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138EF4(void) -{ - ewram17840.unk8 = 4; - gDoingBattleAnim = TRUE; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 4); - gBattleBankFunc[gActiveBank] = bx_wait_t5; -} - -void sub_8138F44(void) -{ - u8 val = gBattleBufferA[gActiveBank][1]; - - ewram17840.unk8 = val; - gDoingBattleAnim = TRUE; - move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 4); - gBattleBankFunc[gActiveBank] = bx_wait_t5; -} - -void sub_8138FA0(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8138FAC(void) -{ - u16 r0 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); - - gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; - gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); - gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); - gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; - gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); - gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; - gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; - if (sub_8031720(r0, gUnknown_0202F7C4) != 0) - { - // Dead code. sub_8031720 always returns 0. - WallyBufferExecCompleted(); - } - else - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_81390D0; - } -} - -void sub_81390D0(void) -{ - u16 r4 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); - -#ifndef NONMATCHING - asm("":::"r6"); -#endif - - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite == 1) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (ewram17810[gActiveBank].unk0_6 == 0) - { - sub_80326EC(0); - ExecuteMoveAnim(r4); - ewram17810[gActiveBank].unk4 = 2; - } - break; - case 2: - gAnimScriptCallback(); - if (!gAnimScriptActive) - { - sub_80326EC(1); - if (ewram17800[gActiveBank].substituteSprite == 1) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - ewram17810[gActiveBank].unk4 = 3; - } - break; - case 3: - if (ewram17810[gActiveBank].unk0_6 == 0) - { - sub_8031F24(); - sub_80324BC(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - ewram17810[gActiveBank].unk4 = 0; - WallyBufferExecCompleted(); - } - break; - } -} - -void sub_8139208(void) -{ - u16 *ptr; - - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - ptr = (u16 *)&gBattleBufferA[gActiveBank][2]; - if (*ptr == 2) - DestroyMenuCursor(); - BufferStringBattle(*ptr); - sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 0x90, 2, 15); - gBattleBankFunc[gActiveBank] = sub_8137454; -} - -void dp01t_11_5_message_for_player_only(void) -{ - if (GetBankSide(gActiveBank) == 0) - sub_8139208(); - else - WallyBufferExecCompleted(); -} - -void sub_8139298(void) -{ - s32 i; - - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 160; - gUnknown_03004210.paletteNum = 0; - FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 15, 27, 18); - FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 35, 16, 36); - gBattleBankFunc[gActiveBank] = sub_81372BC; - InitWindow(&gUnknown_03004210, gUnknown_08400CF3, 400, 18, 35); - sub_8002F44(&gUnknown_03004210); - sub_814A5C0(0, 0xFFFF, 12, 0x2D9F, 0); - for (i = 0; i < 4; i++) - nullsub_8(i); - sub_802E3E4(0, 0); - StrCpyDecodeToDisplayedStringBattle(gUnknown_08400CCC); -#ifdef ENGLISH - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 440, 2, 35); -#else - InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 444, 2, 35); -#endif - sub_8002F44(&gUnknown_03004210); -} - -void sub_8139378(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139384(void) -{ - switch (ewram[0x160A9]) - { - case 0: - sub_80304A8(); - ewram[0x160A9]++; - ewram[0x160AB] = 80; - // fall through - case 1: - ewram[0x160AB]--; - if (ewram[0x160AB] == 0) - { - DestroyMenuCursor(); - PlaySE(SE_SELECT); - dp01_build_cmdbuf_x21_a_bb(1, 10, 256); - WallyBufferExecCompleted(); - } - break; - } -} - -void sub_81393EC(void) -{ - BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); - gBattleBankFunc[gActiveBank] = sub_81374C4; - gBankInMenu = gActiveBank; -} - -void sub_813942C(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139438(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139444(void) -{ - s16 r7; - - load_gfxc_health_bar(0); - r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - if (r7 != 0x7FFF) - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, curHP, r7); - } - else - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); - sub_80440EC(gHealthboxIDs[gActiveBank], 0, 0); - } - gBattleBankFunc[gActiveBank] = sub_81377B0; -} - -void sub_8139544(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139550(void) -{ - WallyBufferExecCompleted(); -} - -void sub_813955C(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139568(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139574(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139580(void) -{ - WallyBufferExecCompleted(); -} - -void sub_813958C(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139598(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395A4(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395B0(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395BC(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395C8(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395D4(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395E0(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395EC(void) -{ - WallyBufferExecCompleted(); -} - -void sub_81395F8(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139604(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) - { - WallyBufferExecCompleted(); - } - else - { - gDoingBattleAnim = 1; - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - sub_8047858(gActiveBank); - gBattleBankFunc[gActiveBank] = bx_blink_t5; - } -} - -void sub_8139674(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139680(void) -{ - PlaySE(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - WallyBufferExecCompleted(); -} - -void sub_81396B0(void) -{ - PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - WallyBufferExecCompleted(); -} - -void sub_81396E0(void) -{ - PlayCry1(GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), 25); - WallyBufferExecCompleted(); -} - -void dp01t_2E_5_battle_intro(void) -{ - sub_80E43C0(gBattleBufferA[gActiveBank][1]); - gUnknown_02024DE8 |= 1; - WallyBufferExecCompleted(); -} - -void sub_8139750(void) -{ - u8 paletteNum; - u8 taskId; - - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; - gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); - paletteNum = AllocSpritePalette(0xD6F8); - LoadCompressedPalette(gTrainerBackPicPaletteTable[2].data, 0x100 + paletteNum * 16, 32); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = paletteNum; - taskId = CreateTask(sub_8139A2C, 5); - gTasks[taskId].data[0] = gActiveBank; - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - ewram17810[4].unk9 |= 1; - gBattleBankFunc[gActiveBank] = nullsub_91; -} - -void sub_81398BC(u8 bank) -{ - u16 species; - - ewram17800[bank].transformedSpecies = 0; - gBattlePartyID[bank] = gBattleBufferA[bank][1]; - species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); - gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); - gObjectBankIDs[bank] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(bank, 2), - sub_8077F68(bank), - sub_8079E90(bank)); - gSprites[gUnknown_0300434C[bank]].data1 = gObjectBankIDs[bank]; - gSprites[gObjectBankIDs[bank]].data0 = bank; - gSprites[gObjectBankIDs[bank]].data2 = species; - gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; - StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); - gSprites[gObjectBankIDs[bank]].invisible = TRUE; - gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; - gSprites[gUnknown_0300434C[bank]].data0 = sub_8046400(0, 0xFF); -} - -void sub_8139A2C(u8 taskId) -{ - if (gTasks[taskId].data[1] < 31) - { - gTasks[taskId].data[1]++; - } - else - { - u8 savedActiveBank = gActiveBank; - - gActiveBank = gTasks[taskId].data[0]; - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_81398BC(gActiveBank); - gBattleBankFunc[gActiveBank] = sub_8137538; - gActiveBank = savedActiveBank; - DestroyTask(taskId); - } -} - -void sub_8139AA0(void) -{ - if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) - { - WallyBufferExecCompleted(); - } - else - { - ewram17810[gActiveBank].unk0_0 = 1; - gUnknown_02024E68[gActiveBank] = sub_8044804(gActiveBank, (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); - WallyBufferExecCompleted(); - } -} - -void sub_8139B20(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139B2C(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139B38(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139B44(void) -{ - u8 val2 = gBattleBufferA[gActiveBank][1]; - u16 val = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, val2, val)) - WallyBufferExecCompleted(); - else - gBattleBankFunc[gActiveBank] = sub_8137940; -} - -void sub_8139BA0(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139BAC(void) -{ - WallyBufferExecCompleted(); -} - -void sub_8139BB8(void) -{ - gBattleOutcome = gBattleBufferA[gActiveBank][1]; - FadeOutMapMusic(5); - BeginFastPaletteFade(3); - WallyBufferExecCompleted(); - if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) - gBattleBankFunc[gActiveBank] = sub_813746C; -} - -void nullsub_80(void) -{ -} diff --git a/src/battle_controller_linkopponent2.c b/src/battle_controller_linkopponent2.c new file mode 100644 index 000000000..57932131b --- /dev/null +++ b/src/battle_controller_linkopponent2.c @@ -0,0 +1,1449 @@ +#include "global.h" +#include "battle.h" +#include "battle_interface.h" +#include "data2.h" +#include "link.h" +#include "palette.h" +#include "rom_8077ABC.h" +#include "rom3.h" +#include "songs.h" +#include "sound.h" +#include "sprite.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "util.h" + +struct UnknownStruct3 +{ + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; +}; + +extern u8 gActiveBank; +extern u8 gBattleBufferA[][0x200]; +extern u8 gObjectBankIDs[]; +extern u16 gBattlePartyID[]; +extern u8 gHealthboxIDs[]; +extern u16 gBattleTypeFlags; +extern u8 gBattleMonForms[]; +extern void (*gBattleBankFunc[])(void); +extern u32 *gDisableStructMoveAnim; +extern u32 gMoveDmgMoveAnim; +extern u16 gMovePowerMoveAnim; +extern u8 gHappinessMoveAnim; +extern u16 gWeatherMoveAnim; +extern u32 gPID_perBank[]; +extern u8 gAnimScriptActive; +extern void (*gAnimScriptCallback)(void); +extern u8 gDisplayedStringBattle[]; +extern bool8 gDoingBattleAnim; +extern u8 gBattleOutcome; +extern u16 gUnknown_02024DE8; +extern u8 gUnknown_02024E68[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern u8 gUnknown_0202F7C4; +extern struct Window gUnknown_03004210; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern u8 gUnknown_0300434C[]; + +extern u8 sub_8077F68(); +extern u8 sub_8079E90(); +extern u8 GetBankIdentity(u8); +extern void sub_8031794(struct Pokemon *, u8); +extern void sub_8037A74(void); +extern void sub_8032984(u8, u16); +extern void sub_8037E30(void); +extern void sub_80312F0(struct Sprite *); +extern u8 sub_8046400(); +extern void sub_8032A08(); +extern void sub_8043DB0(); +extern void sub_8037BBC(void); +extern s32 sub_803FC34(u16); +extern void sub_8031A6C(u16, u8); +extern void sub_80313A0(struct Sprite *); +extern void sub_803757C(void); +extern void oamt_add_pos2_onto_pos1(); +extern void oamt_set_x3A_32(); +extern void sub_8078B34(struct Sprite *); +extern void sub_80375B4(void); +extern void sub_8010384(struct Sprite *); +extern void sub_8037B78(void); +extern u8 sub_8031720(); +extern bool8 mplay_80342A4(u8); +extern void ExecuteMoveAnim(); +extern void sub_80326EC(); +extern void sub_8031F24(void); +extern void sub_80324BC(); +extern void BufferStringBattle(); +extern void sub_8037C2C(void); +extern void sub_8043D84(); +extern void sub_8037B24(void); +extern void sub_8045A5C(); +extern void sub_8037FAC(void); +extern void move_anim_start_t2_for_situation(); +extern void dp01t_0F_4_move_anim(void); +extern void sub_8047858(); +extern u8 GetBankSide(u8); +extern void sub_80E43C0(); +extern void sub_803A3A8(struct Sprite *); +extern void sub_8044CA0(u8); +extern void nullsub_47(void); +extern bool8 IsDoubleBattle(void); +extern void sub_8037840(void); +extern void sub_8031B74(); +extern u8 sub_8078874(); +extern u8 move_anim_start_t3(); +extern void sub_8037FD8(void); +extern void sub_8037F34(void); +extern void LinkOpponentBufferExecCompleted(void); + +// this file's functions + +u32 dp01_getattr_by_ch1_for_player_pokemon__(u8, u8 *); +void sub_8038900(u8); +void sub_8039430(u8, u8); +void sub_8039648(void); +void sub_8039B64(void); +void sub_803A2C4(u8); +void sub_803A4E0(void); + +void LinkOpponentHandleGetAttributes(void); +void LinkOpponentHandlecmd1(void); +void LinkOpponentHandleSetAttributes(void); +void LinkOpponentHandlecmd3(void); +void LinkOpponentHandleLoadPokeSprite(void); +void LinkOpponentHandleSendOutPoke(void); +void LinkOpponentHandleReturnPokeToBall(void); +void LinkOpponentHandleTrainerThrow(void); +void LinkOpponentHandleTrainerSlide(void); +void LinkOpponentHandleTrainerSlideBack(void); +void LinkOpponentHandlecmd10(void); +void LinkOpponentHandlecmd11(void); +void LinkOpponentHandlecmd12(void); +void LinkOpponentHandleBallThrow(void); +void LinkOpponentHandlePuase(void); +void LinkOpponentHandleMoveAnimation(void); +void LinkOpponentHandlePrintString(void); +void LinkOpponentHandlePrintStringPlayerOnly(void); +void LinkOpponentHandlecmd18(void); +void LinkOpponentHandlecmd19(void); +void LinkOpponentHandlecmd20(void); +void LinkOpponentHandleOpenBag(void); +void LinkOpponentHandlecmd22(void); +void LinkOpponentHandlecmd23(void); +void LinkOpponentHandleHealthBarUpdate(void); +void LinkOpponentHandleExpBarUpdate(void); +void LinkOpponentHandleStatusIconUpdate(void); +void LinkOpponentHandleStatusAnimation(void); +void LinkOpponentHandleStatusXor(void); +void LinkOpponentHandlecmd29(void); +void LinkOpponentHandleDMATransfer(void); +void LinkOpponentHandlecmd31(void); +void LinkOpponentHandlecmd32(void); +void LinkOpponentHandlecmd33(void); +void LinkOpponentHandlecmd34(void); +void LinkOpponentHandlecmd35(void); +void LinkOpponentHandlecmd36(void); +void LinkOpponentHandlecmd37(void); +void LinkOpponentHandlecmd38(void); +void LinkOpponentHandlecmd39(void); +void LinkOpponentHandlecmd40(void); +void LinkOpponentHandleHitAnimation(void); +void LinkOpponentHandlecmd42(void); +void LinkOpponentHandleEffectivenessSound(void); +void LinkOpponentHandlecmd44(void); +void LinkOpponentHandleFaintingCry(void); +void LinkOpponentHandleIntroSlide(void); +void LinkOpponentHandleTrainerBallThrow(void); +void LinkOpponentHandlecmd48(void); +void LinkOpponentHandlecmd49(void); +void LinkOpponentHandlecmd50(void); +void LinkOpponentHandleSpriteInvisibility(void); +void LinkOpponentHandleBattleAnimation(void); +void LinkOpponentHandleLinkStandbyMsg(void); +void LinkOpponentHandleResetActionMoveSelection(void); +void LinkOpponentHandlecmd55(void); +void LinkOpponentHandlecmd56(void); + +// const data + +typedef void (*BattleBufferCmd) (void); +const BattleBufferCmd gLinkOpponentBufferCommands[] = +{ + LinkOpponentHandleGetAttributes, + LinkOpponentHandlecmd1, + LinkOpponentHandleSetAttributes, + LinkOpponentHandlecmd3, + LinkOpponentHandleLoadPokeSprite, + LinkOpponentHandleSendOutPoke, + LinkOpponentHandleReturnPokeToBall, + LinkOpponentHandleTrainerThrow, + LinkOpponentHandleTrainerSlide, + LinkOpponentHandleTrainerSlideBack, + LinkOpponentHandlecmd10, + LinkOpponentHandlecmd11, + LinkOpponentHandlecmd12, + LinkOpponentHandleBallThrow, + LinkOpponentHandlePuase, + LinkOpponentHandleMoveAnimation, + LinkOpponentHandlePrintString, + LinkOpponentHandlePrintStringPlayerOnly, + LinkOpponentHandlecmd18, + LinkOpponentHandlecmd19, + LinkOpponentHandlecmd20, + LinkOpponentHandleOpenBag, + LinkOpponentHandlecmd22, + LinkOpponentHandlecmd23, + LinkOpponentHandleHealthBarUpdate, + LinkOpponentHandleExpBarUpdate, + LinkOpponentHandleStatusIconUpdate, + LinkOpponentHandleStatusAnimation, + LinkOpponentHandleStatusXor, + LinkOpponentHandlecmd29, + LinkOpponentHandleDMATransfer, + LinkOpponentHandlecmd31, + LinkOpponentHandlecmd32, + LinkOpponentHandlecmd33, + LinkOpponentHandlecmd34, + LinkOpponentHandlecmd35, + LinkOpponentHandlecmd36, + LinkOpponentHandlecmd37, + LinkOpponentHandlecmd38, + LinkOpponentHandlecmd39, + LinkOpponentHandlecmd40, + LinkOpponentHandleHitAnimation, + LinkOpponentHandlecmd42, + LinkOpponentHandleEffectivenessSound, + LinkOpponentHandlecmd44, + LinkOpponentHandleFaintingCry, + LinkOpponentHandleIntroSlide, + LinkOpponentHandleTrainerBallThrow, + LinkOpponentHandlecmd48, + LinkOpponentHandlecmd49, + LinkOpponentHandlecmd50, + LinkOpponentHandleSpriteInvisibility, + LinkOpponentHandleBattleAnimation, + LinkOpponentHandleLinkStandbyMsg, + LinkOpponentHandleResetActionMoveSelection, + LinkOpponentHandlecmd55, + LinkOpponentHandlecmd56 +}; + +// code + +void LinkOpponentHandleGetAttributes(void) +{ + u8 buffer[0x100]; + u32 r6 = 0; + u8 r4; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + r6 = dp01_getattr_by_ch1_for_player_pokemon__(gBattlePartyID[gActiveBank], buffer); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + r6 += dp01_getattr_by_ch1_for_player_pokemon__(i, buffer + r6); + r4 >>= 1; + } + } + Emitcmd29(1, r6, buffer); + LinkOpponentBufferExecCompleted(); +} + +u32 dp01_getattr_by_ch1_for_player_pokemon__(u8 a, u8 *buffer) +{ + struct BattlePokemon battlePokemon; + struct UnknownStruct3 moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + battlePokemon.species = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); + battlePokemon.item = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battlePokemon.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); + battlePokemon.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + } + battlePokemon.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + battlePokemon.friendship = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); + battlePokemon.experience = GetMonData(&gEnemyParty[a], MON_DATA_EXP); + battlePokemon.hpIV = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + battlePokemon.attackIV = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + battlePokemon.defenseIV = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + battlePokemon.speedIV = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + battlePokemon.spAttackIV = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + battlePokemon.spDefenseIV = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + battlePokemon.personality = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); + battlePokemon.status1 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); + battlePokemon.level = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); + battlePokemon.hp = GetMonData(&gEnemyParty[a], MON_DATA_HP); + battlePokemon.maxHP = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); + battlePokemon.attack = GetMonData(&gEnemyParty[a], MON_DATA_ATK); + battlePokemon.defense = GetMonData(&gEnemyParty[a], MON_DATA_DEF); + battlePokemon.speed = GetMonData(&gEnemyParty[a], MON_DATA_SPD); + battlePokemon.spAttack = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); + battlePokemon.spDefense = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); + battlePokemon.isEgg = GetMonData(&gEnemyParty[a], MON_DATA_IS_EGG); + battlePokemon.altAbility = GetMonData(&gEnemyParty[a], MON_DATA_ALT_ABILITY); + battlePokemon.otId = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); + GetMonData(&gEnemyParty[a], MON_DATA_NICKNAME, nickname); + StringCopy10(battlePokemon.nickname, nickname); + GetMonData(&gEnemyParty[a], MON_DATA_OT_NAME, battlePokemon.otName); + src = (u8 *)&battlePokemon; + for (size = 0; size < sizeof(battlePokemon); size++) + buffer[size] = src[size]; + break; + case 1: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 2: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 3: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + src = (u8 *)&moveData; + for (size = 0; size < sizeof(moveData); size++) + buffer[size] = src[size]; + break; + case 4: + case 5: + case 6: + case 7: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 8: + for (size = 0; size < 4; size++) + buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + size++; + break; + case 9: + case 10: + case 11: + case 12: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); + size = 1; + break; + case 17: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 18: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_EXP); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 19: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_EV); + size = 1; + break; + case 20: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_EV); + size = 1; + break; + case 21: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_EV); + size = 1; + break; + case 22: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_EV); + size = 1; + break; + case 23: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV); + size = 1; + break; + case 24: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV); + size = 1; + break; + case 25: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); + size = 1; + break; + case 26: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKERUS); + size = 1; + break; + case 27: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION); + size = 1; + break; + case 28: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL); + size = 1; + break; + case 29: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_GAME); + size = 1; + break; + case 30: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKEBALL); + size = 1; + break; + case 31: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + buffer[1] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + buffer[2] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + buffer[3] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + buffer[4] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + buffer[5] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + size = 6; + break; + case 32: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + size = 1; + break; + case 33: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + size = 1; + break; + case 34: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + size = 1; + break; + case 35: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + size = 1; + break; + case 36: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + size = 1; + break; + case 37: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + size = 1; + break; + case 38: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 39: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 40: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 41: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); + size = 1; + break; + case 42: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 43: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 44: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_ATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 45: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_DEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 46: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPD); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 47: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 48: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 49: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL); + size = 1; + break; + case 50: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY); + size = 1; + break; + case 51: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE); + size = 1; + break; + case 52: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART); + size = 1; + break; + case 53: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH); + size = 1; + break; + case 54: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SHEEN); + size = 1; + break; + case 55: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON); + size = 1; + break; + case 56: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case 57: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case 58: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON); + size = 1; + break; + case 59: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + return size; +} + +void LinkOpponentHandlecmd1(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleSetAttributes(void) +{ + u8 i; + u8 r4; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + sub_8038900(gBattlePartyID[gActiveBank]); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + sub_8038900(i); + r4 >>= 1; + } + } + LinkOpponentBufferExecCompleted(); +} + +void sub_8038900(u8 a) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + { + u8 iv; + + SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); + SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); + } + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); + SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); + SetMonData(&gEnemyParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, (u8 *)&iv); + iv = battlePokemon->attackIV; + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, (u8 *)&iv); + iv = battlePokemon->defenseIV; + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, (u8 *)&iv); + iv = battlePokemon->speedIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, (u8 *)&iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); + SetMonData(&gEnemyParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); + SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); + SetMonData(&gEnemyParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); + SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); + SetMonData(&gEnemyParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); + SetMonData(&gEnemyParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); + SetMonData(&gEnemyParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); + SetMonData(&gEnemyParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); + } + break; + case 1: + SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case 2: + SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case 3: + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); + } + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case 4: + case 5: + case 6: + case 7: + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); + break; + case 8: + SetMonData(&gEnemyParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case 9: + case 10: + case 11: + case 12: + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); + break; + case 17: + SetMonData(&gEnemyParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case 18: + SetMonData(&gEnemyParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case 19: + SetMonData(&gEnemyParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 20: + SetMonData(&gEnemyParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 21: + SetMonData(&gEnemyParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 22: + SetMonData(&gEnemyParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 23: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 24: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 25: + SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case 26: + SetMonData(&gEnemyParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case 27: + SetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case 28: + SetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 29: + SetMonData(&gEnemyParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case 30: + SetMonData(&gEnemyParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case 31: + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case 32: + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 33: + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 34: + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 35: + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 36: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 37: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 38: + SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case 39: + SetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case 40: + SetMonData(&gEnemyParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case 41: + SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 42: + SetMonData(&gEnemyParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 43: + SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 44: + SetMonData(&gEnemyParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case 45: + SetMonData(&gEnemyParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case 46: + SetMonData(&gEnemyParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case 47: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case 48: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case 49: + SetMonData(&gEnemyParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case 50: + SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case 51: + SetMonData(&gEnemyParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case 52: + SetMonData(&gEnemyParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case 53: + SetMonData(&gEnemyParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case 54: + SetMonData(&gEnemyParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case 55: + SetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 56: + SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 57: + SetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 58: + SetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 59: + SetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } +} + +void LinkOpponentHandlecmd3(void) +{ + u8 *dst; + u8 i; + + dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleLoadPokeSprite(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(gActiveBank, 2), + sub_8077F68(gActiveBank), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); + sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_8037A74; +} + +void LinkOpponentHandleSendOutPoke(void) +{ + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_8039430(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_8037E30; +} + +void sub_8039430(u8 a, u8 b) +{ + u16 species; + + sub_8032AA8(a, b); + gBattlePartyID[a] = gBattleBufferA[a][1]; + species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); + gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); + sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); + gObjectBankIDs[a] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(a, 2), + sub_8077F68(a), + sub_8079E90(a)); + gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; + gSprites[gObjectBankIDs[a]].data0 = a; + gSprites[gObjectBankIDs[a]].data2 = species; + gSprites[gObjectBankIDs[a]].oam.paletteNum = a; + StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); + gSprites[gObjectBankIDs[a]].invisible = TRUE; + gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; + gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFE); +} + +void LinkOpponentHandleReturnPokeToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_8039648; + } + else + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8032A08(gActiveBank); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + LinkOpponentBufferExecCompleted(); + } +} + +void sub_8039648(void) +{ + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 2); + gBattleBankFunc[gActiveBank] = sub_8037BBC; + } + break; + } +} + +void LinkOpponentHandleTrainerThrow(void) +{ + s16 xOffset; + u32 gender; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if (GetBankIdentity(gActiveBank) & 2) + xOffset = -16; + else + xOffset = 16; + gender = gLinkPlayers[sub_803FC34(gActiveBank)].gender; + } + else + { + xOffset = 0; + gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; + } + sub_8031A6C(gender, gActiveBank); + GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 176 + xOffset, 40 + 4 * (8 - gTrainerFrontPicCoords[gender].coords), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[gender].tag); + gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; + gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[gender].tag); + gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = gender; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_803757C; +} + +void LinkOpponentHandleTrainerSlide(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_80375B4; +} + +void LinkOpponentHandlecmd10(void) +{ + if (ewram17810[gActiveBank].unk4 == 0) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4++; + } + else if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + PlaySE12WithPanning(SE_POKE_DEAD, 63); + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8010384; + gBattleBankFunc[gActiveBank] = sub_8037B78; + } +} + +void LinkOpponentHandlecmd11(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd12(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleBallThrow(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlePuase(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u32 r0 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + + gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; + gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] + | (gBattleBufferA[gActiveBank][5] << 8); + gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] + | (gBattleBufferA[gActiveBank][7] << 8) + | (gBattleBufferA[gActiveBank][8] << 16) + | (gBattleBufferA[gActiveBank][9] << 24); + gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] + | (gBattleBufferA[gActiveBank][13] << 8); + gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; + gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; + + // Dead code. sub_8031720 always returns 0. + if (sub_8031720(r0, gUnknown_0202F7C4) != 0) + { + LinkOpponentBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_8039B64; + } + } +} + +void sub_8039B64(void) +{ + u16 r4 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + u8 r7 = gBattleBufferA[gActiveBank][11]; + + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + { + ewram17800[gActiveBank].unk0_3 = 1; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + } + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_80326EC(0); + ExecuteMoveAnim(r4); + ewram17810[gActiveBank].unk4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_80326EC(1); + if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + ewram17800[gActiveBank].unk0_3 = 0; + } + ewram17810[gActiveBank].unk4 = 3; + } + break; + case 3: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_8031F24(); + sub_80324BC( + gActiveBank, + gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + ewram17810[gActiveBank].unk4 = 0; + LinkOpponentBufferExecCompleted(); + } + break; + } +} + +void LinkOpponentHandlePrintString(void) +{ + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); + sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); + gBattleBankFunc[gActiveBank] = sub_8037C2C; +} + +void LinkOpponentHandlePrintStringPlayerOnly(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd18(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd19(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd20(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleOpenBag(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd22(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd23(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleHealthBarUpdate(void) +{ + s16 r7; + + load_gfxc_health_bar(0); + r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + if (r7 != 0x7FFF) + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 hp = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); + } + else + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); + } + gBattleBankFunc[gActiveBank] = sub_8037B24; +} + +void LinkOpponentHandleExpBarUpdate(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleStatusIconUpdate(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + sub_8045A5C(gHealthboxIDs[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], 9); + ewram17810[gActiveBank].unk0_4 = 0; + gBattleBankFunc[gActiveBank] = sub_8037FAC; + } +} + +void LinkOpponentHandleStatusAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + move_anim_start_t2_for_situation( + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] + | (gBattleBufferA[gActiveBank][3] << 8) + | (gBattleBufferA[gActiveBank][4] << 16) + | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = sub_8037FAC; + } +} + +void LinkOpponentHandleStatusXor(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd29(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleDMATransfer(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd31(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd32(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd33(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd34(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd35(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd36(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd37(void) +{ + gUnknown_020238C8.unk0_0 = 0; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd38(void) +{ + gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd39(void) +{ + gUnknown_020238C8.unk0_7 = 0; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd40(void) +{ + gUnknown_020238C8.unk0_7 ^= 1; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleHitAnimation(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) + { + LinkOpponentBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + sub_8047858(gActiveBank); + gBattleBankFunc[gActiveBank] = dp01t_0F_4_move_anim; + } +} + +void LinkOpponentHandlecmd42(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == 0) + pan = -64; + else + pan = 63; + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd44(void) +{ + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleFaintingCry(void) +{ + PlayCry3( + GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), + 25, 5); + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleIntroSlide(void) +{ + sub_80E43C0(gBattleBufferA[gActiveBank][1]); + gUnknown_02024DE8 |= 1; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleTrainerBallThrow(void) +{ + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_803A3A8); + taskId = CreateTask(sub_803A2C4, 5); + gTasks[taskId].data[0] = gActiveBank; + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + ewram17840.unk9_0 = 1; + gBattleBankFunc[gActiveBank] = nullsub_47; +} + +void sub_803A2C4(u8 taskId) +{ + u8 r9; + + r9 = gActiveBank; + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8039430(gActiveBank, 0); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8039430(gActiveBank, 0); + gActiveBank ^= 2; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_8039430(gActiveBank, 0); + gActiveBank ^= 2; + } + gBattleBankFunc[gActiveBank] = sub_8037840; + gActiveBank = r9; + DestroyTask(taskId); +} + +void sub_803A3A8(struct Sprite *sprite) +{ + sub_8031B74(sprite->oam.affineParam); + sprite->oam.tileNum = sprite->data5; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); +} + +void LinkOpponentHandlecmd48(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) + { + LinkOpponentBufferExecCompleted(); + return; + } + + ewram17810[gActiveBank].unk0_0 = 1; + if (gBattleBufferA[gActiveBank][2] != 0) + { + if (ewram17810[gActiveBank].unk1_1 < 2) + { + ewram17810[gActiveBank].unk1_1++; + return; + } + else + { + ewram17810[gActiveBank].unk1_1 = 0; + } + } + gUnknown_02024E68[gActiveBank] = sub_8044804( + gActiveBank, + (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2]); + ewram17810[gActiveBank].unk5 = 0; + if (gBattleBufferA[gActiveBank][2] != 0) + ewram17810[gActiveBank].unk5 = 0x5D; + gBattleBankFunc[gActiveBank] = sub_803A4E0; +} + +void sub_803A4E0(void) +{ + if (ewram17810[gActiveBank].unk5++ >= 93) + { + ewram17810[gActiveBank].unk5 = 0; + LinkOpponentBufferExecCompleted(); + } +} + +void LinkOpponentHandlecmd49(void) +{ + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd50(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleSpriteInvisibility(void) +{ + if (sub_8078874(gActiveBank) != 0) + { + gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + sub_8031F88(gActiveBank); + } + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleBattleAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + u8 r3 = gBattleBufferA[gActiveBank][1]; + u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) + LinkOpponentBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = sub_8037FD8; + } +} + +void LinkOpponentHandleLinkStandbyMsg(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandleResetActionMoveSelection(void) +{ + LinkOpponentBufferExecCompleted(); +} + +void LinkOpponentHandlecmd55(void) +{ + if (gBattleBufferA[gActiveBank][1] == 3) + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + else + gBattleOutcome = gBattleBufferA[gActiveBank][1] ^ 3; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + LinkOpponentBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_8037F34; +} + +void LinkOpponentHandlecmd56(void) +{ +} diff --git a/src/battle_controller_linkpartner.c b/src/battle_controller_linkpartner.c new file mode 100644 index 000000000..f516c9bce --- /dev/null +++ b/src/battle_controller_linkpartner.c @@ -0,0 +1,1728 @@ +#include "global.h" +#include "battle.h" +#include "battle_interface.h" +#include "data2.h" +#include "battle_811DA74.h" +#include "battle_anim_813F0F4.h" +#include "link.h" +#include "m4a.h" +#include "main.h" +#include "palette.h" +#include "pokeball.h" +#include "pokemon.h" +#include "rom3.h" +#include "rom_8077ABC.h" +#include "sound.h" +#include "songs.h" +#include "sprite.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "util.h" + +struct UnknownStruct1 +{ + u8 unk0; + u8 unk1; + u8 unk2[0x1FE]; +}; + +//Possibly PokemonSubstruct1 +struct UnknownStruct3 +{ + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; +}; + +extern u16 gBattleTypeFlags; +extern u8 gDisplayedStringBattle[]; +extern u8 gBattleBufferA[][0x200]; +extern u8 gActiveBank; +extern u32 gBattleExecBuffer; +extern u16 gBattlePartyID[]; +extern u8 gObjectBankIDs[]; +extern u8 gBattleOutcome; +extern u16 gUnknown_02024DE8; +extern u8 gUnknown_02024E68[]; +extern u8 gDoingBattleAnim; +extern u32 gPID_perBank[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern u32 *gDisableStructMoveAnim; +extern u32 gMoveDmgMoveAnim; +extern u16 gMovePowerMoveAnim; +extern u8 gHappinessMoveAnim; +extern u16 gWeatherMoveAnim; +extern u8 gUnknown_0202F7C4; +extern struct Window gUnknown_03004210; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern MainCallback gPreBattleCallback1; +extern void (*gBattleBankFunc[])(void); +extern u8 gHealthboxIDs[]; +extern u8 gUnknown_0300434C[]; +extern u8 gBattleMonForms[]; +extern u8 gAnimScriptActive; +extern void (*gAnimScriptCallback)(void); + +extern u8 move_anim_start_t3(); +extern u8 sub_8078874(); +extern void sub_8044CA0(u8); +extern void sub_8030E38(struct Sprite *); +extern void sub_80E43C0(); +extern void sub_8047858(); +extern void move_anim_start_t2_for_situation(); +extern void load_gfxc_health_bar(); +extern void sub_8043D84(); +extern void BufferStringBattle(); +extern void sub_8031F24(void); +extern void sub_80326EC(); +extern void ExecuteMoveAnim(); +extern void sub_80324BC(); +extern u8 sub_8031720(); +extern u8 mplay_80342A4(); +extern void oamt_add_pos2_onto_pos1(); +extern void oamt_set_x3A_32(); +extern void sub_8078B34(struct Sprite *); +extern void sub_80105EC(struct Sprite *); +extern s32 sub_803FC34(u16); +extern void sub_8031AF4(); +extern void sub_80313A0(struct Sprite *); +extern u8 sub_8046400(); +extern void sub_80312F0(struct Sprite *); +extern u8 CreateInvisibleSpriteWithCallback(); +extern void sub_80318FC(); +extern u8 sub_8077ABC(); +extern u8 sub_8077F68(); +extern u8 sub_8079E90(); +extern void nullsub_10(); +extern void sub_8045A5C(); +extern void sub_804777C(); +extern void sub_8043DFC(); +//extern s16 sub_8045C78(); +extern void sub_80440EC(); +extern void sub_80324F8(); +extern void nullsub_9(u16); +extern void sub_8043DB0(); +extern void move_anim_start_t4(); +extern void c3_0802FDF4(u8); +extern void sub_8031F88(); +extern void sub_8141828(); +extern void c2_8011A1C(void); + +// this file's functions + +void LinkPartnerBufferRunCommand(void); +void sub_811E0A0(void); +void LinkPartnerBufferExecCompleted(void); +u32 dp01_getattr_by_ch1_for_player_pokemon(u8 a, u8 *b); +void sub_811EC68(u8); +void sub_811F864(u8, u8); +void sub_811FA5C(void); +void sub_811FF30(void); +void sub_812071C(u8); +void sub_81208E0(void); + +void LinkPartnerHandleGetAttributes(void); +void LinkPartnerHandlecmd1(void); +void LinkPartnerHandleSetAttributes(void); +void LinkPartnerHandlecmd3(void); +void LinkPartnerHandleLoadPokeSprite(void); +void LinkPartnerHandleSendOutPoke(void); +void LinkPartnerHandleReturnPokeToBall(void); +void LinkPartnerHandleTrainerThrow(void); +void LinkPartnerHandleTrainerSlide(void); +void LinkPartnerHandleTrainerSlideBack(void); +void LinkPartnerHandlecmd10(void); +void LinkPartnerHandlecmd11(void); +void LinkPartnerHandlecmd12(void); +void LinkPartnerHandleBallThrow(void); +void LinkPartnerHandlePuase(void); +void LinkPartnerHandleMoveAnimation(void); +void LinkPartnerHandlePrintString(void); +void LinkPartnerHandlePrintStringPlayerOnly(void); +void LinkPartnerHandlecmd18(void); +void LinkPartnerHandlecmd19(void); +void LinkPartnerHandlecmd20(void); +void LinkPartnerHandleOpenBag(void); +void LinkPartnerHandlecmd22(void); +void LinkPartnerHandlecmd23(void); +void LinkPartnerHandleHealthBarUpdate(void); +void LinkPartnerHandleExpBarUpdate(void); +void LinkPartnerHandleStatusIconUpdate(void); +void LinkPartnerHandleStatusAnimation(void); +void LinkPartnerHandleStatusXor(void); +void LinkPartnerHandlecmd29(void); +void LinkPartnerHandleDMATransfer(void); +void LinkPartnerHandlecmd31(void); +void LinkPartnerHandlecmd32(void); +void LinkPartnerHandlecmd33(void); +void LinkPartnerHandlecmd34(void); +void LinkPartnerHandlecmd35(void); +void LinkPartnerHandlecmd36(void); +void LinkPartnerHandlecmd37(void); +void LinkPartnerHandlecmd38(void); +void LinkPartnerHandlecmd39(void); +void LinkPartnerHandlecmd40(void); +void LinkPartnerHandleHitAnimation(void); +void LinkPartnerHandlecmd42(void); +void LinkPartnerHandleEffectivenessSound(void); +void LinkPartnerHandlecmd44(void); +void LinkPartnerHandleFaintingCry(void); +void LinkPartnerHandleIntroSlide(void); +void LinkPartnerHandleTrainerBallThrow(void); +void LinkPartnerHandlecmd48(void); +void LinkPartnerHandlecmd49(void); +void LinkPartnerHandlecmd50(void); +void LinkPartnerHandleSpriteInvisibility(void); +void LinkPartnerHandleBattleAnimation(void); +void LinkPartnerHandleLinkStandbyMsg(void); +void LinkPartnerHandleResetActionMoveSelection(void); +void LinkPartnerHandlecmd55(void); +void LinkPartnerHandlecmd56(void); + +// const data +typedef void (*BattleBufferCmd) (void); +static const BattleBufferCmd gLinkPartnerBufferCommands[] = +{ + LinkPartnerHandleGetAttributes, + LinkPartnerHandlecmd1, + LinkPartnerHandleSetAttributes, + LinkPartnerHandlecmd3, + LinkPartnerHandleLoadPokeSprite, + LinkPartnerHandleSendOutPoke, + LinkPartnerHandleReturnPokeToBall, + LinkPartnerHandleTrainerThrow, + LinkPartnerHandleTrainerSlide, + LinkPartnerHandleTrainerSlideBack, + LinkPartnerHandlecmd10, + LinkPartnerHandlecmd11, + LinkPartnerHandlecmd12, + LinkPartnerHandleBallThrow, + LinkPartnerHandlePuase, + LinkPartnerHandleMoveAnimation, + LinkPartnerHandlePrintString, + LinkPartnerHandlePrintStringPlayerOnly, + LinkPartnerHandlecmd18, + LinkPartnerHandlecmd19, + LinkPartnerHandlecmd20, + LinkPartnerHandleOpenBag, + LinkPartnerHandlecmd22, + LinkPartnerHandlecmd23, + LinkPartnerHandleHealthBarUpdate, + LinkPartnerHandleExpBarUpdate, + LinkPartnerHandleStatusIconUpdate, + LinkPartnerHandleStatusAnimation, + LinkPartnerHandleStatusXor, + LinkPartnerHandlecmd29, + LinkPartnerHandleDMATransfer, + LinkPartnerHandlecmd31, + LinkPartnerHandlecmd32, + LinkPartnerHandlecmd33, + LinkPartnerHandlecmd34, + LinkPartnerHandlecmd35, + LinkPartnerHandlecmd36, + LinkPartnerHandlecmd37, + LinkPartnerHandlecmd38, + LinkPartnerHandlecmd39, + LinkPartnerHandlecmd40, + LinkPartnerHandleHitAnimation, + LinkPartnerHandlecmd42, + LinkPartnerHandleEffectivenessSound, + LinkPartnerHandlecmd44, + LinkPartnerHandleFaintingCry, + LinkPartnerHandleIntroSlide, + LinkPartnerHandleTrainerBallThrow, + LinkPartnerHandlecmd48, + LinkPartnerHandlecmd49, + LinkPartnerHandlecmd50, + LinkPartnerHandleSpriteInvisibility, + LinkPartnerHandleBattleAnimation, + LinkPartnerHandleLinkStandbyMsg, + LinkPartnerHandleResetActionMoveSelection, + LinkPartnerHandlecmd55, + LinkPartnerHandlecmd56, +}; +// code starts here + +void nullsub_74(void) +{ +} + +void SetBankFuncToLinkPartnerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; +} + +void LinkPartnerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] <= 0x38) + gLinkPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DAE4(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + LinkPartnerBufferExecCompleted(); +} + +void sub_811DB1C(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_10(0); + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DB84(void) +{ + if ((--ewram17810[gActiveBank].unk9) == 0xFF) + { + ewram17810[gActiveBank].unk9 = 0; + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DBC0(void) +{ + bool8 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & 0x40))) + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + if (r6) + { + ewram17810[gActiveBank].unk9 = 3; + gBattleBankFunc[gActiveBank] = sub_811DB84; + } +} + +void sub_811DCA0(void) +{ + u8 r2; + + if (!ewram17810[gActiveBank].unk0_3) + { + // I couldn't get it to work as a bitfield here + r2 = *((u8 *)&ewram17810[gActiveBank ^ 2]) & 8; + if (!r2 && (++ewram17810[gActiveBank].unk9) != 1) + { + ewram17810[gActiveBank].unk9 = r2; + if (IsDoubleBattle() && !(gBattleTypeFlags & 0x40)) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); + sub_8045A5C(gHealthboxIDs[gActiveBank ^ 2], &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], 0); + sub_804777C(gActiveBank ^ 2); + sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); + } + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + (s8)ewram17810[4].unk9 &= ~1; + gBattleBankFunc[gActiveBank] = sub_811DBC0; + } + } +} + +void sub_811DDE8(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].animEnded + && gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) + LinkPartnerBufferExecCompleted(); +} + +void bx_t3_healthbar_update(void) +{ + s16 r4; + + r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + if (r4 != -1) + { + sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); + } + else + { + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DE98(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > 160) + { + nullsub_9(GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DF34(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811DFA0(void) +{ + if (gUnknown_03004210.state == 0) + LinkPartnerBufferExecCompleted(); +} + +void bx_blink_t3(void) +{ + u8 spriteId = gObjectBankIDs[gActiveBank]; + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = 0; + LinkPartnerBufferExecCompleted(); + } + else + { + if ((gSprites[spriteId].data1 % 4) == 0) + { + gSprites[spriteId].invisible ^= 1; + } + gSprites[spriteId].data1++; + } +} + +void sub_811E034(void) +{ + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + gBattleBankFunc[gActiveBank] = sub_811E0A0; + } +} + +void sub_811E0A0(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + LinkPartnerBufferExecCompleted(); +} + +void sub_811E0CC(void) +{ + if (ewram17810[gActiveBank].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + CreateTask(c3_0802FDF4, 10); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 0); + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + sub_8031F88(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_811E034; + } +} + +void sub_811E1BC(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy + && !ewram17810[gActiveBank].unk0_3) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + gBattleBankFunc[gActiveBank] = sub_811E0CC; + } +} + +void sub_811E258(void) +{ + if (gReceivedRemoteLinkPlayers == 0) + { + m4aSongNumStop(0x5A); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(c2_8011A1C); + } +} + +void sub_811E29C(void) +{ + if (!gPaletteFade.active) + { + if (gBattleTypeFlags & 2) + { + sub_800832C(); + gBattleBankFunc[gActiveBank] = sub_811E258; + } + else + { + m4aSongNumStop(0x5A); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + } +} + +void LinkPartnerBufferExecCompleted(void) +{ + u8 multiplayerId; + + gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; + if (gBattleTypeFlags & 2) + { + multiplayerId = GetMultiplayerId(); + dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); + gBattleBufferA[gActiveBank][0] = 0x38; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void sub_811E38C(void) +{ + if (!ewram17810[gActiveBank].unk0_4) + LinkPartnerBufferExecCompleted(); +} + +void sub_811E3B8(void) +{ + if (!ewram17810[gActiveBank].unk0_5) + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleGetAttributes(void) +{ + u8 unk[256]; + int r6 = 0; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + r6 = dp01_getattr_by_ch1_for_player_pokemon(gBattlePartyID[gActiveBank], unk); + } + else + { + u8 r4 = gBattleBufferA[gActiveBank][2]; + + for (i = 0; i < 6; i++) + { + if (r4 & 1) + r6 += dp01_getattr_by_ch1_for_player_pokemon(i, unk + r6); + r4 >>= 1; + } + } + Emitcmd29(1, r6, unk); + LinkPartnerBufferExecCompleted(); +} + +// Duplicate of dp01_getattr_by_ch1_for_player_pokemon_ +u32 dp01_getattr_by_ch1_for_player_pokemon(u8 a, u8 *buffer) +{ + struct BattlePokemon battlePokemon; + struct UnknownStruct3 moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); + battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); + battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); + battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); + StringCopy10(battlePokemon.nickname, nickname); + GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); + src = (u8 *)&battlePokemon; + for (size = 0; size < sizeof(battlePokemon); size++) + buffer[size] = src[size]; + break; + case 1: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 2: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 3: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + src = (u8 *)&moveData; + for (size = 0; size < sizeof(moveData); size++) + buffer[size] = src[size]; + break; + case 4: + case 5: + case 6: + case 7: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 8: + for (size = 0; size < 4; size++) + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + size++; + break; + case 9: + case 10: + case 11: + case 12: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); + size = 1; + break; + case 17: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 18: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 19: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); + size = 1; + break; + case 20: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); + size = 1; + break; + case 21: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); + size = 1; + break; + case 22: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); + size = 1; + break; + case 23: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); + size = 1; + break; + case 24: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); + size = 1; + break; + case 25: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + size = 1; + break; + case 26: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); + size = 1; + break; + case 27: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); + size = 1; + break; + case 28: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); + size = 1; + break; + case 29: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); + size = 1; + break; + case 30: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); + size = 1; + break; + case 31: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 6; + break; + case 32: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + size = 1; + break; + case 33: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + size = 1; + break; + case 34: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + size = 1; + break; + case 35: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + size = 1; + break; + case 36: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + size = 1; + break; + case 37: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 1; + break; + case 38: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 39: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 40: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 41: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + size = 1; + break; + case 42: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 43: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 44: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 45: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 46: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 47: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 48: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 49: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); + size = 1; + break; + case 50: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); + size = 1; + break; + case 51: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); + size = 1; + break; + case 52: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); + size = 1; + break; + case 53: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); + size = 1; + break; + case 54: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); + size = 1; + break; + case 55: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); + size = 1; + break; + case 56: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case 57: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case 58: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); + size = 1; + break; + case 59: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + return size; +} + +void LinkPartnerHandlecmd1(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleSetAttributes(void) +{ + u8 i; + u8 r4; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + sub_811EC68(gBattlePartyID[gActiveBank]); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + sub_811EC68(i); + r4 >>= 1; + } + } + LinkPartnerBufferExecCompleted(); +} + +// Duplicate of dp01_setattr_by_ch1_for_player_pokemon +void sub_811EC68(u8 a) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + { + u8 iv; + + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); + SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); + SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); + SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); + SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); + SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); + } + break; + case 1: + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case 2: + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case 3: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case 4: + case 5: + case 6: + case 7: + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); + break; + case 8: + SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case 9: + case 10: + case 11: + case 12: + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); + break; + case 17: + SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case 18: + SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case 19: + SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 20: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 21: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 22: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 23: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 24: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 25: + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case 26: + SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case 27: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case 28: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 29: + SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case 30: + SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case 31: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case 32: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 33: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 34: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 35: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 36: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 37: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 38: + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case 39: + SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case 40: + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case 41: + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 42: + SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 43: + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 44: + SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case 45: + SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case 46: + SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case 47: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case 48: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case 49: + SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case 50: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case 51: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case 52: + SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case 53: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case 54: + SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case 55: + SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 56: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 57: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 58: + SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 59: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +void LinkPartnerHandlecmd3(void) +{ + u8 *dst; + u8 i; + + dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleLoadPokeSprite(void) +{ + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + GetMonSpriteTemplate_803C56C( + GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), + GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(gActiveBank, 2), + sub_8077F68(gActiveBank), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); + gBattleBankFunc[gActiveBank] = sub_811DDE8; +} + +void LinkPartnerHandleSendOutPoke(void) +{ + sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_811F864(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_811E1BC; +} + +void sub_811F864(u8 a, u8 b) +{ + u16 species; + + sub_8032AA8(a, b); + gBattlePartyID[a] = gBattleBufferA[a][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_SPECIES); + gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); + gObjectBankIDs[a] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(a, 2), + sub_8077F68(a), + sub_8079E90(a)); + gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; + gSprites[gObjectBankIDs[a]].data0 = a; + gSprites[gObjectBankIDs[a]].data2 = species; + gSprites[gObjectBankIDs[a]].oam.paletteNum = a; + StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); + gSprites[gObjectBankIDs[a]].invisible = TRUE; + gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; + gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFF); +} + +void LinkPartnerHandleReturnPokeToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_811FA5C; + } + else + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + LinkPartnerBufferExecCompleted(); + } +} + +void sub_811FA5C(void) +{ + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); + gBattleBankFunc[gActiveBank] = sub_811DF34; + } + break; + } +} + +void LinkPartnerHandleTrainerThrow(void) +{ + s16 xOffset; + u32 gender; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if (GetBankIdentity(gActiveBank) & 2) + xOffset = 16; + else + xOffset = -16; + gender = gLinkPlayers[sub_803FC34(gActiveBank)].gender; + } + else + { + xOffset = 0; + gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; + } + sub_8031AF4(gender, gActiveBank); + GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 80 + xOffset, 80 + 4 * (8 - gTrainerBackPicCoords[gender].coords), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_811DAE4; +} + +void LinkPartnerHandleTrainerSlide(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; + gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_811DB1C; +} + +void LinkPartnerHandlecmd10(void) +{ + if (ewram17810[gActiveBank].unk4 == 0) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4++; + } + else if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 5; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80105EC; + gBattleBankFunc[gActiveBank] = sub_811DE98; + } +} + +void LinkPartnerHandlecmd11(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd12(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleBallThrow(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlePuase(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u32 r0 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + + gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; + gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] + | (gBattleBufferA[gActiveBank][5] << 8); + gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] + | (gBattleBufferA[gActiveBank][7] << 8) + | (gBattleBufferA[gActiveBank][8] << 16) + | (gBattleBufferA[gActiveBank][9] << 24); + gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] + | (gBattleBufferA[gActiveBank][13] << 8); + gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; + gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; + + if (sub_8031720(r0, gUnknown_0202F7C4) != 0) + LinkPartnerBufferExecCompleted(); + else + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_811FF30; + } + } +} + +void sub_811FF30(void) +{ + u16 r4 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + u8 r7 = gBattleBufferA[gActiveBank][11]; + + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + { + ewram17800[gActiveBank].unk0_3 = 1; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + } + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_80326EC(0); + ExecuteMoveAnim(r4); + ewram17810[gActiveBank].unk4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_80326EC(1); + if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + ewram17800[gActiveBank].unk0_3 = 0; + } + ewram17810[gActiveBank].unk4 = 3; + } + break; + case 3: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_8031F24(); + sub_80324BC( + gActiveBank, + gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + ewram17810[gActiveBank].unk4 = 0; + LinkPartnerBufferExecCompleted(); + } + break; + } +} + +void LinkPartnerHandlePrintString(void) +{ + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); + sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); + gBattleBankFunc[gActiveBank] = sub_811DFA0; +} + +void LinkPartnerHandlePrintStringPlayerOnly(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd18(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd19(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd20(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleOpenBag(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd22(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd23(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleHealthBarUpdate(void) +{ + s16 r7; + + load_gfxc_health_bar(0); + r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + if (r7 != 0x7FFF) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 hp = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); + } + gBattleBankFunc[gActiveBank] = bx_t3_healthbar_update; +} + +void LinkPartnerHandleExpBarUpdate(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleStatusIconUpdate(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 9); + ewram17810[gActiveBank].unk0_4 = 0; + gBattleBankFunc[gActiveBank] = sub_811E38C; + } +} + +void LinkPartnerHandleStatusAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + move_anim_start_t2_for_situation( + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] + | (gBattleBufferA[gActiveBank][3] << 8) + | (gBattleBufferA[gActiveBank][4] << 16) + | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = sub_811E38C; + } +} + +void LinkPartnerHandleStatusXor(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd29(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleDMATransfer(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd31(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd32(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd33(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd34(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd35(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd36(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd37(void) +{ + gUnknown_020238C8.unk0_0 = 0; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd38(void) +{ + gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd39(void) +{ + gUnknown_020238C8.unk0_7 = 0; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd40(void) +{ + gUnknown_020238C8.unk0_7 ^= 1; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleHitAnimation(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) + { + LinkPartnerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + sub_8047858(gActiveBank); + gBattleBankFunc[gActiveBank] = bx_blink_t3; + } +} + +void LinkPartnerHandlecmd42(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == 0) + pan = -64; + else + pan = 63; + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd44(void) +{ + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleFaintingCry(void) +{ + PlayCry3( + GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), + -25, 5); + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleIntroSlide(void) +{ + sub_80E43C0(gBattleBufferA[gActiveBank][1]); + gUnknown_02024DE8 |= 1; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleTrainerBallThrow(void) +{ + u8 r4; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; + gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); + r4 = AllocSpritePalette(0xD6F9); + LoadCompressedPalette( + gTrainerBackPicPaletteTable[gLinkPlayers[sub_803FC34(gActiveBank)].gender].data, + 0x100 + r4 * 16, 0x20); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = r4; + taskId = CreateTask(sub_812071C, 5); + gTasks[taskId].data[0] = gActiveBank; + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + ewram17840.unk9_0 = 1; + gBattleBankFunc[gActiveBank] = nullsub_74; +} + +void sub_812071C(u8 taskId) +{ + u8 r9; + + if (gTasks[taskId].data[1] < 24) + { + gTasks[taskId].data[1]++; + return; + } + + r9 = gActiveBank; + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_811F864(gActiveBank, 0); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_811F864(gActiveBank, 0); + gActiveBank ^= 2; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_811F864(gActiveBank, 0); + gActiveBank ^= 2; + } + gBattleBankFunc[gActiveBank] = sub_811DCA0; + gActiveBank = r9; + DestroyTask(taskId); +} + +void LinkPartnerHandlecmd48(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) + { + LinkPartnerBufferExecCompleted(); + return; + } + + ewram17810[gActiveBank].unk0_0 = 1; + gUnknown_02024E68[gActiveBank] = sub_8044804( + gActiveBank, + (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2]); + ewram17810[gActiveBank].unk5 = 0; + if (gBattleBufferA[gActiveBank][2] != 0) + ewram17810[gActiveBank].unk5 = 0x5D; + gBattleBankFunc[gActiveBank] = sub_81208E0; +} + +void sub_81208E0(void) +{ + if (ewram17810[gActiveBank].unk5++ >= 93) + { + ewram17810[gActiveBank].unk5 = 0; + LinkPartnerBufferExecCompleted(); + } +} + +void LinkPartnerHandlecmd49(void) +{ + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd50(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleSpriteInvisibility(void) +{ + if (sub_8078874(gActiveBank) != 0) + { + gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + sub_8031F88(gActiveBank); + } + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleBattleAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + u8 r3 = gBattleBufferA[gActiveBank][1]; + u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) + LinkPartnerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = sub_811E3B8; + } +} + +void LinkPartnerHandleLinkStandbyMsg(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandleResetActionMoveSelection(void) +{ + LinkPartnerBufferExecCompleted(); +} + +void LinkPartnerHandlecmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + LinkPartnerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_811E29C; +} + +void LinkPartnerHandlecmd56(void) +{ +} diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c new file mode 100644 index 000000000..b24130bb8 --- /dev/null +++ b/src/battle_controller_opponent.c @@ -0,0 +1,2055 @@ +#include "global.h" +#include "battle.h" +#include "battle_interface.h" +#include "data2.h" +#include "battle_811DA74.h" +#include "battle_anim_813F0F4.h" +#include "link.h" +#include "m4a.h" +#include "main.h" +#include "palette.h" +#include "pokeball.h" +#include "pokemon.h" +#include "rom3.h" +#include "rom_8077ABC.h" +#include "sound.h" +#include "songs.h" +#include "sprite.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "util.h" + +struct UnknownStruct3 +{ + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; +}; + +extern u8 gActiveBank; +extern u8 gBattleBufferA[][0x200]; +extern u16 gBattlePartyID[]; +extern u8 gObjectBankIDs[]; +extern u8 gBattleMonForms[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern void (*gBattleBankFunc[])(void); +extern u8 gUnknown_0300434C[]; +extern u8 gHealthboxIDs[]; +extern u16 gBattleTypeFlags; +extern u16 gTrainerBattleOpponent; +extern u32 *gDisableStructMoveAnim; +extern u32 gMoveDmgMoveAnim; +extern u16 gMovePowerMoveAnim; +extern u8 gHappinessMoveAnim; +extern u16 gWeatherMoveAnim; +extern u32 gPID_perBank[]; +extern u8 gUnknown_0202F7C4; +extern u8 gAnimScriptActive; +extern void (*gAnimScriptCallback)(void); +extern struct Window gUnknown_03004210; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern u8 gDisplayedStringBattle[]; +extern u8 gBankTarget; +extern u8 gAbsentBankFlags; +extern bool8 gDoingBattleAnim; +extern u16 gUnknown_02024DE8; +extern u8 gUnknown_02024E68[]; +extern MainCallback gPreBattleCallback1; +extern void (*const gOpponentBufferCommands[])(void); +extern struct MusicPlayerInfo gMPlay_SE1; +extern struct MusicPlayerInfo gMPlay_SE2; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u32 gBattleExecBuffer; + +extern u8 sub_8077ABC(); +extern u8 sub_8077F68(); +extern u8 sub_8079E90(); +extern void sub_8033018(void); +extern void sub_8031794(); +extern u8 GetBankIdentity(u8); +extern void sub_8032984(u8, u16); +extern void sub_80333D4(void); +extern void sub_80312F0(struct Sprite *); +extern u8 sub_8046400(); +extern void sub_8032A08(); +extern void sub_8043DB0(); +extern void sub_8033160(void); +extern u8 sub_8135FBC(void); +extern u8 get_trainer_class_pic_index(void); +extern void sub_80313A0(struct Sprite *); +extern void sub_8032B4C(void); +extern void sub_8031A6C(u16, u8); +extern void sub_8032B84(void); +extern void sub_8078B34(struct Sprite *); +extern void sub_8032BBC(void); +extern void oamt_add_pos2_onto_pos1(); +extern void oamt_set_x3A_32(); +extern void sub_803311C(void); +extern void sub_8010384(struct Sprite *); +extern bool8 mplay_80342A4(u8); +extern u8 sub_8031720(); +extern void ExecuteMoveAnim(); +extern void sub_80326EC(); +extern void sub_8031F24(void); +extern void sub_80324BC(); +extern void BufferStringBattle(); +extern void sub_80331D0(void); +extern void sub_8036B0C(void); +extern u8 GetBankByPlayerAI(u8); +extern u8 sub_8036CD4(void); +extern void sub_80330C8(void); +extern void sub_8043D84(); +extern void sub_8045A5C(); +void sub_8033494(void); +extern void move_anim_start_t2_for_situation(); +extern void bx_blink_t7(void); +extern void sub_8047858(); +extern u8 GetBankSide(u8); +extern void sub_80E43C0(); +extern void sub_8044CA0(u8); +extern void nullsub_45(void); +extern void sub_8031B74(); +extern bool8 IsDoubleBattle(void); +extern void sub_8032E2C(void); +extern u8 sub_8078874(); +extern u8 move_anim_start_t3(); +extern void sub_80334C0(void); + +// this file's functions + +void OpponentBufferExecCompleted(void); +void OpponentBufferRunCommand(void); +u32 sub_8033598(u8, u8 *); +void sub_8033E24(u8); +void sub_803495C(u8, u8); +void sub_8034B74(void); +void sub_8035238(void); +void sub_8035C10(struct Sprite *); +void sub_8035C44(u8); +void sub_8035E2C(void); +void sub_80332D0(void); + +void OpponentHandleGetAttributes(void); +void OpponentHandlecmd1(void); +void OpponentHandleSetAttributes(void); +void OpponentHandlecmd3(void); +void OpponentHandleLoadPokeSprite(void); +void OpponentHandleSendOutPoke(void); +void OpponentHandleReturnPokeToBall(void); +void OpponentHandleTrainerThrow(void); +void OpponentHandleTrainerSlide(void); +void OpponentHandleTrainerSlideBack(void); +void OpponentHandlecmd10(void); +void OpponentHandlecmd11(void); +void OpponentHandlecmd12(void); +void OpponentHandleBallThrow(void); +void OpponentHandlePuase(void); +void OpponentHandleMoveAnimation(void); +void OpponentHandlePrintString(void); +void OpponentHandlePrintStringPlayerOnly(void); +void OpponentHandlecmd18(void); +void OpponentHandlecmd19(void); +void OpponentHandlecmd20(void); +void OpponentHandleOpenBag(void); +void OpponentHandlecmd22(void); +void OpponentHandlecmd23(void); +void OpponentHandleHealthBarUpdate(void); +void OpponentHandleExpBarUpdate(void); +void OpponentHandleStatusIconUpdate(void); +void OpponentHandleStatusAnimation(void); +void OpponentHandleStatusXor(void); +void OpponentHandlecmd29(void); +void OpponentHandleDMATransfer(void); +void OpponentHandlecmd31(void); +void OpponentHandlecmd32(void); +void OpponentHandlecmd33(void); +void OpponentHandlecmd34(void); +void OpponentHandlecmd35(void); +void OpponentHandlecmd36(void); +void OpponentHandlecmd37(void); +void OpponentHandlecmd38(void); +void OpponentHandlecmd39(void); +void OpponentHandlecmd40(void); +void OpponentHandleHitAnimation(void); +void OpponentHandlecmd42(void); +void OpponentHandleEffectivenessSound(void); +void OpponentHandlecmd44(void); +void OpponentHandleFaintingCry(void); +void OpponentHandleIntroSlide(void); +void OpponentHandleTrainerBallThrow(void); +void OpponentHandlecmd48(void); +void OpponentHandlecmd49(void); +void OpponentHandlecmd50(void); +void OpponentHandleSpriteInvisibility(void); +void OpponentHandleBattleAnimation(void); +void OpponentHandleLinkStandbyMsg(void); +void OpponentHandleResetActionMoveSelection(void); +void OpponentHandlecmd55(void); +void OpponentHandlecmd56(void); + +// const data +typedef void (*BattleBufferCmd) (void); +static const BattleBufferCmd gOpponentBufferCommands[] = +{ + OpponentHandleGetAttributes, + OpponentHandlecmd1, + OpponentHandleSetAttributes, + OpponentHandlecmd3, + OpponentHandleLoadPokeSprite, + OpponentHandleSendOutPoke, + OpponentHandleReturnPokeToBall, + OpponentHandleTrainerThrow, + OpponentHandleTrainerSlide, + OpponentHandleTrainerSlideBack, + OpponentHandlecmd10, + OpponentHandlecmd11, + OpponentHandlecmd12, + OpponentHandleBallThrow, + OpponentHandlePuase, + OpponentHandleMoveAnimation, + OpponentHandlePrintString, + OpponentHandlePrintStringPlayerOnly, + OpponentHandlecmd18, + OpponentHandlecmd19, + OpponentHandlecmd20, + OpponentHandleOpenBag, + OpponentHandlecmd22, + OpponentHandlecmd23, + OpponentHandleHealthBarUpdate, + OpponentHandleExpBarUpdate, + OpponentHandleStatusIconUpdate, + OpponentHandleStatusAnimation, + OpponentHandleStatusXor, + OpponentHandlecmd29, + OpponentHandleDMATransfer, + OpponentHandlecmd31, + OpponentHandlecmd32, + OpponentHandlecmd33, + OpponentHandlecmd34, + OpponentHandlecmd35, + OpponentHandlecmd36, + OpponentHandlecmd37, + OpponentHandlecmd38, + OpponentHandlecmd39, + OpponentHandlecmd40, + OpponentHandleHitAnimation, + OpponentHandlecmd42, + OpponentHandleEffectivenessSound, + OpponentHandlecmd44, + OpponentHandleFaintingCry, + OpponentHandleIntroSlide, + OpponentHandleTrainerBallThrow, + OpponentHandlecmd48, + OpponentHandlecmd49, + OpponentHandlecmd50, + OpponentHandleSpriteInvisibility, + OpponentHandleBattleAnimation, + OpponentHandleLinkStandbyMsg, + OpponentHandleResetActionMoveSelection, + OpponentHandlecmd55, + OpponentHandlecmd56, +}; + +static const u8 sUnknownBytes[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; + +// code + +void nullsub_45(void) +{ +} + +void SetBankFuncToOpponentBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; +} + +void OpponentBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] <= 0x38) + gOpponentBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + OpponentBufferExecCompleted(); + } +} + +void sub_8032B4C(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + OpponentBufferExecCompleted(); +} + +// Duplicate of sub_8032B4C +void sub_8032B84(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + OpponentBufferExecCompleted(); +} + +void sub_8032BBC(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + sub_8031B74(gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam); + gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = gSprites[gObjectBankIDs[gActiveBank]].data5; + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + OpponentBufferExecCompleted(); + } +} + +void sub_8032C4C(void) +{ + if ((--ewram17810[gActiveBank].unk9) == 0xFF) + { + ewram17810[gActiveBank].unk9 = 0; + OpponentBufferExecCompleted(); + } +} + +void sub_8032C88(void) +{ + bool8 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + ewram17810[gActiveBank ^ 2].unk0_7 = 0; + ewram17810[gActiveBank ^ 2].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + m4aMPlayContinue(&gMPlay_BGM); + else + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256); + ewram17810[gActiveBank].unk9 = 3; + gBattleBankFunc[gActiveBank] = sub_8032C4C; + } +} + +void sub_8032E2C(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) + sub_8141828(gActiveBank ^ 2, &gEnemyParty[gBattlePartyID[gActiveBank ^ 2]]); + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank ^ 2], + &gEnemyParty[gBattlePartyID[gActiveBank ^ 2]], + 0); + sub_804777C(gActiveBank ^ 2); + sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); + sub_8032984( + gActiveBank ^ 2, + GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank ^ 2]], MON_DATA_SPECIES)); + } + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank], + &gEnemyParty[gBattlePartyID[gActiveBank]], + 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + sub_8032984( + gActiveBank, + GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + + ewram17840.unk9_0 = 0; + gBattleBankFunc[gActiveBank] = sub_8032C88; + } +} + +void sub_8033018(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].animEnded == TRUE + && gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) + { + if (!ewram17810[gActiveBank].unk0_7) + { + sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + return; + } + if (ewram17810[gActiveBank].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + OpponentBufferExecCompleted(); + return; + } + } +} + +void sub_80330C8(void) +{ + s16 r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); + + sub_8043DFC(gHealthboxIDs[gActiveBank]); + if (r4 != -1) + sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); + else + OpponentBufferExecCompleted(); +} + +void sub_803311C(void) +{ + if (!gSprites[gObjectBankIDs[gActiveBank]].inUse) + { + sub_8043DB0(gHealthboxIDs[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void sub_8033160(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8032A08(gActiveBank); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void sub_80331D0(void) +{ + if (gUnknown_03004210.state == 0) + OpponentBufferExecCompleted(); +} + +void bx_blink_t7(void) +{ + u8 spriteId = gObjectBankIDs[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = 0; + OpponentBufferExecCompleted(); + } + else + { + if (((u16)gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_8033264(void) +{ + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + gBattleBankFunc[gActiveBank] = sub_80332D0; + } +} + +void sub_80332D0(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + CreateTask(c3_0802FDF4, 10); + OpponentBufferExecCompleted(); + } +} + +void sub_8033308(void) +{ + if (ewram17810[gActiveBank].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 0); + sub_8045A5C( + gHealthboxIDs[gActiveBank], + &gEnemyParty[gBattlePartyID[gActiveBank]], + 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + sub_8031F88(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_8033264; + } +} + +void sub_80333D4(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gEnemyParty[gBattlePartyID[gActiveBank]]); + if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy + && !ewram17810[gActiveBank].unk0_3) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_8033308; + } +} + +void sub_8033494(void) +{ + if (!ewram17810[gActiveBank].unk0_4) + OpponentBufferExecCompleted(); +} + +void sub_80334C0(void) +{ + if (!ewram17810[gActiveBank].unk0_5) + OpponentBufferExecCompleted(); +} + +void OpponentBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = OpponentBufferRunCommand; + gBattleExecBuffer &= ~gBitTable[gActiveBank]; +} + +void OpponentHandleGetAttributes(void) +{ + u8 buffer[256]; + int r6 = 0; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + r6 = sub_8033598(gBattlePartyID[gActiveBank], buffer); + } + else + { + u8 r4 = gBattleBufferA[gActiveBank][2]; + + for (i = 0; i < 6; i++) + { + if (r4 & 1) + r6 += sub_8033598(i, buffer + r6); + r4 >>= 1; + } + } + Emitcmd29(1, r6, buffer); + OpponentBufferExecCompleted(); +} + +u32 sub_8033598(u8 a, u8 *buffer) +{ + struct BattlePokemon battlePokemon; + struct UnknownStruct3 moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + battlePokemon.species = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); + battlePokemon.item = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battlePokemon.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); + battlePokemon.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + } + battlePokemon.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + battlePokemon.friendship = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); + battlePokemon.experience = GetMonData(&gEnemyParty[a], MON_DATA_EXP); + battlePokemon.hpIV = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + battlePokemon.attackIV = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + battlePokemon.defenseIV = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + battlePokemon.speedIV = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + battlePokemon.spAttackIV = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + battlePokemon.spDefenseIV = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + battlePokemon.personality = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); + battlePokemon.status1 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); + battlePokemon.level = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); + battlePokemon.hp = GetMonData(&gEnemyParty[a], MON_DATA_HP); + battlePokemon.maxHP = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); + battlePokemon.attack = GetMonData(&gEnemyParty[a], MON_DATA_ATK); + battlePokemon.defense = GetMonData(&gEnemyParty[a], MON_DATA_DEF); + battlePokemon.speed = GetMonData(&gEnemyParty[a], MON_DATA_SPD); + battlePokemon.spAttack = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); + battlePokemon.spDefense = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); + battlePokemon.isEgg = GetMonData(&gEnemyParty[a], MON_DATA_IS_EGG); + battlePokemon.altAbility = GetMonData(&gEnemyParty[a], MON_DATA_ALT_ABILITY); + battlePokemon.otId = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); + GetMonData(&gEnemyParty[a], MON_DATA_NICKNAME, nickname); + StringCopy10(battlePokemon.nickname, nickname); + GetMonData(&gEnemyParty[a], MON_DATA_OT_NAME, battlePokemon.otName); + src = (u8 *)&battlePokemon; + for (size = 0; size < sizeof(battlePokemon); size++) + buffer[size] = src[size]; + break; + case 1: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 2: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 3: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + src = (u8 *)&moveData; + for (size = 0; size < sizeof(moveData); size++) + buffer[size] = src[size]; + break; + case 4: + case 5: + case 6: + case 7: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 8: + for (size = 0; size < 4; size++) + buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); + buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); + size++; + break; + case 9: + case 10: + case 11: + case 12: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); + size = 1; + break; + case 17: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 18: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_EXP); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 19: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_EV); + size = 1; + break; + case 20: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_EV); + size = 1; + break; + case 21: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_EV); + size = 1; + break; + case 22: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_EV); + size = 1; + break; + case 23: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV); + size = 1; + break; + case 24: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV); + size = 1; + break; + case 25: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); + size = 1; + break; + case 26: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKERUS); + size = 1; + break; + case 27: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION); + size = 1; + break; + case 28: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL); + size = 1; + break; + case 29: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_GAME); + size = 1; + break; + case 30: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKEBALL); + size = 1; + break; + case 31: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + buffer[1] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + buffer[2] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + buffer[3] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + buffer[4] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + buffer[5] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + size = 6; + break; + case 32: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); + size = 1; + break; + case 33: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); + size = 1; + break; + case 34: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); + size = 1; + break; + case 35: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); + size = 1; + break; + case 36: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); + size = 1; + break; + case 37: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); + size = 1; + break; + case 38: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 39: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 40: + data32 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 41: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); + size = 1; + break; + case 42: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 43: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 44: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_ATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 45: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_DEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 46: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPD); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 47: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 48: + data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 49: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL); + size = 1; + break; + case 50: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY); + size = 1; + break; + case 51: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE); + size = 1; + break; + case 52: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART); + size = 1; + break; + case 53: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH); + size = 1; + break; + case 54: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SHEEN); + size = 1; + break; + case 55: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON); + size = 1; + break; + case 56: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case 57: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case 58: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON); + size = 1; + break; + case 59: + buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + return size; +} + +void OpponentHandlecmd1(void) +{ + struct BattlePokemon buffer; + u8 *src = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 *dst = (u8 *)&buffer + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = src[i]; + Emitcmd29(1, gBattleBufferA[gActiveBank][2], dst); + OpponentBufferExecCompleted(); +} + +void OpponentHandleSetAttributes(void) +{ + u8 i; + u8 r4; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + sub_8033E24(gBattlePartyID[gActiveBank]); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + sub_8033E24(i); + r4 >>= 1; + } + } + OpponentBufferExecCompleted(); +} + +void sub_8033E24(u8 a) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + { + u8 iv; + + SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); + SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); + } + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); + SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); + SetMonData(&gEnemyParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, (u8 *)&iv); + iv = battlePokemon->attackIV; + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, (u8 *)&iv); + iv = battlePokemon->defenseIV; + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, (u8 *)&iv); + iv = battlePokemon->speedIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, (u8 *)&iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); + SetMonData(&gEnemyParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); + SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); + SetMonData(&gEnemyParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); + SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); + SetMonData(&gEnemyParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); + SetMonData(&gEnemyParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); + SetMonData(&gEnemyParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); + SetMonData(&gEnemyParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); + } + break; + case 1: + SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case 2: + SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case 3: + for (i = 0; i < 4; i++) + { + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); + } + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case 4: + case 5: + case 6: + case 7: + SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); + break; + case 8: + SetMonData(&gEnemyParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case 9: + case 10: + case 11: + case 12: + SetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); + break; + case 17: + SetMonData(&gEnemyParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case 18: + SetMonData(&gEnemyParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case 19: + SetMonData(&gEnemyParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 20: + SetMonData(&gEnemyParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 21: + SetMonData(&gEnemyParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 22: + SetMonData(&gEnemyParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 23: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 24: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 25: + SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case 26: + SetMonData(&gEnemyParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case 27: + SetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case 28: + SetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 29: + SetMonData(&gEnemyParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case 30: + SetMonData(&gEnemyParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case 31: + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case 32: + SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 33: + SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 34: + SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 35: + SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 36: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 37: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 38: + SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case 39: + SetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case 40: + SetMonData(&gEnemyParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case 41: + SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 42: + SetMonData(&gEnemyParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 43: + SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 44: + SetMonData(&gEnemyParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case 45: + SetMonData(&gEnemyParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case 46: + SetMonData(&gEnemyParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case 47: + SetMonData(&gEnemyParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case 48: + SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case 49: + SetMonData(&gEnemyParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case 50: + SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case 51: + SetMonData(&gEnemyParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case 52: + SetMonData(&gEnemyParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case 53: + SetMonData(&gEnemyParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case 54: + SetMonData(&gEnemyParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case 55: + SetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 56: + SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 57: + SetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 58: + SetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 59: + SetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } +} + +void OpponentHandlecmd3(void) +{ + u8 *dst; + u8 i; + + dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + OpponentBufferExecCompleted(); +} + +void OpponentHandleLoadPokeSprite(void) +{ + u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(gActiveBank, 2), + sub_8077F68(gActiveBank), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].data2 = species; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); + sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); + gBattleBankFunc[gActiveBank] = sub_8033018; +} + +void OpponentHandleSendOutPoke(void) +{ + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + + sub_803495C(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_80333D4; +} + +void sub_803495C(u8 a, u8 b) +{ + u16 species; + + sub_8032AA8(a, b); + gBattlePartyID[a] = gBattleBufferA[a][1]; + species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); + gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); + sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); + gObjectBankIDs[a] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(a, 2), + sub_8077F68(a), + sub_8079E90(a)); + gSprites[gObjectBankIDs[a]].data0 = a; + gSprites[gObjectBankIDs[a]].data2 = species; + gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; + gSprites[gObjectBankIDs[a]].oam.paletteNum = a; + StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); + gSprites[gObjectBankIDs[a]].invisible = TRUE; + gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; + gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFE); +} + +void OpponentHandleReturnPokeToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_8034B74; + } + else + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8032A08(gActiveBank); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + OpponentBufferExecCompleted(); + } +} + +void sub_8034B74(void) +{ + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 2); + gBattleBankFunc[gActiveBank] = sub_8033160; + } + break; + } +} + +void OpponentHandleTrainerThrow(void) +{ + u32 trainerPicIndex; + + if (gTrainerBattleOpponent == 0x400) + trainerPicIndex = GetSecretBaseTrainerPicIndex(); + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + trainerPicIndex = get_trainer_class_pic_index(); + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + trainerPicIndex = sub_8135FBC(); + else + trainerPicIndex = gTrainers[gTrainerBattleOpponent].trainerPic; + + sub_8031A6C(trainerPicIndex, gActiveBank); + GetMonSpriteTemplate_803C5A0(trainerPicIndex, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 0xB0, + 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicIndex].coords), + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicIndex].tag); + gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; + gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[trainerPicIndex].tag); + gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = trainerPicIndex; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_8032B4C; +} + +void OpponentHandleTrainerSlide(void) +{ + u32 trainerPicIndex; + + if (gTrainerBattleOpponent == 0x400) + trainerPicIndex = GetSecretBaseTrainerPicIndex(); + else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) + trainerPicIndex = get_trainer_class_pic_index(); + else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) + trainerPicIndex = sub_8135FBC(); + else + trainerPicIndex = gTrainers[gTrainerBattleOpponent].trainerPic; + + sub_8031A6C(trainerPicIndex, gActiveBank); + GetMonSpriteTemplate_803C5A0(trainerPicIndex, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 0xB0, + 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicIndex].coords), + 0x1E); + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 96; + gSprites[gObjectBankIDs[gActiveBank]].pos1.x += 32; + gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicIndex].tag); + gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; + gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[trainerPicIndex].tag); + gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = trainerPicIndex; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_8032B84; +} + +void OpponentHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); + gBattleBankFunc[gActiveBank] = sub_8032BBC; +} + +void OpponentHandlecmd10(void) +{ + if (ewram17810[gActiveBank].unk4 == 0) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4++; + } + else if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + PlaySE12WithPanning(SE_POKE_DEAD, 63); + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8010384; + gBattleBankFunc[gActiveBank] = sub_803311C; + } +} + +void OpponentHandlecmd11(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd12(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleBallThrow(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlePuase(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u32 r0 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + + gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; + gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] + | (gBattleBufferA[gActiveBank][5] << 8); + gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] + | (gBattleBufferA[gActiveBank][7] << 8) + | (gBattleBufferA[gActiveBank][8] << 16) + | (gBattleBufferA[gActiveBank][9] << 24); + gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] + | (gBattleBufferA[gActiveBank][13] << 8); + gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; + gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; + + // Dead code. sub_8031720 always returns 0. + if (sub_8031720(r0, gUnknown_0202F7C4) != 0) + { + OpponentBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_8035238; + } + } +} + +void sub_8035238(void) +{ + u16 r4 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8); + u8 r7 = gBattleBufferA[gActiveBank][11]; + + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + { + ewram17800[gActiveBank].unk0_3 = 1; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + } + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_80326EC(0); + ExecuteMoveAnim(r4); + ewram17810[gActiveBank].unk4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_80326EC(1); + if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + ewram17800[gActiveBank].unk0_3 = 0; + } + ewram17810[gActiveBank].unk4 = 3; + } + break; + case 3: + if (!ewram17810[gActiveBank].unk0_6) + { + sub_8031F24(); + sub_80324BC( + gActiveBank, + gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + ewram17810[gActiveBank].unk4 = 0; + OpponentBufferExecCompleted(); + } + break; + } +} + +void OpponentHandlePrintString(void) +{ + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); + sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); + gBattleBankFunc[gActiveBank] = sub_80331D0; +} + +void OpponentHandlePrintStringPlayerOnly(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd18(void) +{ + sub_8036B0C(); + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd19(void) +{ + OpponentBufferExecCompleted(); +} + +#ifdef NONMATCHING +void OpponentHandlecmd20(void) +{ + u16 r4; + // Needed to match closer + struct {u16 moves[4];} *r5 = (void *)&gBattleBufferA[gActiveBank][4]; + + if (gBattleTypeFlags & 0x498) + { + BattleAI_SetupAIData(); + r4 = BattleAI_GetAIActionToUse(); + switch (r4) + { + case 5: + Emitcmd33(1, 4, 0); + break; + case 4: + Emitcmd33(1, 3, 0); + break; + default: + if (gBattleMoves[r5->moves[r4]].target & 0x12) + gBankTarget = gActiveBank; + if (gBattleMoves[r5->moves[r4]].target & 8) + { + gBankTarget = GetBankByPlayerAI(0); + if (gAbsentBankFlags & gBitTable[gBankTarget]) + gBankTarget = GetBankByPlayerAI(2); + } + r4 |= gBankTarget << 8; + Emitcmd33(1, 10, r4); + break; + } + OpponentBufferExecCompleted(); + } + else + { + u16 r2; + + do + { + // Can't for the life of me get this to match. + r4 = Random() % 4; + r2 = r5->moves[r4]; + } while (r2 == 0); + + if (gBattleMoves[r2].target & 0x12) + { + r4 |= gActiveBank << 8; + Emitcmd33(1, 10, r4); + } + else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + { + u16 r2 = GetBankByPlayerAI(Random() & 2) << 8; + + Emitcmd33(1, 10, r4 | r2); + } + else + { + u16 r2 = GetBankByPlayerAI(0) << 8; + + Emitcmd33(1, 10, r4 | r2); + } + OpponentBufferExecCompleted(); + } +} +#else +__attribute__((naked)) +void OpponentHandlecmd20(void) +{ + asm(".syntax unified\n\ + push {r4-r6,lr}\n\ + ldr r6, _0803545C @ =gActiveBank\n\ + ldrb r0, [r6]\n\ + lsls r0, 9\n\ + ldr r1, _08035460 @ =gUnknown_02023A64\n\ + adds r5, r0, r1\n\ + ldr r0, _08035464 @ =gBattleTypeFlags\n\ + ldrh r1, [r0]\n\ + movs r0, 0x93\n\ + lsls r0, 3\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080354F8\n\ + bl BattleAI_SetupAIData\n\ + bl BattleAI_GetAIActionToUse\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + cmp r4, 0x4\n\ + beq _08035468\n\ + cmp r4, 0x5\n\ + bne _08035474\n\ + movs r0, 0x1\n\ + movs r1, 0x4\n\ + b _0803546C\n\ + .align 2, 0\n\ +_0803545C: .4byte gActiveBank\n\ +_08035460: .4byte gUnknown_02023A64\n\ +_08035464: .4byte gBattleTypeFlags\n\ +_08035468:\n\ + movs r0, 0x1\n\ + movs r1, 0x3\n\ +_0803546C:\n\ + movs r2, 0\n\ + bl Emitcmd33\n\ + b _080354E0\n\ +_08035474:\n\ + ldr r3, _080354E8 @ =gBattleMoves\n\ + lsls r0, r4, 1\n\ + adds r2, r5, r0\n\ + ldrh r1, [r2]\n\ + lsls r0, r1, 1\n\ + adds r0, r1\n\ + lsls r0, 2\n\ + adds r0, r3\n\ + ldrb r1, [r0, 0x6]\n\ + movs r0, 0x12\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08035494\n\ + ldr r1, _080354EC @ =gBankTarget\n\ + ldrb r0, [r6]\n\ + strb r0, [r1]\n\ +_08035494:\n\ + ldrh r1, [r2]\n\ + lsls r0, r1, 1\n\ + adds r0, r1\n\ + lsls r0, 2\n\ + adds r0, r3\n\ + ldrb r1, [r0, 0x6]\n\ + movs r0, 0x8\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080354CE\n\ + movs r0, 0\n\ + bl GetBankByPlayerAI\n\ + ldr r5, _080354EC @ =gBankTarget\n\ + strb r0, [r5]\n\ + ldr r0, _080354F0 @ =gAbsentBankFlags\n\ + ldrb r1, [r0]\n\ + ldr r2, _080354F4 @ =gBitTable\n\ + ldrb r0, [r5]\n\ + lsls r0, 2\n\ + adds r0, r2\n\ + ldr r0, [r0]\n\ + ands r1, r0\n\ + cmp r1, 0\n\ + beq _080354CE\n\ + movs r0, 0x2\n\ + bl GetBankByPlayerAI\n\ + strb r0, [r5]\n\ +_080354CE:\n\ + ldr r0, _080354EC @ =gBankTarget\n\ + ldrb r0, [r0]\n\ + lsls r0, 8\n\ + orrs r4, r0\n\ + movs r0, 0x1\n\ + movs r1, 0xA\n\ + adds r2, r4, 0\n\ + bl Emitcmd33\n\ +_080354E0:\n\ + bl OpponentBufferExecCompleted\n\ + b _0803558A\n\ + .align 2, 0\n\ +_080354E8: .4byte gBattleMoves\n\ +_080354EC: .4byte gBankTarget\n\ +_080354F0: .4byte gAbsentBankFlags\n\ +_080354F4: .4byte gBitTable\n\ +_080354F8:\n\ + movs r6, 0x3\n\ +_080354FA:\n\ + bl Random\n\ + adds r4, r0, 0\n\ + ands r4, r6\n\ + lsls r0, r4, 1\n\ + adds r0, r5, r0\n\ + ldrh r2, [r0]\n\ + cmp r2, 0\n\ + beq _080354FA\n\ + ldr r1, _08035534 @ =gBattleMoves\n\ + lsls r0, r2, 1\n\ + adds r0, r2\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x6]\n\ + movs r0, 0x12\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _0803553C\n\ + ldr r0, _08035538 @ =gActiveBank\n\ + ldrb r0, [r0]\n\ + lsls r0, 8\n\ + orrs r4, r0\n\ + movs r0, 0x1\n\ + movs r1, 0xA\n\ + adds r2, r4, 0\n\ + bl Emitcmd33\n\ + b _08035586\n\ + .align 2, 0\n\ +_08035534: .4byte gBattleMoves\n\ +_08035538: .4byte gActiveBank\n\ +_0803553C:\n\ + ldr r0, _0803556C @ =gBattleTypeFlags\n\ + ldrh r1, [r0]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08035570\n\ + bl Random\n\ + movs r1, 0x2\n\ + ands r1, r0\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + adds r0, r1, 0\n\ + bl GetBankByPlayerAI\n\ + adds r2, r0, 0\n\ + lsls r2, 24\n\ + lsrs r2, 16\n\ + orrs r2, r4\n\ + movs r0, 0x1\n\ + movs r1, 0xA\n\ + bl Emitcmd33\n\ + b _08035586\n\ + .align 2, 0\n\ +_0803556C: .4byte gBattleTypeFlags\n\ +_08035570:\n\ + movs r0, 0\n\ + bl GetBankByPlayerAI\n\ + adds r2, r0, 0\n\ + lsls r2, 24\n\ + lsrs r2, 16\n\ + orrs r2, r4\n\ + movs r0, 0x1\n\ + movs r1, 0xA\n\ + bl Emitcmd33\n\ +_08035586:\n\ + bl OpponentBufferExecCompleted\n\ +_0803558A:\n\ + pop {r4-r6}\n\ + pop {r0}\n\ + bx r0\n\ + .syntax divided\n"); +} +#endif + +void OpponentHandleOpenBag(void) +{ + // What is this? + Emitcmd35(1, ewram[0x160D4 + gActiveBank / 2 * 2]); + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd22(void) +{ + s32 r4; + + if (ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2] == 6) + { + u8 r6; + u8 r5; + + r4 = sub_8036CD4(); + if (r4 == 6) + { + if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) + { + r5 = GetBankByPlayerAI(1); + r6 = r5; + } + else + { + r6 = GetBankByPlayerAI(1); + r5 = GetBankByPlayerAI(3); + } + for (r4 = 0; r4 < 6; r4++) + { + if (GetMonData(&gEnemyParty[r4], MON_DATA_HP) != 0 + && r4 != gBattlePartyID[r6] + && r4 != gBattlePartyID[r5]) + break; + } + } + } + else + { + r4 = ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2]; + ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2] = 6; + } + ewram[0x16068 + gActiveBank] = r4; + Emitcmd34(1, r4, 0); + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd23(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleHealthBarUpdate(void) +{ + s16 r7; + + load_gfxc_health_bar(0); + r7 = (gBattleBufferA[gActiveBank][3] << 8) | gBattleBufferA[gActiveBank][2]; + if (r7 != 0x7FFF) + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 hp = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); + } + else + { + u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); + } + gBattleBankFunc[gActiveBank] = sub_80330C8; +} + +void OpponentHandleExpBarUpdate(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleStatusIconUpdate(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + sub_8045A5C(gHealthboxIDs[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], 9); + ewram17810[gActiveBank].unk0_4 = 0; + gBattleBankFunc[gActiveBank] = sub_8033494; + } +} + +void OpponentHandleStatusAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + move_anim_start_t2_for_situation( + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] + | (gBattleBufferA[gActiveBank][3] << 8) + | (gBattleBufferA[gActiveBank][4] << 16) + | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = sub_8033494; + } +} + +void OpponentHandleStatusXor(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd29(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleDMATransfer(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd31(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd32(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd33(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd34(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd35(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd36(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd37(void) +{ + gUnknown_020238C8.unk0_0 = 0; + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd38(void) +{ + gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd39(void) +{ + gUnknown_020238C8.unk0_7 = 0; + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd40(void) +{ + gUnknown_020238C8.unk0_7 ^= 1; + OpponentBufferExecCompleted(); +} + +void OpponentHandleHitAnimation(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) + { + OpponentBufferExecCompleted(); + } + else + { + gDoingBattleAnim = TRUE; + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + sub_8047858(gActiveBank); + gBattleBankFunc[gActiveBank] = bx_blink_t7; + } +} + +void OpponentHandlecmd42(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == 0) + pan = -64; + else + pan = 63; + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd44(void) +{ + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + OpponentBufferExecCompleted(); +} + +void OpponentHandleFaintingCry(void) +{ + PlayCry3( + GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), + 25, 5); + OpponentBufferExecCompleted(); +} + +void OpponentHandleIntroSlide(void) +{ + sub_80E43C0(gBattleBufferA[gActiveBank][1]); + gUnknown_02024DE8 |= 1; + OpponentBufferExecCompleted(); +} + +void OpponentHandleTrainerBallThrow(void) +{ + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8035C10); + taskId = CreateTask(sub_8035C44, 5); + gTasks[taskId].data[0] = gActiveBank; + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + ewram17840.unk9_0 = 1; + gBattleBankFunc[gActiveBank] = nullsub_45; +} + +void sub_8035C10(struct Sprite *sprite) +{ + sub_8031B74(sprite->oam.affineParam); + sprite->oam.tileNum = sprite->data5; + FreeSpriteOamMatrix(sprite); + DestroySprite(sprite); +} + +void sub_8035C44(u8 taskId) +{ + u8 r9; + + r9 = gActiveBank; + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_803495C(gActiveBank, 0); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_803495C(gActiveBank, 0); + gActiveBank ^= 2; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_803495C(gActiveBank, 0); + gActiveBank ^= 2; + } + gBattleBankFunc[gActiveBank] = sub_8032E2C; + gActiveBank = r9; + DestroyTask(taskId); +} + +void OpponentHandlecmd48(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) + { + OpponentBufferExecCompleted(); + return; + } + + ewram17810[gActiveBank].unk0_0 = 1; + if (gBattleBufferA[gActiveBank][2] != 0) + { + if (ewram17810[gActiveBank].unk1_1 < 2) + { + ewram17810[gActiveBank].unk1_1++; + return; + } + else + { + ewram17810[gActiveBank].unk1_1 = 0; + } + } + gUnknown_02024E68[gActiveBank] = sub_8044804( + gActiveBank, + (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2]); + ewram17810[gActiveBank].unk5 = 0; + if (gBattleBufferA[gActiveBank][2] != 0) + ewram17810[gActiveBank].unk5 = 0x5D; + gBattleBankFunc[gActiveBank] = sub_8035E2C; +} + +void sub_8035E2C(void) +{ + if (ewram17810[gActiveBank].unk5++ >= 93) + { + ewram17810[gActiveBank].unk5 = 0; + OpponentBufferExecCompleted(); + } +} + +void OpponentHandlecmd49(void) +{ + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd50(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleSpriteInvisibility(void) +{ + if (sub_8078874(gActiveBank) != 0) + { + gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + sub_8031F88(gActiveBank); + } + OpponentBufferExecCompleted(); +} + +void OpponentHandleBattleAnimation(void) +{ + if (mplay_80342A4(gActiveBank) == 0) + { + u8 r3 = gBattleBufferA[gActiveBank][1]; + u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) + OpponentBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = sub_80334C0; + } +} + +void OpponentHandleLinkStandbyMsg(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandleResetActionMoveSelection(void) +{ + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd55(void) +{ + if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) + { + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + OpponentBufferExecCompleted(); +} + +void OpponentHandlecmd56(void) +{ +} diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c new file mode 100644 index 000000000..a537d9adb --- /dev/null +++ b/src/battle_controller_player.c @@ -0,0 +1,3066 @@ +#include "global.h" +#include "data2.h" +#include "battle.h" +#include "battle_interface.h" +#include "battle_message.h" +#include "item.h" +#include "items.h" +#include "link.h" +#include "m4a.h" +#include "main.h" +#include "menu_cursor.h" +#include "moves.h" +#include "palette.h" +#include "pokemon.h" +#include "rom3.h" +#include "songs.h" +#include "sound.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "util.h" + +//Possibly PokemonSubstruct1 +struct UnknownStruct3 +{ + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; +}; + +#if ENGLISH +#define SUB_803037C_TILE_DATA_OFFSET 440 +#elif GERMAN +#define SUB_803037C_TILE_DATA_OFFSET 444 +#endif + +extern u16 gUnknown_030042A4; +extern u16 gUnknown_030042A0; + +extern struct Window gUnknown_03004210; + +extern void (*gBattleBankFunc[])(void); + +extern u8 gActiveBank; +extern u8 gActionSelectionCursor[]; +extern u8 gDisplayedStringBattle[]; +extern u8 gMoveSelectionCursor[]; +extern u8 gBattleBufferA[][0x200]; +extern u8 gBankInMenu; +extern u16 gBattlePartyID[]; +extern u8 gHealthboxIDs[]; +extern u8 gDoingBattleAnim; +extern u8 gObjectBankIDs[]; +extern u16 gBattleTypeFlags; +extern u8 gBattleOutcome; +extern void (*gAnimScriptCallback)(void); +extern bool8 gAnimScriptActive; +extern u16 gMovePowerMoveAnim; +extern u32 gMoveDmgMoveAnim; +extern u8 gHappinessMoveAnim; +extern u16 gWeatherMoveAnim; +extern u32 *gDisableStructMoveAnim; +extern u32 gPID_perBank[]; +extern u8 gBattleMonForms[]; +extern u16 gUnknown_02024DE8; +extern u8 gUnknown_02024E68[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern u8 gUnknown_0202F7C4; +extern u8 gUnknown_02038470[]; +extern u16 gUnknown_030041B0; +extern u16 gUnknown_030041B4; +extern u16 gUnknown_030041B8; +extern u16 gUnknown_03004280; +extern u16 gUnknown_03004288; +extern u16 gUnknown_030042A4; +extern u16 gUnknown_030042C0; +extern u8 gUnknown_03004344; +extern u8 gUnknown_0300434C[]; + +extern const u8 gUnknown_08400CA8[]; +extern const u8 gUnknown_08400CF3[]; +extern const u8 gUnknown_08400D38[]; + +extern void sub_802C68C(void); +extern void sub_802E1B0(void); +extern void sub_802E220(); +extern void sub_802E2D4(); +extern void sub_802E004(void); +extern void sub_802DF30(void); +extern void BattleMusicStop(void); +extern void PlayerBufferExecCompleted(void); +extern void bx_t1_healthbar_update(void); +extern void nullsub_91(void); +extern void sub_802D924(u8); +extern void sub_802E434(void); +extern bool8 mplay_80342A4(u8); +extern void move_anim_start_t2_for_situation(); +extern void bx_blink_t1(void); +extern void sub_8047858(); +extern u8 GetBankSide(u8); +extern void sub_80E43C0(); +extern void oamt_add_pos2_onto_pos1(); +extern void sub_8078B34(struct Sprite *); +extern void oamt_set_x3A_32(); +extern void sub_80318FC(); +extern bool8 IsDoubleBattle(void); +extern void sub_802D500(void); +extern bool8 sub_8078874(u8); +extern bool8 move_anim_start_t3(); +extern void sub_802E460(void); +extern void b_link_standby_message(void); +extern void sub_802D18C(void); +extern void sub_802DF18(void); +extern void BufferStringBattle(); +extern void sub_80326EC(); +extern void ExecuteMoveAnim(); +extern void sub_8031F24(void); +extern void sub_80324BC(); +extern u8 sub_8031720(); +extern void bx_wait_t1(void); +extern u8 GetBankByPlayerAI(u8); +extern void sub_802DE10(void); +extern void sub_80105EC(struct Sprite *); +extern void sub_802D274(void); +extern void sub_802D23C(void); +extern u8 GetBankIdentity(u8); +extern void sub_8031AF4(); +extern void sub_80313A0(struct Sprite *); +extern void sub_802D204(void); +extern u8 sub_8079E90(); +extern void sub_802DEAC(void); +extern void sub_80312F0(struct Sprite *); +extern u8 sub_8077ABC(); +extern u8 sub_8077F68(); +extern u8 sub_8046400(); +extern void sub_802D798(void); +extern void bx_0802E404(void); +extern u8 gActiveBank; +extern void (*gBattleBankFunc[])(void); +extern bool8 gDoingBattleAnim; +extern u16 gBattleTypeFlags; +extern u32 gBattleExecBuffer; +extern u8 gBattleBufferA[][0x200]; +extern u8 gObjectBankIDs[]; +extern u8 gActionSelectionCursor[]; +extern u8 gMoveSelectionCursor[]; +extern u8 gAbsentBankFlags; +extern u8 gUnknown_03004344; +extern u8 gNoOfAllBanks; +extern u16 gBattlePartyID[]; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern struct Window gUnknown_03004210; +extern const u8 gUnknown_08400D89[]; +extern u8 gUnknown_03004348; +extern struct BattlePokemon gBattleMons[]; +extern MainCallback gPreBattleCallback1; +extern u8 gHealthboxIDs[]; +extern struct MusicPlayerInfo gMPlay_BGM; +extern u8 gUnknown_0300434C[]; +extern u8 gUnknown_0202E8F4; +extern u8 gUnknown_0202E8F5; +extern u8 gUnknown_02038470[]; +extern u16 gScriptItemId; +extern u8 gDisplayedStringBattle[]; +extern const u8 gUnknown_08400CE0[]; + +extern void dp11b_obj_instanciate(u8, u8, s8, s8); +extern u8 GetBankIdentity(u8); +extern u8 GetBankByPlayerAI(u8); +extern void dp11b_obj_free(u8, u8); +extern void sub_8010520(struct Sprite *); +extern void sub_8010574(struct Sprite *); +extern bool8 IsDoubleBattle(); +extern void sub_804777C(); +extern void sub_8141828(); +extern void sub_8094E20(u8); +extern void nullsub_14(void); +extern void sub_80A6DCC(void); +extern void ReshowBattleScreenAfterMenu(void); + +void PlayerHandleGetAttributes(void); +void PlayerHandlecmd1(void); +void PlayerHandleSetAttributes(void); +void PlayerHandlecmd3(void); +void PlayerHandleLoadPokeSprite(void); +void PlayerHandleSendOutPoke(void); +void PlayerHandleReturnPokeToBall(void); +void PlayerHandleTrainerThrow(void); +void PlayerHandleTrainerSlide(void); +void PlayerHandleTrainerSlideBack(void); +void PlayerHandlecmd10(void); +void PlayerHandlecmd11(void); +void PlayerHandlecmd12(void); +void PlayerHandleBallThrow(void); +void PlayerHandlePuase(void); +void PlayerHandleMoveAnimation(void); +void PlayerHandlePrintString(void); +void PlayerHandlePrintStringPlayerOnly(void); +void PlayerHandlecmd18(void); +void PlayerHandlecmd19(void); +void PlayerHandlecmd20(void); +void PlayerHandleOpenBag(void); +void PlayerHandlecmd22(void); +void PlayerHandlecmd23(void); +void PlayerHandleHealthBarUpdate(void); +void PlayerHandleExpBarUpdate(void); +void PlayerHandleStatusIconUpdate(void); +void PlayerHandleStatusAnimation(void); +void PlayerHandleStatusXor(void); +void PlayerHandlecmd29(void); +void PlayerHandleDMATransfer(void); +void PlayerHandlecmd31(void); +void PlayerHandlecmd32(void); +void PlayerHandlecmd33(void); +void PlayerHandlecmd34(void); +void PlayerHandlecmd35(void); +void PlayerHandlecmd36(void); +void PlayerHandlecmd37(void); +void PlayerHandlecmd38(void); +void PlayerHandlecmd39(void); +void PlayerHandlecmd40(void); +void PlayerHandleHitAnimation(void); +void PlayerHandlecmd42(void); +void PlayerHandleEffectivenessSound(void); +void PlayerHandlecmd44(void); +void PlayerHandleFaintingCry(void); +void PlayerHandleIntroSlide(void); +void PlayerHandleTrainerBallThrow(void); +void PlayerHandlecmd48(void); +void PlayerHandlecmd49(void); +void PlayerHandlecmd50(void); +void PlayerHandleSpriteInvisibility(void); +void PlayerHandleBattleAnimation(void); +void PlayerHandleLinkStandbyMsg(void); +void PlayerHandleResetActionMoveSelection(void); +void PlayerHandlecmd55(void); +void PlayerHandlecmd56(void); + +const u8 gString_TurnJP[] = _("ターン"); + +void (*const gPlayerBufferCommands[])(void) = +{ + PlayerHandleGetAttributes, + PlayerHandlecmd1, + PlayerHandleSetAttributes, + PlayerHandlecmd3, + PlayerHandleLoadPokeSprite, + PlayerHandleSendOutPoke, + PlayerHandleReturnPokeToBall, + PlayerHandleTrainerThrow, + PlayerHandleTrainerSlide, + PlayerHandleTrainerSlideBack, + PlayerHandlecmd10, + PlayerHandlecmd11, + PlayerHandlecmd12, + PlayerHandleBallThrow, + PlayerHandlePuase, + PlayerHandleMoveAnimation, + PlayerHandlePrintString, + PlayerHandlePrintStringPlayerOnly, + PlayerHandlecmd18, + PlayerHandlecmd19, + PlayerHandlecmd20, + PlayerHandleOpenBag, + PlayerHandlecmd22, + PlayerHandlecmd23, + PlayerHandleHealthBarUpdate, + PlayerHandleExpBarUpdate, + PlayerHandleStatusIconUpdate, + PlayerHandleStatusAnimation, + PlayerHandleStatusXor, + PlayerHandlecmd29, + PlayerHandleDMATransfer, + PlayerHandlecmd31, + PlayerHandlecmd32, + PlayerHandlecmd33, + PlayerHandlecmd34, + PlayerHandlecmd35, + PlayerHandlecmd36, + PlayerHandlecmd37, + PlayerHandlecmd38, + PlayerHandlecmd39, + PlayerHandlecmd40, + PlayerHandleHitAnimation, + PlayerHandlecmd42, + PlayerHandleEffectivenessSound, + PlayerHandlecmd44, + PlayerHandleFaintingCry, + PlayerHandleIntroSlide, + PlayerHandleTrainerBallThrow, + PlayerHandlecmd48, + PlayerHandlecmd49, + PlayerHandlecmd50, + PlayerHandleSpriteInvisibility, + PlayerHandleBattleAnimation, + PlayerHandleLinkStandbyMsg, + PlayerHandleResetActionMoveSelection, + PlayerHandlecmd55, + PlayerHandlecmd56, +}; + +void PlayerBufferRunCommand(void); +void sub_802C2EC(void); +void sub_802C68C(void); +void sub_802CA60(void); +void sub_802D730(void); +void sub_802DA9C(u8); +void sub_802DB6C(u8); +void sub_802DCB0(u8); +void sub_802DD10(u8); +void sub_802DDC4(u8); +void sub_802DF88(void); +void sub_802E03C(void); +void sub_802E12C(s32, const u8 *); +void sub_802E1B0(void); +void sub_802E220(void); +void sub_802E2D4(void); +void sub_802E3B4(u8, int); +void nullsub_7(u8); +void b_link_standby_message(void); +u32 dp01_getattr_by_ch1_for_player_pokemon_(u8, u8 *); +void dp01_setattr_by_ch1_for_player_pokemon(u8); +void sub_802F934(u8, u8); +void sub_802FB2C(void); +void sub_8030190(void); +void sub_80304A8(void); +void sub_8030E38(struct Sprite *); +void task05_08033660(u8); +void sub_8031064(void); + +void nullsub_91(void) +{ +} + +void SetBankFuncToPlayerBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + gDoingBattleAnim = FALSE; +} + +void PlayerBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = PlayerBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 playerId = GetMultiplayerId(); + + dp01_prepare_buffer_wireless_probably(2, 4, &playerId); + gBattleBufferA[gActiveBank][0] = 0x38; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void PlayerBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < 0x39) + gPlayerBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + PlayerBufferExecCompleted(); + } +} + +void bx_0802E404(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) + PlayerBufferExecCompleted(); +} + +void sub_802C098(void) +{ + u16 itemId = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + if (gMain.newKeys & A_BUTTON) + { + PlaySE(SE_SELECT); + DestroyMenuCursor(); + + // Useless switch statement. + switch (gActionSelectionCursor[gActiveBank]) + { + case 0: + Emitcmd33(1, 0, 0); + break; + case 1: + Emitcmd33(1, 1, 0); + break; + case 2: + Emitcmd33(1, 2, 0); + break; + case 3: + Emitcmd33(1, 3, 0); + break; + } + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gActionSelectionCursor[gActiveBank] & 1) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gActionSelectionCursor[gActiveBank] & 1)) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 1; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gActionSelectionCursor[gActiveBank] & 2) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gActionSelectionCursor[gActiveBank] & 2)) + { + PlaySE(SE_SELECT); + nullsub_8(gActionSelectionCursor[gActiveBank]); + gActionSelectionCursor[gActiveBank] ^= 2; + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + } + } + else if (gMain.newKeys & B_BUTTON) + { + if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) + && GetBankIdentity(gActiveBank) == 2 + && !(gAbsentBankFlags & gBitTable[GetBankByPlayerAI(0)]) + && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + if (gBattleBufferA[gActiveBank][1] == 1) + { + // Add item to bag if it is a ball + if (itemId <= ITEM_PREMIER_BALL) + AddBagItem(itemId, 1); + else + return; + } + PlaySE(SE_SELECT); + Emitcmd33(1, 12, 0); + PlayerBufferExecCompleted(); + DestroyMenuCursor(); + } + } + else if (gMain.newKeys & START_BUTTON) + { + sub_804454C(); + } +} + +void unref_sub_802C2B8(void) +{ + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + gBattleBankFunc[gActiveBank] = sub_802C2EC; +} + +// TODO: fix this function +void sub_802C2EC(void) +{ + u8 arr[4] = {0, 2, 3, 1}; + s32 i; + + dp11b_obj_instanciate(gUnknown_03004344, 1, 15, 1); + i = 0; + if (gNoOfAllBanks != 0) + { + do + { + if (i != gUnknown_03004344) + dp11b_obj_free(i, 1); + i++; + } while (i < gNoOfAllBanks); + } + if (gMain.newKeys & A_BUTTON) + { + DestroyMenuCursor(); + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + Emitcmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); + dp11b_obj_free(gUnknown_03004344, 1); + PlayerBufferExecCompleted(); + } + //_0802C3A8 + else if (gMain.newKeys & B_BUTTON) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + gBattleBankFunc[gActiveBank] = sub_802C68C; + dp11b_obj_instanciate(gActiveBank, 1, 7, 1); + dp11b_obj_instanciate(gActiveBank, 0, 7, 1); + dp11b_obj_free(gUnknown_03004344, 1); + } + else if (gMain.newKeys & 0x60) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + do + { + u8 var = GetBankIdentity(gUnknown_03004344); + + for (i = 0; i < 4; i++) + { + if (var == arr[i]) + break; + } + do + { + i--; + if (i < 0) + i = 3; + gUnknown_03004344 = GetBankByPlayerAI(arr[i]); + } while(gUnknown_03004344 == gNoOfAllBanks); + i = 0; + switch (GetBankIdentity(gUnknown_03004344)) + { + case 0: + case 2: + if (gActiveBank == gUnknown_03004344) + { + u32 moveId; + + asm("":::"memory"); + moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); + if (!(gBattleMoves[moveId].target & 2)) + break; + } + i++; + break; + case 1: + case 3: + i++; + } + //_0802C500 + if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) + i = 0; + } while (i == 0); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } + //_0802C540 + else if (gMain.newKeys & 0x90) + { + PlaySE(SE_SELECT); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010574; + do + { + u8 var = GetBankIdentity(gUnknown_03004344); + + for (i = 0; i < 4; i++) + { + if (var == arr[i]) + break; + } + do + { + i++; + if (i > 3) + i = 0; + gUnknown_03004344 = GetBankByPlayerAI(arr[i]); + } while (gUnknown_03004344 == gNoOfAllBanks); + i = 0; + switch (GetBankIdentity(gUnknown_03004344)) + { + case 0: + case 2: + if (gActiveBank == gUnknown_03004344) + { + u32 moveId; + + asm("":::"memory"); + moveId = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + gMoveSelectionCursor[gActiveBank]); + if (!(gBattleMoves[moveId].target & 2)) + break; + } + i++; + break; + case 1: + case 3: + i++; + } + if (gAbsentBankFlags & gBitTable[gUnknown_03004344]) + i = 0; + } while (i == 0); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } +} + +struct UnknownStruct1 +{ + u16 moves[4]; + u8 pp[4]; + u8 unkC[0x12-0xC]; + u8 unk12; + u8 unk13; + u8 filler14[0x20-0x14]; +}; + +const u8 gUnknown_081FAE80[] = _("{PALETTE 5}{COLOR_HIGHLIGHT_SHADOW WHITE LIGHT_BLUE WHITE2}"); + +void sub_802C68C(void) +{ + u32 r8 = 0; + struct UnknownStruct1 *r6 = (struct UnknownStruct1 *)(gBattleBufferA[gActiveBank] + 4); + + if (gMain.newKeys & A_BUTTON) + { + u32 r4; + + PlaySE(SE_SELECT); + + if (r6->moves[gMoveSelectionCursor[gActiveBank]] == MOVE_CURSE) + r4 = (r6->unk12 != TYPE_GHOST && (r6->unk13 ^ 7)) ? 0x10 : 0; + else + r4 = gBattleMoves[r6->moves[gMoveSelectionCursor[gActiveBank]]].target; + + if (r4 & 0x10) + gUnknown_03004344 = gActiveBank; + else + gUnknown_03004344 = GetBankByPlayerAI((GetBankIdentity(gActiveBank) & 1) ^ 1); + + if (gBattleBufferA[gActiveBank][1] == 0) + { + if ((r4 & 2) && gBattleBufferA[gActiveBank][2] == 0) + r8++; + } + else + { + if (!(r4 & 0x7D)) + r8++; + if (r6->pp[gMoveSelectionCursor[gActiveBank]] == 0) + { + r8 = 0; + } + else if (!(r4 & 0x12) && CountAliveMons(0) <= 1) + { + gUnknown_03004344 = sub_803C434(gActiveBank); + r8 = 0; + } + } + if (r8 == 0) + { + DestroyMenuCursor(); + Emitcmd33(1, 10, gMoveSelectionCursor[gActiveBank] | (gUnknown_03004344 << 8)); + PlayerBufferExecCompleted(); + } + else + { + gBattleBankFunc[gActiveBank] = sub_802C2EC; + if (r4 & 0x12) + gUnknown_03004344 = gActiveBank; + else if (gAbsentBankFlags & gBitTable[GetBankByPlayerAI(1)]) + gUnknown_03004344 = GetBankByPlayerAI(3); + else + gUnknown_03004344 = GetBankByPlayerAI(1); + gSprites[gObjectBankIDs[gUnknown_03004344]].callback = sub_8010520; + } + } + else if (gMain.newKeys & B_BUTTON) + { + DestroyMenuCursor(); + PlaySE(SE_SELECT); + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 320; + Emitcmd33(1, 10, 0xFFFF); + PlayerBufferExecCompleted(); + } + else if (gMain.newKeys & DPAD_LEFT) + { + if (gMoveSelectionCursor[gActiveBank] & 1) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_RIGHT) + { + if (!(gMoveSelectionCursor[gActiveBank] & 1) + && (gMoveSelectionCursor[gActiveBank] ^ 1) < gUnknown_03004348) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 1; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_UP) + { + if (gMoveSelectionCursor[gActiveBank] & 2) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & DPAD_DOWN) + { + if (!(gMoveSelectionCursor[gActiveBank] & 2) + && (gMoveSelectionCursor[gActiveBank] ^ 2) < gUnknown_03004348) + { + nullsub_7(gMoveSelectionCursor[gActiveBank]); + gMoveSelectionCursor[gActiveBank] ^= 2; + PlaySE(SE_SELECT); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E220(); + sub_802E2D4(); + } + } + else if (gMain.newKeys & SELECT_BUTTON) + { + if (gUnknown_03004348 > 1 && !(gBattleTypeFlags & BATTLE_TYPE_LINK)) + { + sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_081FAE80); + if (gMoveSelectionCursor[gActiveBank] != 0) + gUnknown_03004344 = 0; + else + gUnknown_03004344 = gMoveSelectionCursor[gActiveBank] + 1; + sub_802E3B4(gUnknown_03004344, 27); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D89, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + gBattleBankFunc[gActiveBank] = sub_802CA60; + } + } +} + +extern const u8 gUnknown_08400D49[]; +extern const u8 gUnknown_08400D38[]; + +void sub_802CA60(void) +{ + u8 perMovePPBonuses[4]; + struct + { + u16 moves[4]; + u8 pp[4]; + u8 filler18[8]; // what is this? + } sp0; + //struct UnknownStruct1 sp0; + u8 totalPPBonuses; + + if (gMain.newKeys & (A_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + if (gMoveSelectionCursor[gActiveBank] != gUnknown_03004344) + { + struct UnknownStruct1 *r9 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + s32 i; + + i = r9->moves[gMoveSelectionCursor[gActiveBank]]; + r9->moves[gMoveSelectionCursor[gActiveBank]] = r9->moves[gUnknown_03004344]; + r9->moves[gUnknown_03004344] = i; + + i = r9->pp[gMoveSelectionCursor[gActiveBank]]; + r9->pp[gMoveSelectionCursor[gActiveBank]] = r9->pp[gUnknown_03004344]; + r9->pp[gUnknown_03004344] = i; + + i = r9->unkC[gMoveSelectionCursor[gActiveBank]]; + r9->unkC[gMoveSelectionCursor[gActiveBank]] = r9->unkC[gUnknown_03004344]; + r9->unkC[gUnknown_03004344] = i; + + if (gDisableStructs[gActiveBank].unk18_b & gBitTable[gMoveSelectionCursor[gActiveBank]]) + { + gDisableStructs[gActiveBank].unk18_b &= ~gBitTable[gMoveSelectionCursor[gActiveBank]]; + gDisableStructs[gActiveBank].unk18_b |= gBitTable[gUnknown_03004344]; + } + + sub_802E1B0(); + + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (gBattleMons[gActiveBank].ppBonuses & (3 << (i * 2))) >> (i * 2); + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + gBattleMons[gActiveBank].ppBonuses = totalPPBonuses; + + for (i = 0; i < 4; i++) + { + gBattleMons[gActiveBank].moves[i] = r9->moves[i]; + gBattleMons[gActiveBank].pp[i] = r9->pp[i]; + } + if (!(gBattleMons[gActiveBank].status2 & 0x200000)) + { + for (i = 0; i < 4; i++) + { + sp0.moves[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i); + sp0.pp[i] = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i); + } + + totalPPBonuses = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES); + for (i = 0; i < 4; i++) + perMovePPBonuses[i] = (totalPPBonuses & (3 << (i * 2))) >> (i * 2); + + i = sp0.moves[gMoveSelectionCursor[gActiveBank]]; + sp0.moves[gMoveSelectionCursor[gActiveBank]] = sp0.moves[gUnknown_03004344]; + sp0.moves[gUnknown_03004344] = i; + + i = sp0.pp[gMoveSelectionCursor[gActiveBank]]; + sp0.pp[gMoveSelectionCursor[gActiveBank]] = sp0.pp[gUnknown_03004344]; + sp0.pp[gUnknown_03004344] = i; + + totalPPBonuses = perMovePPBonuses[gMoveSelectionCursor[gActiveBank]]; + perMovePPBonuses[gMoveSelectionCursor[gActiveBank]] = perMovePPBonuses[gUnknown_03004344]; + perMovePPBonuses[gUnknown_03004344] = totalPPBonuses; + + totalPPBonuses = 0; + for (i = 0; i < 4; i++) + totalPPBonuses |= perMovePPBonuses[i] << (i * 2); + + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MOVE1 + i, (u8 *)&sp0.moves[i]); + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP1 + i, &sp0.pp[i]); + } + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_PP_BONUSES, &totalPPBonuses); + } + } + else + { + sub_802E12C(gUnknown_03004344, gUnknown_08400D49); + } + gBattleBankFunc[gActiveBank] = sub_802C68C; + gMoveSelectionCursor[gActiveBank] = gUnknown_03004344; + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if (gMain.newKeys & (B_BUTTON | SELECT_BUTTON)) + { + PlaySE(SE_SELECT); + nullsub_7(gUnknown_03004344); + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + sub_802E12C(gMoveSelectionCursor[gActiveBank], gUnknown_08400D49); + gBattleBankFunc[gActiveBank] = sub_802C68C; + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 0x290, 0x17, 0x37); + sub_8002F44(&gUnknown_03004210); + sub_802E220(); + sub_802E2D4(); + } + if ((gMain.newKeys & DPAD_LEFT) && (gUnknown_03004344 & 1)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_RIGHT) && !(gUnknown_03004344 & 1) && (gUnknown_03004344 ^ 1) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 1; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_UP) && (gUnknown_03004344 & 2)) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } + if ((gMain.newKeys & DPAD_DOWN) && !(gUnknown_03004344 & 2) && (gUnknown_03004344 ^ 2) < gUnknown_03004348) + { + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0x1D); + else + nullsub_7(gUnknown_03004344); + gUnknown_03004344 ^= 2; + PlaySE(SE_SELECT); + if (gUnknown_03004344 == gMoveSelectionCursor[gActiveBank]) + sub_802E3B4(gUnknown_03004344, 0); + else + sub_802E3B4(gUnknown_03004344, 0x1B); + } +} + +void sub_802D148(void) +{ + if (gReceivedRemoteLinkPlayers == 0) + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(c2_8011A1C); + } +} + +void sub_802D18C(void) +{ + if (!gPaletteFade.active) + { + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + sub_800832C(); + gBattleBankFunc[gActiveBank] = sub_802D148; + } + else + { + m4aSongNumStop(SE_HINSI); + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } + } +} + +void sub_802D204(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +// duplicate of sub_802D204 +void sub_802D23C(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + PlayerBufferExecCompleted(); +} + +void sub_802D274(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + { + nullsub_10(gSaveBlock2.playerGender); + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + PlayerBufferExecCompleted(); + } +} + +void sub_802D2E0(void) +{ + if (--ewram17810[gActiveBank].unk9 == 0xFF) + { + ewram17810[gActiveBank].unk9 = 0; + PlayerBufferExecCompleted(); + } +} + +void sub_802D31C(void) +{ + bool8 r6 = FALSE; + + if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & BATTLE_TYPE_MULTI))) + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + else + { + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) + r6 = TRUE; + } + if (IsCryPlayingOrClearCrySongs()) + r6 = FALSE; + + if (r6 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + ewram17810[gActiveBank ^ 2].unk0_7 = 0; + ewram17810[gActiveBank ^ 2].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + m4aMPlayContinue(&gMPlay_BGM); + else + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 256); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + if (IsDoubleBattle()) + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], gActiveBank ^ 2); + ewram17810[gActiveBank].unk9 = 3; + gBattleBankFunc[gActiveBank] = sub_802D2E0; + } +} + +void sub_802D500(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) + sub_8141828(gActiveBank ^ 2, &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]]); + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank ^ 2], + &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], + 0); + sub_804777C(gActiveBank ^ 2); + sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); + } + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C( + gHealthboxIDs[gActiveBank], + &gPlayerParty[gBattlePartyID[gActiveBank]], + 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + ewram17840.unk9_0 = 0; + gBattleBankFunc[gActiveBank] = sub_802D31C; + } +} + +void sub_802D680(void) +{ + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy + && ewram17810[gActiveBank].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + gBattleBankFunc[gActiveBank] = sub_802D730; + } +} + +void sub_802D730(void) +{ + if (!ewram17810[gActiveBank].unk0_6 && !IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void sub_802D798(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy + && !ewram17810[gActiveBank].unk0_3) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + sub_8031F88(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_802D680; + } +} + +void c3_0802FDF4(u8 taskId) +{ + if (!IsCryPlayingOrClearCrySongs()) + { + m4aMPlayVolumeControl(&gMPlay_BGM, 0xFFFF, 0x100); + DestroyTask(taskId); + } +} + +void bx_t1_healthbar_update(void) +{ + s16 r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); + + sub_8043DFC(gHealthboxIDs[gActiveBank]); + if (r4 != -1) + { + sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); + } + else + { + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlayerBufferExecCompleted(); + } +} + +void sub_802D90C(void) +{ + if (gUnknown_03004210.state == 0) + PlayerBufferExecCompleted(); +} + +// Rare Candy usage, maybe? +void sub_802D924(u8 taskId) +{ + u32 pkmnIndex = (u8)gTasks[taskId].data[0]; + u8 bank = gTasks[taskId].data[2]; + s16 gainedExp = gTasks[taskId].data[1]; + + if (IsDoubleBattle() == TRUE || pkmnIndex != gBattlePartyID[bank]) + { + struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; + u16 species = GetMonData(pkmn, MON_DATA_SPECIES); + u8 level = GetMonData(pkmn, MON_DATA_LEVEL); + u32 currExp = GetMonData(pkmn, MON_DATA_EXP); + u32 nextLvlExp = gExperienceTables[gBaseStats[species].growthRate][level + 1]; + + if (currExp + gainedExp >= nextLvlExp) + { + u8 savedActiveBank; + + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&nextLvlExp); + CalculateMonStats(pkmn); + gainedExp -= nextLvlExp - currExp; + savedActiveBank = gActiveBank; + gActiveBank = bank; + Emitcmd33(1, 11, gainedExp); + gActiveBank = savedActiveBank; + + if (IsDoubleBattle() == TRUE + && ((u16)pkmnIndex == gBattlePartyID[bank] || (u16)pkmnIndex == gBattlePartyID[bank ^ 2])) + gTasks[taskId].func = sub_802DCB0; + else + gTasks[taskId].func = sub_802DDC4; + } + else + { + currExp += gainedExp; + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&currExp); + gBattleBankFunc[bank] = sub_802D90C; + DestroyTask(taskId); + } + } + else + { + gTasks[taskId].func = sub_802DA9C; + } +} + +void sub_802DA9C(u8 taskId) +{ + u8 pkmnIndex = gTasks[taskId].data[0]; + s32 r9 = gTasks[taskId].data[1]; + u8 bank = gTasks[taskId].data[2]; + struct Pokemon *pkmn = &gPlayerParty[pkmnIndex]; + u8 level = GetMonData(pkmn, MON_DATA_LEVEL); + u16 species = GetMonData(pkmn, MON_DATA_SPECIES); + u32 exp = GetMonData(pkmn, MON_DATA_EXP); + u32 currLvlExp = gExperienceTables[gBaseStats[species].growthRate][level]; + u32 expToNextLvl; + + exp -= currLvlExp; + expToNextLvl = gExperienceTables[gBaseStats[species].growthRate][level + 1] - currLvlExp; + sub_8043D84(bank, gHealthboxIDs[bank], expToNextLvl, exp, -r9); + PlaySE(SE_EXP); + gTasks[taskId].func = sub_802DB6C; +} + +#ifdef NONMATCHING +void sub_802DB6C(u8 taskId) +{ + if (gTasks[taskId].data[10] < 13) + { + gTasks[taskId].data[10]++; + } + else + { + u8 r9 = gTasks[taskId].data[0]; + s32 r10 = gTasks[taskId].data[1]; //s16? + u8 r7 = gTasks[taskId].data[2]; + s16 r4; + + r4 = sub_8045C78(r7, gHealthboxIDs[r7], 1, 0); + sub_8043DFC(gHealthboxIDs[r7]); + if (r4 == -1) + { + struct Pokemon *pkmn; + u8 r4; + u32 sp4; + u16 r0; + u32 sp0; + + m4aSongNumStop(SE_EXP); + pkmn = &gPlayerParty[r9]; + r4 = GetMonData(pkmn, MON_DATA_LEVEL); + sp4 = GetMonData(pkmn, MON_DATA_EXP); + r0 = GetMonData(pkmn, MON_DATA_SPECIES); + sp0 = gExperienceTables[gBaseStats[r0].growthRate][r4 + 1]; + if (sp4 + r10 >= sp0) + { + u8 r5; + u32 asdf; + + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp0); + CalculateMonStats(pkmn); + //r10 -= sp0 - sp4; + asdf = sp0 - sp4; + //asdf = r10 - (sp0 - sp4); + r10 -= asdf; + r5 = gActiveBank; + gActiveBank = r7; + Emitcmd33(1, 11, r10); + gActiveBank = r5; + gTasks[taskId].func = sub_802DCB0; + } + else + { + //u32 asdf = sp4 + r10; + sp4 += r10; + SetMonData(pkmn, MON_DATA_EXP, (u8 *)&sp4); + gBattleBankFunc[r7] = sub_802D90C; + DestroyTask(taskId); + } + } + } +} +#else +__attribute__((naked)) +void sub_802DB6C(u8 taskId) +{ + asm_unified("push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x8\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r8, r0\n\ + ldr r1, _0802DB98 @ =gTasks\n\ + lsls r0, 2\n\ + add r0, r8\n\ + lsls r0, 3\n\ + adds r6, r0, r1\n\ + ldrh r1, [r6, 0x1C]\n\ + movs r2, 0x1C\n\ + ldrsh r0, [r6, r2]\n\ + cmp r0, 0xC\n\ + bgt _0802DB9C\n\ + adds r0, r1, 0x1\n\ + strh r0, [r6, 0x1C]\n\ + b _0802DC98\n\ + .align 2, 0\n\ +_0802DB98: .4byte gTasks\n\ +_0802DB9C:\n\ + ldrb r0, [r6, 0x8]\n\ + mov r9, r0\n\ + ldrh r2, [r6, 0xA]\n\ + mov r10, r2\n\ + ldrb r7, [r6, 0xC]\n\ + ldr r5, _0802DC64 @ =gHealthboxIDs\n\ + adds r5, r7, r5\n\ + ldrb r1, [r5]\n\ + adds r0, r7, 0\n\ + movs r2, 0x1\n\ + movs r3, 0\n\ + bl sub_8045C78\n\ + adds r4, r0, 0\n\ + lsls r4, 16\n\ + lsrs r4, 16\n\ + ldrb r0, [r5]\n\ + bl sub_8043DFC\n\ + lsls r4, 16\n\ + asrs r4, 16\n\ + movs r0, 0x1\n\ + negs r0, r0\n\ + cmp r4, r0\n\ + bne _0802DC98\n\ + movs r0, 0x21\n\ + bl m4aSongNumStop\n\ + movs r0, 0x64\n\ + mov r1, r9\n\ + muls r1, r0\n\ + ldr r0, _0802DC68 @ =gPlayerParty\n\ + adds r5, r1, r0\n\ + adds r0, r5, 0\n\ + movs r1, 0x38\n\ + bl GetMonData\n\ + adds r4, r0, 0\n\ + lsls r4, 24\n\ + lsrs r4, 24\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + bl GetMonData\n\ + str r0, [sp, 0x4]\n\ + adds r0, r5, 0\n\ + movs r1, 0xB\n\ + bl GetMonData\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + ldr r3, _0802DC6C @ =gExperienceTables\n\ + adds r4, 0x1\n\ + lsls r4, 2\n\ + ldr r2, _0802DC70 @ =gBaseStats\n\ + lsls r1, r0, 3\n\ + subs r1, r0\n\ + lsls r1, 2\n\ + adds r1, r2\n\ + ldrb r1, [r1, 0x13]\n\ + movs r0, 0xCA\n\ + lsls r0, 1\n\ + muls r0, r1\n\ + adds r4, r0\n\ + adds r4, r3\n\ + ldr r1, [r4]\n\ + str r1, [sp]\n\ + mov r2, r10\n\ + lsls r0, r2, 16\n\ + asrs r4, r0, 16\n\ + ldr r0, [sp, 0x4]\n\ + adds r0, r4\n\ + cmp r0, r1\n\ + blt _0802DC7C\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + mov r2, sp\n\ + bl SetMonData\n\ + adds r0, r5, 0\n\ + bl CalculateMonStats\n\ + ldr r2, [sp]\n\ + add r0, sp, 0x4\n\ + ldrh r0, [r0]\n\ + subs r2, r0\n\ + subs r2, r4, r2\n\ + ldr r4, _0802DC74 @ =gActiveBank\n\ + ldrb r5, [r4]\n\ + strb r7, [r4]\n\ + lsls r2, 16\n\ + lsrs r2, 16\n\ + movs r0, 0x1\n\ + movs r1, 0xB\n\ + bl Emitcmd33\n\ + strb r5, [r4]\n\ + ldr r0, _0802DC78 @ =sub_802DCB0\n\ + str r0, [r6]\n\ + b _0802DC98\n\ + .align 2, 0\n\ +_0802DC64: .4byte gHealthboxIDs\n\ +_0802DC68: .4byte gPlayerParty\n\ +_0802DC6C: .4byte gExperienceTables\n\ +_0802DC70: .4byte gBaseStats\n\ +_0802DC74: .4byte gActiveBank\n\ +_0802DC78: .4byte sub_802DCB0\n\ +_0802DC7C:\n\ + str r0, [sp, 0x4]\n\ + add r2, sp, 0x4\n\ + adds r0, r5, 0\n\ + movs r1, 0x19\n\ + bl SetMonData\n\ + ldr r1, _0802DCA8 @ =gBattleBankFunc\n\ + lsls r0, r7, 2\n\ + adds r0, r1\n\ + ldr r1, _0802DCAC @ =sub_802D90C\n\ + str r1, [r0]\n\ + mov r0, r8\n\ + bl DestroyTask\n\ +_0802DC98:\n\ + add sp, 0x8\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ +_0802DCA8: .4byte gBattleBankFunc\n\ +_0802DCAC: .4byte sub_802D90C\n"); +} +#endif + +void sub_802DCB0(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + u8 pkmnIndex = gTasks[taskId].data[0]; + + if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) + bank ^= 2; + move_anim_start_t4(bank, bank, bank, 0); + gTasks[taskId].func = sub_802DD10; +} + +void sub_802DD10(u8 taskId) +{ + u8 bank = gTasks[taskId].data[2]; + + if (!ewram17810[bank].unk0_6) + { + u8 pkmnIndex = gTasks[taskId].data[0]; + + GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value + if (IsDoubleBattle() == TRUE && pkmnIndex == gBattlePartyID[bank ^ 2]) + sub_8045A5C(gHealthboxIDs[bank ^ 2], &gPlayerParty[pkmnIndex], 0); + else + sub_8045A5C(gHealthboxIDs[bank], &gPlayerParty[pkmnIndex], 0); + gTasks[taskId].func = sub_802DDC4; + } +} + +void sub_802DDC4(u8 taskId) +{ + u8 pkmnIndex; + u8 bank; + + pkmnIndex = gTasks[taskId].data[0]; + GetMonData(&gPlayerParty[pkmnIndex], MON_DATA_LEVEL); // Unused return value + bank = gTasks[taskId].data[2]; + gBattleBankFunc[bank] = sub_802D90C; + DestroyTask(taskId); +} + +void sub_802DE10(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > DISPLAY_HEIGHT) + { + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + nullsub_9(species); + FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void sub_802DEAC(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +// Duplicate of sub_802D90C +void sub_802DF18(void) +{ + if (gUnknown_03004210.state == 0) + PlayerBufferExecCompleted(); +} + +void sub_802DF30(void) +{ + if (!gPaletteFade.active) + { + u8 r4; + + gBattleBankFunc[gActiveBank] = sub_802DF88; + r4 = gTasks[gUnknown_0300434C[gActiveBank]].data[0]; + DestroyTask(gUnknown_0300434C[gActiveBank]); + sub_8094E20(r4); + } +} + +void sub_802DF88(void) +{ + if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) + { + if (gUnknown_0202E8F4 == 1) + Emitcmd34(1, gUnknown_0202E8F5, gUnknown_02038470); + else + Emitcmd34(1, 6, NULL); + if ((gBattleBufferA[gActiveBank][1] & 0xF) == 1) + b_link_standby_message(); + PlayerBufferExecCompleted(); + } +} + +void sub_802E004(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = sub_802E03C; + nullsub_14(); + sub_80A6DCC(); + } +} + +void sub_802E03C(void) +{ + if (gMain.callback2 == sub_800F808 && !gPaletteFade.active) + { + Emitcmd35(1, gScriptItemId); + PlayerBufferExecCompleted(); + } +} + +void bx_wait_t1(void) +{ + if (!gDoingBattleAnim || !ewram17810[gActiveBank].unk0_6) + PlayerBufferExecCompleted(); +} + +void bx_blink_t1(void) +{ + u8 spriteId = gObjectBankIDs[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = 0; + PlayerBufferExecCompleted(); + } + else + { + if (((u16)gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_802E12C(s32 a, const u8 *b) +{ + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + + StringCopy(gDisplayedStringBattle, b); + StringAppend(gDisplayedStringBattle, gMoveNames[r4->moves[a]]); + InitWindow( + &gUnknown_03004210, + gDisplayedStringBattle, + 0x300 + a * 20, + (a & 1) ? 11 : 1, + (a < 2) ? 0x37 : 0x39); + sub_8002F44(&gUnknown_03004210); +} + +void sub_802E1B0(void) +{ + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + s32 i; + + gUnknown_03004348 = 0; + FillWindowRect(&gUnknown_03004210, 0x1016, 1, 0x37, 0x14, 0x3A); + for (i = 0; i < 4; i++) + { + nullsub_7(i); + sub_802E12C(i, gUnknown_08400D49); + if (r4->moves[i] != 0) + gUnknown_03004348++; + } +} + +void sub_802E220(void) +{ + if (gBattleBufferA[gActiveBank][2] != 1) + { + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + u8 *str = gDisplayedStringBattle; + + str = StringCopy(str, gUnknown_08400D49); + str[0] = EXT_CTRL_CODE_BEGIN; + str[1] = 0x11; + str[2] = 2; + str += 3; + str[0] = EXT_CTRL_CODE_BEGIN; + str[1] = 0x14; + str[2] = 6; + str += 3; + str = ConvertIntToDecimalStringN(str, r4->pp[gMoveSelectionCursor[gActiveBank]], 1, 2); + *str++ = CHAR_SLASH; + ConvertIntToDecimalStringN(str, r4->unkC[gMoveSelectionCursor[gActiveBank]], 1, 2); + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2A2, 0x19, 0x37); + sub_8002F44(&gUnknown_03004210); + } +} + +extern const u8 gUnknown_08400D52[]; +extern const u8 gTypeNames[][7]; + +void sub_802E2D4(void) +{ + if (gBattleBufferA[gActiveBank][2] == 1) + { + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x37, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gUnknown_08400D52, 0x290, 0x13, 0x37); + } + else + { + struct UnknownStruct1 *r4 = (struct UnknownStruct1 *)&gBattleBufferA[gActiveBank][4]; + u8 *str = gDisplayedStringBattle; + + str = StringCopy(str, gUnknown_08400D49); + StringCopy(str, gTypeNames[gBattleMoves[r4->moves[gMoveSelectionCursor[gActiveBank]]].type]); + FillWindowRect(&gUnknown_03004210, 0x1016, 0x17, 0x39, 0x1C, 0x3A); + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 0x2C0, 0x17, 0x39); + } + sub_8002F44(&gUnknown_03004210); +} + +const u8 gUnknown_081FAE89[][2] = +{ + { 8, 120}, + {88, 120}, + { 8, 136}, + {88, 136}, +}; + +const u8 gUnknown_081FAE91[][2] = +{ + {144, 120}, + {190, 120}, + {144, 136}, + {190, 136}, + { 72, 72}, + { 32, 90}, + { 80, 80}, + { 80, 88}, +}; + +void sub_802E3B4(u8 a, int unused) +{ + sub_814A958(0x48); + sub_814A880(gUnknown_081FAE89[a][0], gUnknown_081FAE89[a][1]); +} + +void nullsub_7(u8 a) +{ +} + +void sub_802E3E4(u8 a, int unused) +{ + sub_814A958(0x2A); + sub_814A880(gUnknown_081FAE91[a][0], gUnknown_081FAE91[a][1]); +} + +void nullsub_8(u8 a) +{ +} + +void sub_802E414(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void sub_802E424(void) +{ + SetMainCallback2(ReshowBattleScreenAfterMenu); +} + +void sub_802E434(void) +{ + if (!ewram17810[gActiveBank].unk0_4) + PlayerBufferExecCompleted(); +} + +void sub_802E460(void) +{ + if (!ewram17810[gActiveBank].unk0_5) + PlayerBufferExecCompleted(); +} + +void b_link_standby_message(void) +{ + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + sub_8002EB0(&gUnknown_03004210, gUnknown_08400CE0, 0x90, 2, 15); + } +} + +void PlayerHandleGetAttributes(void) +{ + u8 unkData[0x100]; + u32 offset = 0; + u8 r4; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + offset += dp01_getattr_by_ch1_for_player_pokemon_(gBattlePartyID[gActiveBank], unkData); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + offset += dp01_getattr_by_ch1_for_player_pokemon_(i, unkData + offset); + r4 >>= 1; + } + } + Emitcmd29(1, offset, unkData); + PlayerBufferExecCompleted(); +} + +// Duplicate of dp01_getattr_by_ch1_for_player_pokemon +u32 dp01_getattr_by_ch1_for_player_pokemon_(u8 a, u8 *buffer) +{ + struct BattlePokemon battlePokemon; + struct UnknownStruct3 moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); + battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); + battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); + battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); + StringCopy10(battlePokemon.nickname, nickname); + GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); + src = (u8 *)&battlePokemon; + for (size = 0; size < sizeof(battlePokemon); size++) + buffer[size] = src[size]; + break; + case 1: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 2: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 3: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + src = (u8 *)&moveData; + for (size = 0; size < sizeof(moveData); size++) + buffer[size] = src[size]; + break; + case 4: + case 5: + case 6: + case 7: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 8: + for (size = 0; size < 4; size++) + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + size++; + break; + case 9: + case 10: + case 11: + case 12: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); + size = 1; + break; + case 17: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 18: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 19: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); + size = 1; + break; + case 20: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); + size = 1; + break; + case 21: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); + size = 1; + break; + case 22: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); + size = 1; + break; + case 23: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); + size = 1; + break; + case 24: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); + size = 1; + break; + case 25: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + size = 1; + break; + case 26: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); + size = 1; + break; + case 27: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); + size = 1; + break; + case 28: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); + size = 1; + break; + case 29: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); + size = 1; + break; + case 30: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); + size = 1; + break; + case 31: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 6; + break; + case 32: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + size = 1; + break; + case 33: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + size = 1; + break; + case 34: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + size = 1; + break; + case 35: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + size = 1; + break; + case 36: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + size = 1; + break; + case 37: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 1; + break; + case 38: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 39: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 40: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 41: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + size = 1; + break; + case 42: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 43: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 44: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 45: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 46: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 47: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 48: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 49: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); + size = 1; + break; + case 50: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); + size = 1; + break; + case 51: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); + size = 1; + break; + case 52: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); + size = 1; + break; + case 53: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); + size = 1; + break; + case 54: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); + size = 1; + break; + case 55: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); + size = 1; + break; + case 56: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case 57: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case 58: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); + size = 1; + break; + case 59: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + return size; +} + +void PlayerHandlecmd1(void) +{ + struct BattlePokemon battleMon; // I think this is a BattlePokemon + u8 *src = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 *dst = (u8 *)&battleMon + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = src[i]; + Emitcmd29(1, gBattleBufferA[gActiveBank][2], dst); + PlayerBufferExecCompleted(); +} + +void PlayerHandleSetAttributes(void) +{ + u8 r4; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + dp01_setattr_by_ch1_for_player_pokemon(gBattlePartyID[gActiveBank]); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + dp01_setattr_by_ch1_for_player_pokemon(i); + r4 >>= 1; + } + } + PlayerBufferExecCompleted(); +} + +// Duplicate of sub_811EC68 +void dp01_setattr_by_ch1_for_player_pokemon(u8 a) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + { + u8 iv; + + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); + SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); + SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); + SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); + SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); + SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); + } + break; + case 1: + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case 2: + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case 3: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case 4: + case 5: + case 6: + case 7: + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); + break; + case 8: + SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case 9: + case 10: + case 11: + case 12: + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); + break; + case 17: + SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case 18: + SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case 19: + SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 20: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 21: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 22: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 23: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 24: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 25: + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case 26: + SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case 27: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case 28: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 29: + SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case 30: + SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case 31: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case 32: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 33: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 34: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 35: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 36: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 37: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 38: + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case 39: + SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case 40: + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case 41: + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 42: + SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 43: + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 44: + SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case 45: + SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case 46: + SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case 47: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case 48: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case 49: + SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case 50: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case 51: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case 52: + SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case 53: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case 54: + SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case 55: + SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 56: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 57: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 58: + SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 59: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +void PlayerHandlecmd3(void) +{ + u8 *dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; + u8 i; + + for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) + dst[i] = gBattleBufferA[gActiveBank][3 + i]; + PlayerBufferExecCompleted(); +} + +void PlayerHandleLoadPokeSprite(void) +{ + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gBattleBankFunc[gActiveBank] = bx_0802E404; +} + +void PlayerHandleSendOutPoke(void) +{ + sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + gActionSelectionCursor[gActiveBank] = 0; + gMoveSelectionCursor[gActiveBank] = 0; + sub_802F934(gActiveBank, gBattleBufferA[gActiveBank][2]); + gBattleBankFunc[gActiveBank] = sub_802D798; +} + +void sub_802F934(u8 bank, u8 b) +{ + u16 species; + + sub_8032AA8(bank, b); + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); + gObjectBankIDs[bank] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(bank, 2), + sub_8077F68(bank), + sub_8079E90(bank)); + gSprites[gUnknown_0300434C[bank]].data1 = gObjectBankIDs[bank]; + gSprites[gObjectBankIDs[bank]].data0 = bank; + gSprites[gObjectBankIDs[bank]].data2 = species; + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); + gSprites[gObjectBankIDs[bank]].invisible = TRUE; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gUnknown_0300434C[bank]].data0 = sub_8046400(0, 0xFF); +} + +void PlayerHandleReturnPokeToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_802FB2C; + } + else + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + PlayerBufferExecCompleted(); + } +} + +void sub_802FB2C(void) +{ + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (!ewram17810[gActiveBank].unk0_6) + { + ewram17810[gActiveBank].unk4 = 0; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); + gBattleBankFunc[gActiveBank] = sub_802DEAC; + } + } +} + +void PlayerHandleTrainerThrow(void) +{ + s16 r7; + + if (gBattleTypeFlags & BATTLE_TYPE_MULTI) + { + if (GetBankIdentity(gActiveBank) & 2) + r7 = 16; + else + r7 = -16; + } + else + { + r7 = 0; + } + sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + r7 + 80, + (8 - gTrainerBackPicCoords[gSaveBlock2.playerGender].coords) * 4 + 80, + sub_8079E90(gActiveBank)); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_802D204; +} + +void PlayerHandleTrainerSlide(void) +{ + sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 80, + (8 - gTrainerBackPicCoords[gSaveBlock2.playerGender].coords) * 4 + 80, + 30); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -96; + gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_802D23C; +} + +void PlayerHandleTrainerSlideBack(void) +{ + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; + gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); + gBattleBankFunc[gActiveBank] = sub_802D274; +} + +void PlayerHandlecmd10(void) +{ + if (ewram17810[gActiveBank].unk4 == 0) + { + if (ewram17800[gActiveBank].unk0_2) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4++; + } + else + { + if (ewram17810[gActiveBank].unk0_6 == 0) + { + ewram17810[gActiveBank].unk4 = 0; + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + PlaySE12WithPanning(SE_POKE_DEAD, -64); + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + gSprites[gObjectBankIDs[gActiveBank]].data2 = 5; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80105EC; + gBattleBankFunc[gActiveBank] = sub_802DE10; + } + } +} + +void PlayerHandlecmd11(void) +{ + BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd12(void) +{ + ewram17840.unk8 = 4; + gDoingBattleAnim = 1; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 3); + gBattleBankFunc[gActiveBank] = bx_wait_t1; +} + +void PlayerHandleBallThrow(void) +{ + u8 var = gBattleBufferA[gActiveBank][1]; + + ewram17840.unk8 = var; + gDoingBattleAnim = 1; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 3); + gBattleBankFunc[gActiveBank] = bx_wait_t1; +} + +void PlayerHandlePuase(void) +{ + u8 var = gBattleBufferA[gActiveBank][1]; + + // WTF is this?? + while (var != 0) + var--; + + PlayerBufferExecCompleted(); +} + +void PlayerHandleMoveAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u16 r0 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; + gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; + gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; + if (sub_8031720(r0, gUnknown_0202F7C4) != 0) + { + // Dead code. sub_8031720 always returns 0. + PlayerBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_8030190; + } + } +} + +void sub_8030190(void) +{ + u16 r4 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + u8 r7 = gBattleBufferA[gActiveBank][11]; + + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2 == 1 && ewram17800[gActiveBank].unk0_3 == 0) + { + ewram17800[gActiveBank].unk0_3 = 1; + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + } + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (ewram17810[gActiveBank].unk0_6 == 0) + { + sub_80326EC(0); + ExecuteMoveAnim(r4); + ewram17810[gActiveBank].unk4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_80326EC(1); + if (ewram17800[gActiveBank].unk0_2 == 1 && r7 < 2) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + ewram17800[gActiveBank].unk0_3 = 0; + } + ewram17810[gActiveBank].unk4 = 3; + } + break; + case 3: + if (ewram17810[gActiveBank].unk0_6 == 0) + { + sub_8031F24(); + sub_80324BC(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + ewram17810[gActiveBank].unk4 = 0; + PlayerBufferExecCompleted(); + } + break; + } +} + +void PlayerHandlePrintString(void) +{ + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); + sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 0x90, 2, 15); + gBattleBankFunc[gActiveBank] = sub_802DF18; +} + +void PlayerHandlePrintStringPlayerOnly(void) +{ + if (GetBankSide(gActiveBank) == 0) + PlayerHandlePrintString(); + else + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd18(void) +{ + int r4; + + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 160; + FillWindowRect(&gUnknown_03004210, 10, 2, 15, 27, 18); + FillWindowRect(&gUnknown_03004210, 10, 2, 35, 16, 38); + + gBattleBankFunc[gActiveBank] = sub_802C098; + + InitWindow(&gUnknown_03004210, gUnknown_08400CF3, 400, 18, 35); + sub_8002F44(&gUnknown_03004210); + sub_814A5C0(0, 0xFFFF, 12, 11679, 0); + + for (r4 = 0; r4 < 4; r4++) + nullsub_8(r4); + + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + + StrCpyDecodeToDisplayedStringBattle((u8 *) gUnknown_08400CA8); + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, SUB_803037C_TILE_DATA_OFFSET, 2, 35); + sub_8002F44(&gUnknown_03004210); +} + +void PlayerHandlecmd19() +{ +} + +void PlayerHandlecmd20(void) +{ + sub_814A5C0(0, 0xFFFF, 12, 0x2D9F, 0); + sub_80304A8(); + gBattleBankFunc[gActiveBank] = sub_802C68C; +} + +void sub_80304A8(void) +{ + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 320; + sub_802E1B0(); + gUnknown_03004344 = 0xFF; + sub_802E3B4(gMoveSelectionCursor[gActiveBank], 0); + if (gBattleBufferA[gActiveBank][2] != 1) + { + InitWindow(&gUnknown_03004210, gUnknown_08400D38, 656, 23, 55); + sub_8002F44(&gUnknown_03004210); + } + sub_802E220(); + sub_802E2D4(); +} + +void PlayerHandleOpenBag(void) +{ + s32 i; + + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); + gBattleBankFunc[gActiveBank] = sub_802E004; + gBankInMenu = gActiveBank; + for (i = 0; i < 3; i++) + gUnknown_02038470[i] = gBattleBufferA[gActiveBank][1 + i]; +} + +void PlayerHandlecmd22(void) +{ + s32 i; + + gUnknown_0300434C[gActiveBank] = CreateTask(TaskDummy, 0xFF); + gTasks[gUnknown_0300434C[gActiveBank]].data[0] = gBattleBufferA[gActiveBank][1] & 0xF; + ewram[0x16054] = gBattleBufferA[gActiveBank][1] >> 4; + ewram[0x1609D] = gBattleBufferA[gActiveBank][2]; + ewram[0x160C0] = gBattleBufferA[gActiveBank][3]; + for (i = 0; i < 3; i++) + gUnknown_02038470[i] = gBattleBufferA[gActiveBank][4 + i]; + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); + gBattleBankFunc[gActiveBank] = sub_802DF30; + gBankInMenu = gActiveBank; +} + +void PlayerHandlecmd23(void) +{ + BattleMusicStop(); + BeginNormalPaletteFade(0xFFFFFFFF, 2, 0, 16, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandleHealthBarUpdate(void) +{ + s16 r7; + + load_gfxc_health_bar(0); + r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + if (r7 != 0x7FFF) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, curHP, r7); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); + sub_80440EC(gHealthboxIDs[gActiveBank], 0, 0); + } + gBattleBankFunc[gActiveBank] = bx_t1_healthbar_update; +} + +void PlayerHandleExpBarUpdate(void) +{ + u8 r7 = gBattleBufferA[gActiveBank][1]; + + if (GetMonData(&gPlayerParty[r7], MON_DATA_LEVEL) >= 100) + { + PlayerBufferExecCompleted(); + } + else + { + u16 r4; + u8 taskId; + + load_gfxc_health_bar(1); + GetMonData(&gPlayerParty[r7], MON_DATA_SPECIES); // unused return value + r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + taskId = CreateTask(sub_802D924, 10); + gTasks[taskId].data[0] = r7; + gTasks[taskId].data[1] = r4; + gTasks[taskId].data[2] = gActiveBank; + gBattleBankFunc[gActiveBank] = nullsub_91; + } +} + +void PlayerHandleStatusIconUpdate(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 9); + ewram17810[gActiveBank].unk0_4 = 0; + gBattleBankFunc[gActiveBank] = sub_802E434; + } +} + +void PlayerHandleStatusAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + move_anim_start_t2_for_situation( + gBattleBufferA[gActiveBank][1], + gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8) | (gBattleBufferA[gActiveBank][4] << 16) | (gBattleBufferA[gActiveBank][5] << 24)); + gBattleBankFunc[gActiveBank] = sub_802E434; + } +} + +void PlayerHandleStatusXor(void) +{ + u8 val = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS) ^ gBattleBufferA[gActiveBank][1]; + + SetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_STATUS, &val); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd29(void) +{ + PlayerBufferExecCompleted(); +} + +void PlayerHandleDMATransfer(void) +{ + u32 val1 = gBattleBufferA[gActiveBank][1] + | (gBattleBufferA[gActiveBank][2] << 8) + | (gBattleBufferA[gActiveBank][3] << 16) + | (gBattleBufferA[gActiveBank][4] << 24); + u16 val2 = gBattleBufferA[gActiveBank][5] | (gBattleBufferA[gActiveBank][6] << 8); + + const u8 *src = &gBattleBufferA[gActiveBank][7]; + u8 *dst = (u8 *)val1; + u32 size = val2; + + while (1) + { + if (size <= 0x1000) + { + DmaCopy16(3, src, dst, size); + break; + } + DmaCopy16(3, src, dst, 0x1000); + src += 0x1000; + dst += 0x1000; + size -= 0x1000; + } + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd31(void) +{ + PlayBGM(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd32(void) +{ + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd33(void) +{ + Emitcmd33(1, 0, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd34(void) +{ + Emitcmd34(1, 0, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd35(void) +{ + Emitcmd35(1, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd36(void) +{ + Emitcmd36(1, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd37(void) +{ + gUnknown_020238C8.unk0_0 = 0; + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd38(void) +{ + gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd39(void) +{ + gUnknown_020238C8.unk0_7 = 0; + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd40(void) +{ + gUnknown_020238C8.unk0_7 ^= 1; + PlayerBufferExecCompleted(); +} + +void PlayerHandleHitAnimation(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) + { + PlayerBufferExecCompleted(); + } + else + { + gDoingBattleAnim = 1; + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + sub_8047858(gActiveBank); + gBattleBankFunc[gActiveBank] = bx_blink_t1; + } +} + +void PlayerHandlecmd42(void) +{ + PlayerBufferExecCompleted(); +} + +void PlayerHandleEffectivenessSound(void) +{ + s8 pan; + + if (GetBankSide(gActiveBank) == 0) + pan = -64; + else + pan = 63; + PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd44(void) +{ + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + PlayerBufferExecCompleted(); +} + +void PlayerHandleFaintingCry(void) +{ + u16 species = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); + + PlayCry3(species, -25, 5); + PlayerBufferExecCompleted(); +} + +void PlayerHandleIntroSlide(void) +{ + sub_80E43C0(gBattleBufferA[gActiveBank][1]); + gUnknown_02024DE8 |= 1; + PlayerBufferExecCompleted(); +} + +void PlayerHandleTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; + gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); + paletteNum = AllocSpritePalette(0xD6F8); + LoadCompressedPalette(gTrainerBackPicPaletteTable[gSaveBlock2.playerGender].data, 0x100 + paletteNum * 16, 32); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = paletteNum; + taskId = CreateTask(task05_08033660, 5); + gTasks[taskId].data[0] = gActiveBank; + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + ewram17810[4].unk9 |= 1; + gBattleBankFunc[gActiveBank] = nullsub_91; +} + +void sub_8030E38(struct Sprite *sprite) +{ + u8 r4 = sprite->data5; + + FreeSpriteOamMatrix(sprite); + FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); + DestroySprite(sprite); + sub_80318FC(&gPlayerParty[gBattlePartyID[r4]], r4); + StartSpriteAnim(&gSprites[gObjectBankIDs[r4]], 0); +} + +void task05_08033660(u8 taskId) +{ + if (gTasks[taskId].data[1] < 31) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + if (!IsDoubleBattle() || (gBattleTypeFlags & 0x40)) + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_802F934(gActiveBank, 0); + } + else + { + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_802F934(gActiveBank, 0); + gActiveBank ^= 2; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + sub_802F934(gActiveBank, 0); + gActiveBank ^= 2; + } + gBattleBankFunc[gActiveBank] = sub_802D500; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +void PlayerHandlecmd48(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) + { + PlayerBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk0_0 = 1; + gUnknown_02024E68[gActiveBank] = sub_8044804(gActiveBank, (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + ewram17810[gActiveBank].unk5 = 0; + if (gBattleBufferA[gActiveBank][2] != 0) + ewram17810[gActiveBank].unk5 = 0x5D; + gBattleBankFunc[gActiveBank] = sub_8031064; + } +} + +void sub_8031064(void) +{ + if (ewram17810[gActiveBank].unk5++ > 0x5C) + { + ewram17810[gActiveBank].unk5 = 0; + PlayerBufferExecCompleted(); + } +} + +void PlayerHandlecmd49(void) +{ + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd50(void) +{ + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + PlayerBufferExecCompleted(); +} + +void PlayerHandleSpriteInvisibility(void) +{ + if (sub_8078874(gActiveBank)) + { + gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; + sub_8031F88(gActiveBank); + } + PlayerBufferExecCompleted(); +} + +void PlayerHandleBattleAnimation(void) +{ + if (!mplay_80342A4(gActiveBank)) + { + u8 val2 = gBattleBufferA[gActiveBank][1]; + u16 val = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, val2, val)) + PlayerBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = sub_802E460; + } +} + +void PlayerHandleLinkStandbyMsg(void) +{ + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + b_link_standby_message(); + // fall through + case 1: + dp11b_obj_free(gActiveBank, 1); + dp11b_obj_free(gActiveBank, 0); + break; + case 2: + b_link_standby_message(); + break; + } + PlayerBufferExecCompleted(); +} + +void PlayerHandleResetActionMoveSelection(void) +{ + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + gActionSelectionCursor[gActiveBank] = 0; + gMoveSelectionCursor[gActiveBank] = 0; + break; + case 1: + gActionSelectionCursor[gActiveBank] = 0; + break; + case 2: + gMoveSelectionCursor[gActiveBank] = 0; + break; + } + PlayerBufferExecCompleted(); +} + +void PlayerHandlecmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + PlayerBufferExecCompleted(); + gBattleBankFunc[gActiveBank] = sub_802D18C; +} + +void PlayerHandlecmd56(void) +{ +} diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c new file mode 100644 index 000000000..46e34589a --- /dev/null +++ b/src/battle_controller_safari.c @@ -0,0 +1,173 @@ +#include "global.h" +#include "battle_anim_81258BC.h" +#include "battle.h" +#include "battle_message.h" +#include "menu_cursor.h" +#include "text.h" + +extern struct Window gUnknown_03004210; +extern u8 gDisplayedStringBattle[]; +extern u8 gActionSelectionCursor[]; + +extern const u8 gUnknown_08400CBB[]; +extern u8 gActiveBank; +extern const u8 gUnknown_08400D15[]; + +extern void *gBattleBankFunc[]; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; + +#if ENGLISH +#define SUB_812BB10_TILE_DATA_OFFSET 440 +#elif GERMAN +#define SUB_812BB10_TILE_DATA_OFFSET 444 +#endif + +// this file's functions +void SafariHandleGetAttributes(void); +void SafariHandlecmd1(void); +void SafariHandleSetAttributes(void); +void SafariHandlecmd3(void); +void SafariHandleLoadPokeSprite(void); +void SafariHandleSendOutPoke(void); +void SafariHandleReturnPokeToBall(void); +void SafariHandleTrainerThrow(void); +void SafariHandleTrainerSlide(void); +void SafariHandleTrainerSlideBack(void); +void SafariHandlecmd10(void); +void SafariHandlecmd11(void); +void SafariHandlecmd12(void); +void SafariHandleBallThrow(void); +void SafariHandlePuase(void); +void SafariHandleMoveAnimation(void); +void SafariHandlePrintString(void); +void SafariHandlePrintStringPlayerOnly(void); +void SafariHandlecmd18(void); +void SafariHandlecmd19(void); +void SafariHandlecmd20(void); +void SafariHandleOpenBag(void); +void SafariHandlecmd22(void); +void SafariHandlecmd23(void); +void SafariHandleHealthBarUpdate(void); +void SafariHandleExpBarUpdate(void); +void SafariHandleStatusIconUpdate(void); +void SafariHandleStatusAnimation(void); +void SafariHandleStatusXor(void); +void SafariHandlecmd29(void); +void SafariHandleDMATransfer(void); +void SafariHandlecmd31(void); +void SafariHandlecmd32(void); +void SafariHandlecmd33(void); +void SafariHandlecmd34(void); +void SafariHandlecmd35(void); +void SafariHandlecmd36(void); +void SafariHandlecmd37(void); +void SafariHandlecmd38(void); +void SafariHandlecmd39(void); +void SafariHandlecmd40(void); +void SafariHandleHitAnimation(void); +void SafariHandlecmd42(void); +void SafariHandleEffectivenessSound(void); +void SafariHandlecmd44(void); +void SafariHandleFaintingCry(void); +void SafariHandleIntroSlide(void); +void SafariHandleTrainerBallThrow(void); +void SafariHandlecmd48(void); +void SafariHandlecmd49(void); +void SafariHandlecmd50(void); +void SafariHandleSpriteInvisibility(void); +void SafariHandleBattleAnimation(void); +void SafariHandleLinkStandbyMsg(void); +void SafariHandleResetActionMoveSelection(void); +void SafariHandlecmd55(void); +void SafariHandlecmd56(void); + +// const data +typedef void (*BattleBufferCmd) (void); +const BattleBufferCmd gSafariBufferCommands[] = +{ + SafariHandleGetAttributes, + SafariHandlecmd1, + SafariHandleSetAttributes, + SafariHandlecmd3, + SafariHandleLoadPokeSprite, + SafariHandleSendOutPoke, + SafariHandleReturnPokeToBall, + SafariHandleTrainerThrow, + SafariHandleTrainerSlide, + SafariHandleTrainerSlideBack, + SafariHandlecmd10, + SafariHandlecmd11, + SafariHandlecmd12, + SafariHandleBallThrow, + SafariHandlePuase, + SafariHandleMoveAnimation, + SafariHandlePrintString, + SafariHandlePrintStringPlayerOnly, + SafariHandlecmd18, + SafariHandlecmd19, + SafariHandlecmd20, + SafariHandleOpenBag, + SafariHandlecmd22, + SafariHandlecmd23, + SafariHandleHealthBarUpdate, + SafariHandleExpBarUpdate, + SafariHandleStatusIconUpdate, + SafariHandleStatusAnimation, + SafariHandleStatusXor, + SafariHandlecmd29, + SafariHandleDMATransfer, + SafariHandlecmd31, + SafariHandlecmd32, + SafariHandlecmd33, + SafariHandlecmd34, + SafariHandlecmd35, + SafariHandlecmd36, + SafariHandlecmd37, + SafariHandlecmd38, + SafariHandlecmd39, + SafariHandlecmd40, + SafariHandleHitAnimation, + SafariHandlecmd42, + SafariHandleEffectivenessSound, + SafariHandlecmd44, + SafariHandleFaintingCry, + SafariHandleIntroSlide, + SafariHandleTrainerBallThrow, + SafariHandlecmd48, + SafariHandlecmd49, + SafariHandlecmd50, + SafariHandleSpriteInvisibility, + SafariHandleBattleAnimation, + SafariHandleLinkStandbyMsg, + SafariHandleResetActionMoveSelection, + SafariHandlecmd55, + SafariHandlecmd56, +}; +// code + +void SafariHandlecmd18(void) { + int i; + + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 160; + gUnknown_03004210.paletteNum = 0; + FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 15, 27, 18); + FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 35, 16, 36); + gBattleBankFunc[gActiveBank] = bx_battle_menu_t6_2; + + InitWindow(&gUnknown_03004210, gUnknown_08400D15, 400, 18, 35); + sub_8002F44(&gUnknown_03004210); + sub_814A5C0(0, 0xFFFF, 12, 11679, 0); + + for (i = 0; i < 4; i++) + { + nullsub_8(i); + } + + sub_802E3E4(gActionSelectionCursor[gActiveBank], 0); + StrCpyDecodeToDisplayedStringBattle((u8 *) gUnknown_08400CBB); + + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, SUB_812BB10_TILE_DATA_OFFSET, 2, 35); + sub_8002F44(&gUnknown_03004210); +} diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c new file mode 100644 index 000000000..08bad3c12 --- /dev/null +++ b/src/battle_controller_wally.c @@ -0,0 +1,1611 @@ +#include "global.h" +#include "battle.h" +#include "battle_interface.h" +#include "battle_message.h" +#include "data2.h" +#include "link.h" +#include "main.h" +#include "menu_cursor.h" +#include "palette.h" +#include "pokemon.h" +#include "rom3.h" +#include "songs.h" +#include "sound.h" +#include "sprite.h" +#include "item_use.h" +#include "string_util.h" +#include "task.h" +#include "text.h" +#include "util.h" + +//Possibly PokemonSubstruct1 +struct UnknownStruct3 +{ + u16 moves[4]; + u8 pp[4]; + u8 ppBonuses; +}; + +extern u8 gActiveBank; +extern void (*gBattleBankFunc[])(void); +extern u32 gBattleExecBuffer; +extern u8 gBattleBufferA[][0x200]; +extern u8 gObjectBankIDs[]; +extern MainCallback gPreBattleCallback1; +extern bool8 gDoingBattleAnim; +extern u16 gBattlePartyID[]; +extern u8 gHealthboxIDs[]; +extern u16 gBattleTypeFlags; +extern u16 gMovePowerMoveAnim; +extern u32 gMoveDmgMoveAnim; +extern u8 gHappinessMoveAnim; +extern u16 gWeatherMoveAnim; +extern u32 *gDisableStructMoveAnim; +extern u32 gPID_perBank[]; +extern void (*gAnimScriptCallback)(void); +extern bool8 gAnimScriptActive; +extern u8 gDisplayedStringBattle[]; +extern u8 gBankInMenu; +extern u8 gBattleMonForms[]; +extern u8 gBattleOutcome; +extern u16 gUnknown_02024DE8; +extern u8 gUnknown_02024E68[]; +extern struct SpriteTemplate gUnknown_02024E8C; +extern u8 gUnknown_0202F7C4; +extern struct Window gUnknown_03004210; +extern u16 gUnknown_030042A0; +extern u16 gUnknown_030042A4; +extern u8 gUnknown_0300434C[]; +extern const u8 gUnknown_08400CCC[]; +extern const u8 gUnknown_08400CF3[]; + +// TODO: include rom3.h when my other PR gets merged +extern void Emitcmd33(u8, u8, u16); +extern void Emitcmd35(u8, u16); + +extern void nullsub_14(void); +extern void PrepareBagForWallyTutorial(void); +extern void sub_8141828(); +extern void sub_8045A5C(); +extern void sub_804777C(); +extern void sub_8043DFC(); +extern bool8 IsDoubleBattle(void); +extern void c3_0802FDF4(u8); +extern void PlayerHandlecmd1(void); +extern void sub_8031AF4(); +extern u8 GetBankIdentity(u8); +extern void sub_80313A0(struct Sprite *); +extern u8 GetBankByPlayerAI(u8); +extern u8 sub_8031720(); +extern void ExecuteMoveAnim(); +extern void sub_80326EC(); +extern void sub_8031F24(void); +extern void sub_80324BC(); +extern void BufferStringBattle(); +extern u8 GetBankSide(u8); +extern void sub_80304A8(void); +extern void sub_8047858(); +extern void sub_80E43C0(); +extern void oamt_add_pos2_onto_pos1(); +extern void sub_8078B34(struct Sprite *); +extern void sub_8030E38(struct Sprite *); +extern void oamt_set_x3A_32(); +extern u8 sub_8046400(); +extern u8 sub_8077ABC(); +extern u8 sub_8077F68(); +extern u8 sub_8079E90(); +extern void sub_80312F0(struct Sprite *); +extern bool8 move_anim_start_t3(); + +// this file's functions + +void WallyBufferRunCommand(void); +void sub_81374FC(void); +void sub_81376B8(void); +void WallyBufferExecCompleted(void); +u32 sub_8137A84(u8, u8 *); +void sub_8138294(u8); +void sub_81390D0(void); +void sub_8139A2C(u8); + +void WallyHandleGetAttributes(void); +void WallyHandlecmd1(void); +void WallyHandleSetAttributes(void); +void WallyHandlecmd3(void); +void WallyHandleLoadPokeSprite(void); +void WallyHandleSendOutPoke(void); +void WallyHandleReturnPokeToBall(void); +void WallyHandleTrainerThrow(void); +void WallyHandleTrainerSlide(void); +void WallyHandleTrainerSlideBack(void); +void WallyHandlecmd10(void); +void WallyHandlecmd11(void); +void WallyHandlecmd12(void); +void WallyHandleBallThrow(void); +void WallyHandlePuase(void); +void WallyHandleMoveAnimation(void); +void WallyHandlePrintString(void); +void WallyHandlePrintStringPlayerOnly(void); +void WallyHandlecmd18(void); +void WallyHandlecmd19(void); +void WallyHandlecmd20(void); +void WallyHandleOpenBag(void); +void WallyHandlecmd22(void); +void WallyHandlecmd23(void); +void WallyHandleHealthBarUpdate(void); +void WallyHandleExpBarUpdate(void); +void WallyHandleStatusIconUpdate(void); +void WallyHandleStatusAnimation(void); +void WallyHandleStatusXor(void); +void WallyHandlecmd29(void); +void WallyHandleDMATransfer(void); +void WallyHandlecmd31(void); +void WallyHandlecmd32(void); +void WallyHandlecmd33(void); +void WallyHandlecmd34(void); +void WallyHandlecmd35(void); +void WallyHandlecmd36(void); +void WallyHandlecmd37(void); +void WallyHandlecmd38(void); +void WallyHandlecmd39(void); +void WallyHandlecmd40(void); +void WallyHandleHitAnimation(void); +void WallyHandlecmd42(void); +void WallyHandleEffectivenessSound(void); +void WallyHandlecmd44(void); +void WallyHandleFaintingCry(void); +void WallyHandleIntroSlide(void); +void WallyHandleTrainerBallThrow(void); +void WallyHandlecmd48(void); +void WallyHandlecmd49(void); +void WallyHandlecmd50(void); +void WallyHandleSpriteInvisibility(void); +void WallyHandleBattleAnimation(void); +void WallyHandleLinkStandbyMsg(void); +void WallyHandleResetActionMoveSelection(void); +void WallyHandlecmd55(void); +void WallyHandlecmd56(void); + +// const data + +typedef void (*BattleBufferCmd) (void); +static const BattleBufferCmd gWallyBufferCommands[] = +{ + WallyHandleGetAttributes, + WallyHandlecmd1, + WallyHandleSetAttributes, + WallyHandlecmd3, + WallyHandleLoadPokeSprite, + WallyHandleSendOutPoke, + WallyHandleReturnPokeToBall, + WallyHandleTrainerThrow, + WallyHandleTrainerSlide, + WallyHandleTrainerSlideBack, + WallyHandlecmd10, + WallyHandlecmd11, + WallyHandlecmd12, + WallyHandleBallThrow, + WallyHandlePuase, + WallyHandleMoveAnimation, + WallyHandlePrintString, + WallyHandlePrintStringPlayerOnly, + WallyHandlecmd18, + WallyHandlecmd19, + WallyHandlecmd20, + WallyHandleOpenBag, + WallyHandlecmd22, + WallyHandlecmd23, + WallyHandleHealthBarUpdate, + WallyHandleExpBarUpdate, + WallyHandleStatusIconUpdate, + WallyHandleStatusAnimation, + WallyHandleStatusXor, + WallyHandlecmd29, + WallyHandleDMATransfer, + WallyHandlecmd31, + WallyHandlecmd32, + WallyHandlecmd33, + WallyHandlecmd34, + WallyHandlecmd35, + WallyHandlecmd36, + WallyHandlecmd37, + WallyHandlecmd38, + WallyHandlecmd39, + WallyHandlecmd40, + WallyHandleHitAnimation, + WallyHandlecmd42, + WallyHandleEffectivenessSound, + WallyHandlecmd44, + WallyHandleFaintingCry, + WallyHandleIntroSlide, + WallyHandleTrainerBallThrow, + WallyHandlecmd48, + WallyHandlecmd49, + WallyHandlecmd50, + WallyHandleSpriteInvisibility, + WallyHandleBattleAnimation, + WallyHandleLinkStandbyMsg, + WallyHandleResetActionMoveSelection, + WallyHandlecmd55, + WallyHandlecmd56, +}; + +// code + +void unref_sub_8137220(void) +{ +} + +void SetBankFuncToWallyBufferRunCommand(void) +{ + gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; + ewram[0x160A8] = 0; + ewram[0x160A9] = 0; + ewram[0x160AA] = 0; + ewram[0x160AB] = 0; +} + +void WallyBufferRunCommand(void) +{ + if (gBattleExecBuffer & gBitTable[gActiveBank]) + { + if (gBattleBufferA[gActiveBank][0] < 0x39) + gWallyBufferCommands[gBattleBufferA[gActiveBank][0]](); + else + WallyBufferExecCompleted(); + } +} + +void sub_81372BC(void) +{ + u8 r4; + + switch (ewram[0x160A8]) + { + case 0: + ewram[0x160AA] = 64; + ewram[0x160A8]++; + // fall through + case 1: + r4 = --ewram[0x160AA]; + if (r4 == 0) + { + PlaySE(SE_SELECT); + Emitcmd33(1, 0, 0); + WallyBufferExecCompleted(); + ewram[0x160A8]++; + ewram[0x160A9] = r4; + ewram[0x160AA] = 64; + } + break; + case 2: + r4 = --ewram[0x160AA]; + if (r4 == 0) + { + PlaySE(SE_SELECT); + Emitcmd33(1, 0, 0); + WallyBufferExecCompleted(); + ewram[0x160A8]++; + ewram[0x160A9] = r4; + ewram[0x160AA] = 64; + } + break; + case 3: + r4 = --ewram[0x160AA]; + if (r4 == 0) + { + Emitcmd33(1, 9, 0); + WallyBufferExecCompleted(); + ewram[0x160A8]++; + ewram[0x160A9] = r4; + ewram[0x160AA] = 64; + } + break; + case 4: + if (--ewram[0x160AA] == 0) + { + PlaySE(SE_SELECT); + nullsub_8(0); + sub_802E3E4(1, 0); + ewram[0x160AA] = 64; + ewram[0x160A8]++; + } + break; + case 5: + if (--ewram[0x160AA] == 0) + { + PlaySE(SE_SELECT); + DestroyMenuCursor(); + Emitcmd33(1, 1, 0); + WallyBufferExecCompleted(); + } + break; + } +} + +void sub_813741C(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + WallyBufferExecCompleted(); +} + +void sub_8137454(void) +{ + if (gUnknown_03004210.state == 0) + WallyBufferExecCompleted(); +} + +void sub_813746C(void) +{ + if (!gPaletteFade.active) + { + gMain.inBattle = FALSE; + gMain.callback1 = gPreBattleCallback1; + SetMainCallback2(gMain.savedCallback); + } +} + +void bx_wait_t5(void) +{ + if (!gDoingBattleAnim) + WallyBufferExecCompleted(); +} + +void sub_81374C4(void) +{ + if (!gPaletteFade.active) + { + gBattleBankFunc[gActiveBank] = sub_81374FC; + nullsub_14(); + PrepareBagForWallyTutorial(); + } +} + +void sub_81374FC(void) +{ + if (gMain.callback2 == sub_800F808 + && !gPaletteFade.active) + { + Emitcmd35(1, gScriptItemId); + WallyBufferExecCompleted(); + } +} + +void sub_8137538(void) +{ + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) + sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); + + if (!ewram17810[gActiveBank ^ 2].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_7) + sub_8141828(gActiveBank ^ 2, &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]]); + + if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank ^ 2].unk0_3) + { + if (IsDoubleBattle() && !(gBattleTypeFlags & BATTLE_TYPE_MULTI)) + { + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); + sub_8045A5C(gHealthboxIDs[gActiveBank ^ 2], &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], 0); + sub_804777C(gActiveBank ^ 2); + sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); + } + DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); + sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); + sub_804777C(gActiveBank); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + ewram17840.unk9_0 = 0; + gBattleBankFunc[gActiveBank] = sub_81376B8; + } +} + +void sub_81376B8(void) +{ + bool8 r4 = FALSE; + + if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) + r4 = TRUE; + if (r4 && ewram17810[gActiveBank].unk1_0 && ewram17810[gActiveBank ^ 2].unk1_0) + { + ewram17810[gActiveBank].unk0_7 = 0; + ewram17810[gActiveBank].unk1_0 = 0; + ewram17810[gActiveBank ^ 2].unk0_7 = 0; + ewram17810[gActiveBank ^ 2].unk1_0 = 0; + FreeSpriteTilesByTag(0x27F9); + FreeSpritePaletteByTag(0x27F9); + CreateTask(c3_0802FDF4, 10); + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + WallyBufferExecCompleted(); + } +} + +void sub_81377B0(void) +{ + s16 r4; + + r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); + sub_8043DFC(gHealthboxIDs[gActiveBank]); + if (r4 != -1) + { + sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); + } + else + { + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + WallyBufferExecCompleted(); + } +} + +void bx_blink_t5(void) +{ + u8 spriteId = gObjectBankIDs[gActiveBank]; + + if (gSprites[spriteId].data1 == 32) + { + gSprites[spriteId].data1 = 0; + gSprites[spriteId].invisible = FALSE; + gDoingBattleAnim = FALSE; + WallyBufferExecCompleted(); + } + else + { + if (((u16)gSprites[spriteId].data1 % 4) == 0) + gSprites[spriteId].invisible ^= 1; + gSprites[spriteId].data1++; + } +} + +void sub_813789C(void) +{ + if (!ewram17810[gActiveBank].unk0_6) + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + WallyBufferExecCompleted(); + } +} + +// Duplicate of sub_813741C +void sub_8137908(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) + WallyBufferExecCompleted(); +} + +void sub_8137940(void) +{ + if (!ewram17810[gActiveBank].unk0_5) + WallyBufferExecCompleted(); +} + +void WallyBufferExecCompleted(void) +{ + gBattleBankFunc[gActiveBank] = WallyBufferRunCommand; + if (gBattleTypeFlags & BATTLE_TYPE_LINK) + { + u8 multiplayerId = GetMultiplayerId(); + + dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); + gBattleBufferA[gActiveBank][0] = 0x38; + } + else + { + gBattleExecBuffer &= ~gBitTable[gActiveBank]; + } +} + +void unref_sub_81379E4(void) +{ + if (!ewram17810[gActiveBank].unk0_4) + WallyBufferExecCompleted(); +} + +void WallyHandleGetAttributes(void) +{ + u8 arr[0x100]; + u32 r6 = 0; + u8 r4; + s32 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + r6 = sub_8137A84(gBattlePartyID[gActiveBank], arr); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + r6 += sub_8137A84(i, arr + r6); + r4 >>= 1; + } + } + Emitcmd29(1, r6, arr); + WallyBufferExecCompleted(); +} + +u32 sub_8137A84(u8 a, u8 *buffer) +{ + struct BattlePokemon battlePokemon; + struct UnknownStruct3 moveData; + u8 nickname[20]; + u8 *src; + s16 data16; + u32 data32; + s32 size = 0; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + for (size = 0; size < 4; size++) + { + battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); + battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); + battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); + battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); + StringCopy10(battlePokemon.nickname, nickname); + GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); + src = (u8 *)&battlePokemon; + for (size = 0; size < sizeof(battlePokemon); size++) + buffer[size] = src[size]; + break; + case 1: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 2: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 3: + for (size = 0; size < 4; size++) + { + moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); + moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + } + moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + src = (u8 *)&moveData; + for (size = 0; size < sizeof(moveData); size++) + buffer[size] = src[size]; + break; + case 4: + case 5: + case 6: + case 7: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 8: + for (size = 0; size < 4; size++) + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); + buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); + size++; + break; + case 9: + case 10: + case 11: + case 12: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); + size = 1; + break; + case 17: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 18: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + size = 3; + break; + case 19: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); + size = 1; + break; + case 20: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); + size = 1; + break; + case 21: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); + size = 1; + break; + case 22: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); + size = 1; + break; + case 23: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); + size = 1; + break; + case 24: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); + size = 1; + break; + case 25: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); + size = 1; + break; + case 26: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); + size = 1; + break; + case 27: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); + size = 1; + break; + case 28: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); + size = 1; + break; + case 29: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); + size = 1; + break; + case 30: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); + size = 1; + break; + case 31: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 6; + break; + case 32: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); + size = 1; + break; + case 33: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); + size = 1; + break; + case 34: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); + size = 1; + break; + case 35: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); + size = 1; + break; + case 36: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); + size = 1; + break; + case 37: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); + size = 1; + break; + case 38: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 39: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 40: + data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); + buffer[0] = (data32 & 0x000000FF); + buffer[1] = (data32 & 0x0000FF00) >> 8; + buffer[2] = (data32 & 0x00FF0000) >> 16; + buffer[3] = (data32 & 0xFF000000) >> 24; + size = 4; + break; + case 41: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); + size = 1; + break; + case 42: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 43: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 44: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 45: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 46: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 47: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 48: + data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); + buffer[0] = data16; + buffer[1] = data16 >> 8; + size = 2; + break; + case 49: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); + size = 1; + break; + case 50: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); + size = 1; + break; + case 51: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); + size = 1; + break; + case 52: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); + size = 1; + break; + case 53: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); + size = 1; + break; + case 54: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); + size = 1; + break; + case 55: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); + size = 1; + break; + case 56: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); + size = 1; + break; + case 57: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); + size = 1; + break; + case 58: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); + size = 1; + break; + case 59: + buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); + size = 1; + break; + } + return size; +} + +void WallyHandlecmd1(void) +{ + PlayerHandlecmd1(); +} + +void WallyHandleSetAttributes(void) +{ + u8 r4; + u8 i; + + if (gBattleBufferA[gActiveBank][2] == 0) + { + sub_8138294(gBattlePartyID[gActiveBank]); + } + else + { + r4 = gBattleBufferA[gActiveBank][2]; + for (i = 0; i < 6; i++) + { + if (r4 & 1) + sub_8138294(i); + r4 >>= 1; + } + } + WallyBufferExecCompleted(); +} + +void sub_8138294(u8 a) +{ + struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; + struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; + s32 i; + + switch (gBattleBufferA[gActiveBank][1]) + { + case 0: + { + u8 iv; + + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); + SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); + iv = battlePokemon->hpIV; + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); + iv = battlePokemon->attackIV; + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); + iv = battlePokemon->defenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); + iv = battlePokemon->speedIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); + iv = battlePokemon->spAttackIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); + iv = battlePokemon->spDefenseIV; + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); + SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); + SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); + SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); + SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); + } + break; + case 1: + SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); + break; + case 2: + SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); + break; + case 3: + for (i = 0; i < 4; i++) + { + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); + } + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); + break; + case 4: + case 5: + case 6: + case 7: + SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); + break; + case 8: + SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); + break; + case 9: + case 10: + case 11: + case 12: + SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); + break; + case 17: + SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); + break; + case 18: + SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); + break; + case 19: + SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 20: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 21: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 22: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 23: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 24: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); + break; + case 25: + SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); + break; + case 26: + SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); + break; + case 27: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); + break; + case 28: + SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 29: + SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); + break; + case 30: + SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); + break; + case 31: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); + break; + case 32: + SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 33: + SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 34: + SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 35: + SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 36: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 37: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); + break; + case 38: + SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); + break; + case 39: + SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); + break; + case 40: + SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); + break; + case 41: + SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); + break; + case 42: + SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 43: + SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); + break; + case 44: + SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); + break; + case 45: + SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); + break; + case 46: + SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); + break; + case 47: + SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); + break; + case 48: + SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); + break; + case 49: + SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); + break; + case 50: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); + break; + case 51: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); + break; + case 52: + SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); + break; + case 53: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); + break; + case 54: + SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); + break; + case 55: + SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 56: + SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 57: + SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 58: + SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + case 59: + SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); + break; + } + sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); +} + +void WallyHandlecmd3(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleLoadPokeSprite(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleSendOutPoke(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleReturnPokeToBall(void) +{ + if (gBattleBufferA[gActiveBank][1] == 0) + { + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); + gBattleBankFunc[gActiveBank] = sub_813789C; + } + else + { + FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); + DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); + sub_8043DB0(gHealthboxIDs[gActiveBank]); + WallyBufferExecCompleted(); + } +} + +void WallyHandleTrainerThrow(void) +{ + sub_8031AF4(2, gActiveBank); + GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords), + 30); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; + gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_813741C; +} + +void WallyHandleTrainerSlide(void) +{ + sub_8031AF4(2, gActiveBank); + GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); + gObjectBankIDs[gActiveBank] = CreateSprite( + &gUnknown_02024E8C, + 80, 80 + 4 * (8 - gTrainerBackPicCoords[2].coords), + 30); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; + gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -96; + gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; + gBattleBankFunc[gActiveBank] = sub_8137908; +} + +void WallyHandleTrainerSlideBack(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd10(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd11(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd12(void) +{ + ewram17840.unk8 = 4; + gDoingBattleAnim = TRUE; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 4); + gBattleBankFunc[gActiveBank] = bx_wait_t5; +} + +void WallyHandleBallThrow(void) +{ + u8 val = gBattleBufferA[gActiveBank][1]; + + ewram17840.unk8 = val; + gDoingBattleAnim = TRUE; + move_anim_start_t4(gActiveBank, gActiveBank, GetBankByPlayerAI(1), 4); + gBattleBankFunc[gActiveBank] = bx_wait_t5; +} + +void WallyHandlePuase(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleMoveAnimation(void) +{ + u16 r0 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + + gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; + gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] | (gBattleBufferA[gActiveBank][5] << 8); + gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] | (gBattleBufferA[gActiveBank][7] << 8) | (gBattleBufferA[gActiveBank][8] << 16) | (gBattleBufferA[gActiveBank][9] << 24); + gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; + gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] | (gBattleBufferA[gActiveBank][13] << 8); + gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; + gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; + if (sub_8031720(r0, gUnknown_0202F7C4) != 0) + { + // Dead code. sub_8031720 always returns 0. + WallyBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk4 = 0; + gBattleBankFunc[gActiveBank] = sub_81390D0; + } +} + +void sub_81390D0(void) +{ + u16 r4 = gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8); + +#ifndef NONMATCHING + asm("":::"r6"); +#endif + + switch (ewram17810[gActiveBank].unk4) + { + case 0: + if (ewram17800[gActiveBank].unk0_2 == 1) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); + ewram17810[gActiveBank].unk4 = 1; + break; + case 1: + if (ewram17810[gActiveBank].unk0_6 == 0) + { + sub_80326EC(0); + ExecuteMoveAnim(r4); + ewram17810[gActiveBank].unk4 = 2; + } + break; + case 2: + gAnimScriptCallback(); + if (!gAnimScriptActive) + { + sub_80326EC(1); + if (ewram17800[gActiveBank].unk0_2 == 1) + move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); + ewram17810[gActiveBank].unk4 = 3; + } + break; + case 3: + if (ewram17810[gActiveBank].unk0_6 == 0) + { + sub_8031F24(); + sub_80324BC(gActiveBank, gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + ewram17810[gActiveBank].unk4 = 0; + WallyBufferExecCompleted(); + } + break; + } +} + +void WallyHandlePrintString(void) +{ + u16 *ptr; + + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 0; + ptr = (u16 *)&gBattleBufferA[gActiveBank][2]; + if (*ptr == 2) + DestroyMenuCursor(); + BufferStringBattle(*ptr); + sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 0x90, 2, 15); + gBattleBankFunc[gActiveBank] = sub_8137454; +} + +void WallyHandlePrintStringPlayerOnly(void) +{ + if (GetBankSide(gActiveBank) == 0) + WallyHandlePrintString(); + else + WallyBufferExecCompleted(); +} + +void WallyHandlecmd18(void) +{ + s32 i; + + gUnknown_030042A4 = 0; + gUnknown_030042A0 = 160; + gUnknown_03004210.paletteNum = 0; + FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 15, 27, 18); + FillWindowRect_DefaultPalette(&gUnknown_03004210, 10, 2, 35, 16, 36); + gBattleBankFunc[gActiveBank] = sub_81372BC; + InitWindow(&gUnknown_03004210, gUnknown_08400CF3, 400, 18, 35); + sub_8002F44(&gUnknown_03004210); + sub_814A5C0(0, 0xFFFF, 12, 0x2D9F, 0); + for (i = 0; i < 4; i++) + nullsub_8(i); + sub_802E3E4(0, 0); + StrCpyDecodeToDisplayedStringBattle(gUnknown_08400CCC); +#ifdef ENGLISH + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 440, 2, 35); +#else + InitWindow(&gUnknown_03004210, gDisplayedStringBattle, 444, 2, 35); +#endif + sub_8002F44(&gUnknown_03004210); +} + +void WallyHandlecmd19(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd20(void) +{ + switch (ewram[0x160A9]) + { + case 0: + sub_80304A8(); + ewram[0x160A9]++; + ewram[0x160AB] = 80; + // fall through + case 1: + ewram[0x160AB]--; + if (ewram[0x160AB] == 0) + { + DestroyMenuCursor(); + PlaySE(SE_SELECT); + Emitcmd33(1, 10, 256); + WallyBufferExecCompleted(); + } + break; + } +} + +void WallyHandleOpenBag(void) +{ + BeginNormalPaletteFade(0xFFFFFFFF, 0, 0, 16, 0); + gBattleBankFunc[gActiveBank] = sub_81374C4; + gBankInMenu = gActiveBank; +} + +void WallyHandlecmd22(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd23(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleHealthBarUpdate(void) +{ + s16 r7; + + load_gfxc_health_bar(0); + r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + if (r7 != 0x7FFF) + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + u32 curHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, curHP, r7); + } + else + { + u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); + + sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); + sub_80440EC(gHealthboxIDs[gActiveBank], 0, 0); + } + gBattleBankFunc[gActiveBank] = sub_81377B0; +} + +void WallyHandleExpBarUpdate(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleStatusIconUpdate(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleStatusAnimation(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleStatusXor(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd29(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleDMATransfer(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd31(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd32(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd33(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd34(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd35(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd36(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd37(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd38(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd39(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd40(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleHitAnimation(void) +{ + if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) + { + WallyBufferExecCompleted(); + } + else + { + gDoingBattleAnim = 1; + gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; + sub_8047858(gActiveBank); + gBattleBankFunc[gActiveBank] = bx_blink_t5; + } +} + +void WallyHandlecmd42(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleEffectivenessSound(void) +{ + PlaySE(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + WallyBufferExecCompleted(); +} + +void WallyHandlecmd44(void) +{ + PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); + WallyBufferExecCompleted(); +} + +void WallyHandleFaintingCry(void) +{ + PlayCry1(GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), 25); + WallyBufferExecCompleted(); +} + +void WallyHandleIntroSlide(void) +{ + sub_80E43C0(gBattleBufferA[gActiveBank][1]); + gUnknown_02024DE8 |= 1; + WallyBufferExecCompleted(); +} + +void WallyHandleTrainerBallThrow(void) +{ + u8 paletteNum; + u8 taskId; + + oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); + gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; + gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; + gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; + gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; + gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; + oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); + StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); + paletteNum = AllocSpritePalette(0xD6F8); + LoadCompressedPalette(gTrainerBackPicPaletteTable[2].data, 0x100 + paletteNum * 16, 32); + gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = paletteNum; + taskId = CreateTask(sub_8139A2C, 5); + gTasks[taskId].data[0] = gActiveBank; + if (ewram17810[gActiveBank].unk0_0) + gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; + ewram17810[4].unk9 |= 1; + gBattleBankFunc[gActiveBank] = nullsub_91; +} + +void sub_81398BC(u8 bank) +{ + u16 species; + + ewram17800[bank].unk2 = 0; + gBattlePartyID[bank] = gBattleBufferA[bank][1]; + species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); + gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); + GetMonSpriteTemplate_803C56C(species, GetBankIdentity(bank)); + gObjectBankIDs[bank] = CreateSprite( + &gUnknown_02024E8C, + sub_8077ABC(bank, 2), + sub_8077F68(bank), + sub_8079E90(bank)); + gSprites[gUnknown_0300434C[bank]].data1 = gObjectBankIDs[bank]; + gSprites[gObjectBankIDs[bank]].data0 = bank; + gSprites[gObjectBankIDs[bank]].data2 = species; + gSprites[gObjectBankIDs[bank]].oam.paletteNum = bank; + StartSpriteAnim(&gSprites[gObjectBankIDs[bank]], gBattleMonForms[bank]); + gSprites[gObjectBankIDs[bank]].invisible = TRUE; + gSprites[gObjectBankIDs[bank]].callback = SpriteCallbackDummy; + gSprites[gUnknown_0300434C[bank]].data0 = sub_8046400(0, 0xFF); +} + +void sub_8139A2C(u8 taskId) +{ + if (gTasks[taskId].data[1] < 31) + { + gTasks[taskId].data[1]++; + } + else + { + u8 savedActiveBank = gActiveBank; + + gActiveBank = gTasks[taskId].data[0]; + gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; + sub_81398BC(gActiveBank); + gBattleBankFunc[gActiveBank] = sub_8137538; + gActiveBank = savedActiveBank; + DestroyTask(taskId); + } +} + +void WallyHandlecmd48(void) +{ + if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) + { + WallyBufferExecCompleted(); + } + else + { + ewram17810[gActiveBank].unk0_0 = 1; + gUnknown_02024E68[gActiveBank] = sub_8044804(gActiveBank, (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], gBattleBufferA[gActiveBank][1], gBattleBufferA[gActiveBank][2]); + WallyBufferExecCompleted(); + } +} + +void WallyHandlecmd49(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd50(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleSpriteInvisibility(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleBattleAnimation(void) +{ + u8 val2 = gBattleBufferA[gActiveBank][1]; + u16 val = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); + + if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, val2, val)) + WallyBufferExecCompleted(); + else + gBattleBankFunc[gActiveBank] = sub_8137940; +} + +void WallyHandleLinkStandbyMsg(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandleResetActionMoveSelection(void) +{ + WallyBufferExecCompleted(); +} + +void WallyHandlecmd55(void) +{ + gBattleOutcome = gBattleBufferA[gActiveBank][1]; + FadeOutMapMusic(5); + BeginFastPaletteFade(3); + WallyBufferExecCompleted(); + if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) + gBattleBankFunc[gActiveBank] = sub_813746C; +} + +void WallyHandlecmd56(void) +{ +} diff --git a/src/rom3.c b/src/rom3.c index 803bbf943..e9e664069 100644 --- a/src/rom3.c +++ b/src/rom3.c @@ -573,7 +573,7 @@ void EmitGetAttributes(u8 a, u8 b, u8 c) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x01_a_b_0(u8 a, u8 b, u8 c) +void Emitcmd1(u8 a, u8 b, u8 c) { gBattleBuffersTransferData[0] = 1; gBattleBuffersTransferData[1] = b; @@ -594,7 +594,7 @@ void EmitSetAttributes(u8 a, u8 b, u8 c, u8 d, void *e) dp01_prepare_buffer(a, gBattleBuffersTransferData, d + 3); } -void unref_sub_800C6A4(u8 a, u8 b, u8 c, u8 *d) +void Emitcmd3(u8 a, u8 b, u8 c, u8 *d) { int i; @@ -606,7 +606,7 @@ void unref_sub_800C6A4(u8 a, u8 b, u8 c, u8 *d) dp01_prepare_buffer(a, gBattleBuffersTransferData, c + 3); } -void dp01_build_cmdbuf_x04_4_4_4(u8 a) +void EmitLoadPokeSprite(u8 a) { gBattleBuffersTransferData[0] = 4; gBattleBuffersTransferData[1] = 4; @@ -615,7 +615,7 @@ void dp01_build_cmdbuf_x04_4_4_4(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitSwitchInAnim(u8 a, u8 b, u8 c) +void EmitSendOutPoke(u8 a, u8 b, u8 c) { gBattleBuffersTransferData[0] = 5; gBattleBuffersTransferData[1] = b; @@ -631,7 +631,7 @@ void EmitReturnPokeToBall(u8 a, u8 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void dp01_build_cmdbuf_x07_7_7_7(u8 a) +void EmitTrainerThrow(u8 a) { gBattleBuffersTransferData[0] = 7; gBattleBuffersTransferData[1] = 7; @@ -649,7 +649,7 @@ void EmitTrainerSlide(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x09_9_9_9(u8 a) +void EmitTrainerSlideBack(u8 a) { gBattleBuffersTransferData[0] = 9; gBattleBuffersTransferData[1] = 9; @@ -658,7 +658,7 @@ void dp01_build_cmdbuf_x09_9_9_9(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitFaintAnimation(u8 a) +void Emitcmd10(u8 a) { gBattleBuffersTransferData[0] = 10; gBattleBuffersTransferData[1] = 10; @@ -667,7 +667,7 @@ void EmitFaintAnimation(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x0B_B_B_B(u8 a) +void Emitcmd11(u8 a) { gBattleBuffersTransferData[0] = 11; gBattleBuffersTransferData[1] = 11; @@ -676,7 +676,7 @@ void dp01_build_cmdbuf_x0B_B_B_B(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x0C_C_C_C(u8 a) +void Emitcmd12(u8 a) { gBattleBuffersTransferData[0] = 12; gBattleBuffersTransferData[1] = 12; @@ -685,14 +685,14 @@ void dp01_build_cmdbuf_x0C_C_C_C(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitBallThrowAnim(u8 a, u8 b) +void EmitBallThrow(u8 a, u8 b) { gBattleBuffersTransferData[0] = 13; gBattleBuffersTransferData[1] = b; dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void unref_sub_800C828(u8 a, u8 b, u8 *c) +void EmitPuase(u8 a, u8 b, u8 *c) { int i; @@ -1021,7 +1021,7 @@ _0800CB54: .4byte gBattleTextBuff1\n\ .syntax divided\n"); } -void dp01_build_cmdbuf_x12_a_bb(u8 a, u8 b, u16 c) +void Emitcmd18(u8 a, u8 b, u16 c) { gBattleBuffersTransferData[0] = 18; gBattleBuffersTransferData[1] = b; @@ -1030,14 +1030,14 @@ void dp01_build_cmdbuf_x12_a_bb(u8 a, u8 b, u16 c) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void unref_sub_800CB84(u8 a, u8 b) +void Emitcmd19(u8 a, u8 b) { gBattleBuffersTransferData[0] = 19; gBattleBuffersTransferData[1] = b; dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void sub_800CBA4(u8 a, u8 b, u8 c, u8 *d) +void Emitcmd20(u8 a, u8 b, u8 c, u8 *d) { u32 i; @@ -1050,7 +1050,7 @@ void sub_800CBA4(u8 a, u8 b, u8 c, u8 *d) dp01_prepare_buffer(a, gBattleBuffersTransferData, 24); } -void sub_800CBE0(u8 a, u8 *b) +void EmitOpenBag(u8 a, u8 *b) { int i; @@ -1060,7 +1060,7 @@ void sub_800CBE0(u8 a, u8 *b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitChoosePokemon(u8 a, u8 b, u8 c, u8 d, u8 *e) +void Emitcmd22(u8 a, u8 b, u8 c, u8 d, u8 *e) { int i; @@ -1073,7 +1073,7 @@ void EmitChoosePokemon(u8 a, u8 b, u8 c, u8 d, u8 *e) dp01_prepare_buffer(a, gBattleBuffersTransferData, 8); //but only 7 bytes were written } -void dp01_build_cmdbuf_x17_17_17_17(u8 a) +void Emitcmd23(u8 a) { gBattleBuffersTransferData[0] = 23; gBattleBuffersTransferData[1] = 23; @@ -1136,7 +1136,7 @@ void EmitStatusXor(u8 a, u8 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void dp01_build_cmdbuf_x1D_1D_numargs_varargs(u8 a, u16 b, u8 *c) +void Emitcmd29(u8 a, u16 b, u8 *c) { int i; @@ -1149,7 +1149,7 @@ void dp01_build_cmdbuf_x1D_1D_numargs_varargs(u8 a, u16 b, u8 *c) dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 4); } -void unref_sub_800CDD4(u8 a, u32 b, u16 c, u8 *d) +void EmitDMATransfer(u8 a, u32 b, u16 c, u8 *d) { int i; @@ -1165,7 +1165,7 @@ void unref_sub_800CDD4(u8 a, u32 b, u16 c, u8 *d) dp01_prepare_buffer(a, gBattleBuffersTransferData, c + 7); } -void unref_sub_800CE3C(u8 a, u16 b, u8 *c) +void Emitcmd31(u8 a, u16 b, u8 *c) { int i; @@ -1177,7 +1177,7 @@ void unref_sub_800CE3C(u8 a, u16 b, u8 *c) dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 3); } -void unref_sub_800CE84(u8 a, u16 b, u8 *c) +void Emitcmd32(u8 a, u16 b, u8 *c) { int i; @@ -1189,7 +1189,7 @@ void unref_sub_800CE84(u8 a, u16 b, u8 *c) dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 3); } -void dp01_build_cmdbuf_x21_a_bb(u8 a, u8 b, u16 c) +void Emitcmd33(u8 a, u8 b, u16 c) { gBattleBuffersTransferData[0] = 33; gBattleBuffersTransferData[1] = b; @@ -1198,7 +1198,7 @@ void dp01_build_cmdbuf_x21_a_bb(u8 a, u8 b, u16 c) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x22_a_three_bytes(u8 a, u8 b, u8 *c) +void Emitcmd34(u8 a, u8 b, u8 *c) { int i; @@ -1209,7 +1209,7 @@ void dp01_build_cmdbuf_x22_a_three_bytes(u8 a, u8 b, u8 *c) dp01_prepare_buffer(a, gBattleBuffersTransferData, 5); } -void dp01_build_cmdbuf_x23_aa_0(u8 a, u16 b) +void Emitcmd35(u8 a, u16 b) { gBattleBuffersTransferData[0] = 35; gBattleBuffersTransferData[1] = b; @@ -1218,7 +1218,7 @@ void dp01_build_cmdbuf_x23_aa_0(u8 a, u16 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x24_aa_0(u8 a, u16 b) +void Emitcmd36(u8 a, u16 b) { gBattleBuffersTransferData[0] = 36; gBattleBuffersTransferData[1] = b; @@ -1227,7 +1227,7 @@ void dp01_build_cmdbuf_x24_aa_0(u8 a, u16 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x25_25_25_25(u8 a) +void Emitcmd37(u8 a) { gBattleBuffersTransferData[0] = 37; gBattleBuffersTransferData[1] = 37; @@ -1236,14 +1236,14 @@ void dp01_build_cmdbuf_x25_25_25_25(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x26_a(u8 a, u8 b) +void Emitcmd38(u8 a, u8 b) { gBattleBuffersTransferData[0] = 38; gBattleBuffersTransferData[1] = b; dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void dp01_build_cmdbuf_x27_27_27_27(u8 a) +void Emitcmd39(u8 a) { gBattleBuffersTransferData[0] = 39; gBattleBuffersTransferData[1] = 39; @@ -1252,7 +1252,7 @@ void dp01_build_cmdbuf_x27_27_27_27(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x28_28_28_28(u8 a) +void Emitcmd40(u8 a) { gBattleBuffersTransferData[0] = 40; gBattleBuffersTransferData[1] = 40; @@ -1270,7 +1270,7 @@ void EmitHitAnimation(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x2A_2A_2A_2A(u8 a) +void Emitcmd42(u8 a) { gBattleBuffersTransferData[0] = 42; gBattleBuffersTransferData[1] = 42; @@ -1288,7 +1288,7 @@ void EmitEffectivenessSound(u8 a, u16 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitPlaySound(u8 a, u16 b) +void Emitcmd44(u8 a, u16 b) { gBattleBuffersTransferData[0] = 44; gBattleBuffersTransferData[1] = b; @@ -1306,14 +1306,14 @@ void EmitFaintingCry(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void EmitBattleIntroSlide(u8 a, u8 b) +void EmitIntroSlide(u8 a, u8 b) { gBattleBuffersTransferData[0] = 46; gBattleBuffersTransferData[1] = b; dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void dp01_build_cmdbuf_x2F_2F_2F_2F(u8 a) +void EmitTrainerBallThrow(u8 a) { gBattleBuffersTransferData[0] = 47; gBattleBuffersTransferData[1] = 47; @@ -1322,7 +1322,7 @@ void dp01_build_cmdbuf_x2F_2F_2F_2F(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x30_TODO(u8 a, u8 *b, u8 c) +void Emitcmd48(u8 a, u8 *b, u8 c) { int i; @@ -1335,7 +1335,7 @@ void dp01_build_cmdbuf_x30_TODO(u8 a, u8 *b, u8 c) dp01_prepare_buffer(a, gBattleBuffersTransferData, 52); } -void dp01_build_cmdbuf_x31_31_31_31(u8 a) +void Emitcmd49(u8 a) { gBattleBuffersTransferData[0] = 49; gBattleBuffersTransferData[1] = 49; @@ -1344,7 +1344,7 @@ void dp01_build_cmdbuf_x31_31_31_31(u8 a) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void dp01_build_cmdbuf_x32_32_32_32(u8 a) +void Emitcmd50(u8 a) { gBattleBuffersTransferData[0] = 50; gBattleBuffersTransferData[1] = 50; @@ -1385,7 +1385,7 @@ void EmitResetActionMoveSelection(u8 a, u8 b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); } -void dp01_build_cmdbuf_x37_a(u8 a, u8 b) +void Emitcmd55(u8 a, u8 b) { gBattleBuffersTransferData[0] = 55; gBattleBuffersTransferData[1] = b; -- cgit v1.2.3 From 42a36959b95aad5a55a2f7bb17dcdc941dd89750 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sat, 26 Aug 2017 20:19:34 -0500 Subject: fix build --- src/battle_2.c | 4 +- src/battle_7.c | 56 +- src/battle_8.c | 1642 --------------------------------- src/battle_811DA74.c | 1606 -------------------------------- src/battle_controller_linkopponent2.c | 14 +- src/battle_controller_linkpartner.c | 22 +- src/battle_controller_opponent.c | 16 +- src/battle_controller_player.c | 26 +- src/battle_controller_wally.c | 12 +- 9 files changed, 75 insertions(+), 3323 deletions(-) delete mode 100644 src/battle_8.c delete mode 100644 src/battle_811DA74.c (limited to 'src') diff --git a/src/battle_2.c b/src/battle_2.c index 06e20bb06..106d3333b 100644 --- a/src/battle_2.c +++ b/src/battle_2.c @@ -1347,8 +1347,8 @@ void sub_8010384(struct Sprite *sprite) u16 species; u8 yOffset; - if (ewram17800[r6].unk2 != 0) - species = ewram17800[r6].unk2; + if (ewram17800[r6].transformedSpecies != 0) + species = ewram17800[r6].transformedSpecies; else species = sprite->data2; diff --git a/src/battle_7.c b/src/battle_7.c index 4ae220f6c..cf3a3522e 100644 --- a/src/battle_7.c +++ b/src/battle_7.c @@ -177,9 +177,9 @@ bool8 move_anim_start_t3(u8 a, u8 b, u8 c, u8 d, u16 e) gBattleMonForms[a] = e & 0x7F; return TRUE; } - if (ewram17800[a].unk0_2 && sub_803163C(d) == 0) + if (ewram17800[a].substituteSprite && sub_803163C(d) == 0) return TRUE; - if (ewram17800[a].unk0_2 && d == 2 && gSprites[gObjectBankIDs[a]].invisible) + if (ewram17800[a].substituteSprite && d == 2 && gSprites[gObjectBankIDs[a]].invisible) { refresh_graphics_maybe(a, 1, gObjectBankIDs[a]); sub_80324E0(a); @@ -268,7 +268,7 @@ bool8 mplay_80342A4(u8 a) return TRUE; } -void sub_8031794(struct Pokemon *pkmn, u8 b) +void BattleLoadOpponentMonSprite(struct Pokemon *pkmn, u8 b) { u32 personalityValue; u16 species; @@ -279,14 +279,14 @@ void sub_8031794(struct Pokemon *pkmn, u8 b) const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[b].unk2 == 0) + if (ewram17800[b].transformedSpecies == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); r7 = personalityValue; } else { - species = ewram17800[b].unk2; + species = ewram17800[b].transformedSpecies; r7 = gPID_perBank[b]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); @@ -300,7 +300,7 @@ void sub_8031794(struct Pokemon *pkmn, u8 b) species, r7); paletteOffset = 0x100 + b * 16; - if (ewram17800[b].unk2 == 0) + if (ewram17800[b].transformedSpecies == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); @@ -313,14 +313,14 @@ void sub_8031794(struct Pokemon *pkmn, u8 b) sub_800D238(lzPaletteData, ewram + 0x16400); LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); } - if (ewram17800[b].unk2 != 0) + if (ewram17800[b].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); } } -void sub_80318FC(struct Pokemon *pkmn, u8 b) +void BattleLoadPlayerMonSprite(struct Pokemon *pkmn, u8 b) { u32 personalityValue; u16 species; @@ -331,14 +331,14 @@ void sub_80318FC(struct Pokemon *pkmn, u8 b) const u8 *lzPaletteData; personalityValue = GetMonData(pkmn, MON_DATA_PERSONALITY); - if (ewram17800[b].unk2 == 0) + if (ewram17800[b].transformedSpecies == 0) { species = GetMonData(pkmn, MON_DATA_SPECIES); r7 = personalityValue; } else { - species = ewram17800[b].unk2; + species = ewram17800[b].transformedSpecies; r7 = gPID_perBank[b]; } otId = GetMonData(pkmn, MON_DATA_OT_ID); @@ -352,7 +352,7 @@ void sub_80318FC(struct Pokemon *pkmn, u8 b) species, r7); paletteOffset = 0x100 + b * 16; - if (ewram17800[b].unk2 == 0) + if (ewram17800[b].transformedSpecies == 0) lzPaletteData = pokemon_get_pal(pkmn); else lzPaletteData = species_and_otid_get_pal(species, otId, personalityValue); @@ -365,7 +365,7 @@ void sub_80318FC(struct Pokemon *pkmn, u8 b) sub_800D238(lzPaletteData, ewram + 0x16400); LoadPalette(ewram + 0x16400 + gBattleMonForms[b] * 32, paletteOffset, 0x20); } - if (ewram17800[b].unk2 != 0) + if (ewram17800[b].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); @@ -400,7 +400,7 @@ void sub_8031A6C(u16 a, u8 b) LoadCompressedObjectPalette(&gTrainerFrontPicPaletteTable[a]); } -void sub_8031AF4(u16 a, u8 b) +void LoadPlayerTrainerBankSprite(u16 a, u8 b) { u8 status; @@ -602,12 +602,12 @@ void sub_8031F24(void) s32 i; for (i = 0; i < gNoOfAllBanks; i++) - ewram17800[i].unk0_0 = gSprites[gObjectBankIDs[i]].invisible; + ewram17800[i].invisible = gSprites[gObjectBankIDs[i]].invisible; } void sub_8031F88(u8 a) { - ewram17800[a].unk0_0 = gSprites[gObjectBankIDs[a]].invisible; + ewram17800[a].invisible = gSprites[gObjectBankIDs[a]].invisible; } void sub_8031FC4(u8 a, u8 b, bool8 c) @@ -625,7 +625,7 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) paletteOffset = 0x100 + a * 16; LoadPalette(ewram + 0x16400 + ewram17840.unk0 * 32, paletteOffset, 32); gBattleMonForms[a] = ewram17840.unk0; - if (ewram17800[a].unk2 != 0) + if (ewram17800[a].transformedSpecies != 0) { BlendPalette(paletteOffset, 16, 6, 0x7FFF); CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); @@ -704,7 +704,7 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) CpuCopy32(gPlttBufferFaded + paletteOffset, gPlttBufferUnfaded + paletteOffset, 32); if (!IsContest()) { - ewram17800[a].unk2 = species; + ewram17800[a].transformedSpecies = species; gBattleMonForms[a] = gBattleMonForms[b]; } gSprites[gObjectBankIDs[a]].pos1.y = sub_8077F68(a); @@ -712,7 +712,7 @@ void sub_8031FC4(u8 a, u8 b, bool8 c) } } -void sub_8032350(u8 a, u8 b) +void BattleLoadSubstituteSprite(u8 a, u8 b) { u8 r4; u16 foo; @@ -745,16 +745,16 @@ void sub_8032350(u8 a, u8 b) if (!IsContest()) { if (GetBankSide(a) != 0) - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); else - sub_80318FC(&gPlayerParty[gBattlePartyID[a]], a); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[a]], a); } } } void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) { - sub_8032350(a, b); + BattleLoadSubstituteSprite(a, b); StartSpriteAnim(&gSprites[spriteId], gBattleMonForms[a]); if (b == 0) gSprites[spriteId].pos1.y = sub_8077F7C(a); @@ -765,12 +765,12 @@ void refresh_graphics_maybe(u8 a, u8 b, u8 spriteId) void sub_80324BC(u8 a, u16 b) { if (b == 0xA4) - ewram17800[a].unk0_2 = 1; + ewram17800[a].substituteSprite = 1; } void sub_80324E0(u8 a) { - ewram17800[a].unk0_2 = 0; + ewram17800[a].substituteSprite = 0; } void sub_80324F8(struct Pokemon *pkmn, u8 b) @@ -891,9 +891,9 @@ void sub_80328A4(struct Sprite *sprite) } if (gAnimScriptActive || r7->invisible) invisible = TRUE; - else if (ewram17800[r4].unk2 != 0 && gEnemyMonElevation[ewram17800[r4].unk2] == 0) + else if (ewram17800[r4].transformedSpecies != 0 && gEnemyMonElevation[ewram17800[r4].transformedSpecies] == 0) invisible = TRUE; - if (ewram17800[r4].unk0_2) + if (ewram17800[r4].substituteSprite) invisible = TRUE; sprite->pos1.x = r7->pos1.x; sprite->pos2.x = r7->pos2.x; @@ -909,8 +909,8 @@ void sub_8032984(u8 a, u16 b) { if (GetBankSide(a) != 0) { - if (ewram17800[a].unk2 != 0) - b = ewram17800[a].unk2; + if (ewram17800[a].transformedSpecies != 0) + b = ewram17800[a].transformedSpecies; if (gEnemyMonElevation[b] != 0) gSprites[ewram17810[a].unk7].callback = sub_80328A4; else @@ -948,7 +948,7 @@ void sub_8032A38(void) void sub_8032AA8(u8 a, u8 b) { - ewram17800[a].unk2 = 0; + ewram17800[a].transformedSpecies = 0; gBattleMonForms[a] = 0; if (b == 0) sub_80324E0(a); diff --git a/src/battle_8.c b/src/battle_8.c deleted file mode 100644 index 44e42d0d6..000000000 --- a/src/battle_8.c +++ /dev/null @@ -1,1642 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_ai.h" -#include "battle_interface.h" -#include "data2.h" -#include "graphics.h" -#include "main.h" -#include "pokemon.h" -#include "rng.h" -#include "rom3.h" -#include "songs.h" -#include "sound.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -struct UnknownStruct3 -{ - u16 moves[4]; - u8 pp[4]; - u8 ppBonuses; -}; - -extern u8 gActiveBank; -extern u8 gBattleBufferA[][0x200]; -extern u16 gBattlePartyID[]; -extern u8 gObjectBankIDs[]; -extern u8 gBattleMonForms[]; -extern struct SpriteTemplate gUnknown_02024E8C; -extern void (*gBattleBankFunc[])(void); -extern u8 gUnknown_0300434C[]; -extern u8 gHealthboxIDs[]; -extern u16 gBattleTypeFlags; -extern u16 gTrainerBattleOpponent; -extern u32 *gDisableStructMoveAnim; -extern u32 gMoveDmgMoveAnim; -extern u16 gMovePowerMoveAnim; -extern u8 gHappinessMoveAnim; -extern u16 gWeatherMoveAnim; -extern u32 gPID_perBank[]; -extern u8 gUnknown_0202F7C4; -extern u8 gAnimScriptActive; -extern void (*gAnimScriptCallback)(void); -extern struct Window gUnknown_03004210; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; -extern u8 gDisplayedStringBattle[]; -extern u8 gBankTarget; -extern u8 gAbsentBankFlags; -extern bool8 gDoingBattleAnim; -extern u16 gUnknown_02024DE8; -extern u8 gUnknown_02024E68[]; -extern MainCallback gPreBattleCallback1; - -extern u8 sub_8077ABC(); -extern u8 sub_8077F68(); -extern u8 sub_8079E90(); -extern void sub_8033018(void); -extern void BattleLoadOpponentMonSprite(); -extern u8 GetBankIdentity(u8); -extern void sub_8032984(u8, u16); -extern void sub_80333D4(void); -extern void sub_80312F0(struct Sprite *); -extern u8 sub_8046400(); -extern void sub_8032A08(); -extern void sub_8043DB0(); -extern void sub_8033160(void); -extern u8 sub_8135FBC(void); -extern u8 get_trainer_class_pic_index(void); -extern void sub_80313A0(struct Sprite *); -extern void sub_8032B4C(void); -extern void sub_8031A6C(u16, u8); -extern void sub_8032B84(void); -extern void sub_8078B34(struct Sprite *); -extern void sub_8032BBC(void); -extern void oamt_add_pos2_onto_pos1(); -extern void oamt_set_x3A_32(); -extern void sub_803311C(void); -extern void sub_8010384(struct Sprite *); -extern bool8 mplay_80342A4(u8); -extern u8 sub_8031720(); -extern void ExecuteMoveAnim(); -extern void sub_80326EC(); -extern void sub_8031F24(void); -extern void sub_80324BC(); -extern void BufferStringBattle(); -extern void sub_80331D0(void); -extern void sub_8036B0C(void); -extern u8 GetBankByPlayerAI(u8); -extern u8 sub_8036CD4(void); -extern void sub_80330C8(void); -extern void sub_8043D84(); -extern void sub_8045A5C(); -void sub_8033494(void); -extern void move_anim_start_t2_for_situation(); -extern void bx_blink_t7(void); -extern void sub_8047858(); -extern u8 GetBankSide(u8); -extern void sub_80E43C0(); -extern void sub_8044CA0(u8); -extern void nullsub_45(void); -extern void sub_8031B74(); -extern bool8 IsDoubleBattle(void); -extern void sub_8032E2C(void); -extern u8 sub_8078874(); -extern u8 move_anim_start_t3(); -extern void sub_80334C0(void); -extern void OpponentBufferExecCompleted(void); - -u32 sub_8033598(u8, u8 *); -void sub_8033E24(u8); -void sub_803495C(u8, u8); -void sub_8034B74(void); -void sub_8035238(void); -void sub_8035C10(struct Sprite *); -void sub_8035C44(u8); -void sub_8035E2C(void); - -void OpponentHandleGetAttributes(void) -{ - u8 buffer[256]; - int r6 = 0; - s32 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - r6 = sub_8033598(gBattlePartyID[gActiveBank], buffer); - } - else - { - u8 r4 = gBattleBufferA[gActiveBank][2]; - - for (i = 0; i < 6; i++) - { - if (r4 & 1) - r6 += sub_8033598(i, buffer + r6); - r4 >>= 1; - } - } - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, r6, buffer); - OpponentBufferExecCompleted(); -} - -u32 sub_8033598(u8 a, u8 *buffer) -{ - struct BattlePokemon battlePokemon; - struct UnknownStruct3 moveData; - u8 nickname[20]; - u8 *src; - s16 data16; - u32 data32; - s32 size = 0; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - battlePokemon.species = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); - battlePokemon.item = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); - for (size = 0; size < 4; size++) - { - battlePokemon.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); - battlePokemon.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - } - battlePokemon.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - battlePokemon.friendship = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); - battlePokemon.experience = GetMonData(&gEnemyParty[a], MON_DATA_EXP); - battlePokemon.hpIV = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - battlePokemon.attackIV = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - battlePokemon.defenseIV = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - battlePokemon.speedIV = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - battlePokemon.spAttackIV = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - battlePokemon.spDefenseIV = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - battlePokemon.personality = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); - battlePokemon.status1 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); - battlePokemon.level = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); - battlePokemon.hp = GetMonData(&gEnemyParty[a], MON_DATA_HP); - battlePokemon.maxHP = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); - battlePokemon.attack = GetMonData(&gEnemyParty[a], MON_DATA_ATK); - battlePokemon.defense = GetMonData(&gEnemyParty[a], MON_DATA_DEF); - battlePokemon.speed = GetMonData(&gEnemyParty[a], MON_DATA_SPD); - battlePokemon.spAttack = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); - battlePokemon.spDefense = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); - battlePokemon.isEgg = GetMonData(&gEnemyParty[a], MON_DATA_IS_EGG); - battlePokemon.altAbility = GetMonData(&gEnemyParty[a], MON_DATA_ALT_ABILITY); - battlePokemon.otId = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); - GetMonData(&gEnemyParty[a], MON_DATA_NICKNAME, nickname); - StringCopy10(battlePokemon.nickname, nickname); - GetMonData(&gEnemyParty[a], MON_DATA_OT_NAME, battlePokemon.otName); - src = (u8 *)&battlePokemon; - for (size = 0; size < sizeof(battlePokemon); size++) - buffer[size] = src[size]; - break; - case 1: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPECIES); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 2: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 3: - for (size = 0; size < 4; size++) - { - moveData.moves[size] = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + size); - moveData.pp[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - } - moveData.ppBonuses = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - src = (u8 *)&moveData; - for (size = 0; size < sizeof(moveData); size++) - buffer[size] = src[size]; - break; - case 4: - case 5: - case 6: - case 7: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 8: - for (size = 0; size < 4; size++) - buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + size); - buffer[size] = GetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES); - size++; - break; - case 9: - case 10: - case 11: - case 12: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); - size = 1; - break; - case 17: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_OT_ID); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 18: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_EXP); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 19: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_EV); - size = 1; - break; - case 20: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_EV); - size = 1; - break; - case 21: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_EV); - size = 1; - break; - case 22: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_EV); - size = 1; - break; - case 23: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV); - size = 1; - break; - case 24: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV); - size = 1; - break; - case 25: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP); - size = 1; - break; - case 26: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKERUS); - size = 1; - break; - case 27: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION); - size = 1; - break; - case 28: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL); - size = 1; - break; - case 29: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_MET_GAME); - size = 1; - break; - case 30: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_POKEBALL); - size = 1; - break; - case 31: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - buffer[1] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - buffer[2] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - buffer[3] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - buffer[4] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - buffer[5] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - size = 6; - break; - case 32: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_HP_IV); - size = 1; - break; - case 33: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_ATK_IV); - size = 1; - break; - case 34: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_DEF_IV); - size = 1; - break; - case 35: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPD_IV); - size = 1; - break; - case 36: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV); - size = 1; - break; - case 37: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV); - size = 1; - break; - case 38: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 39: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 40: - data32 = GetMonData(&gEnemyParty[a], MON_DATA_STATUS); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 41: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_LEVEL); - size = 1; - break; - case 42: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 43: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_MAX_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 44: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_ATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 45: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_DEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 46: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPD); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 47: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 48: - data16 = GetMonData(&gEnemyParty[a], MON_DATA_SPDEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 49: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL); - size = 1; - break; - case 50: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY); - size = 1; - break; - case 51: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE); - size = 1; - break; - case 52: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART); - size = 1; - break; - case 53: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH); - size = 1; - break; - case 54: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SHEEN); - size = 1; - break; - case 55: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON); - size = 1; - break; - case 56: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON); - size = 1; - break; - case 57: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON); - size = 1; - break; - case 58: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON); - size = 1; - break; - case 59: - buffer[0] = GetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON); - size = 1; - break; - } - return size; -} - -void dp01t_01_2_read_pokmon_data_slice(void) -{ - struct BattlePokemon buffer; - u8 *src = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - u8 *dst = (u8 *)&buffer + gBattleBufferA[gActiveBank][1]; - u8 i; - - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = src[i]; - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, gBattleBufferA[gActiveBank][2], dst); - OpponentBufferExecCompleted(); -} - -void OpponentHandleSetAttributes(void) -{ - u8 i; - u8 r4; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - sub_8033E24(gBattlePartyID[gActiveBank]); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - sub_8033E24(i); - r4 >>= 1; - } - } - OpponentBufferExecCompleted(); -} - -void sub_8033E24(u8 a) -{ - struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; - struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; - s32 i; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - { - u8 iv; - - SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); - SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); - for (i = 0; i < 4; i++) - { - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); - } - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); - SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); - SetMonData(&gEnemyParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); - iv = battlePokemon->hpIV; - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, (u8 *)&iv); - iv = battlePokemon->attackIV; - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, (u8 *)&iv); - iv = battlePokemon->defenseIV; - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, (u8 *)&iv); - iv = battlePokemon->speedIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, (u8 *)&iv); - iv = battlePokemon->spAttackIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); - iv = battlePokemon->spDefenseIV; - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); - SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); - SetMonData(&gEnemyParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); - SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); - SetMonData(&gEnemyParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); - SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); - SetMonData(&gEnemyParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); - SetMonData(&gEnemyParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); - SetMonData(&gEnemyParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); - SetMonData(&gEnemyParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); - } - break; - case 1: - SetMonData(&gEnemyParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); - break; - case 2: - SetMonData(&gEnemyParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); - break; - case 3: - for (i = 0; i < 4; i++) - { - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); - } - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); - break; - case 4: - case 5: - case 6: - case 7: - SetMonData(&gEnemyParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); - break; - case 8: - SetMonData(&gEnemyParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gEnemyParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gEnemyParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gEnemyParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gEnemyParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); - break; - case 9: - case 10: - case 11: - case 12: - SetMonData(&gEnemyParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); - break; - case 17: - SetMonData(&gEnemyParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); - break; - case 18: - SetMonData(&gEnemyParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); - break; - case 19: - SetMonData(&gEnemyParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 20: - SetMonData(&gEnemyParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 21: - SetMonData(&gEnemyParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 22: - SetMonData(&gEnemyParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 23: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 24: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 25: - SetMonData(&gEnemyParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); - break; - case 26: - SetMonData(&gEnemyParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); - break; - case 27: - SetMonData(&gEnemyParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); - break; - case 28: - SetMonData(&gEnemyParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 29: - SetMonData(&gEnemyParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); - break; - case 30: - SetMonData(&gEnemyParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); - break; - case 31: - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); - break; - case 32: - SetMonData(&gEnemyParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 33: - SetMonData(&gEnemyParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 34: - SetMonData(&gEnemyParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 35: - SetMonData(&gEnemyParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 36: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 37: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 38: - SetMonData(&gEnemyParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); - break; - case 39: - SetMonData(&gEnemyParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); - break; - case 40: - SetMonData(&gEnemyParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); - break; - case 41: - SetMonData(&gEnemyParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 42: - SetMonData(&gEnemyParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 43: - SetMonData(&gEnemyParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 44: - SetMonData(&gEnemyParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); - break; - case 45: - SetMonData(&gEnemyParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); - break; - case 46: - SetMonData(&gEnemyParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); - break; - case 47: - SetMonData(&gEnemyParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); - break; - case 48: - SetMonData(&gEnemyParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); - break; - case 49: - SetMonData(&gEnemyParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); - break; - case 50: - SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); - break; - case 51: - SetMonData(&gEnemyParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); - break; - case 52: - SetMonData(&gEnemyParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); - break; - case 53: - SetMonData(&gEnemyParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); - break; - case 54: - SetMonData(&gEnemyParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); - break; - case 55: - SetMonData(&gEnemyParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 56: - SetMonData(&gEnemyParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 57: - SetMonData(&gEnemyParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 58: - SetMonData(&gEnemyParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 59: - SetMonData(&gEnemyParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - } -} - -void sub_8034744(void) -{ - u8 *dst; - u8 i; - - dst = (u8 *)&gEnemyParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = gBattleBufferA[gActiveBank][3 + i]; - OpponentBufferExecCompleted(); -} - -void OpponentHandleLoadPokeSprite(void) -{ - u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - - BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(gActiveBank, 2), - sub_8077F68(gActiveBank), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].data2 = species; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); - sub_8032984(gActiveBank, GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); - gBattleBankFunc[gActiveBank] = sub_8033018; -} - -void OpponentHandleSendOutPoke(void) -{ - gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - - sub_803495C(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattleBankFunc[gActiveBank] = sub_80333D4; -} - -void sub_803495C(u8 a, u8 b) -{ - u16 species; - - sub_8032AA8(a, b); - gBattlePartyID[a] = gBattleBufferA[a][1]; - species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); - gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); - gObjectBankIDs[a] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(a, 2), - sub_8077F68(a), - sub_8079E90(a)); - gSprites[gObjectBankIDs[a]].data0 = a; - gSprites[gObjectBankIDs[a]].data2 = species; - gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; - gSprites[gObjectBankIDs[a]].oam.paletteNum = a; - StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); - gSprites[gObjectBankIDs[a]].invisible = TRUE; - gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; - gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFE); -} - -void OpponentHandleReturnPokeToBall(void) -{ - if (gBattleBufferA[gActiveBank][1] == 0) - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_8034B74; - } - else - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8032A08(gActiveBank); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - OpponentBufferExecCompleted(); - } -} - -void sub_8034B74(void) -{ - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 2); - gBattleBankFunc[gActiveBank] = sub_8033160; - } - break; - } -} - -void OpponentHandleTrainerThrow(void) -{ - u32 trainerPicIndex; - - if (gTrainerBattleOpponent == 0x400) - trainerPicIndex = GetSecretBaseTrainerPicIndex(); - else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) - trainerPicIndex = get_trainer_class_pic_index(); - else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) - trainerPicIndex = sub_8135FBC(); - else - trainerPicIndex = gTrainers[gTrainerBattleOpponent].trainerPic; - - sub_8031A6C(trainerPicIndex, gActiveBank); - GetMonSpriteTemplate_803C5A0(trainerPicIndex, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 0xB0, - 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicIndex].coords), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = 2; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicIndex].tag); - gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; - gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[trainerPicIndex].tag); - gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = trainerPicIndex; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_8032B4C; -} - -void OpponentHandleTrainerSlide(void) -{ - u32 trainerPicIndex; - - if (gTrainerBattleOpponent == 0x400) - trainerPicIndex = GetSecretBaseTrainerPicIndex(); - else if (gBattleTypeFlags & BATTLE_TYPE_BATTLE_TOWER) - trainerPicIndex = get_trainer_class_pic_index(); - else if (gBattleTypeFlags & BATTLE_TYPE_EREADER_TRAINER) - trainerPicIndex = sub_8135FBC(); - else - trainerPicIndex = gTrainers[gTrainerBattleOpponent].trainerPic; - - sub_8031A6C(trainerPicIndex, gActiveBank); - GetMonSpriteTemplate_803C5A0(trainerPicIndex, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 0xB0, - 40 + 4 * (8 - gTrainerFrontPicCoords[trainerPicIndex].coords), - 0x1E); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 96; - gSprites[gObjectBankIDs[gActiveBank]].pos1.x += 32; - gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = IndexOfSpritePaletteTag(gTrainerFrontPicPaletteTable[trainerPicIndex].tag); - gSprites[gObjectBankIDs[gActiveBank]].data5 = gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum; - gSprites[gObjectBankIDs[gActiveBank]].oam.tileNum = GetSpriteTileStartByTag(gTrainerFrontPicTable[trainerPicIndex].tag); - gSprites[gObjectBankIDs[gActiveBank]].oam.affineParam = trainerPicIndex; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_8032B84; -} - -void OpponentHandleTrainerSlideBack(void) -{ - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); - gBattleBankFunc[gActiveBank] = sub_8032BBC; -} - -void sub_8035030(void) -{ - if (ewram17810[gActiveBank].unk4 == 0) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4++; - } - else if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - PlaySE12WithPanning(SE_POKE_DEAD, 63); - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8010384; - gBattleBankFunc[gActiveBank] = sub_803311C; - } -} - -void sub_80350D4(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80350E0(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleBallThrow(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandlePause(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleMoveAnimation(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - u32 r0 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - - gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; - gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] - | (gBattleBufferA[gActiveBank][5] << 8); - gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] - | (gBattleBufferA[gActiveBank][7] << 8) - | (gBattleBufferA[gActiveBank][8] << 16) - | (gBattleBufferA[gActiveBank][9] << 24); - gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; - gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] - | (gBattleBufferA[gActiveBank][13] << 8); - gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; - gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; - - // Dead code. sub_8031720 always returns 0. - if (sub_8031720(r0, gUnknown_0202F7C4) != 0) - { - OpponentBufferExecCompleted(); - } - else - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_8035238; - } - } -} - -void sub_8035238(void) -{ - u16 r4 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - u8 r7 = gBattleBufferA[gActiveBank][11]; - - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) - { - ewram17800[gActiveBank].unk0_3 = 1; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - } - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_80326EC(0); - ExecuteMoveAnim(r4); - ewram17810[gActiveBank].unk4 = 2; - } - break; - case 2: - gAnimScriptCallback(); - if (!gAnimScriptActive) - { - sub_80326EC(1); - if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) - { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - ewram17800[gActiveBank].unk0_3 = 0; - } - ewram17810[gActiveBank].unk4 = 3; - } - break; - case 3: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_8031F24(); - sub_80324BC( - gActiveBank, - gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - ewram17810[gActiveBank].unk4 = 0; - OpponentBufferExecCompleted(); - } - break; - } -} - -void OpponentHandlePrintString(void) -{ - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); - sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); - gBattleBankFunc[gActiveBank] = sub_80331D0; -} - -void OpponentHandlePrintStringPlayerOnly(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_803540C(void) -{ - sub_8036B0C(); - OpponentBufferExecCompleted(); -} - -void sub_803541C(void) -{ - OpponentBufferExecCompleted(); -} - -#ifdef NONMATCHING -void sub_8035428(void) -{ - u16 r4; - // Needed to match closer - struct {u16 moves[4];} *r5 = (void *)&gBattleBufferA[gActiveBank][4]; - - if (gBattleTypeFlags & 0x498) - { - BattleAI_SetupAIData(); - r4 = BattleAI_GetAIActionToUse(); - switch (r4) - { - case 5: - dp01_build_cmdbuf_x21_a_bb(1, 4, 0); - break; - case 4: - dp01_build_cmdbuf_x21_a_bb(1, 3, 0); - break; - default: - if (gBattleMoves[r5->moves[r4]].target & 0x12) - gBankTarget = gActiveBank; - if (gBattleMoves[r5->moves[r4]].target & 8) - { - gBankTarget = GetBankByPlayerAI(0); - if (gAbsentBankFlags & gBitTable[gBankTarget]) - gBankTarget = GetBankByPlayerAI(2); - } - r4 |= gBankTarget << 8; - dp01_build_cmdbuf_x21_a_bb(1, 10, r4); - break; - } - OpponentBufferExecCompleted(); - } - else - { - u16 r2; - - do - { - // Can't for the life of me get this to match. - r4 = Random() % 4; - r2 = r5->moves[r4]; - } while (r2 == 0); - - if (gBattleMoves[r2].target & 0x12) - { - r4 |= gActiveBank << 8; - dp01_build_cmdbuf_x21_a_bb(1, 10, r4); - } - else if (gBattleTypeFlags & BATTLE_TYPE_DOUBLE) - { - u16 r2 = GetBankByPlayerAI(Random() & 2) << 8; - - dp01_build_cmdbuf_x21_a_bb(1, 10, r4 | r2); - } - else - { - u16 r2 = GetBankByPlayerAI(0) << 8; - - dp01_build_cmdbuf_x21_a_bb(1, 10, r4 | r2); - } - OpponentBufferExecCompleted(); - } -} -#else -__attribute__((naked)) -void sub_8035428(void) -{ - asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - ldr r6, _0803545C @ =gActiveBank\n\ - ldrb r0, [r6]\n\ - lsls r0, 9\n\ - ldr r1, _08035460 @ =gUnknown_02023A64\n\ - adds r5, r0, r1\n\ - ldr r0, _08035464 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x93\n\ - lsls r0, 3\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080354F8\n\ - bl BattleAI_SetupAIData\n\ - bl BattleAI_GetAIActionToUse\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - cmp r4, 0x4\n\ - beq _08035468\n\ - cmp r4, 0x5\n\ - bne _08035474\n\ - movs r0, 0x1\n\ - movs r1, 0x4\n\ - b _0803546C\n\ - .align 2, 0\n\ -_0803545C: .4byte gActiveBank\n\ -_08035460: .4byte gUnknown_02023A64\n\ -_08035464: .4byte gBattleTypeFlags\n\ -_08035468:\n\ - movs r0, 0x1\n\ - movs r1, 0x3\n\ -_0803546C:\n\ - movs r2, 0\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ - b _080354E0\n\ -_08035474:\n\ - ldr r3, _080354E8 @ =gBattleMoves\n\ - lsls r0, r4, 1\n\ - adds r2, r5, r0\n\ - ldrh r1, [r2]\n\ - lsls r0, r1, 1\n\ - adds r0, r1\n\ - lsls r0, 2\n\ - adds r0, r3\n\ - ldrb r1, [r0, 0x6]\n\ - movs r0, 0x12\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08035494\n\ - ldr r1, _080354EC @ =gBankTarget\n\ - ldrb r0, [r6]\n\ - strb r0, [r1]\n\ -_08035494:\n\ - ldrh r1, [r2]\n\ - lsls r0, r1, 1\n\ - adds r0, r1\n\ - lsls r0, 2\n\ - adds r0, r3\n\ - ldrb r1, [r0, 0x6]\n\ - movs r0, 0x8\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080354CE\n\ - movs r0, 0\n\ - bl GetBankByPlayerAI\n\ - ldr r5, _080354EC @ =gBankTarget\n\ - strb r0, [r5]\n\ - ldr r0, _080354F0 @ =gAbsentBankFlags\n\ - ldrb r1, [r0]\n\ - ldr r2, _080354F4 @ =gBitTable\n\ - ldrb r0, [r5]\n\ - lsls r0, 2\n\ - adds r0, r2\n\ - ldr r0, [r0]\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - beq _080354CE\n\ - movs r0, 0x2\n\ - bl GetBankByPlayerAI\n\ - strb r0, [r5]\n\ -_080354CE:\n\ - ldr r0, _080354EC @ =gBankTarget\n\ - ldrb r0, [r0]\n\ - lsls r0, 8\n\ - orrs r4, r0\n\ - movs r0, 0x1\n\ - movs r1, 0xA\n\ - adds r2, r4, 0\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ -_080354E0:\n\ - bl OpponentBufferExecCompleted\n\ - b _0803558A\n\ - .align 2, 0\n\ -_080354E8: .4byte gBattleMoves\n\ -_080354EC: .4byte gBankTarget\n\ -_080354F0: .4byte gAbsentBankFlags\n\ -_080354F4: .4byte gBitTable\n\ -_080354F8:\n\ - movs r6, 0x3\n\ -_080354FA:\n\ - bl Random\n\ - adds r4, r0, 0\n\ - ands r4, r6\n\ - lsls r0, r4, 1\n\ - adds r0, r5, r0\n\ - ldrh r2, [r0]\n\ - cmp r2, 0\n\ - beq _080354FA\n\ - ldr r1, _08035534 @ =gBattleMoves\n\ - lsls r0, r2, 1\n\ - adds r0, r2\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x6]\n\ - movs r0, 0x12\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803553C\n\ - ldr r0, _08035538 @ =gActiveBank\n\ - ldrb r0, [r0]\n\ - lsls r0, 8\n\ - orrs r4, r0\n\ - movs r0, 0x1\n\ - movs r1, 0xA\n\ - adds r2, r4, 0\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ - b _08035586\n\ - .align 2, 0\n\ -_08035534: .4byte gBattleMoves\n\ -_08035538: .4byte gActiveBank\n\ -_0803553C:\n\ - ldr r0, _0803556C @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08035570\n\ - bl Random\n\ - movs r1, 0x2\n\ - ands r1, r0\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - adds r0, r1, 0\n\ - bl GetBankByPlayerAI\n\ - adds r2, r0, 0\n\ - lsls r2, 24\n\ - lsrs r2, 16\n\ - orrs r2, r4\n\ - movs r0, 0x1\n\ - movs r1, 0xA\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ - b _08035586\n\ - .align 2, 0\n\ -_0803556C: .4byte gBattleTypeFlags\n\ -_08035570:\n\ - movs r0, 0\n\ - bl GetBankByPlayerAI\n\ - adds r2, r0, 0\n\ - lsls r2, 24\n\ - lsrs r2, 16\n\ - orrs r2, r4\n\ - movs r0, 0x1\n\ - movs r1, 0xA\n\ - bl dp01_build_cmdbuf_x21_a_bb\n\ -_08035586:\n\ - bl OpponentBufferExecCompleted\n\ -_0803558A:\n\ - pop {r4-r6}\n\ - pop {r0}\n\ - bx r0\n\ - .syntax divided\n"); -} -#endif - -void sub_8035590(void) -{ - // What is this? - dp01_build_cmdbuf_x23_aa_0(1, ewram[0x160D4 + gActiveBank / 2 * 2]); - OpponentBufferExecCompleted(); -} - -void sub_80355C0(void) -{ - s32 r4; - - if (ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2] == 6) - { - u8 r6; - u8 r5; - - r4 = sub_8036CD4(); - if (r4 == 6) - { - if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) - { - r5 = GetBankByPlayerAI(1); - r6 = r5; - } - else - { - r6 = GetBankByPlayerAI(1); - r5 = GetBankByPlayerAI(3); - } - for (r4 = 0; r4 < 6; r4++) - { - if (GetMonData(&gEnemyParty[r4], MON_DATA_HP) != 0 - && r4 != gBattlePartyID[r6] - && r4 != gBattlePartyID[r5]) - break; - } - } - } - else - { - r4 = ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2]; - ewram[0x160C8 + GetBankIdentity(gActiveBank) / 2] = 6; - } - ewram[0x16068 + gActiveBank] = r4; - dp01_build_cmdbuf_x22_a_three_bytes(1, r4, 0); - OpponentBufferExecCompleted(); -} - -void sub_80356C0(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleHealthBarUpdate(void) -{ - s16 r7; - - load_gfxc_health_bar(0); - r7 = (gBattleBufferA[gActiveBank][3] << 8) | gBattleBufferA[gActiveBank][2]; - if (r7 != 0x7FFF) - { - u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - u32 hp = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); - } - else - { - u32 maxHP = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); - } - gBattleBankFunc[gActiveBank] = sub_80330C8; -} - -void OpponentHandleExpBarUpdate(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleStatusIconUpdate(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - sub_8045A5C(gHealthboxIDs[gActiveBank], &gEnemyParty[gBattlePartyID[gActiveBank]], 9); - ewram17810[gActiveBank].unk0_4 = 0; - gBattleBankFunc[gActiveBank] = sub_8033494; - } -} - -void OpponentHandleStatusAnimation(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - move_anim_start_t2_for_situation( - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2] - | (gBattleBufferA[gActiveBank][3] << 8) - | (gBattleBufferA[gActiveBank][4] << 16) - | (gBattleBufferA[gActiveBank][5] << 24)); - gBattleBankFunc[gActiveBank] = sub_8033494; - } -} - -void OpponentHandleStatusXor(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358B0(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleDMATransfer(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358C8(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358D4(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358E0(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358EC(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_80358F8(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_8035904(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_8035910(void) -{ - gUnknown_020238C8.unk0_0 = 0; - OpponentBufferExecCompleted(); -} - -void sub_803592C(void) -{ - gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; - OpponentBufferExecCompleted(); -} - -void sub_8035964(void) -{ - gUnknown_020238C8.unk0_7 = 0; - OpponentBufferExecCompleted(); -} - -void sub_803597C(void) -{ - gUnknown_020238C8.unk0_7 ^= 1; - OpponentBufferExecCompleted(); -} - -void OpponentHandleHitAnimation(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) - { - OpponentBufferExecCompleted(); - } - else - { - gDoingBattleAnim = TRUE; - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - sub_8047858(gActiveBank); - gBattleBankFunc[gActiveBank] = bx_blink_t7; - } -} - -void sub_8035A14(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleEffectivenessSound(void) -{ - s8 pan; - - if (GetBankSide(gActiveBank) == 0) - pan = -64; - else - pan = 63; - PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); - OpponentBufferExecCompleted(); -} - -void sub_8035A64(void) -{ - PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - OpponentBufferExecCompleted(); -} - -void OpponentHandleFaintingCry(void) -{ - PlayCry3( - GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), - 25, 5); - OpponentBufferExecCompleted(); -} - -void dp01t_2E_7_battle_intro(void) -{ - sub_80E43C0(gBattleBufferA[gActiveBank][1]); - gUnknown_02024DE8 |= 1; - OpponentBufferExecCompleted(); -} - -void sub_8035B04(void) -{ - u8 taskId; - - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 280; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8035C10); - taskId = CreateTask(sub_8035C44, 5); - gTasks[taskId].data[0] = gActiveBank; - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - ewram17840.unk9_0 = 1; - gBattleBankFunc[gActiveBank] = nullsub_45; -} - -void sub_8035C10(struct Sprite *sprite) -{ - sub_8031B74(sprite->oam.affineParam); - sprite->oam.tileNum = sprite->data5; - FreeSpriteOamMatrix(sprite); - DestroySprite(sprite); -} - -void sub_8035C44(u8 taskId) -{ - u8 r9; - - r9 = gActiveBank; - gActiveBank = gTasks[taskId].data[0]; - if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_803495C(gActiveBank, 0); - } - else - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_803495C(gActiveBank, 0); - gActiveBank ^= 2; - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_803495C(gActiveBank, 0); - gActiveBank ^= 2; - } - gBattleBankFunc[gActiveBank] = sub_8032E2C; - gActiveBank = r9; - DestroyTask(taskId); -} - -void dp01t_30_7_0803D67C(void) -{ - if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) - { - OpponentBufferExecCompleted(); - return; - } - - ewram17810[gActiveBank].unk0_0 = 1; - if (gBattleBufferA[gActiveBank][2] != 0) - { - if (ewram17810[gActiveBank].unk1_1 < 2) - { - ewram17810[gActiveBank].unk1_1++; - return; - } - else - { - ewram17810[gActiveBank].unk1_1 = 0; - } - } - gUnknown_02024E68[gActiveBank] = sub_8044804( - gActiveBank, - (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2]); - ewram17810[gActiveBank].unk5 = 0; - if (gBattleBufferA[gActiveBank][2] != 0) - ewram17810[gActiveBank].unk5 = 0x5D; - gBattleBankFunc[gActiveBank] = sub_8035E2C; -} - -void sub_8035E2C(void) -{ - if (ewram17810[gActiveBank].unk5++ >= 93) - { - ewram17810[gActiveBank].unk5 = 0; - OpponentBufferExecCompleted(); - } -} - -void sub_8035E6C(void) -{ - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - OpponentBufferExecCompleted(); -} - -void sub_8035EB8(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleSpriteInvisibility(void) -{ - if (sub_8078874(gActiveBank) != 0) - { - gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - sub_8031F88(gActiveBank); - } - OpponentBufferExecCompleted(); -} - -void OpponentHandleBattleAnimation(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - u8 r3 = gBattleBufferA[gActiveBank][1]; - u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) - OpponentBufferExecCompleted(); - else - gBattleBankFunc[gActiveBank] = sub_80334C0; - } -} - -void OpponentHandleLinkStandbyMsg(void) -{ - OpponentBufferExecCompleted(); -} - -void OpponentHandleResetActionMoveSelection(void) -{ - OpponentBufferExecCompleted(); -} - -void sub_8035FA4(void) -{ - if ((gBattleTypeFlags & BATTLE_TYPE_LINK) && !(gBattleTypeFlags & BATTLE_TYPE_WILD)) - { - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(gMain.savedCallback); - } - OpponentBufferExecCompleted(); -} - -void nullsub_46(void) -{ -} diff --git a/src/battle_811DA74.c b/src/battle_811DA74.c deleted file mode 100644 index 14f547b82..000000000 --- a/src/battle_811DA74.c +++ /dev/null @@ -1,1606 +0,0 @@ -#include "global.h" -#include "battle.h" -#include "battle_interface.h" -#include "data2.h" -#include "battle_811DA74.h" -#include "battle_anim_813F0F4.h" -#include "link.h" -#include "m4a.h" -#include "main.h" -#include "palette.h" -#include "pokeball.h" -#include "pokemon.h" -#include "rom3.h" -#include "rom_8077ABC.h" -#include "sound.h" -#include "songs.h" -#include "sprite.h" -#include "string_util.h" -#include "task.h" -#include "text.h" -#include "util.h" - -struct UnknownStruct1 -{ - u8 unk0; - u8 unk1; - u8 unk2[0x1FE]; -}; - -//Possibly PokemonSubstruct1 -struct UnknownStruct3 -{ - u16 moves[4]; - u8 pp[4]; - u8 ppBonuses; -}; - -extern u16 gBattleTypeFlags; -extern u8 gDisplayedStringBattle[]; -extern u8 gBattleBufferA[][0x200]; -extern u8 gActiveBank; -extern u32 gBattleExecBuffer; -extern u16 gBattlePartyID[]; -extern u8 gObjectBankIDs[]; -extern u8 gBattleOutcome; -extern u16 gUnknown_02024DE8; -extern u8 gUnknown_02024E68[]; -extern u8 gDoingBattleAnim; -extern u32 gPID_perBank[]; -extern struct SpriteTemplate gUnknown_02024E8C; -extern u32 *gDisableStructMoveAnim; -extern u32 gMoveDmgMoveAnim; -extern u16 gMovePowerMoveAnim; -extern u8 gHappinessMoveAnim; -extern u16 gWeatherMoveAnim; -extern u8 gUnknown_0202F7C4; -extern struct Window gUnknown_03004210; -extern u16 gUnknown_030042A0; -extern u16 gUnknown_030042A4; -extern MainCallback gPreBattleCallback1; -extern void (*gBattleBankFunc[])(void); -extern u8 gHealthboxIDs[]; -extern u8 gUnknown_0300434C[]; -extern u8 gBattleMonForms[]; -extern u8 gAnimScriptActive; -extern void (*gAnimScriptCallback)(void); -extern void (*const gLinkPartnerBufferCommands[])(void); - -extern u8 move_anim_start_t3(); -extern u8 sub_8078874(); -extern void sub_8044CA0(u8); -extern void sub_8030E38(struct Sprite *); -extern void sub_80E43C0(); -extern void sub_8047858(); -extern void move_anim_start_t2_for_situation(); -extern void load_gfxc_health_bar(); -extern void sub_8043D84(); -extern void BufferStringBattle(); -extern void sub_8031F24(void); -extern void sub_80326EC(); -extern void ExecuteMoveAnim(); -extern void sub_80324BC(); -extern u8 sub_8031720(); -extern u8 mplay_80342A4(); -extern void oamt_add_pos2_onto_pos1(); -extern void oamt_set_x3A_32(); -extern void sub_8078B34(struct Sprite *); -extern void sub_80105EC(struct Sprite *); -extern s32 sub_803FC34(u16); -extern void LoadPlayerTrainerBankSprite(); -extern void sub_80313A0(struct Sprite *); -extern u8 sub_8046400(); -extern void sub_80312F0(struct Sprite *); -extern u8 CreateInvisibleSpriteWithCallback(); -extern void BattleLoadPlayerMonSprite(); -extern u8 sub_8077ABC(); -extern u8 sub_8077F68(); -extern u8 sub_8079E90(); -extern void nullsub_10(); -extern void sub_8045A5C(); -extern void sub_804777C(); -extern void sub_8043DFC(); -//extern s16 sub_8045C78(); -extern void sub_80440EC(); -extern void sub_80324F8(); -extern void nullsub_9(u16); -extern void sub_8043DB0(); -extern void move_anim_start_t4(); -extern void c3_0802FDF4(u8); -extern void sub_8031F88(); -extern void sub_8141828(); -extern void c2_8011A1C(void); - -void LinkPartnerBufferRunCommand(void); -void sub_811E0A0(void); -void LinkPartnerBufferExecCompleted(void); -u32 dp01_getattr_by_ch1_for_player_pokemon(u8 a, u8 *b); -void sub_811EC68(u8); -void sub_811F864(u8, u8); -void sub_811FA5C(void); -void sub_811FF30(void); -void sub_812071C(u8); -void sub_81208E0(void); - - -void nullsub_74(void) -{ -} - -void SetBankFuncToLinkPartnerBufferRunCommand(void) -{ - gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; -} - -void LinkPartnerBufferRunCommand(void) -{ - if (gBattleExecBuffer & gBitTable[gActiveBank]) - { - if (gBattleBufferA[gActiveBank][0] <= 0x38) - gLinkPartnerBufferCommands[gBattleBufferA[gActiveBank][0]](); - else - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DAE4(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - LinkPartnerBufferExecCompleted(); -} - -void sub_811DB1C(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].callback == SpriteCallbackDummy) - { - nullsub_10(0); - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DB84(void) -{ - if ((--ewram17810[gActiveBank].unk9) == 0xFF) - { - ewram17810[gActiveBank].unk9 = 0; - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DBC0(void) -{ - bool8 r6 = FALSE; - - if (!IsDoubleBattle() || (IsDoubleBattle() && (gBattleTypeFlags & 0x40))) - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - else - { - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy - && gSprites[gHealthboxIDs[gActiveBank ^ 2]].callback == SpriteCallbackDummy) - r6 = TRUE; - } - if (IsCryPlayingOrClearCrySongs()) - r6 = FALSE; - if (r6) - { - ewram17810[gActiveBank].unk9 = 3; - gBattleBankFunc[gActiveBank] = sub_811DB84; - } -} - -void sub_811DCA0(void) -{ - u8 r2; - - if (!ewram17810[gActiveBank].unk0_3) - { - // I couldn't get it to work as a bitfield here - r2 = *((u8 *)&ewram17810[gActiveBank ^ 2]) & 8; - if (!r2 && (++ewram17810[gActiveBank].unk9) != 1) - { - ewram17810[gActiveBank].unk9 = r2; - if (IsDoubleBattle() && !(gBattleTypeFlags & 0x40)) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank ^ 2]]); - sub_8045A5C(gHealthboxIDs[gActiveBank ^ 2], &gPlayerParty[gBattlePartyID[gActiveBank ^ 2]], 0); - sub_804777C(gActiveBank ^ 2); - sub_8043DFC(gHealthboxIDs[gActiveBank ^ 2]); - } - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - (s8)ewram17810[4].unk9 &= ~1; - gBattleBankFunc[gActiveBank] = sub_811DBC0; - } - } -} - -void sub_811DDE8(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].animEnded - && gSprites[gObjectBankIDs[gActiveBank]].pos2.x == 0) - LinkPartnerBufferExecCompleted(); -} - -void bx_t3_healthbar_update(void) -{ - s16 r4; - - r4 = sub_8045C78(gActiveBank, gHealthboxIDs[gActiveBank], 0, 0); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - if (r4 != -1) - { - sub_80440EC(gHealthboxIDs[gActiveBank], r4, 0); - } - else - { - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DE98(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].pos1.y + gSprites[gObjectBankIDs[gActiveBank]].pos2.y > 160) - { - nullsub_9(GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES)); - FreeOamMatrix(gSprites[gObjectBankIDs[gActiveBank]].oam.matrixNum); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DF34(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811DFA0(void) -{ - if (gUnknown_03004210.state == 0) - LinkPartnerBufferExecCompleted(); -} - -void bx_blink_t3(void) -{ - u8 spriteId = gObjectBankIDs[gActiveBank]; - if (gSprites[spriteId].data1 == 32) - { - gSprites[spriteId].data1 = 0; - gSprites[spriteId].invisible = FALSE; - gDoingBattleAnim = 0; - LinkPartnerBufferExecCompleted(); - } - else - { - if ((gSprites[spriteId].data1 % 4) == 0) - { - gSprites[spriteId].invisible ^= 1; - } - gSprites[spriteId].data1++; - } -} - -void sub_811E034(void) -{ - if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - gBattleBankFunc[gActiveBank] = sub_811E0A0; - } -} - -void sub_811E0A0(void) -{ - if (!ewram17810[gActiveBank].unk0_6) - LinkPartnerBufferExecCompleted(); -} - -void sub_811E0CC(void) -{ - if (ewram17810[gActiveBank].unk1_0) - { - ewram17810[gActiveBank].unk0_7 = 0; - ewram17810[gActiveBank].unk1_0 = 0; - FreeSpriteTilesByTag(0x27F9); - FreeSpritePaletteByTag(0x27F9); - CreateTask(c3_0802FDF4, 10); - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 0); - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 0); - sub_804777C(gActiveBank); - sub_8043DFC(gHealthboxIDs[gActiveBank]); - sub_8031F88(gActiveBank); - gBattleBankFunc[gActiveBank] = sub_811E034; - } -} - -void sub_811E1BC(void) -{ - if (!ewram17810[gActiveBank].unk0_3 && !ewram17810[gActiveBank].unk0_7) - sub_8141828(gActiveBank, &gPlayerParty[gBattlePartyID[gActiveBank]]); - if (gSprites[gUnknown_0300434C[gActiveBank]].callback == SpriteCallbackDummy - && !ewram17810[gActiveBank].unk0_3) - { - DestroySprite(&gSprites[gUnknown_0300434C[gActiveBank]]); - gBattleBankFunc[gActiveBank] = sub_811E0CC; - } -} - -void sub_811E258(void) -{ - if (gReceivedRemoteLinkPlayers == 0) - { - m4aSongNumStop(0x5A); - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(c2_8011A1C); - } -} - -void sub_811E29C(void) -{ - if (!gPaletteFade.active) - { - if (gBattleTypeFlags & 2) - { - sub_800832C(); - gBattleBankFunc[gActiveBank] = sub_811E258; - } - else - { - m4aSongNumStop(0x5A); - gMain.inBattle = FALSE; - gMain.callback1 = gPreBattleCallback1; - SetMainCallback2(gMain.savedCallback); - } - } -} - -void LinkPartnerBufferExecCompleted(void) -{ - u8 multiplayerId; - - gBattleBankFunc[gActiveBank] = LinkPartnerBufferRunCommand; - if (gBattleTypeFlags & 2) - { - multiplayerId = GetMultiplayerId(); - dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); - gBattleBufferA[gActiveBank][0] = 0x38; - } - else - { - gBattleExecBuffer &= ~gBitTable[gActiveBank]; - } -} - -void sub_811E38C(void) -{ - if (!ewram17810[gActiveBank].unk0_4) - LinkPartnerBufferExecCompleted(); -} - -void sub_811E3B8(void) -{ - if (!ewram17810[gActiveBank].unk0_5) - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleGetAttributes(void) -{ - u8 unk[256]; - int r6 = 0; - s32 i; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - r6 = dp01_getattr_by_ch1_for_player_pokemon(gBattlePartyID[gActiveBank], unk); - } - else - { - u8 r4 = gBattleBufferA[gActiveBank][2]; - - for (i = 0; i < 6; i++) - { - if (r4 & 1) - r6 += dp01_getattr_by_ch1_for_player_pokemon(i, unk + r6); - r4 >>= 1; - } - } - dp01_build_cmdbuf_x1D_1D_numargs_varargs(1, r6, unk); - LinkPartnerBufferExecCompleted(); -} - -// Duplicate of dp01_getattr_by_ch1_for_player_pokemon_ -u32 dp01_getattr_by_ch1_for_player_pokemon(u8 a, u8 *buffer) -{ - struct BattlePokemon battlePokemon; - struct UnknownStruct3 moveData; - u8 nickname[20]; - u8 *src; - s16 data16; - u32 data32; - s32 size = 0; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - battlePokemon.species = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - battlePokemon.item = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - for (size = 0; size < 4; size++) - { - battlePokemon.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - battlePokemon.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - battlePokemon.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - battlePokemon.friendship = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - battlePokemon.experience = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - battlePokemon.hpIV = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - battlePokemon.attackIV = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - battlePokemon.defenseIV = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - battlePokemon.speedIV = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - battlePokemon.spAttackIV = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - battlePokemon.spDefenseIV = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - battlePokemon.personality = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - battlePokemon.status1 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - battlePokemon.level = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - battlePokemon.hp = GetMonData(&gPlayerParty[a], MON_DATA_HP); - battlePokemon.maxHP = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - battlePokemon.attack = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - battlePokemon.defense = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - battlePokemon.speed = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - battlePokemon.spAttack = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - battlePokemon.spDefense = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - battlePokemon.isEgg = GetMonData(&gPlayerParty[a], MON_DATA_IS_EGG); - battlePokemon.altAbility = GetMonData(&gPlayerParty[a], MON_DATA_ALT_ABILITY); - battlePokemon.otId = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - GetMonData(&gPlayerParty[a], MON_DATA_NICKNAME, nickname); - StringCopy10(battlePokemon.nickname, nickname); - GetMonData(&gPlayerParty[a], MON_DATA_OT_NAME, battlePokemon.otName); - src = (u8 *)&battlePokemon; - for (size = 0; size < sizeof(battlePokemon); size++) - buffer[size] = src[size]; - break; - case 1: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPECIES); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 2: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 3: - for (size = 0; size < 4; size++) - { - moveData.moves[size] = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + size); - moveData.pp[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - } - moveData.ppBonuses = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - src = (u8 *)&moveData; - for (size = 0; size < sizeof(moveData); size++) - buffer[size] = src[size]; - break; - case 4: - case 5: - case 6: - case 7: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 8: - for (size = 0; size < 4; size++) - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + size); - buffer[size] = GetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES); - size++; - break; - case 9: - case 10: - case 11: - case 12: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9); - size = 1; - break; - case 17: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_OT_ID); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 18: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_EXP); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - size = 3; - break; - case 19: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_EV); - size = 1; - break; - case 20: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_EV); - size = 1; - break; - case 21: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_EV); - size = 1; - break; - case 22: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_EV); - size = 1; - break; - case 23: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV); - size = 1; - break; - case 24: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV); - size = 1; - break; - case 25: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP); - size = 1; - break; - case 26: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKERUS); - size = 1; - break; - case 27: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION); - size = 1; - break; - case 28: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL); - size = 1; - break; - case 29: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_MET_GAME); - size = 1; - break; - case 30: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_POKEBALL); - size = 1; - break; - case 31: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - buffer[1] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - buffer[2] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - buffer[3] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - buffer[4] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - buffer[5] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 6; - break; - case 32: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_HP_IV); - size = 1; - break; - case 33: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_ATK_IV); - size = 1; - break; - case 34: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_DEF_IV); - size = 1; - break; - case 35: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPD_IV); - size = 1; - break; - case 36: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV); - size = 1; - break; - case 37: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV); - size = 1; - break; - case 38: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 39: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 40: - data32 = GetMonData(&gPlayerParty[a], MON_DATA_STATUS); - buffer[0] = (data32 & 0x000000FF); - buffer[1] = (data32 & 0x0000FF00) >> 8; - buffer[2] = (data32 & 0x00FF0000) >> 16; - buffer[3] = (data32 & 0xFF000000) >> 24; - size = 4; - break; - case 41: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_LEVEL); - size = 1; - break; - case 42: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 43: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_MAX_HP); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 44: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_ATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 45: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_DEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 46: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPD); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 47: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPATK); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 48: - data16 = GetMonData(&gPlayerParty[a], MON_DATA_SPDEF); - buffer[0] = data16; - buffer[1] = data16 >> 8; - size = 2; - break; - case 49: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL); - size = 1; - break; - case 50: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY); - size = 1; - break; - case 51: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE); - size = 1; - break; - case 52: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART); - size = 1; - break; - case 53: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH); - size = 1; - break; - case 54: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SHEEN); - size = 1; - break; - case 55: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON); - size = 1; - break; - case 56: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON); - size = 1; - break; - case 57: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON); - size = 1; - break; - case 58: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON); - size = 1; - break; - case 59: - buffer[0] = GetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON); - size = 1; - break; - } - return size; -} - -void sub_811EC04(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleSetAttributes(void) -{ - u8 i; - u8 r4; - - if (gBattleBufferA[gActiveBank][2] == 0) - { - sub_811EC68(gBattlePartyID[gActiveBank]); - } - else - { - r4 = gBattleBufferA[gActiveBank][2]; - for (i = 0; i < 6; i++) - { - if (r4 & 1) - sub_811EC68(i); - r4 >>= 1; - } - } - LinkPartnerBufferExecCompleted(); -} - -// Duplicate of dp01_setattr_by_ch1_for_player_pokemon -void sub_811EC68(u8 a) -{ - struct BattlePokemon *battlePokemon = (struct BattlePokemon *)&gBattleBufferA[gActiveBank][3]; - struct UnknownStruct3 *moveData = (struct UnknownStruct3 *)&gBattleBufferA[gActiveBank][3]; - s32 i; - - switch (gBattleBufferA[gActiveBank][1]) - { - case 0: - { - u8 iv; - - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, (u8 *)&battlePokemon->species); - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, (u8 *)&battlePokemon->item); - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&battlePokemon->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&battlePokemon->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, (u8 *)&battlePokemon->ppBonuses); - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, (u8 *)&battlePokemon->friendship); - SetMonData(&gPlayerParty[a], MON_DATA_EXP, (u8 *)&battlePokemon->experience); - iv = battlePokemon->hpIV; - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, (u8 *)&iv); - iv = battlePokemon->attackIV; - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, (u8 *)&iv); - iv = battlePokemon->defenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, (u8 *)&iv); - iv = battlePokemon->speedIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, (u8 *)&iv); - iv = battlePokemon->spAttackIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, (u8 *)&iv); - iv = battlePokemon->spDefenseIV; - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, (u8 *)&iv); - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, (u8 *)&battlePokemon->personality); - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, (u8 *)&battlePokemon->status1); - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, (u8 *)&battlePokemon->level); - SetMonData(&gPlayerParty[a], MON_DATA_HP, (u8 *)&battlePokemon->hp); - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, (u8 *)&battlePokemon->maxHP); - SetMonData(&gPlayerParty[a], MON_DATA_ATK, (u8 *)&battlePokemon->attack); - SetMonData(&gPlayerParty[a], MON_DATA_DEF, (u8 *)&battlePokemon->defense); - SetMonData(&gPlayerParty[a], MON_DATA_SPD, (u8 *)&battlePokemon->speed); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, (u8 *)&battlePokemon->spAttack); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, (u8 *)&battlePokemon->spDefense); - } - break; - case 1: - SetMonData(&gPlayerParty[a], MON_DATA_SPECIES, &gBattleBufferA[gActiveBank][3]); - break; - case 2: - SetMonData(&gPlayerParty[a], MON_DATA_HELD_ITEM, &gBattleBufferA[gActiveBank][3]); - break; - case 3: - for (i = 0; i < 4; i++) - { - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + i, (u8 *)&moveData->moves[i]); - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + i, (u8 *)&moveData->pp[i]); - } - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &moveData->ppBonuses); - break; - case 4: - case 5: - case 6: - case 7: - SetMonData(&gPlayerParty[a], MON_DATA_MOVE1 + gBattleBufferA[gActiveBank][1] - 4, &gBattleBufferA[gActiveBank][3]); - break; - case 8: - SetMonData(&gPlayerParty[a], MON_DATA_PP1, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_PP2, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_PP3, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_PP4, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_PP_BONUSES, &gBattleBufferA[gActiveBank][7]); - break; - case 9: - case 10: - case 11: - case 12: - SetMonData(&gPlayerParty[a], MON_DATA_PP1 + gBattleBufferA[gActiveBank][1] - 9, &gBattleBufferA[gActiveBank][3]); - break; - case 17: - SetMonData(&gPlayerParty[a], MON_DATA_OT_ID, &gBattleBufferA[gActiveBank][3]); - break; - case 18: - SetMonData(&gPlayerParty[a], MON_DATA_EXP, &gBattleBufferA[gActiveBank][3]); - break; - case 19: - SetMonData(&gPlayerParty[a], MON_DATA_HP_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 20: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 21: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 22: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 23: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 24: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_EV, &gBattleBufferA[gActiveBank][3]); - break; - case 25: - SetMonData(&gPlayerParty[a], MON_DATA_FRIENDSHIP, &gBattleBufferA[gActiveBank][3]); - break; - case 26: - SetMonData(&gPlayerParty[a], MON_DATA_POKERUS, &gBattleBufferA[gActiveBank][3]); - break; - case 27: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LOCATION, &gBattleBufferA[gActiveBank][3]); - break; - case 28: - SetMonData(&gPlayerParty[a], MON_DATA_MET_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 29: - SetMonData(&gPlayerParty[a], MON_DATA_MET_GAME, &gBattleBufferA[gActiveBank][3]); - break; - case 30: - SetMonData(&gPlayerParty[a], MON_DATA_POKEBALL, &gBattleBufferA[gActiveBank][3]); - break; - case 31: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][4]); - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][5]); - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][6]); - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][7]); - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][8]); - break; - case 32: - SetMonData(&gPlayerParty[a], MON_DATA_HP_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 33: - SetMonData(&gPlayerParty[a], MON_DATA_ATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 34: - SetMonData(&gPlayerParty[a], MON_DATA_DEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 35: - SetMonData(&gPlayerParty[a], MON_DATA_SPD_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 36: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 37: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF_IV, &gBattleBufferA[gActiveBank][3]); - break; - case 38: - SetMonData(&gPlayerParty[a], MON_DATA_PERSONALITY, &gBattleBufferA[gActiveBank][3]); - break; - case 39: - SetMonData(&gPlayerParty[a], MON_DATA_CHECKSUM, &gBattleBufferA[gActiveBank][3]); - break; - case 40: - SetMonData(&gPlayerParty[a], MON_DATA_STATUS, &gBattleBufferA[gActiveBank][3]); - break; - case 41: - SetMonData(&gPlayerParty[a], MON_DATA_LEVEL, &gBattleBufferA[gActiveBank][3]); - break; - case 42: - SetMonData(&gPlayerParty[a], MON_DATA_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 43: - SetMonData(&gPlayerParty[a], MON_DATA_MAX_HP, &gBattleBufferA[gActiveBank][3]); - break; - case 44: - SetMonData(&gPlayerParty[a], MON_DATA_ATK, &gBattleBufferA[gActiveBank][3]); - break; - case 45: - SetMonData(&gPlayerParty[a], MON_DATA_DEF, &gBattleBufferA[gActiveBank][3]); - break; - case 46: - SetMonData(&gPlayerParty[a], MON_DATA_SPD, &gBattleBufferA[gActiveBank][3]); - break; - case 47: - SetMonData(&gPlayerParty[a], MON_DATA_SPATK, &gBattleBufferA[gActiveBank][3]); - break; - case 48: - SetMonData(&gPlayerParty[a], MON_DATA_SPDEF, &gBattleBufferA[gActiveBank][3]); - break; - case 49: - SetMonData(&gPlayerParty[a], MON_DATA_COOL, &gBattleBufferA[gActiveBank][3]); - break; - case 50: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY, &gBattleBufferA[gActiveBank][3]); - break; - case 51: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE, &gBattleBufferA[gActiveBank][3]); - break; - case 52: - SetMonData(&gPlayerParty[a], MON_DATA_SMART, &gBattleBufferA[gActiveBank][3]); - break; - case 53: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH, &gBattleBufferA[gActiveBank][3]); - break; - case 54: - SetMonData(&gPlayerParty[a], MON_DATA_SHEEN, &gBattleBufferA[gActiveBank][3]); - break; - case 55: - SetMonData(&gPlayerParty[a], MON_DATA_COOL_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 56: - SetMonData(&gPlayerParty[a], MON_DATA_BEAUTY_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 57: - SetMonData(&gPlayerParty[a], MON_DATA_CUTE_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 58: - SetMonData(&gPlayerParty[a], MON_DATA_SMART_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - case 59: - SetMonData(&gPlayerParty[a], MON_DATA_TOUGH_RIBBON, &gBattleBufferA[gActiveBank][3]); - break; - } - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); -} - -void sub_811F664(void) -{ - u8 *dst; - u8 i; - - dst = (u8 *)&gPlayerParty[gBattlePartyID[gActiveBank]] + gBattleBufferA[gActiveBank][1]; - for (i = 0; i < gBattleBufferA[gActiveBank][2]; i++) - dst[i] = gBattleBufferA[gActiveBank][3 + i]; - LinkPartnerBufferExecCompleted(); -} - -void sub_811F6D8(void) -{ - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - GetMonSpriteTemplate_803C56C( - GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), - GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(gActiveBank, 2), - sub_8077F68(gActiveBank), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = -240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], gBattleMonForms[gActiveBank]); - gBattleBankFunc[gActiveBank] = sub_811DDE8; -} - -void sub_811F7F4(void) -{ - sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - sub_811F864(gActiveBank, gBattleBufferA[gActiveBank][2]); - gBattleBankFunc[gActiveBank] = sub_811E1BC; -} - -void sub_811F864(u8 a, u8 b) -{ - u16 species; - - sub_8032AA8(a, b); - gBattlePartyID[a] = gBattleBufferA[a][1]; - species = GetMonData(&gPlayerParty[gBattlePartyID[a]], MON_DATA_SPECIES); - gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); - gObjectBankIDs[a] = CreateSprite( - &gUnknown_02024E8C, - sub_8077ABC(a, 2), - sub_8077F68(a), - sub_8079E90(a)); - gSprites[gUnknown_0300434C[a]].data1 = gObjectBankIDs[a]; - gSprites[gObjectBankIDs[a]].data0 = a; - gSprites[gObjectBankIDs[a]].data2 = species; - gSprites[gObjectBankIDs[a]].oam.paletteNum = a; - StartSpriteAnim(&gSprites[gObjectBankIDs[a]], gBattleMonForms[a]); - gSprites[gObjectBankIDs[a]].invisible = TRUE; - gSprites[gObjectBankIDs[a]].callback = SpriteCallbackDummy; - gSprites[gUnknown_0300434C[a]].data0 = sub_8046400(0, 0xFF); -} - -void sub_811F9D0(void) -{ - if (gBattleBufferA[gActiveBank][1] == 0) - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_811FA5C; - } - else - { - FreeSpriteOamMatrix(&gSprites[gObjectBankIDs[gActiveBank]]); - DestroySprite(&gSprites[gObjectBankIDs[gActiveBank]]); - sub_8043DB0(gHealthboxIDs[gActiveBank]); - LinkPartnerBufferExecCompleted(); - } -} - -void sub_811FA5C(void) -{ - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 1); - gBattleBankFunc[gActiveBank] = sub_811DF34; - } - break; - } -} - -void sub_811FAE4(void) -{ - s16 xOffset; - u32 gender; - - if (gBattleTypeFlags & BATTLE_TYPE_MULTI) - { - if (GetBankIdentity(gActiveBank) & 2) - xOffset = 16; - else - xOffset = -16; - gender = gLinkPlayers[sub_803FC34(gActiveBank)].gender; - } - else - { - xOffset = 0; - gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; - } - LoadPlayerTrainerBankSprite(gender, gActiveBank); - GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); - gObjectBankIDs[gActiveBank] = CreateSprite( - &gUnknown_02024E8C, - 80 + xOffset, 80 + 4 * (8 - gTrainerBackPicCoords[gender].coords), - sub_8079E90(gActiveBank)); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; - gSprites[gObjectBankIDs[gActiveBank]].pos2.x = 240; - gSprites[gObjectBankIDs[gActiveBank]].data0 = -2; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80313A0; - gBattleBankFunc[gActiveBank] = sub_811DAE4; -} - -void sub_811FC30(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_811FC3C(void) -{ - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 35; - gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], SpriteCallbackDummy); - gBattleBankFunc[gActiveBank] = sub_811DB1C; -} - -void sub_811FCE8(void) -{ - if (ewram17810[gActiveBank].unk4 == 0) - { - if (ewram17800[gActiveBank].substituteSprite) - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - ewram17810[gActiveBank].unk4++; - } - else if (!ewram17810[gActiveBank].unk0_6) - { - ewram17810[gActiveBank].unk4 = 0; - sub_80324F8(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - PlaySE12WithPanning(SE_POKE_DEAD, -64); - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - gSprites[gObjectBankIDs[gActiveBank]].data2 = 5; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_80105EC; - gBattleBankFunc[gActiveBank] = sub_811DE98; - } -} - -void sub_811FDCC(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_811FDD8(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_811FDE4(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_811FDF0(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_811FDFC(void) -{ - if (!mplay_80342A4(gActiveBank)) - { - u32 r0 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - - gUnknown_0202F7C4 = gBattleBufferA[gActiveBank][3]; - gMovePowerMoveAnim = gBattleBufferA[gActiveBank][4] - | (gBattleBufferA[gActiveBank][5] << 8); - gMoveDmgMoveAnim = gBattleBufferA[gActiveBank][6] - | (gBattleBufferA[gActiveBank][7] << 8) - | (gBattleBufferA[gActiveBank][8] << 16) - | (gBattleBufferA[gActiveBank][9] << 24); - gHappinessMoveAnim = gBattleBufferA[gActiveBank][10]; - gWeatherMoveAnim = gBattleBufferA[gActiveBank][12] - | (gBattleBufferA[gActiveBank][13] << 8); - gDisableStructMoveAnim = (u32 *)&gBattleBufferA[gActiveBank][16]; - gPID_perBank[gActiveBank] = *gDisableStructMoveAnim; - - if (sub_8031720(r0, gUnknown_0202F7C4) != 0) - LinkPartnerBufferExecCompleted(); - else - { - ewram17810[gActiveBank].unk4 = 0; - gBattleBankFunc[gActiveBank] = sub_811FF30; - } - } -} - -void sub_811FF30(void) -{ - u16 r4 = gBattleBufferA[gActiveBank][1] - | (gBattleBufferA[gActiveBank][2] << 8); - u8 r7 = gBattleBufferA[gActiveBank][11]; - - switch (ewram17810[gActiveBank].unk4) - { - case 0: - if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) - { - ewram17800[gActiveBank].unk0_3 = 1; - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); - } - ewram17810[gActiveBank].unk4 = 1; - break; - case 1: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_80326EC(0); - ExecuteMoveAnim(r4); - ewram17810[gActiveBank].unk4 = 2; - } - break; - case 2: - gAnimScriptCallback(); - if (!gAnimScriptActive) - { - sub_80326EC(1); - if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) - { - move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); - ewram17800[gActiveBank].unk0_3 = 0; - } - ewram17810[gActiveBank].unk4 = 3; - } - break; - case 3: - if (!ewram17810[gActiveBank].unk0_6) - { - sub_8031F24(); - sub_80324BC( - gActiveBank, - gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - ewram17810[gActiveBank].unk4 = 0; - LinkPartnerBufferExecCompleted(); - } - break; - } -} - -void sub_8120094(void) -{ - gUnknown_030042A4 = 0; - gUnknown_030042A0 = 0; - BufferStringBattle(*(u16 *)&gBattleBufferA[gActiveBank][2]); - sub_8002EB0(&gUnknown_03004210, gDisplayedStringBattle, 144, 2, 15); - gBattleBankFunc[gActiveBank] = sub_811DFA0; -} - -void sub_81200F8(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120104(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120110(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_812011C(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120128(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120134(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120140(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleHealthBarUpdate(void) -{ - s16 r7; - - load_gfxc_health_bar(0); - r7 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - if (r7 != 0x7FFF) - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - u32 hp = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, hp, r7); - } - else - { - u32 maxHP = GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_MAX_HP); - - sub_8043D84(gActiveBank, gHealthboxIDs[gActiveBank], maxHP, 0, r7); - } - gBattleBankFunc[gActiveBank] = bx_t3_healthbar_update; -} - -void LinkPartnerHandleExpBarUpdate(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleStatusIconUpdate(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - sub_8045A5C(gHealthboxIDs[gActiveBank], &gPlayerParty[gBattlePartyID[gActiveBank]], 9); - ewram17810[gActiveBank].unk0_4 = 0; - gBattleBankFunc[gActiveBank] = sub_811E38C; - } -} - -void LinkPartnerHandleStatusAnimation(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - move_anim_start_t2_for_situation( - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2] - | (gBattleBufferA[gActiveBank][3] << 8) - | (gBattleBufferA[gActiveBank][4] << 16) - | (gBattleBufferA[gActiveBank][5] << 24)); - gBattleBankFunc[gActiveBank] = sub_811E38C; - } -} - -void sub_8120324(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120330(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_812033C(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120348(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120354(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120360(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_812036C(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120378(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120384(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120390(void) -{ - gUnknown_020238C8.unk0_0 = 0; - LinkPartnerBufferExecCompleted(); -} - -void sub_81203AC(void) -{ - gUnknown_020238C8.unk0_0 = gBattleBufferA[gActiveBank][1]; - LinkPartnerBufferExecCompleted(); -} - -void sub_81203E4(void) -{ - gUnknown_020238C8.unk0_7 = 0; - LinkPartnerBufferExecCompleted(); -} - -void sub_81203FC(void) -{ - gUnknown_020238C8.unk0_7 ^= 1; - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleHitAnimation(void) -{ - if (gSprites[gObjectBankIDs[gActiveBank]].invisible == TRUE) - { - LinkPartnerBufferExecCompleted(); - } - else - { - gDoingBattleAnim = TRUE; - gSprites[gObjectBankIDs[gActiveBank]].data1 = 0; - sub_8047858(gActiveBank); - gBattleBankFunc[gActiveBank] = bx_blink_t3; - } -} - -void sub_8120494(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleEffectivenessSound(void) -{ - s8 pan; - - if (GetBankSide(gActiveBank) == 0) - pan = -64; - else - pan = 63; - PlaySE12WithPanning(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8), pan); - LinkPartnerBufferExecCompleted(); -} - -void sub_81204E4(void) -{ - PlayFanfare(gBattleBufferA[gActiveBank][1] | (gBattleBufferA[gActiveBank][2] << 8)); - LinkPartnerBufferExecCompleted(); -} - -void LinkPartnerHandleFaintingCry(void) -{ - PlayCry3( - GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), - -25, 5); - LinkPartnerBufferExecCompleted(); -} - -void dp01t_2E_3_battle_intro(void) -{ - sub_80E43C0(gBattleBufferA[gActiveBank][1]); - gUnknown_02024DE8 |= 1; - LinkPartnerBufferExecCompleted(); -} - -void sub_8120588(void) -{ - u8 r4; - u8 taskId; - - oamt_add_pos2_onto_pos1(&gSprites[gObjectBankIDs[gActiveBank]]); - gSprites[gObjectBankIDs[gActiveBank]].data0 = 50; - gSprites[gObjectBankIDs[gActiveBank]].data2 = -40; - gSprites[gObjectBankIDs[gActiveBank]].data4 = gSprites[gObjectBankIDs[gActiveBank]].pos1.y; - gSprites[gObjectBankIDs[gActiveBank]].callback = sub_8078B34; - gSprites[gObjectBankIDs[gActiveBank]].data5 = gActiveBank; - oamt_set_x3A_32(&gSprites[gObjectBankIDs[gActiveBank]], sub_8030E38); - StartSpriteAnim(&gSprites[gObjectBankIDs[gActiveBank]], 1); - r4 = AllocSpritePalette(0xD6F9); - LoadCompressedPalette( - gTrainerBackPicPaletteTable[gLinkPlayers[sub_803FC34(gActiveBank)].gender].data, - 0x100 + r4 * 16, 0x20); - gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = r4; - taskId = CreateTask(sub_812071C, 5); - gTasks[taskId].data[0] = gActiveBank; - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - ewram17840.unk9_0 = 1; - gBattleBankFunc[gActiveBank] = nullsub_74; -} - -void sub_812071C(u8 taskId) -{ - u8 r9; - - if (gTasks[taskId].data[1] < 24) - { - gTasks[taskId].data[1]++; - return; - } - - r9 = gActiveBank; - gActiveBank = gTasks[taskId].data[0]; - if (!IsDoubleBattle() || (gBattleTypeFlags & BATTLE_TYPE_MULTI)) - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_811F864(gActiveBank, 0); - } - else - { - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_811F864(gActiveBank, 0); - gActiveBank ^= 2; - gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); - sub_811F864(gActiveBank, 0); - gActiveBank ^= 2; - } - gBattleBankFunc[gActiveBank] = sub_811DCA0; - gActiveBank = r9; - DestroyTask(taskId); -} - -void dp01t_30_3_80EB11C(void) -{ - if (gBattleBufferA[gActiveBank][1] != 0 && GetBankSide(gActiveBank) == 0) - { - LinkPartnerBufferExecCompleted(); - return; - } - - ewram17810[gActiveBank].unk0_0 = 1; - gUnknown_02024E68[gActiveBank] = sub_8044804( - gActiveBank, - (struct BattleInterfaceStruct2 *)&gBattleBufferA[gActiveBank][4], - gBattleBufferA[gActiveBank][1], - gBattleBufferA[gActiveBank][2]); - ewram17810[gActiveBank].unk5 = 0; - if (gBattleBufferA[gActiveBank][2] != 0) - ewram17810[gActiveBank].unk5 = 0x5D; - gBattleBankFunc[gActiveBank] = sub_81208E0; -} - -void sub_81208E0(void) -{ - if (ewram17810[gActiveBank].unk5++ >= 93) - { - ewram17810[gActiveBank].unk5 = 0; - LinkPartnerBufferExecCompleted(); - } -} - -void sub_8120920(void) -{ - if (ewram17810[gActiveBank].unk0_0) - gTasks[gUnknown_02024E68[gActiveBank]].func = sub_8044CA0; - LinkPartnerBufferExecCompleted(); -} - -void sub_812096C(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120978(void) -{ - if (sub_8078874(gActiveBank) != 0) - { - gSprites[gObjectBankIDs[gActiveBank]].invisible = gBattleBufferA[gActiveBank][1]; - sub_8031F88(gActiveBank); - } - LinkPartnerBufferExecCompleted(); -} - -void sub_81209D8(void) -{ - if (mplay_80342A4(gActiveBank) == 0) - { - u8 r3 = gBattleBufferA[gActiveBank][1]; - u16 r4 = gBattleBufferA[gActiveBank][2] | (gBattleBufferA[gActiveBank][3] << 8); - - if (move_anim_start_t3(gActiveBank, gActiveBank, gActiveBank, r3, r4) != 0) - LinkPartnerBufferExecCompleted(); - else - gBattleBankFunc[gActiveBank] = sub_811E3B8; - } -} - -void sub_8120A40(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120A4C(void) -{ - LinkPartnerBufferExecCompleted(); -} - -void sub_8120A58(void) -{ - gBattleOutcome = gBattleBufferA[gActiveBank][1]; - FadeOutMapMusic(5); - BeginFastPaletteFade(3); - LinkPartnerBufferExecCompleted(); - gBattleBankFunc[gActiveBank] = sub_811E29C; -} - -void nullsub_75(void) -{ -} diff --git a/src/battle_controller_linkopponent2.c b/src/battle_controller_linkopponent2.c index 57932131b..2ca7c7970 100644 --- a/src/battle_controller_linkopponent2.c +++ b/src/battle_controller_linkopponent2.c @@ -52,7 +52,7 @@ extern u8 gUnknown_0300434C[]; extern u8 sub_8077F68(); extern u8 sub_8079E90(); extern u8 GetBankIdentity(u8); -extern void sub_8031794(struct Pokemon *, u8); +extern void BattleLoadOpponentMonSprite(struct Pokemon *, u8); extern void sub_8037A74(void); extern void sub_8032984(u8, u16); extern void sub_8037E30(void); @@ -822,7 +822,7 @@ void LinkOpponentHandleLoadPokeSprite(void) { u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -852,7 +852,7 @@ void sub_8039430(u8 a, u8 b) gBattlePartyID[a] = gBattleBufferA[a][1]; species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); gObjectBankIDs[a] = CreateSprite( &gUnknown_02024E8C, @@ -891,7 +891,7 @@ void sub_8039648(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -960,7 +960,7 @@ void LinkOpponentHandlecmd10(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -1035,7 +1035,7 @@ void sub_8039B64(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -1055,7 +1055,7 @@ void sub_8039B64(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_controller_linkpartner.c b/src/battle_controller_linkpartner.c index f516c9bce..4308a8a5c 100644 --- a/src/battle_controller_linkpartner.c +++ b/src/battle_controller_linkpartner.c @@ -86,12 +86,12 @@ extern void oamt_set_x3A_32(); extern void sub_8078B34(struct Sprite *); extern void sub_80105EC(struct Sprite *); extern s32 sub_803FC34(u16); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern void sub_80313A0(struct Sprite *); extern u8 sub_8046400(); extern void sub_80312F0(struct Sprite *); extern u8 CreateInvisibleSpriteWithCallback(); -extern void sub_80318FC(); +extern void BattleLoadPlayerMonSprite(); extern u8 sub_8077ABC(); extern u8 sub_8077F68(); extern u8 sub_8079E90(); @@ -420,7 +420,7 @@ void sub_811E034(void) { if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_811E0A0; } @@ -1111,7 +1111,7 @@ void LinkPartnerHandlecmd3(void) void LinkPartnerHandleLoadPokeSprite(void) { - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C( GetMonData(&gPlayerParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES), GetBankIdentity(gActiveBank)); @@ -1131,7 +1131,7 @@ void LinkPartnerHandleSendOutPoke(void) { sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_811F864(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattleBankFunc[gActiveBank] = sub_811E1BC; } @@ -1181,7 +1181,7 @@ void sub_811FA5C(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -1214,7 +1214,7 @@ void LinkPartnerHandleTrainerThrow(void) xOffset = 0; gender = gLinkPlayers[GetMultiplayerId() ^ 1].gender; } - sub_8031AF4(gender, gActiveBank); + LoadPlayerTrainerBankSprite(gender, gActiveBank); GetMonSpriteTemplate_803C5A0(gender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1247,7 +1247,7 @@ void LinkPartnerHandlecmd10(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -1322,7 +1322,7 @@ void sub_811FF30(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -1342,7 +1342,7 @@ void sub_811FF30(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; @@ -1630,7 +1630,7 @@ void sub_812071C(u8 taskId) sub_811F864(gActiveBank, 0); gActiveBank ^= 2; gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_811F864(gActiveBank, 0); gActiveBank ^= 2; } diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index b24130bb8..abfa3fef2 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -67,7 +67,7 @@ extern u8 sub_8077ABC(); extern u8 sub_8077F68(); extern u8 sub_8079E90(); extern void sub_8033018(void); -extern void sub_8031794(); +extern void BattleLoadOpponentMonSprite(); extern u8 GetBankIdentity(u8); extern void sub_8032984(u8, u16); extern void sub_80333D4(void); @@ -465,7 +465,7 @@ void sub_8033264(void) { if (gSprites[gHealthboxIDs[gActiveBank]].callback == SpriteCallbackDummy) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_80332D0; } @@ -1127,7 +1127,7 @@ void OpponentHandleLoadPokeSprite(void) { u16 species = GetMonData(&gEnemyParty[gBattlePartyID[gActiveBank]], MON_DATA_SPECIES); - sub_8031794(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[gActiveBank]], gActiveBank); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1159,7 +1159,7 @@ void sub_803495C(u8 a, u8 b) gBattlePartyID[a] = gBattleBufferA[a][1]; species = GetMonData(&gEnemyParty[gBattlePartyID[a]], MON_DATA_SPECIES); gUnknown_0300434C[a] = CreateInvisibleSpriteWithCallback(sub_80312F0); - sub_8031794(&gEnemyParty[gBattlePartyID[a]], a); + BattleLoadOpponentMonSprite(&gEnemyParty[gBattlePartyID[a]], a); GetMonSpriteTemplate_803C56C(species, GetBankIdentity(a)); gObjectBankIDs[a] = CreateSprite( &gUnknown_02024E8C, @@ -1198,7 +1198,7 @@ void sub_8034B74(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -1289,7 +1289,7 @@ void OpponentHandlecmd10(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -1364,7 +1364,7 @@ void sub_8035238(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 && !ewram17800[gActiveBank].unk0_3) + if (ewram17800[gActiveBank].substituteSprite && !ewram17800[gActiveBank].unk0_3) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -1384,7 +1384,7 @@ void sub_8035238(void) if (!gAnimScriptActive) { sub_80326EC(1); - if ((ewram17800[gActiveBank].unk0_2) && r7 <= 1) + if ((ewram17800[gActiveBank].substituteSprite) && r7 <= 1) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index a537d9adb..269f20642 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -102,7 +102,7 @@ extern void sub_80E43C0(); extern void oamt_add_pos2_onto_pos1(); extern void sub_8078B34(struct Sprite *); extern void oamt_set_x3A_32(); -extern void sub_80318FC(); +extern void BattleLoadPlayerMonSprite(); extern bool8 IsDoubleBattle(void); extern void sub_802D500(void); extern bool8 sub_8078874(u8); @@ -124,7 +124,7 @@ extern void sub_80105EC(struct Sprite *); extern void sub_802D274(void); extern void sub_802D23C(void); extern u8 GetBankIdentity(u8); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern void sub_80313A0(struct Sprite *); extern void sub_802D204(void); extern u8 sub_8079E90(); @@ -1067,7 +1067,7 @@ void sub_802D680(void) ewram17810[gActiveBank].unk1_0 = 0; FreeSpriteTilesByTag(0x27F9); FreeSpritePaletteByTag(0x27F9); - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); gBattleBankFunc[gActiveBank] = sub_802D730; } @@ -2298,7 +2298,7 @@ void PlayerHandlecmd3(void) void PlayerHandleLoadPokeSprite(void) { - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); gSprites[gObjectBankIDs[gActiveBank]].oam.paletteNum = gActiveBank; gBattleBankFunc[gActiveBank] = bx_0802E404; } @@ -2307,7 +2307,7 @@ void PlayerHandleSendOutPoke(void) { sub_8032AA8(gActiveBank, gBattleBufferA[gActiveBank][2]); gBattlePartyID[gActiveBank] = gBattleBufferA[gActiveBank][1]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); gActionSelectionCursor[gActiveBank] = 0; gMoveSelectionCursor[gActiveBank] = 0; sub_802F934(gActiveBank, gBattleBufferA[gActiveBank][2]); @@ -2359,7 +2359,7 @@ void sub_802FB2C(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -2388,7 +2388,7 @@ void PlayerHandleTrainerThrow(void) { r7 = 0; } - sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -2404,7 +2404,7 @@ void PlayerHandleTrainerThrow(void) void PlayerHandleTrainerSlide(void) { - sub_8031AF4(gSaveBlock2.playerGender, gActiveBank); + LoadPlayerTrainerBankSprite(gSaveBlock2.playerGender, gActiveBank); GetMonSpriteTemplate_803C5A0(gSaveBlock2.playerGender, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -2434,7 +2434,7 @@ void PlayerHandlecmd10(void) { if (ewram17810[gActiveBank].unk4 == 0) { - if (ewram17800[gActiveBank].unk0_2) + if (ewram17800[gActiveBank].substituteSprite) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4++; } @@ -2522,7 +2522,7 @@ void sub_8030190(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 == 1 && ewram17800[gActiveBank].unk0_3 == 0) + if (ewram17800[gActiveBank].substituteSprite == 1 && ewram17800[gActiveBank].unk0_3 == 0) { ewram17800[gActiveBank].unk0_3 = 1; move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); @@ -2542,7 +2542,7 @@ void sub_8030190(void) if (!gAnimScriptActive) { sub_80326EC(1); - if (ewram17800[gActiveBank].unk0_2 == 1 && r7 < 2) + if (ewram17800[gActiveBank].substituteSprite == 1 && r7 < 2) { move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17800[gActiveBank].unk0_3 = 0; @@ -2916,7 +2916,7 @@ void sub_8030E38(struct Sprite *sprite) FreeSpriteOamMatrix(sprite); FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum)); DestroySprite(sprite); - sub_80318FC(&gPlayerParty[gBattlePartyID[r4]], r4); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[r4]], r4); StartSpriteAnim(&gSprites[gObjectBankIDs[r4]], 0); } @@ -2942,7 +2942,7 @@ void task05_08033660(u8 taskId) sub_802F934(gActiveBank, 0); gActiveBank ^= 2; gBattleBufferA[gActiveBank][1] = gBattlePartyID[gActiveBank]; - sub_80318FC(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); + BattleLoadPlayerMonSprite(&gPlayerParty[gBattlePartyID[gActiveBank]], gActiveBank); sub_802F934(gActiveBank, 0); gActiveBank ^= 2; } diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 08bad3c12..36e525bcc 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -72,7 +72,7 @@ extern void sub_8043DFC(); extern bool8 IsDoubleBattle(void); extern void c3_0802FDF4(u8); extern void PlayerHandlecmd1(void); -extern void sub_8031AF4(); +extern void LoadPlayerTrainerBankSprite(); extern u8 GetBankIdentity(u8); extern void sub_80313A0(struct Sprite *); extern u8 GetBankByPlayerAI(u8); @@ -1106,7 +1106,7 @@ void WallyHandleReturnPokeToBall(void) void WallyHandleTrainerThrow(void) { - sub_8031AF4(2, gActiveBank); + LoadPlayerTrainerBankSprite(2, gActiveBank); GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1121,7 +1121,7 @@ void WallyHandleTrainerThrow(void) void WallyHandleTrainerSlide(void) { - sub_8031AF4(2, gActiveBank); + LoadPlayerTrainerBankSprite(2, gActiveBank); GetMonSpriteTemplate_803C5A0(2, GetBankIdentity(gActiveBank)); gObjectBankIDs[gActiveBank] = CreateSprite( &gUnknown_02024E8C, @@ -1206,7 +1206,7 @@ void sub_81390D0(void) switch (ewram17810[gActiveBank].unk4) { case 0: - if (ewram17800[gActiveBank].unk0_2 == 1) + if (ewram17800[gActiveBank].substituteSprite == 1) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 5); ewram17810[gActiveBank].unk4 = 1; break; @@ -1223,7 +1223,7 @@ void sub_81390D0(void) if (!gAnimScriptActive) { sub_80326EC(1); - if (ewram17800[gActiveBank].unk0_2 == 1) + if (ewram17800[gActiveBank].substituteSprite == 1) move_anim_start_t4(gActiveBank, gActiveBank, gActiveBank, 6); ewram17810[gActiveBank].unk4 = 3; } @@ -1507,7 +1507,7 @@ void sub_81398BC(u8 bank) { u16 species; - ewram17800[bank].unk2 = 0; + ewram17800[bank].transformedSpecies = 0; gBattlePartyID[bank] = gBattleBufferA[bank][1]; species = GetMonData(&gPlayerParty[gBattlePartyID[bank]], MON_DATA_SPECIES); gUnknown_0300434C[bank] = CreateInvisibleSpriteWithCallback(sub_80312F0); -- cgit v1.2.3 From 2f7e3b3f6bfa62d60adb6f24f8a59f93987dca3d Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sun, 27 Aug 2017 11:14:39 -0500 Subject: Emitcmd22 -> EmitChoosePokemon --- src/battle_4.c | 4 ++-- src/rom3.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/battle_4.c b/src/battle_4.c index a3cfbc2de..a796ace94 100644 --- a/src/battle_4.c +++ b/src/battle_4.c @@ -10205,7 +10205,7 @@ void sub_8022A3C(u8 unkown) { //BATTLE_STRUCT->unk16064[gActiveBank] = gBattlePartyID[gActiveBank]; ewram[gActiveBank + 0x16064] = gBattlePartyID[gActiveBank]; - Emitcmd22(0, 1, unkown, 0, BATTLE_STRUCT->unk1606C[gActiveBank]); + EmitChoosePokemon(0, 1, unkown, 0, BATTLE_STRUCT->unk1606C[gActiveBank]); MarkBufferBankForExecution(gActiveBank); } @@ -11173,7 +11173,7 @@ _080231F8:\n\ movs r0, 0\n\ adds r1, r5, 0\n\ movs r3, 0\n\ - bl Emitcmd22\n\ + bl EmitChoosePokemon\n\ ldrb r0, [r4]\n\ bl MarkBufferBankForExecution\n\ ldr r0, [r6]\n\ diff --git a/src/rom3.c b/src/rom3.c index e9e664069..da2ea1357 100644 --- a/src/rom3.c +++ b/src/rom3.c @@ -1060,7 +1060,7 @@ void EmitOpenBag(u8 a, u8 *b) dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); } -void Emitcmd22(u8 a, u8 b, u8 c, u8 d, u8 *e) +void EmitChoosePokemon(u8 a, u8 b, u8 c, u8 d, u8 *e) { int i; -- cgit v1.2.3 From df0edd693361f4f4e587a39360fd035e7cec8cda Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 27 Aug 2017 19:28:57 +0200 Subject: fix nonmatchings, add labels --- src/battle_controller_linkpartner.c | 2 +- src/battle_controller_player.c | 2 +- src/battle_controller_wally.c | 2 +- src/battle_message.c | 19 +- src/rom3.c | 455 +++++++++--------------------------- 5 files changed, 120 insertions(+), 360 deletions(-) (limited to 'src') diff --git a/src/battle_controller_linkpartner.c b/src/battle_controller_linkpartner.c index 4308a8a5c..7fd5261aa 100644 --- a/src/battle_controller_linkpartner.c +++ b/src/battle_controller_linkpartner.c @@ -501,7 +501,7 @@ void LinkPartnerBufferExecCompleted(void) if (gBattleTypeFlags & 2) { multiplayerId = GetMultiplayerId(); - dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); + PrepareBufferDataTransferLink(2, 4, &multiplayerId); gBattleBufferA[gActiveBank][0] = 0x38; } else diff --git a/src/battle_controller_player.c b/src/battle_controller_player.c index 269f20642..5cfdeefbe 100644 --- a/src/battle_controller_player.c +++ b/src/battle_controller_player.c @@ -346,7 +346,7 @@ void PlayerBufferExecCompleted(void) { u8 playerId = GetMultiplayerId(); - dp01_prepare_buffer_wireless_probably(2, 4, &playerId); + PrepareBufferDataTransferLink(2, 4, &playerId); gBattleBufferA[gActiveBank][0] = 0x38; } else diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index 36e525bcc..e4b593df7 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -484,7 +484,7 @@ void WallyBufferExecCompleted(void) { u8 multiplayerId = GetMultiplayerId(); - dp01_prepare_buffer_wireless_probably(2, 4, &multiplayerId); + PrepareBufferDataTransferLink(2, 4, &multiplayerId); gBattleBufferA[gActiveBank][0] = 0x38; } else diff --git a/src/battle_message.c b/src/battle_message.c index 37ec14459..a3cc320ad 100644 --- a/src/battle_message.c +++ b/src/battle_message.c @@ -116,22 +116,7 @@ struct StatusFlagString extern const struct StatusFlagString gUnknown_081FA6D4[7]; // status flag/text extern const u8 gUnknown_084017A8[8]; // empty flags -struct StringInfo -{ - u16 currentMove; - u16 lastMove; - u16 lastItem; - u8 lastAbility; - u8 scrActive; - u8 unk1605E; - u8 hpScale; - u8 StringBank; - u8 moveType; - u8 abilities[4]; - u8 textBuffs[3][0x10]; -}; - -extern struct StringInfo* gSelectedOrderFromParty; +extern struct StringInfoBattle* gSelectedOrderFromParty; #define gStringInfo gSelectedOrderFromParty void sub_8121D1C(u8* textBuff); @@ -156,7 +141,7 @@ void BufferStringBattle(u16 stringID) int i; const u8* stringPtr = NULL; - gStringInfo = (struct StringInfo*)(&gBattleBufferA[gActiveBank][4]); + gStringInfo = (struct StringInfoBattle*)(&gBattleBufferA[gActiveBank][4]); gLastUsedItem = gStringInfo->lastItem; gLastUsedAbility = gStringInfo->lastAbility; BATTLE_STRUCT->scriptingActive = gStringInfo->scrActive; diff --git a/src/rom3.c b/src/rom3.c index da2ea1357..3b4b6a941 100644 --- a/src/rom3.c +++ b/src/rom3.c @@ -14,6 +14,8 @@ #include "species.h" #include "task.h" #include "util.h" +#include "battle_message.h" +#include "data2.h" extern u8 unk_2000000[]; @@ -343,30 +345,30 @@ void sub_800BD54(void) } } -void dp01_prepare_buffer(u8 a, u8 *b, u16 c) +void PrepareBufferDataTransfer(u8 a, u8 *data, u16 size) { int i; if (gBattleTypeFlags & BATTLE_TYPE_LINK) { - dp01_prepare_buffer_wireless_probably(a, c, b); + PrepareBufferDataTransferLink(a, size, data); } else { switch (a) { case 0: - for (i = 0; i < c; i++) + for (i = 0; i < size; i++) { - gBattleBufferA[gActiveBank][i] = *b; - b++; + gBattleBufferA[gActiveBank][i] = *data; + data++; } break; case 1: - for (i = 0; i < c; i++) + for (i = 0; i < size; i++) { - gBattleBufferB[gActiveBank][i] = *b; - b++; + gBattleBufferB[gActiveBank][i] = *data; + data++; } break; } @@ -390,12 +392,12 @@ void sub_800BF28(void) CpuFill16(0, EWRAM_14000, 0x2000); } -void dp01_prepare_buffer_wireless_probably(u8 a, u16 b, u8 *c) +void PrepareBufferDataTransferLink(u8 a, u16 size, u8 *data) { s32 r9; int i; - r9 = b - b % 4 + 4; + r9 = size - size % 4 + 4; if (gTasks[gUnknown_020238C4].data[14] + r9 + 9 > 0x1000) { gTasks[gUnknown_020238C4].data[12] = gTasks[gUnknown_020238C4].data[14]; @@ -409,8 +411,8 @@ void dp01_prepare_buffer_wireless_probably(u8 a, u16 b, u8 *c) unk_2000000[gTasks[gUnknown_020238C4].data[14] + 0x14005] = (r9 & 0x0000FF00) >> 8; unk_2000000[gTasks[gUnknown_020238C4].data[14] + 0x14006] = gAbsentBankFlags; unk_2000000[gTasks[gUnknown_020238C4].data[14] + 0x14007] = gEffectBank; - for (i = 0; i < b; i++) - unk_2000000[gTasks[gUnknown_020238C4].data[14] + 0x14008 + i] = c[i]; + for (i = 0; i < size; i++) + unk_2000000[gTasks[gUnknown_020238C4].data[14] + 0x14008 + i] = data[i]; gTasks[gUnknown_020238C4].data[14] = gTasks[gUnknown_020238C4].data[14] + r9 + 8; } @@ -570,7 +572,7 @@ void EmitGetAttributes(u8 a, u8 b, u8 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd1(u8 a, u8 b, u8 c) @@ -579,7 +581,7 @@ void Emitcmd1(u8 a, u8 b, u8 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitSetAttributes(u8 a, u8 b, u8 c, u8 d, void *e) @@ -591,7 +593,7 @@ void EmitSetAttributes(u8 a, u8 b, u8 c, u8 d, void *e) gBattleBuffersTransferData[2] = c; for (i = 0; i < d; i++) gBattleBuffersTransferData[3 + i] = *(u8*)(e++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, d + 3); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, d + 3); } void Emitcmd3(u8 a, u8 b, u8 c, u8 *d) @@ -603,7 +605,7 @@ void Emitcmd3(u8 a, u8 b, u8 c, u8 *d) gBattleBuffersTransferData[2] = c; for (i = 0; i < c; i++) gBattleBuffersTransferData[3 + i] = *(d++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, c + 3); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, c + 3); } void EmitLoadPokeSprite(u8 a) @@ -612,7 +614,7 @@ void EmitLoadPokeSprite(u8 a) gBattleBuffersTransferData[1] = 4; gBattleBuffersTransferData[2] = 4; gBattleBuffersTransferData[3] = 4; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitSendOutPoke(u8 a, u8 b, u8 c) @@ -621,14 +623,14 @@ void EmitSendOutPoke(u8 a, u8 b, u8 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = 5; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitReturnPokeToBall(u8 a, u8 b) { gBattleBuffersTransferData[0] = 6; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void EmitTrainerThrow(u8 a) @@ -637,7 +639,7 @@ void EmitTrainerThrow(u8 a) gBattleBuffersTransferData[1] = 7; gBattleBuffersTransferData[2] = 7; gBattleBuffersTransferData[3] = 7; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitTrainerSlide(u8 a) @@ -646,7 +648,7 @@ void EmitTrainerSlide(u8 a) gBattleBuffersTransferData[1] = 8; gBattleBuffersTransferData[2] = 8; gBattleBuffersTransferData[3] = 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitTrainerSlideBack(u8 a) @@ -655,7 +657,7 @@ void EmitTrainerSlideBack(u8 a) gBattleBuffersTransferData[1] = 9; gBattleBuffersTransferData[2] = 9; gBattleBuffersTransferData[3] = 9; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd10(u8 a) @@ -664,7 +666,7 @@ void Emitcmd10(u8 a) gBattleBuffersTransferData[1] = 10; gBattleBuffersTransferData[2] = 10; gBattleBuffersTransferData[3] = 10; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd11(u8 a) @@ -673,7 +675,7 @@ void Emitcmd11(u8 a) gBattleBuffersTransferData[1] = 11; gBattleBuffersTransferData[2] = 11; gBattleBuffersTransferData[3] = 11; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd12(u8 a) @@ -682,14 +684,14 @@ void Emitcmd12(u8 a) gBattleBuffersTransferData[1] = 12; gBattleBuffersTransferData[2] = 12; gBattleBuffersTransferData[3] = 12; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitBallThrow(u8 a, u8 b) { gBattleBuffersTransferData[0] = 13; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void EmitPuase(u8 a, u8 b, u8 *c) @@ -700,7 +702,7 @@ void EmitPuase(u8 a, u8 b, u8 *c) gBattleBuffersTransferData[1] = b; for (i = 0; i < b * 3; i++) gBattleBuffersTransferData[2 + i] = *(c++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, b * 3 + 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, b * 3 + 2); } void EmitMoveAnimation(u8 a, u16 b, u8 c, u16 d, s32 e, u8 f, struct DisableStruct *g) @@ -730,295 +732,68 @@ void EmitMoveAnimation(u8 a, u16 b, u8 c, u16 d, s32 e, u8 f, struct DisableStru gBattleBuffersTransferData[14] = 0; gBattleBuffersTransferData[15] = 0; memcpy(&gBattleBuffersTransferData[16], g, sizeof(*g)); - dp01_prepare_buffer(a, gBattleBuffersTransferData, 0x2C); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 0x2C); } -#ifdef NONMATCHING -void EmitPrintString(u8 a, u16 b) +void EmitPrintString(u8 a, u16 stringID) { - int i; - //u16 *r12; + s32 i; + struct StringInfoBattle* stringInfo; gBattleBuffersTransferData[0] = 16; gBattleBuffersTransferData[1] = gBattleOutcome; - gBattleBuffersTransferData[2] = b; - gBattleBuffersTransferData[3] = (b & 0xFF00) >> 8; - - *((u16 *)&gBattleBuffersTransferData[4]) = gCurrentMove; - *((u16 *)&gBattleBuffersTransferData[6]) = gUnknown_02024BE8; - *((u16 *)&gBattleBuffersTransferData[8]) = gLastUsedItem; + gBattleBuffersTransferData[2] = stringID; + gBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8; + + stringInfo = (struct StringInfoBattle*)(&gBattleBuffersTransferData[4]); + stringInfo->currentMove = gCurrentMove; + stringInfo->lastMove = gUnknown_02024BE8; + stringInfo->lastItem = gLastUsedItem; + stringInfo->lastAbility = gLastUsedAbility; + stringInfo->scrActive = BATTLE_STRUCT->scriptingActive; + stringInfo->unk1605E = BATTLE_STRUCT->unk1605E; + stringInfo->hpScale = BATTLE_STRUCT->hpScale; + stringInfo->StringBank = gStringBank; + stringInfo->moveType = gBattleMoves[gCurrentMove].type; - gBattleBuffersTransferData[10] = gLastUsedAbility; - gBattleBuffersTransferData[11] = unk_2000000[0x16000 + 3]; - gBattleBuffersTransferData[12] = unk_2000000[0x16000 + 0x5E]; - gBattleBuffersTransferData[13] = unk_2000000[0x16000 + 0xC1]; - gBattleBuffersTransferData[14] = gStringBank; - gBattleBuffersTransferData[15] = gBattleMoves[gCurrentMove].type; for (i = 0; i < 4; i++) + stringInfo->abilities[i] = gBattleMons[i].ability; + for (i = 0; i < 0x10; i++) { - gBattleBuffersTransferData[16 + i] = gBattleMons[i].ability; - } - for (i = 0; i < 16; i++) - { - gBattleBuffersTransferData[20 + i] = gBattleTextBuff1[i]; - gBattleBuffersTransferData[36 + i] = gBattleTextBuff2[i]; - gBattleBuffersTransferData[52 + i] = gBattleTextBuff3[i]; + stringInfo->textBuffs[0][i] = gBattleTextBuff1[i]; + stringInfo->textBuffs[1][i] = gBattleTextBuff2[i]; + stringInfo->textBuffs[2][i] = gBattleTextBuff3[i]; } - dp01_prepare_buffer(a, gBattleBuffersTransferData, 0x44); -} -#else -__attribute__((naked)) -void EmitPrintString(u8 a, u16 b) -{ - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - ldr r2, _0800CA2C @ =gBattleBuffersTransferData\n\ - movs r0, 0x10\n\ - strb r0, [r2]\n\ - ldr r0, _0800CA30 @ =gBattleOutcome\n\ - ldrb r0, [r0]\n\ - strb r0, [r2, 0x1]\n\ - strb r1, [r2, 0x2]\n\ - lsrs r1, 8\n\ - strb r1, [r2, 0x3]\n\ - adds r0, r2, 0x4\n\ - mov r12, r0\n\ - ldr r4, _0800CA34 @ =gCurrentMove\n\ - ldrh r0, [r4]\n\ - strh r0, [r2, 0x4]\n\ - ldr r0, _0800CA38 @ =gUnknown_02024BE8\n\ - ldrh r0, [r0]\n\ - mov r1, r12\n\ - strh r0, [r1, 0x2]\n\ - ldr r0, _0800CA3C @ =gLastUsedItem\n\ - ldrh r0, [r0]\n\ - strh r0, [r1, 0x4]\n\ - ldr r0, _0800CA40 @ =gLastUsedAbility\n\ - ldrb r0, [r0]\n\ - strb r0, [r1, 0x6]\n\ - ldr r1, _0800CA44 @ =0x02000000\n\ - ldr r3, _0800CA48 @ =0x00016003\n\ - adds r0, r1, r3\n\ - ldrb r0, [r0]\n\ - mov r7, r12\n\ - strb r0, [r7, 0x7]\n\ - adds r3, 0x5B\n\ - adds r0, r1, r3\n\ - ldrb r0, [r0]\n\ - strb r0, [r7, 0x8]\n\ - ldr r7, _0800CA4C @ =0x000160c1\n\ - adds r1, r7\n\ - ldrb r0, [r1]\n\ - mov r1, r12\n\ - strb r0, [r1, 0x9]\n\ - ldr r0, _0800CA50 @ =gStringBank\n\ - ldrb r0, [r0]\n\ - strb r0, [r1, 0xA]\n\ - ldr r3, _0800CA54 @ =gBattleMoves\n\ - ldrh r1, [r4]\n\ - lsls r0, r1, 1\n\ - adds r0, r1\n\ - lsls r0, 2\n\ - adds r0, r3\n\ - ldrb r0, [r0, 0x2]\n\ - mov r3, r12\n\ - strb r0, [r3, 0xB]\n\ - movs r3, 0\n\ - mov r9, r2\n\ - ldr r7, _0800CA58 @ =gBattleTextBuff3\n\ - mov r8, r7\n\ - adds r2, 0x10\n\ - ldr r0, _0800CA5C @ =gBattleMons\n\ - adds r4, r0, 0\n\ - adds r4, 0x20\n\ -_0800C9D2:\n\ - adds r1, r2, r3\n\ - ldrb r0, [r4]\n\ - strb r0, [r1]\n\ - adds r4, 0x58\n\ - adds r3, 0x1\n\ - cmp r3, 0x3\n\ - ble _0800C9D2\n\ - movs r3, 0\n\ - mov r5, r12\n\ - adds r5, 0x10\n\ - mov r4, r12\n\ - adds r4, 0x20\n\ - ldr r6, _0800CA60 @ =gBattleTextBuff2\n\ - mov r2, r12\n\ - adds r2, 0x30\n\ -_0800C9F0:\n\ - adds r1, r5, r3\n\ - ldr r7, _0800CA64 @ =gBattleTextBuff1\n\ - adds r0, r3, r7\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r1, r4, r3\n\ - adds r0, r3, r6\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r1, r2, r3\n\ - mov r7, r8\n\ - adds r0, r3, r7\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r3, 0x1\n\ - cmp r3, 0xF\n\ - ble _0800C9F0\n\ - mov r0, r10\n\ - mov r1, r9\n\ - movs r2, 0x44\n\ - bl dp01_prepare_buffer\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_0800CA2C: .4byte gBattleBuffersTransferData\n\ -_0800CA30: .4byte gBattleOutcome\n\ -_0800CA34: .4byte gCurrentMove\n\ -_0800CA38: .4byte gUnknown_02024BE8\n\ -_0800CA3C: .4byte gLastUsedItem\n\ -_0800CA40: .4byte gLastUsedAbility\n\ -_0800CA44: .4byte 0x02000000\n\ -_0800CA48: .4byte 0x00016003\n\ -_0800CA4C: .4byte 0x000160c1\n\ -_0800CA50: .4byte gStringBank\n\ -_0800CA54: .4byte gBattleMoves\n\ -_0800CA58: .4byte gBattleTextBuff3\n\ -_0800CA5C: .4byte gBattleMons\n\ -_0800CA60: .4byte gBattleTextBuff2\n\ -_0800CA64: .4byte gBattleTextBuff1\n\ - .syntax divided\n"); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4); } -#endif -__attribute__((naked)) void EmitPrintStringPlayerOnly(u8 a, u16 stringID) { - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - ldr r2, _0800CB28 @ =gBattleBuffersTransferData\n\ - movs r0, 0x11\n\ - strb r0, [r2]\n\ - strb r0, [r2, 0x1]\n\ - strb r1, [r2, 0x2]\n\ - lsrs r1, 8\n\ - strb r1, [r2, 0x3]\n\ - adds r0, r2, 0x4\n\ - mov r12, r0\n\ - ldr r0, _0800CB2C @ =gCurrentMove\n\ - ldrh r0, [r0]\n\ - strh r0, [r2, 0x4]\n\ - ldr r0, _0800CB30 @ =gUnknown_02024BE8\n\ - ldrh r0, [r0]\n\ - mov r1, r12\n\ - strh r0, [r1, 0x2]\n\ - ldr r0, _0800CB34 @ =gLastUsedItem\n\ - ldrh r0, [r0]\n\ - strh r0, [r1, 0x4]\n\ - ldr r0, _0800CB38 @ =gLastUsedAbility\n\ - ldrb r0, [r0]\n\ - strb r0, [r1, 0x6]\n\ - ldr r0, _0800CB3C @ =0x02000000\n\ - ldr r3, _0800CB40 @ =0x00016003\n\ - adds r1, r0, r3\n\ - ldrb r1, [r1]\n\ - mov r7, r12\n\ - strb r1, [r7, 0x7]\n\ - ldr r1, _0800CB44 @ =0x0001605e\n\ - adds r0, r1\n\ - ldrb r0, [r0]\n\ - strb r0, [r7, 0x8]\n\ - movs r3, 0\n\ - mov r9, r2\n\ - ldr r7, _0800CB48 @ =gBattleTextBuff3\n\ - mov r8, r7\n\ - mov r4, r9\n\ - adds r4, 0x10\n\ - ldr r0, _0800CB4C @ =gBattleMons\n\ - adds r2, r0, 0\n\ - adds r2, 0x20\n\ -_0800CACE:\n\ - adds r1, r4, r3\n\ - ldrb r0, [r2]\n\ - strb r0, [r1]\n\ - adds r2, 0x58\n\ - adds r3, 0x1\n\ - cmp r3, 0x3\n\ - ble _0800CACE\n\ - movs r3, 0\n\ - mov r5, r12\n\ - adds r5, 0x10\n\ - mov r4, r12\n\ - adds r4, 0x20\n\ - ldr r6, _0800CB50 @ =gBattleTextBuff2\n\ - mov r2, r12\n\ - adds r2, 0x30\n\ -_0800CAEC:\n\ - adds r1, r5, r3\n\ - ldr r7, _0800CB54 @ =gBattleTextBuff1\n\ - adds r0, r3, r7\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r1, r4, r3\n\ - adds r0, r3, r6\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r1, r2, r3\n\ - mov r7, r8\n\ - adds r0, r3, r7\n\ - ldrb r0, [r0]\n\ - strb r0, [r1]\n\ - adds r3, 0x1\n\ - cmp r3, 0xF\n\ - ble _0800CAEC\n\ - mov r0, r10\n\ - mov r1, r9\n\ - movs r2, 0x44\n\ - bl dp01_prepare_buffer\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ -_0800CB28: .4byte gBattleBuffersTransferData\n\ -_0800CB2C: .4byte gCurrentMove\n\ -_0800CB30: .4byte gUnknown_02024BE8\n\ -_0800CB34: .4byte gLastUsedItem\n\ -_0800CB38: .4byte gLastUsedAbility\n\ -_0800CB3C: .4byte 0x02000000\n\ -_0800CB40: .4byte 0x00016003\n\ -_0800CB44: .4byte 0x0001605e\n\ -_0800CB48: .4byte gBattleTextBuff3\n\ -_0800CB4C: .4byte gBattleMons\n\ -_0800CB50: .4byte gBattleTextBuff2\n\ -_0800CB54: .4byte gBattleTextBuff1\n\ - .syntax divided\n"); + s32 i; + struct StringInfoBattle* stringInfo; + + gBattleBuffersTransferData[0] = 17; + gBattleBuffersTransferData[1] = 17; + gBattleBuffersTransferData[2] = stringID; + gBattleBuffersTransferData[3] = (stringID & 0xFF00) >> 8; + + stringInfo = (struct StringInfoBattle*)(&gBattleBuffersTransferData[4]); + stringInfo->currentMove = gCurrentMove; + stringInfo->lastMove = gUnknown_02024BE8; + stringInfo->lastItem = gLastUsedItem; + stringInfo->lastAbility = gLastUsedAbility; + stringInfo->scrActive = BATTLE_STRUCT->scriptingActive; + stringInfo->unk1605E = BATTLE_STRUCT->unk1605E; + + for (i = 0; i < 4; i++) + stringInfo->abilities[i] = gBattleMons[i].ability; + for (i = 0; i < 0x10; i++) + { + stringInfo->textBuffs[0][i] = gBattleTextBuff1[i]; + stringInfo->textBuffs[1][i] = gBattleTextBuff2[i]; + stringInfo->textBuffs[2][i] = gBattleTextBuff3[i]; + } + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, sizeof(struct StringInfoBattle) + 4); } void Emitcmd18(u8 a, u8 b, u16 c) @@ -1027,14 +802,14 @@ void Emitcmd18(u8 a, u8 b, u16 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = (c & 0xFF00) >> 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd19(u8 a, u8 b) { gBattleBuffersTransferData[0] = 19; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void Emitcmd20(u8 a, u8 b, u8 c, u8 *d) @@ -1047,7 +822,7 @@ void Emitcmd20(u8 a, u8 b, u8 c, u8 *d) gBattleBuffersTransferData[3] = 0; for (i = 0; i < 20; i++) gBattleBuffersTransferData[4 + i] = d[i]; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 24); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 24); } void EmitOpenBag(u8 a, u8 *b) @@ -1057,7 +832,7 @@ void EmitOpenBag(u8 a, u8 *b) gBattleBuffersTransferData[0] = 21; for (i = 0; i < 3; i++) gBattleBuffersTransferData[1 + i] = b[i]; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitChoosePokemon(u8 a, u8 b, u8 c, u8 d, u8 *e) @@ -1070,7 +845,7 @@ void EmitChoosePokemon(u8 a, u8 b, u8 c, u8 d, u8 *e) gBattleBuffersTransferData[3] = d; for (i = 0; i < 3; i++) gBattleBuffersTransferData[4 + i] = e[i]; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 8); //but only 7 bytes were written + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 8); //but only 7 bytes were written } void Emitcmd23(u8 a) @@ -1079,7 +854,7 @@ void Emitcmd23(u8 a) gBattleBuffersTransferData[1] = 23; gBattleBuffersTransferData[2] = 23; gBattleBuffersTransferData[3] = 23; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } // FIXME: I think this function is supposed to take s16 as its second argument, @@ -1090,7 +865,7 @@ void EmitHealthBarUpdate(u8 a, u16 b) gBattleBuffersTransferData[1] = 0; gBattleBuffersTransferData[2] = (s16)b; gBattleBuffersTransferData[3] = ((s16)b & 0xFF00) >> 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } // FIXME: I think this function is supposed to take s16 as its third argument, @@ -1101,7 +876,7 @@ void EmitExpBarUpdate(u8 a, u8 b, u16 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (s16)c; gBattleBuffersTransferData[3] = ((s16)c & 0xFF00) >> 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitStatusIconUpdate(u8 a, u32 b, u32 c) @@ -1115,7 +890,7 @@ void EmitStatusIconUpdate(u8 a, u32 b, u32 c) gBattleBuffersTransferData[6] = (c & 0x0000FF00) >> 8; gBattleBuffersTransferData[7] = (c & 0x00FF0000) >> 16; gBattleBuffersTransferData[8] = (c & 0xFF000000) >> 24; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 9); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 9); } void EmitStatusAnimation(u8 a, u8 b, u32 c) @@ -1126,14 +901,14 @@ void EmitStatusAnimation(u8 a, u8 b, u32 c) gBattleBuffersTransferData[3] = (c & 0x0000FF00) >> 8; gBattleBuffersTransferData[4] = (c & 0x00FF0000) >> 16; gBattleBuffersTransferData[5] = (c & 0xFF000000) >> 24; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 6); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 6); } void EmitStatusXor(u8 a, u8 b) { gBattleBuffersTransferData[0] = 28; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void Emitcmd29(u8 a, u16 b, u8 *c) @@ -1146,7 +921,7 @@ void Emitcmd29(u8 a, u16 b, u8 *c) gBattleBuffersTransferData[3] = (b & 0xFF00) >> 8; for (i = 0; i < b; i++) gBattleBuffersTransferData[4 + i] = *(c++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, b + 4); } void EmitDMATransfer(u8 a, u32 b, u16 c, u8 *d) @@ -1162,7 +937,7 @@ void EmitDMATransfer(u8 a, u32 b, u16 c, u8 *d) gBattleBuffersTransferData[6] = (c & 0xFF00) >> 8; for (i = 0; i < c; i++) gBattleBuffersTransferData[7 + i] = *(d++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, c + 7); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, c + 7); } void Emitcmd31(u8 a, u16 b, u8 *c) @@ -1174,7 +949,7 @@ void Emitcmd31(u8 a, u16 b, u8 *c) gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; for (i = 0; i < b; i++) gBattleBuffersTransferData[3 + i] = *(c++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 3); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, b + 3); } void Emitcmd32(u8 a, u16 b, u8 *c) @@ -1186,7 +961,7 @@ void Emitcmd32(u8 a, u16 b, u8 *c) gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; for (i = 0; i < b; i++) gBattleBuffersTransferData[3 + i] = *(c++); - dp01_prepare_buffer(a, gBattleBuffersTransferData, b + 3); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, b + 3); } void Emitcmd33(u8 a, u8 b, u16 c) @@ -1195,7 +970,7 @@ void Emitcmd33(u8 a, u8 b, u16 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = (c & 0xFF00) >> 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd34(u8 a, u8 b, u8 *c) @@ -1206,7 +981,7 @@ void Emitcmd34(u8 a, u8 b, u8 *c) gBattleBuffersTransferData[1] = b; for (i = 0; i < 3; i++) gBattleBuffersTransferData[2 + i] = c[i]; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 5); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 5); } void Emitcmd35(u8 a, u16 b) @@ -1215,7 +990,7 @@ void Emitcmd35(u8 a, u16 b) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd36(u8 a, u16 b) @@ -1224,7 +999,7 @@ void Emitcmd36(u8 a, u16 b) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd37(u8 a) @@ -1233,14 +1008,14 @@ void Emitcmd37(u8 a) gBattleBuffersTransferData[1] = 37; gBattleBuffersTransferData[2] = 37; gBattleBuffersTransferData[3] = 37; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd38(u8 a, u8 b) { gBattleBuffersTransferData[0] = 38; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void Emitcmd39(u8 a) @@ -1249,7 +1024,7 @@ void Emitcmd39(u8 a) gBattleBuffersTransferData[1] = 39; gBattleBuffersTransferData[2] = 39; gBattleBuffersTransferData[3] = 39; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd40(u8 a) @@ -1258,7 +1033,7 @@ void Emitcmd40(u8 a) gBattleBuffersTransferData[1] = 40; gBattleBuffersTransferData[2] = 40; gBattleBuffersTransferData[3] = 40; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitHitAnimation(u8 a) @@ -1267,7 +1042,7 @@ void EmitHitAnimation(u8 a) gBattleBuffersTransferData[1] = 41; gBattleBuffersTransferData[2] = 41; gBattleBuffersTransferData[3] = 41; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd42(u8 a) @@ -1276,7 +1051,7 @@ void Emitcmd42(u8 a) gBattleBuffersTransferData[1] = 42; gBattleBuffersTransferData[2] = 42; gBattleBuffersTransferData[3] = 42; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitEffectivenessSound(u8 a, u16 b) @@ -1285,7 +1060,7 @@ void EmitEffectivenessSound(u8 a, u16 b) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd44(u8 a, u16 b) @@ -1294,7 +1069,7 @@ void Emitcmd44(u8 a, u16 b) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = (b & 0xFF00) >> 8; gBattleBuffersTransferData[3] = 0; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitFaintingCry(u8 a) @@ -1303,14 +1078,14 @@ void EmitFaintingCry(u8 a) gBattleBuffersTransferData[1] = 45; gBattleBuffersTransferData[2] = 45; gBattleBuffersTransferData[3] = 45; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitIntroSlide(u8 a, u8 b) { gBattleBuffersTransferData[0] = 46; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void EmitTrainerBallThrow(u8 a) @@ -1319,7 +1094,7 @@ void EmitTrainerBallThrow(u8 a) gBattleBuffersTransferData[1] = 47; gBattleBuffersTransferData[2] = 47; gBattleBuffersTransferData[3] = 47; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd48(u8 a, u8 *b, u8 c) @@ -1332,7 +1107,7 @@ void Emitcmd48(u8 a, u8 *b, u8 c) gBattleBuffersTransferData[3] = 48; for (i = 0; i < 48; i++) gBattleBuffersTransferData[4 + i] = b[i]; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 52); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 52); } void Emitcmd49(u8 a) @@ -1341,7 +1116,7 @@ void Emitcmd49(u8 a) gBattleBuffersTransferData[1] = 49; gBattleBuffersTransferData[2] = 49; gBattleBuffersTransferData[3] = 49; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void Emitcmd50(u8 a) @@ -1350,7 +1125,7 @@ void Emitcmd50(u8 a) gBattleBuffersTransferData[1] = 50; gBattleBuffersTransferData[2] = 50; gBattleBuffersTransferData[3] = 50; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitSpriteInvisibility(u8 a, u8 b) @@ -1359,7 +1134,7 @@ void EmitSpriteInvisibility(u8 a, u8 b) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = 51; gBattleBuffersTransferData[3] = 51; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitBattleAnimation(u8 a, u8 b, u16 c) @@ -1368,26 +1143,26 @@ void EmitBattleAnimation(u8 a, u8 b, u16 c) gBattleBuffersTransferData[1] = b; gBattleBuffersTransferData[2] = c; gBattleBuffersTransferData[3] = (c & 0xFF00) >> 8; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 4); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 4); } void EmitLinkStandbyMsg(u8 a, u8 b) { gBattleBuffersTransferData[0] = 53; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void EmitResetActionMoveSelection(u8 a, u8 b) { gBattleBuffersTransferData[0] = 54; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } void Emitcmd55(u8 a, u8 b) { gBattleBuffersTransferData[0] = 55; gBattleBuffersTransferData[1] = b; - dp01_prepare_buffer(a, gBattleBuffersTransferData, 2); + PrepareBufferDataTransfer(a, gBattleBuffersTransferData, 2); } -- cgit v1.2.3 From 2c700bb131d1fac95b587e1c188fac67ab97b40e Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 27 Aug 2017 22:17:24 +0200 Subject: clean up and match damage calc --- src/calculate_base_damage.c | 1318 +++---------------------------------------- 1 file changed, 78 insertions(+), 1240 deletions(-) (limited to 'src') diff --git a/src/calculate_base_damage.c b/src/calculate_base_damage.c index 0f2605e5b..5044145b3 100644 --- a/src/calculate_base_damage.c +++ b/src/calculate_base_damage.c @@ -7,52 +7,37 @@ #include "hold_effects.h" #include "item.h" #include "items.h" -#include "main.h" #include "pokemon.h" #include "species.h" -#include "sprite.h" -#include "string_util.h" -#include "strings2.h" -#include "text.h" +#include "moves.h" +#include "battle_move_effects.h" -extern u8 gPlayerPartyCount; -extern u8 gEnemyPartyCount; - -extern u16 unk_20160BC[]; -extern struct SecretBaseRecord gSecretBaseRecord; extern u32 dword_2017100[]; extern u16 gBattleTypeFlags; extern struct BattlePokemon gBattleMons[4]; extern u16 gCurrentMove; -extern u8 gLastUsedAbility; extern u8 gCritMultiplier; extern u16 gBattleWeather; extern struct BattleEnigmaBerry gEnigmaBerries[]; extern u16 gBattleMovePower; -extern struct SpriteTemplate gUnknown_02024E8C; extern u16 gTrainerBattleOpponent; -extern struct PokemonStorage gPokemonStorage; -extern u8 gBadEggNickname[]; -extern struct SpriteTemplate gSpriteTemplate_8208288[]; -extern u8 gTrainerClassToPicIndex[]; -extern u8 gTrainerClassToNameIndex[]; -extern u8 gUnknown_08208238[]; -extern u8 gUnknown_0820823C[]; -extern u8 gStatStageRatios[]; -extern u8 gHoldEffectToType[][2]; +extern const u8 gHoldEffectToType[][2]; +extern const u8 gStatStageRatios[][2]; + +u8 GetBankSide(u8 bank); -#define APPLY_STAT_MOD(var, mon, stat, statIndex) \ -{ \ - (var) = (stat) * (gStatStageRatios)[(mon)->statStages[(statIndex)] * 2]; \ - (var) /= (gStatStageRatios + 1)[(mon)->statStages[(statIndex)] * 2]; \ +#define APPLY_STAT_MOD(var, mon, stat, statIndex) \ +{ \ + (var) = (stat) * (gStatStageRatios)[(mon)->statStages[(statIndex)]][0]; \ + (var) /= (gStatStageRatios)[(mon)->statStages[(statIndex)]][1]; \ } -#ifdef NONMATCHING -s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *defender, u32 move, u16 a4, u16 powerOverride, u8 typeOverride, u8 a7, u8 a8) +s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *defender, u32 move, u16 sideStatus, u16 powerOverride, u8 typeOverride, u8 bankAtk, u8 bankDef) { - s32 i; + u32 i; s32 damage = 0; + s32 damageHelper; u8 type; u16 attack, defense; u16 spAttack, spDefense; @@ -60,7 +45,6 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de u8 defenderHoldEffectParam; u8 attackerHoldEffect; u8 attackerHoldEffectParam; - s32 a, b; if (!powerOverride) gBattleMovePower = gBattleMoves[move].power; @@ -79,8 +63,8 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if (attacker->item == ITEM_ENIGMA_BERRY) { - attackerHoldEffect = gEnigmaBerries[a7].holdEffect; - attackerHoldEffectParam = gEnigmaBerries[a7].holdEffectParam; + attackerHoldEffect = gEnigmaBerries[bankAtk].holdEffect; + attackerHoldEffectParam = gEnigmaBerries[bankAtk].holdEffectParam; } else { @@ -90,8 +74,8 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if (defender->item == ITEM_ENIGMA_BERRY) { - defenderHoldEffect = gEnigmaBerries[a8].holdEffect; - defenderHoldEffectParam = gEnigmaBerries[a8].holdEffectParam; + defenderHoldEffect = gEnigmaBerries[bankDef].holdEffect; + defenderHoldEffectParam = gEnigmaBerries[bankDef].holdEffectParam; } else { @@ -107,7 +91,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gTrainerBattleOpponent != 1024 && FlagGet(BADGE01_GET) - && !GetBankSide(a7)) + && !GetBankSide(bankAtk)) attack = (110 * attack) / 100; if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) @@ -115,7 +99,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gTrainerBattleOpponent != 1024 && FlagGet(BADGE05_GET) - && !GetBankSide(a8)) + && !GetBankSide(bankDef)) defense = (110 * defense) / 100; if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) @@ -123,7 +107,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gTrainerBattleOpponent != 1024 && FlagGet(BADGE07_GET) - && !GetBankSide(a7)) + && !GetBankSide(bankAtk)) spAttack = (110 * spAttack) / 100; if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) @@ -131,7 +115,7 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) && gTrainerBattleOpponent != 1024 && FlagGet(BADGE07_GET) - && !GetBankSide(a8)) + && !GetBankSide(bankDef)) spDefense = (110 * spDefense) / 100; } } @@ -171,17 +155,17 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de spAttack /= 2; if (attacker->ability == ABILITY_HUSTLE) attack = (150 * attack) / 100; - if (attacker->ability == ABILITY_PLUS && AbilityBattleEffects(0xE, 0, ABILITY_MINUS, 0, 0)) + if (attacker->ability == ABILITY_PLUS && AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_MINUS, 0, 0)) spAttack = (150 * spAttack) / 100; - if (attacker->ability == ABILITY_MINUS && AbilityBattleEffects(0xE, 0, ABILITY_PLUS, 0, 0)) + if (attacker->ability == ABILITY_MINUS && AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_PLUS, 0, 0)) spAttack = (150 * spAttack) / 100; if (attacker->ability == ABILITY_GUTS && attacker->status1) attack = (150 * attack) / 100; if (defender->ability == ABILITY_MARVEL_SCALE && defender->status1) defense = (150 * defense) / 100; - if (type == TYPE_ELECTRIC && AbilityBattleEffects(0xE, 0, 0, 0xFD, 0)) + if (type == TYPE_ELECTRIC && AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, 0, 0xFD, 0)) gBattleMovePower /= 2; - if (type == TYPE_FIRE && AbilityBattleEffects(0xE, 0, 0, 0xFE, 0)) + if (type == TYPE_FIRE && AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, 0, 0xFE, 0)) gBattleMovePower /= 2; if (type == TYPE_GRASS && attacker->ability == ABILITY_OVERGROW && attacker->hp <= (attacker->maxHP / 3)) gBattleMovePower = (150 * gBattleMovePower) / 100; @@ -191,39 +175,41 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de gBattleMovePower = (150 * gBattleMovePower) / 100; if (type == TYPE_BUG && attacker->ability == ABILITY_SWARM && attacker->hp <= (attacker->maxHP / 3)) gBattleMovePower = (150 * gBattleMovePower) / 100; - if (gBattleMoves[gCurrentMove].effect == 7) + if (gBattleMoves[gCurrentMove].effect == EFFECT_EXPLOSION) defense /= 2; - if (type < TYPE_MYSTERY) // is physical? + if (type < TYPE_MYSTERY) // is physical { if (gCritMultiplier == 2) { - if (attacker->statStages[1] > 6) - APPLY_STAT_MOD(a, attacker, attack, 1) + if (attacker->statStages[STAT_STAGE_ATK] > 6) + APPLY_STAT_MOD(damage, attacker, attack, STAT_STAGE_ATK) else - a = attack; + damage = attack; } else - APPLY_STAT_MOD(a, attacker, attack, 1) + APPLY_STAT_MOD(damage, attacker, attack, STAT_STAGE_ATK) - a = a * gBattleMovePower * (2 * attacker->level / 5 + 2); + damage = damage * gBattleMovePower; + damage *= (2 * attacker->level / 5 + 2); if (gCritMultiplier == 2) { - if (defender->statStages[2] < 6) - APPLY_STAT_MOD(b, defender, defense, 2) + if (defender->statStages[STAT_STAGE_DEF] < 6) + APPLY_STAT_MOD(damageHelper, defender, defense, STAT_STAGE_DEF) else - b = defense; + damageHelper = defense; } else - APPLY_STAT_MOD(b, defender, defense, 2) + APPLY_STAT_MOD(damageHelper, defender, defense, STAT_STAGE_DEF) - damage = (a / b) / 50; + damage = damage / damageHelper; + damage /= 50; - if ((attacker->status1 & 0x10) && attacker->ability != ABILITY_GUTS) + if ((attacker->status1 & STATUS_BURN) && attacker->ability != ABILITY_GUTS) damage /= 2; - if ((a4 & 1) && gCritMultiplier == 1) + if ((sideStatus & SIDE_STATUS_REFLECT) && gCritMultiplier == 1) { if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && CountAliveMons(2) == 2) damage = 2 * (damage / 3); @@ -246,29 +232,31 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de { if (gCritMultiplier == 2) { - if (attacker->statStages[4] > 6) - APPLY_STAT_MOD(a, attacker, spAttack, 4) + if (attacker->statStages[STAT_STAGE_SPATK] > 6) + APPLY_STAT_MOD(damage, attacker, spAttack, STAT_STAGE_SPATK) else - a = spAttack; + damage = spAttack; } else - APPLY_STAT_MOD(a, attacker, spAttack, 4) + APPLY_STAT_MOD(damage, attacker, spAttack, STAT_STAGE_SPATK) - a = a * gBattleMovePower * (2 * attacker->level / 5 + 2); + damage = damage * gBattleMovePower; + damage *= (2 * attacker->level / 5 + 2); if (gCritMultiplier == 2) { - if (defender->statStages[5] < 6) - APPLY_STAT_MOD(b, defender, spDefense, 5) + if (defender->statStages[STAT_STAGE_SPDEF] < 6) + APPLY_STAT_MOD(damageHelper, defender, spDefense, STAT_STAGE_SPDEF) else - b = spDefense; + damageHelper = spDefense; } else - APPLY_STAT_MOD(b, defender, spDefense, 5) + APPLY_STAT_MOD(damageHelper, defender, spDefense, STAT_STAGE_SPDEF) - damage = (a / b) / 50; + damage = (damage / damageHelper); + damage /= 50; - if ((a4 & 2) && gCritMultiplier == 1) + if ((sideStatus & SIDE_STATUS_LIGHTSCREEN) && gCritMultiplier == 1) { if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && CountAliveMons(2) == 2) damage = 2 * (damage / 3); @@ -279,1196 +267,46 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de if ((gBattleTypeFlags & BATTLE_TYPE_DOUBLE) && gBattleMoves[move].target == 8 && CountAliveMons(2) == 2) damage /= 2; - // are effects of weather negated with cloud nine or air lock? - if (!AbilityBattleEffects(0xE, 0, ABILITY_CLOUD_NINE, 0, 0) && !AbilityBattleEffects(0xE, 0, ABILITY_AIR_LOCK, 0, 0)) + // are effects of weather negated with cloud nine or air lock + if (!AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_CLOUD_NINE, 0, 0) + && !AbilityBattleEffects(ABILITYEFFECT_FIELD_SPORT, 0, ABILITY_AIR_LOCK, 0, 0)) { - // rain? - if (gBattleWeather & 1) + if (gBattleWeather & WEATHER_RAIN_TEMPORARY) { - if (type == TYPE_FIRE) + switch (type) + { + case TYPE_FIRE: damage /= 2; - else if (type == TYPE_WATER) + break; + case TYPE_WATER: damage = (15 * damage) / 10; + break; + } } - // does lack of sun half solar beam damage? - if ((gBattleWeather & 0x9F) && gCurrentMove == 76) + // any weather except sun weakens solar beam + if ((gBattleWeather & (WEATHER_RAIN_ANY | WEATHER_SANDSTORM_ANY | WEATHER_HAIL)) && gCurrentMove == MOVE_SOLAR_BEAM) damage /= 2; - // sunny? - if (gBattleWeather & 0x60) + // sunny + if (gBattleWeather & WEATHER_SUN_ANY) { - if (type == TYPE_FIRE) + switch (type) + { + case TYPE_FIRE: damage = (15 * damage) / 10; - else if (type == TYPE_WATER) + break; + case TYPE_WATER: damage /= 2; + break; + } } } - // flash fire triggered? - if ((dword_2017100[a7] & 1) && type == TYPE_FIRE) + // flash fire triggered + if ((dword_2017100[bankAtk] & 1) && type == TYPE_FIRE) damage = (15 * damage) / 10; } return damage + 2; } -#else -__attribute__((naked)) -s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *defender, u32 move, u16 a4, u16 powerOverride, u8 typeOverride, u8 a7, u8 a8) -{ - asm(".syntax unified\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\ - adds r7, r0, 0\n\ - str r1, [sp, 0x4]\n\ - str r2, [sp, 0x8]\n\ - ldr r0, [sp, 0x4C]\n\ - ldr r1, [sp, 0x50]\n\ - ldr r2, [sp, 0x54]\n\ - ldr r4, [sp, 0x58]\n\ - lsls r3, 16\n\ - lsrs r3, 16\n\ - str r3, [sp, 0xC]\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - lsls r1, 24\n\ - lsrs r6, r1, 24\n\ - lsls r2, 24\n\ - lsrs r2, 24\n\ - str r2, [sp, 0x10]\n\ - lsls r4, 24\n\ - lsrs r4, 24\n\ - movs r5, 0\n\ - cmp r3, 0\n\ - bne _0803BA80\n\ - ldr r2, _0803BA78 @ =gBattleMovePower\n\ - ldr r1, _0803BA7C @ =gBattleMoves\n\ - ldr r3, [sp, 0x8]\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x1]\n\ - strh r0, [r2]\n\ - b _0803BA84\n\ - .align 2, 0\n\ -_0803BA78: .4byte gBattleMovePower\n\ -_0803BA7C: .4byte gBattleMoves\n\ -_0803BA80:\n\ - ldr r0, _0803BA9C @ =gBattleMovePower\n\ - strh r3, [r0]\n\ -_0803BA84:\n\ - cmp r6, 0\n\ - bne _0803BAA4\n\ - ldr r1, _0803BAA0 @ =gBattleMoves\n\ - ldr r6, [sp, 0x8]\n\ - lsls r0, r6, 1\n\ - adds r0, r6\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - mov r9, r0\n\ - b _0803BAAE\n\ - .align 2, 0\n\ -_0803BA9C: .4byte gBattleMovePower\n\ -_0803BAA0: .4byte gBattleMoves\n\ -_0803BAA4:\n\ - movs r0, 0x3F\n\ - mov r9, r0\n\ - mov r1, r9\n\ - ands r1, r6\n\ - mov r9, r1\n\ -_0803BAAE:\n\ - ldrh r6, [r7, 0x2]\n\ - ldr r2, [sp, 0x4]\n\ - ldrh r2, [r2, 0x4]\n\ - str r2, [sp, 0x14]\n\ - ldrh r3, [r7, 0x8]\n\ - mov r8, r3\n\ - ldr r0, [sp, 0x4]\n\ - ldrh r0, [r0, 0xA]\n\ - str r0, [sp, 0x18]\n\ - ldrh r0, [r7, 0x2E]\n\ - cmp r0, 0xAF\n\ - bne _0803BAE0\n\ - ldr r1, _0803BADC @ =gEnigmaBerries\n\ - ldr r2, [sp, 0x10]\n\ - lsls r0, r2, 3\n\ - subs r0, r2\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r3, [r0, 0x7]\n\ - mov r10, r3\n\ - ldrb r0, [r0, 0x1A]\n\ - b _0803BAF6\n\ - .align 2, 0\n\ -_0803BADC: .4byte gEnigmaBerries\n\ -_0803BAE0:\n\ - ldrh r0, [r7, 0x2E]\n\ - bl ItemId_GetHoldEffect\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - ldrh r0, [r7, 0x2E]\n\ - bl ItemId_GetHoldEffectParam\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ -_0803BAF6:\n\ - str r0, [sp, 0x20]\n\ - ldr r1, [sp, 0x4]\n\ - ldrh r0, [r1, 0x2E]\n\ - cmp r0, 0xAF\n\ - bne _0803BB26\n\ - ldr r1, _0803BB10 @ =gEnigmaBerries\n\ - lsls r0, r4, 3\n\ - subs r0, r4\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x7]\n\ - str r0, [sp, 0x1C]\n\ - b _0803BB3C\n\ - .align 2, 0\n\ -_0803BB10: .4byte gEnigmaBerries\n\ -_0803BB14:\n\ - ldr r0, [sp, 0x20]\n\ - adds r0, 0x64\n\ - muls r0, r6\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r6, r0, 16\n\ - b _0803BCDC\n\ -_0803BB26:\n\ - ldr r2, [sp, 0x4]\n\ - ldrh r0, [r2, 0x2E]\n\ - bl ItemId_GetHoldEffect\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x1C]\n\ - ldr r3, [sp, 0x4]\n\ - ldrh r0, [r3, 0x2E]\n\ - bl ItemId_GetHoldEffectParam\n\ -_0803BB3C:\n\ - adds r0, r7, 0\n\ - adds r0, 0x20\n\ - ldrb r1, [r0]\n\ - str r0, [sp, 0x24]\n\ - cmp r1, 0x25\n\ - beq _0803BB4C\n\ - cmp r1, 0x4A\n\ - bne _0803BB50\n\ -_0803BB4C:\n\ - lsls r0, r6, 17\n\ - lsrs r6, r0, 16\n\ -_0803BB50:\n\ - ldr r0, _0803BCB8 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - ldr r0, _0803BCBC @ =0x00000902\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803BB5E\n\ - b _0803BC78\n\ -_0803BB5E:\n\ - movs r0, 0x8\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803BB98\n\ - ldr r0, _0803BCC0 @ =gTrainerBattleOpponent\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 3\n\ - cmp r1, r0\n\ - beq _0803BB98\n\ - ldr r0, _0803BCC4 @ =0x00000807\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BB98\n\ - ldr r0, [sp, 0x10]\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _0803BB98\n\ - movs r0, 0x6E\n\ - muls r0, r6\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r6, r0, 16\n\ -_0803BB98:\n\ - ldr r0, _0803BCB8 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - ldr r0, _0803BCBC @ =0x00000902\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803BC78\n\ - movs r0, 0x8\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803BBE2\n\ - ldr r0, _0803BCC0 @ =gTrainerBattleOpponent\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 3\n\ - cmp r1, r0\n\ - beq _0803BBE2\n\ - ldr r0, _0803BCC8 @ =0x0000080b\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BBE2\n\ - adds r0, r4, 0\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _0803BBE2\n\ - movs r0, 0x6E\n\ - ldr r1, [sp, 0x14]\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x14]\n\ -_0803BBE2:\n\ - ldr r0, _0803BCB8 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - ldr r0, _0803BCBC @ =0x00000902\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803BC78\n\ - movs r0, 0x8\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803BC2E\n\ - ldr r0, _0803BCC0 @ =gTrainerBattleOpponent\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 3\n\ - cmp r1, r0\n\ - beq _0803BC2E\n\ - ldr r0, _0803BCCC @ =0x0000080d\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BC2E\n\ - ldr r0, [sp, 0x10]\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _0803BC2E\n\ - movs r0, 0x6E\n\ - mov r2, r8\n\ - muls r2, r0\n\ - adds r0, r2, 0\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BC2E:\n\ - ldr r0, _0803BCB8 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - ldr r0, _0803BCBC @ =0x00000902\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803BC78\n\ - movs r0, 0x8\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803BC78\n\ - ldr r0, _0803BCC0 @ =gTrainerBattleOpponent\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 3\n\ - cmp r1, r0\n\ - beq _0803BC78\n\ - ldr r0, _0803BCCC @ =0x0000080d\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BC78\n\ - adds r0, r4, 0\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _0803BC78\n\ - movs r0, 0x6E\n\ - ldr r3, [sp, 0x18]\n\ - muls r0, r3\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x18]\n\ -_0803BC78:\n\ - movs r2, 0\n\ - ldr r4, _0803BCD0 @ =gHoldEffectToType\n\ - ldr r0, [sp, 0x4]\n\ - adds r0, 0x20\n\ - str r0, [sp, 0x28]\n\ - adds r3, r4, 0\n\ -_0803BC84:\n\ - lsls r1, r2, 1\n\ - ldrb r0, [r3]\n\ - cmp r10, r0\n\ - bne _0803BCD4\n\ - adds r0, r4, 0x1\n\ - adds r0, r1, r0\n\ - ldrb r0, [r0]\n\ - cmp r9, r0\n\ - bne _0803BCD4\n\ - mov r1, r9\n\ - cmp r1, 0x8\n\ - bhi _0803BC9E\n\ - b _0803BB14\n\ -_0803BC9E:\n\ - ldr r0, [sp, 0x20]\n\ - adds r0, 0x64\n\ - mov r2, r8\n\ - muls r2, r0\n\ - adds r0, r2, 0\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ - b _0803BCDC\n\ - .align 2, 0\n\ -_0803BCB8: .4byte gBattleTypeFlags\n\ -_0803BCBC: .4byte 0x00000902\n\ -_0803BCC0: .4byte gTrainerBattleOpponent\n\ -_0803BCC4: .4byte 0x00000807\n\ -_0803BCC8: .4byte 0x0000080b\n\ -_0803BCCC: .4byte 0x0000080d\n\ -_0803BCD0: .4byte gHoldEffectToType\n\ -_0803BCD4:\n\ - adds r3, 0x2\n\ - adds r2, 0x1\n\ - cmp r2, 0x10\n\ - bls _0803BC84\n\ -_0803BCDC:\n\ - mov r3, r10\n\ - cmp r3, 0x1D\n\ - bne _0803BCF0\n\ - movs r0, 0x96\n\ - muls r0, r6\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r6, r0, 16\n\ -_0803BCF0:\n\ - mov r0, r10\n\ - cmp r0, 0x22\n\ - bne _0803BD28\n\ - ldr r0, _0803BFDC @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803BD28\n\ - ldr r1, _0803BFE0 @ =0xfffffe69\n\ - adds r0, r1, 0\n\ - ldrh r2, [r7]\n\ - adds r0, r2\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r0, 0x1\n\ - bhi _0803BD28\n\ - movs r0, 0x96\n\ - mov r3, r8\n\ - muls r3, r0\n\ - adds r0, r3, 0\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BD28:\n\ - ldr r0, [sp, 0x1C]\n\ - cmp r0, 0x22\n\ - bne _0803BD60\n\ - ldr r0, _0803BFDC @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803BD60\n\ - ldr r1, _0803BFE0 @ =0xfffffe69\n\ - adds r0, r1, 0\n\ - ldr r2, [sp, 0x4]\n\ - ldrh r2, [r2]\n\ - adds r0, r2\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r0, 0x1\n\ - bhi _0803BD60\n\ - movs r0, 0x96\n\ - ldr r3, [sp, 0x18]\n\ - muls r0, r3\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x18]\n\ -_0803BD60:\n\ - mov r0, r10\n\ - cmp r0, 0x23\n\ - bne _0803BD76\n\ - ldrh r1, [r7]\n\ - ldr r0, _0803BFE4 @ =0x00000175\n\ - cmp r1, r0\n\ - bne _0803BD76\n\ - mov r1, r8\n\ - lsls r0, r1, 17\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BD76:\n\ - ldr r2, [sp, 0x1C]\n\ - cmp r2, 0x24\n\ - bne _0803BD8E\n\ - ldr r3, [sp, 0x4]\n\ - ldrh r1, [r3]\n\ - ldr r0, _0803BFE4 @ =0x00000175\n\ - cmp r1, r0\n\ - bne _0803BD8E\n\ - ldr r1, [sp, 0x18]\n\ - lsls r0, r1, 17\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x18]\n\ -_0803BD8E:\n\ - mov r2, r10\n\ - cmp r2, 0x2D\n\ - bne _0803BDA2\n\ - ldrh r0, [r7]\n\ - cmp r0, 0x19\n\ - bne _0803BDA2\n\ - mov r3, r8\n\ - lsls r0, r3, 17\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BDA2:\n\ - ldr r0, [sp, 0x1C]\n\ - cmp r0, 0x40\n\ - bne _0803BDB8\n\ - ldr r1, [sp, 0x4]\n\ - ldrh r0, [r1]\n\ - cmp r0, 0x84\n\ - bne _0803BDB8\n\ - ldr r2, [sp, 0x14]\n\ - lsls r0, r2, 17\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x14]\n\ -_0803BDB8:\n\ - mov r3, r10\n\ - cmp r3, 0x41\n\ - bne _0803BDCE\n\ - ldrh r0, [r7]\n\ - subs r0, 0x68\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r0, 0x1\n\ - bhi _0803BDCE\n\ - lsls r0, r6, 17\n\ - lsrs r6, r0, 16\n\ -_0803BDCE:\n\ - ldr r1, [sp, 0x28]\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x2F\n\ - bne _0803BDE6\n\ - mov r2, r9\n\ - cmp r2, 0xA\n\ - beq _0803BDE0\n\ - cmp r2, 0xF\n\ - bne _0803BDE6\n\ -_0803BDE0:\n\ - mov r3, r8\n\ - lsrs r3, 1\n\ - mov r8, r3\n\ -_0803BDE6:\n\ - ldr r0, [sp, 0x24]\n\ - ldrb r4, [r0]\n\ - cmp r4, 0x37\n\ - bne _0803BDFC\n\ - movs r0, 0x96\n\ - muls r0, r6\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r6, r0, 16\n\ -_0803BDFC:\n\ - cmp r4, 0x39\n\ - bne _0803BE2A\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0x3A\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BE2A\n\ - movs r0, 0x96\n\ - mov r1, r8\n\ - muls r1, r0\n\ - adds r0, r1, 0\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BE2A:\n\ - ldr r2, [sp, 0x24]\n\ - ldrb r0, [r2]\n\ - cmp r0, 0x3A\n\ - bne _0803BE5C\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0x39\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BE5C\n\ - movs r0, 0x96\n\ - mov r3, r8\n\ - muls r3, r0\n\ - adds r0, r3, 0\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - mov r8, r0\n\ -_0803BE5C:\n\ - ldr r1, [sp, 0x24]\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x3E\n\ - bne _0803BE78\n\ - ldr r0, [r7, 0x4C]\n\ - cmp r0, 0\n\ - beq _0803BE78\n\ - movs r0, 0x96\n\ - muls r0, r6\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r6, r0, 16\n\ -_0803BE78:\n\ - ldr r2, [sp, 0x28]\n\ - ldrb r0, [r2]\n\ - cmp r0, 0x3F\n\ - bne _0803BE9A\n\ - ldr r3, [sp, 0x4]\n\ - ldr r0, [r3, 0x4C]\n\ - cmp r0, 0\n\ - beq _0803BE9A\n\ - movs r0, 0x96\n\ - ldr r1, [sp, 0x14]\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x14]\n\ -_0803BE9A:\n\ - mov r2, r9\n\ - cmp r2, 0xD\n\ - bne _0803BEBE\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0\n\ - movs r3, 0xFD\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BEBE\n\ - ldr r1, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r0, [r1]\n\ - lsrs r0, 1\n\ - strh r0, [r1]\n\ -_0803BEBE:\n\ - mov r3, r9\n\ - cmp r3, 0xA\n\ - bne _0803BEE2\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0\n\ - movs r3, 0xFE\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0803BEE2\n\ - ldr r1, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r0, [r1]\n\ - lsrs r0, 1\n\ - strh r0, [r1]\n\ -_0803BEE2:\n\ - mov r0, r9\n\ - cmp r0, 0xC\n\ - bne _0803BF12\n\ - ldr r1, [sp, 0x24]\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x41\n\ - bne _0803BF12\n\ - ldrh r0, [r7, 0x2C]\n\ - movs r1, 0x3\n\ - bl __udivsi3\n\ - ldrh r1, [r7, 0x28]\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r1, r0\n\ - bhi _0803BF12\n\ - ldr r4, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r1, [r4]\n\ - movs r0, 0x96\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - strh r0, [r4]\n\ -_0803BF12:\n\ - mov r2, r9\n\ - cmp r2, 0xA\n\ - bne _0803BF42\n\ - ldr r3, [sp, 0x24]\n\ - ldrb r0, [r3]\n\ - cmp r0, 0x42\n\ - bne _0803BF42\n\ - ldrh r0, [r7, 0x2C]\n\ - movs r1, 0x3\n\ - bl __udivsi3\n\ - ldrh r1, [r7, 0x28]\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r1, r0\n\ - bhi _0803BF42\n\ - ldr r4, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r1, [r4]\n\ - movs r0, 0x96\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - strh r0, [r4]\n\ -_0803BF42:\n\ - mov r0, r9\n\ - cmp r0, 0xB\n\ - bne _0803BF72\n\ - ldr r1, [sp, 0x24]\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x43\n\ - bne _0803BF72\n\ - ldrh r0, [r7, 0x2C]\n\ - movs r1, 0x3\n\ - bl __udivsi3\n\ - ldrh r1, [r7, 0x28]\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r1, r0\n\ - bhi _0803BF72\n\ - ldr r4, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r1, [r4]\n\ - movs r0, 0x96\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - strh r0, [r4]\n\ -_0803BF72:\n\ - mov r2, r9\n\ - cmp r2, 0x6\n\ - bne _0803BFA2\n\ - ldr r3, [sp, 0x24]\n\ - ldrb r0, [r3]\n\ - cmp r0, 0x44\n\ - bne _0803BFA2\n\ - ldrh r0, [r7, 0x2C]\n\ - movs r1, 0x3\n\ - bl __udivsi3\n\ - ldrh r1, [r7, 0x28]\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - cmp r1, r0\n\ - bhi _0803BFA2\n\ - ldr r4, _0803BFE8 @ =gBattleMovePower\n\ - ldrh r1, [r4]\n\ - movs r0, 0x96\n\ - muls r0, r1\n\ - movs r1, 0x64\n\ - bl __divsi3\n\ - strh r0, [r4]\n\ -_0803BFA2:\n\ - ldr r2, _0803BFEC @ =gBattleMoves\n\ - ldr r0, _0803BFF0 @ =gCurrentMove\n\ - ldrh r1, [r0]\n\ - lsls r0, r1, 1\n\ - adds r0, r1\n\ - lsls r0, 2\n\ - adds r0, r2\n\ - ldrb r0, [r0]\n\ - cmp r0, 0x7\n\ - bne _0803BFBC\n\ - ldr r0, [sp, 0x14]\n\ - lsrs r0, 1\n\ - str r0, [sp, 0x14]\n\ -_0803BFBC:\n\ - mov r1, r9\n\ - cmp r1, 0x8\n\ - bls _0803BFC4\n\ - b _0803C122\n\ -_0803BFC4:\n\ - ldr r0, _0803BFF4 @ =gCritMultiplier\n\ - ldrb r1, [r0]\n\ - adds r4, r0, 0\n\ - cmp r1, 0x2\n\ - bne _0803C000\n\ - movs r0, 0x19\n\ - ldrsb r0, [r7, r0]\n\ - cmp r0, 0x6\n\ - ble _0803BFFC\n\ - ldr r2, _0803BFF8 @ =gStatStageRatios\n\ - b _0803C006\n\ - .align 2, 0\n\ -_0803BFDC: .4byte gBattleTypeFlags\n\ -_0803BFE0: .4byte 0xfffffe69\n\ -_0803BFE4: .4byte 0x00000175\n\ -_0803BFE8: .4byte gBattleMovePower\n\ -_0803BFEC: .4byte gBattleMoves\n\ -_0803BFF0: .4byte gCurrentMove\n\ -_0803BFF4: .4byte gCritMultiplier\n\ -_0803BFF8: .4byte gStatStageRatios\n\ -_0803BFFC:\n\ - adds r5, r6, 0\n\ - b _0803C01E\n\ -_0803C000:\n\ - ldr r2, _0803C050 @ =gStatStageRatios\n\ - movs r0, 0x19\n\ - ldrsb r0, [r7, r0]\n\ -_0803C006:\n\ - lsls r0, 1\n\ - adds r1, r0, r2\n\ - ldrb r1, [r1]\n\ - adds r5, r6, 0\n\ - muls r5, r1\n\ - adds r2, 0x1\n\ - adds r0, r2\n\ - ldrb r1, [r0]\n\ - adds r0, r5, 0\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ -_0803C01E:\n\ - ldr r0, _0803C054 @ =gBattleMovePower\n\ - ldrh r0, [r0]\n\ - muls r5, r0\n\ - adds r0, r7, 0\n\ - adds r0, 0x2A\n\ - ldrb r0, [r0]\n\ - lsls r0, 1\n\ - movs r1, 0x5\n\ - bl __divsi3\n\ - adds r0, 0x2\n\ - muls r5, r0\n\ - ldrb r0, [r4]\n\ - cmp r0, 0x2\n\ - bne _0803C05C\n\ - ldr r2, [sp, 0x4]\n\ - movs r0, 0x1A\n\ - ldrsb r0, [r2, r0]\n\ - cmp r0, 0x5\n\ - bgt _0803C058\n\ - ldr r2, _0803C050 @ =gStatStageRatios\n\ - ldr r3, [sp, 0x4]\n\ - movs r0, 0x1A\n\ - ldrsb r0, [r3, r0]\n\ - b _0803C064\n\ - .align 2, 0\n\ -_0803C050: .4byte gStatStageRatios\n\ -_0803C054: .4byte gBattleMovePower\n\ -_0803C058:\n\ - ldr r3, [sp, 0x14]\n\ - b _0803C07E\n\ -_0803C05C:\n\ - ldr r2, _0803C0DC @ =gStatStageRatios\n\ - ldr r1, [sp, 0x4]\n\ - movs r0, 0x1A\n\ - ldrsb r0, [r1, r0]\n\ -_0803C064:\n\ - lsls r0, 1\n\ - adds r1, r0, r2\n\ - ldrb r1, [r1]\n\ - ldr r6, [sp, 0x14]\n\ - adds r3, r6, 0\n\ - muls r3, r1\n\ - adds r2, 0x1\n\ - adds r0, r2\n\ - ldrb r1, [r0]\n\ - adds r0, r3, 0\n\ - bl __divsi3\n\ - adds r3, r0, 0\n\ -_0803C07E:\n\ - adds r0, r5, 0\n\ - adds r1, r3, 0\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - movs r1, 0x32\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - ldr r0, [r7, 0x4C]\n\ - movs r1, 0x10\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C0A8\n\ - ldr r1, [sp, 0x24]\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x3E\n\ - beq _0803C0A8\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C0A8:\n\ - movs r0, 0x1\n\ - ldr r2, [sp, 0xC]\n\ - ands r0, r2\n\ - cmp r0, 0\n\ - beq _0803C0EA\n\ - ldrb r1, [r4]\n\ - cmp r1, 0x1\n\ - bne _0803C0EA\n\ - ldr r0, _0803C0E0 @ =gBattleTypeFlags\n\ - ldrh r0, [r0]\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - beq _0803C0E4\n\ - movs r0, 0x2\n\ - bl CountAliveMons\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x2\n\ - bne _0803C0E4\n\ - adds r0, r5, 0\n\ - movs r1, 0x3\n\ - bl __divsi3\n\ - lsls r5, r0, 1\n\ - b _0803C0EA\n\ - .align 2, 0\n\ -_0803C0DC: .4byte gStatStageRatios\n\ -_0803C0E0: .4byte gBattleTypeFlags\n\ -_0803C0E4:\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C0EA:\n\ - ldr r0, _0803C148 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C11C\n\ - ldr r0, _0803C14C @ =gBattleMoves\n\ - ldr r3, [sp, 0x8]\n\ - lsls r1, r3, 1\n\ - adds r1, r3\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x6]\n\ - cmp r0, 0x8\n\ - bne _0803C11C\n\ - movs r0, 0x2\n\ - bl CountAliveMons\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x2\n\ - bne _0803C11C\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C11C:\n\ - cmp r5, 0\n\ - bne _0803C122\n\ - movs r5, 0x1\n\ -_0803C122:\n\ - mov r6, r9\n\ - cmp r6, 0x9\n\ - bne _0803C12A\n\ - movs r5, 0\n\ -_0803C12A:\n\ - mov r0, r9\n\ - cmp r0, 0x9\n\ - bhi _0803C132\n\ - b _0803C330\n\ -_0803C132:\n\ - ldr r0, _0803C150 @ =gCritMultiplier\n\ - ldrb r1, [r0]\n\ - adds r4, r0, 0\n\ - cmp r1, 0x2\n\ - bne _0803C15C\n\ - movs r0, 0x1C\n\ - ldrsb r0, [r7, r0]\n\ - cmp r0, 0x6\n\ - ble _0803C158\n\ - ldr r2, _0803C154 @ =gStatStageRatios\n\ - b _0803C162\n\ - .align 2, 0\n\ -_0803C148: .4byte gBattleTypeFlags\n\ -_0803C14C: .4byte gBattleMoves\n\ -_0803C150: .4byte gCritMultiplier\n\ -_0803C154: .4byte gStatStageRatios\n\ -_0803C158:\n\ - mov r5, r8\n\ - b _0803C17A\n\ -_0803C15C:\n\ - ldr r2, _0803C1A8 @ =gStatStageRatios\n\ - movs r0, 0x1C\n\ - ldrsb r0, [r7, r0]\n\ -_0803C162:\n\ - lsls r0, 1\n\ - adds r1, r0, r2\n\ - ldrb r1, [r1]\n\ - mov r5, r8\n\ - muls r5, r1\n\ - adds r2, 0x1\n\ - adds r0, r2\n\ - ldrb r1, [r0]\n\ - adds r0, r5, 0\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ -_0803C17A:\n\ - ldr r0, _0803C1AC @ =gBattleMovePower\n\ - ldrh r0, [r0]\n\ - muls r5, r0\n\ - adds r0, r7, 0\n\ - adds r0, 0x2A\n\ - ldrb r0, [r0]\n\ - lsls r0, 1\n\ - movs r1, 0x5\n\ - bl __divsi3\n\ - adds r0, 0x2\n\ - muls r5, r0\n\ - ldrb r0, [r4]\n\ - cmp r0, 0x2\n\ - bne _0803C1B4\n\ - ldr r1, [sp, 0x4]\n\ - movs r0, 0x1D\n\ - ldrsb r0, [r1, r0]\n\ - cmp r0, 0x5\n\ - bgt _0803C1B0\n\ - ldr r2, _0803C1A8 @ =gStatStageRatios\n\ - b _0803C1BC\n\ - .align 2, 0\n\ -_0803C1A8: .4byte gStatStageRatios\n\ -_0803C1AC: .4byte gBattleMovePower\n\ -_0803C1B0:\n\ - ldr r3, [sp, 0x18]\n\ - b _0803C1D6\n\ -_0803C1B4:\n\ - ldr r2, _0803C21C @ =gStatStageRatios\n\ - ldr r1, [sp, 0x4]\n\ - movs r0, 0x1D\n\ - ldrsb r0, [r1, r0]\n\ -_0803C1BC:\n\ - lsls r0, 1\n\ - adds r1, r0, r2\n\ - ldrb r1, [r1]\n\ - ldr r6, [sp, 0x18]\n\ - adds r3, r6, 0\n\ - muls r3, r1\n\ - adds r2, 0x1\n\ - adds r0, r2\n\ - ldrb r1, [r0]\n\ - adds r0, r3, 0\n\ - bl __divsi3\n\ - adds r3, r0, 0\n\ -_0803C1D6:\n\ - adds r0, r5, 0\n\ - adds r1, r3, 0\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - movs r1, 0x32\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - movs r0, 0x2\n\ - ldr r1, [sp, 0xC]\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C22A\n\ - ldrb r1, [r4]\n\ - cmp r1, 0x1\n\ - bne _0803C22A\n\ - ldr r0, _0803C220 @ =gBattleTypeFlags\n\ - ldrh r0, [r0]\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - beq _0803C224\n\ - movs r0, 0x2\n\ - bl CountAliveMons\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x2\n\ - bne _0803C224\n\ - adds r0, r5, 0\n\ - movs r1, 0x3\n\ - bl __divsi3\n\ - lsls r5, r0, 1\n\ - b _0803C22A\n\ - .align 2, 0\n\ -_0803C21C: .4byte gStatStageRatios\n\ -_0803C220: .4byte gBattleTypeFlags\n\ -_0803C224:\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C22A:\n\ - ldr r0, _0803C2A4 @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C25C\n\ - ldr r0, _0803C2A8 @ =gBattleMoves\n\ - ldr r2, [sp, 0x8]\n\ - lsls r1, r2, 1\n\ - adds r1, r2\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x6]\n\ - cmp r0, 0x8\n\ - bne _0803C25C\n\ - movs r0, 0x2\n\ - bl CountAliveMons\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x2\n\ - bne _0803C25C\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C25C:\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0xD\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0\n\ - bne _0803C30C\n\ - str r0, [sp]\n\ - movs r0, 0xE\n\ - movs r1, 0\n\ - movs r2, 0x4D\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _0803C30C\n\ - ldr r2, _0803C2AC @ =gBattleWeather\n\ - ldrh r1, [r2]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - adds r4, r2, 0\n\ - cmp r0, 0\n\ - beq _0803C2C4\n\ - mov r3, r9\n\ - cmp r3, 0xA\n\ - beq _0803C2B0\n\ - cmp r3, 0xB\n\ - beq _0803C2B8\n\ - b _0803C2C4\n\ - .align 2, 0\n\ -_0803C2A4: .4byte gBattleTypeFlags\n\ -_0803C2A8: .4byte gBattleMoves\n\ -_0803C2AC: .4byte gBattleWeather\n\ -_0803C2B0:\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ - b _0803C2C4\n\ -_0803C2B8:\n\ - lsls r0, r5, 4\n\ - subs r0, r5\n\ - movs r1, 0xA\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ -_0803C2C4:\n\ - ldrh r1, [r4]\n\ - movs r0, 0x9F\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C2DC\n\ - ldr r0, _0803C2F4 @ =gCurrentMove\n\ - ldrh r0, [r0]\n\ - cmp r0, 0x4C\n\ - bne _0803C2DC\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C2DC:\n\ - ldrh r1, [r4]\n\ - movs r0, 0x60\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C30C\n\ - mov r6, r9\n\ - cmp r6, 0xA\n\ - beq _0803C2F8\n\ - cmp r6, 0xB\n\ - beq _0803C306\n\ - b _0803C30C\n\ - .align 2, 0\n\ -_0803C2F4: .4byte gCurrentMove\n\ -_0803C2F8:\n\ - lsls r0, r5, 4\n\ - subs r0, r5\n\ - movs r1, 0xA\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - b _0803C30C\n\ -_0803C306:\n\ - lsrs r0, r5, 31\n\ - adds r0, r5, r0\n\ - asrs r5, r0, 1\n\ -_0803C30C:\n\ - ldr r1, _0803C344 @ =0x02017100\n\ - ldr r2, [sp, 0x10]\n\ - lsls r0, r2, 2\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0803C330\n\ - mov r3, r9\n\ - cmp r3, 0xA\n\ - bne _0803C330\n\ - lsls r0, r5, 4\n\ - subs r0, r5\n\ - movs r1, 0xA\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ -_0803C330:\n\ - adds r0, r5, 0x2\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\n\ - .align 2, 0\n\ -_0803C344: .4byte 0x02017100\n\ - .syntax divided"); -} -#endif -- cgit v1.2.3 From 00e84de641d039b745a1e6564c47eec098a64d7e Mon Sep 17 00:00:00 2001 From: DizzyEggg Date: Sun, 27 Aug 2017 22:42:46 +0200 Subject: cam got rid of nested loops --- src/calculate_base_damage.c | 51 +++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 27 deletions(-) (limited to 'src') diff --git a/src/calculate_base_damage.c b/src/calculate_base_damage.c index 5044145b3..f5c679876 100644 --- a/src/calculate_base_damage.c +++ b/src/calculate_base_damage.c @@ -93,33 +93,30 @@ s32 CalculateBaseDamage(struct BattlePokemon *attacker, struct BattlePokemon *de && FlagGet(BADGE01_GET) && !GetBankSide(bankAtk)) attack = (110 * attack) / 100; - - if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) - { - if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) - && gTrainerBattleOpponent != 1024 - && FlagGet(BADGE05_GET) - && !GetBankSide(bankDef)) - defense = (110 * defense) / 100; - - if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) - { - if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) - && gTrainerBattleOpponent != 1024 - && FlagGet(BADGE07_GET) - && !GetBankSide(bankAtk)) - spAttack = (110 * spAttack) / 100; - - if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) - { - if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) - && gTrainerBattleOpponent != 1024 - && FlagGet(BADGE07_GET) - && !GetBankSide(bankDef)) - spDefense = (110 * spDefense) / 100; - } - } - } + } + if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) + { + if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) + && gTrainerBattleOpponent != 1024 + && FlagGet(BADGE05_GET) + && !GetBankSide(bankDef)) + defense = (110 * defense) / 100; + } + if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) + { + if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) + && gTrainerBattleOpponent != 1024 + && FlagGet(BADGE07_GET) + && !GetBankSide(bankAtk)) + spAttack = (110 * spAttack) / 100; + } + if (!(gBattleTypeFlags & (BATTLE_TYPE_LINK | BATTLE_TYPE_BATTLE_TOWER | BATTLE_TYPE_EREADER_TRAINER))) + { + if ((gBattleTypeFlags & BATTLE_TYPE_TRAINER) + && gTrainerBattleOpponent != 1024 + && FlagGet(BADGE07_GET) + && !GetBankSide(bankDef)) + spDefense = (110 * spDefense) / 100; } for (i = 0; i < 17; i++) -- cgit v1.2.3 From dcd4981fa71d1004337503eb15e96b20afca82f2 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sun, 27 Aug 2017 16:45:54 -0500 Subject: match sub_803C434 --- src/pokemon_2.c | 116 ++++++-------------------------------------------------- 1 file changed, 11 insertions(+), 105 deletions(-) (limited to 'src') diff --git a/src/pokemon_2.c b/src/pokemon_2.c index a77edbdb2..f02ce6170 100644 --- a/src/pokemon_2.c +++ b/src/pokemon_2.c @@ -80,125 +80,31 @@ u8 CountAliveMons(u8 a1) return retVal; } -#ifdef NONMATCHING u8 sub_803C434(u8 a1) { - u32 status0 = GetBankIdentity(a1); - register u8 status_ asm("r4"); - u8 status; - register u32 mask1 asm("r1") = 1; - register u32 mask2 asm("r6") = 1; - - status_ = mask2; - status_ &= status0; - status = status_ ^ mask1; - - { - register u16 val_ asm("r1") = gBattleTypeFlags; - u32 val = mask2; - val &= val_; - if (!val) - { - return GetBankByPlayerAI(status); - } - } + u8 status = GetBankIdentity(a1) & 1; + status ^= 1; + if (!(gBattleTypeFlags & BATTLE_TYPE_DOUBLE)) + return GetBankByPlayerAI(status); if (CountAliveMons(0) > 1) { - u16 r = Random(); - register u32 val asm("r1") = mask2; - val &= r; - if (!val) - { - u32 status2 = 2; - status2 ^= status; - return GetBankByPlayerAI(status2); - } + u8 val; + + if ((Random() & 1) == 0) + val = status ^ 2; else - { - return GetBankByPlayerAI(status); - } + val = status; + return GetBankByPlayerAI(val); } else { - if (gAbsentBankFlags & gBitTable[status]) + if ((gAbsentBankFlags & gBitTable[status])) return GetBankByPlayerAI(status ^ 2); else return GetBankByPlayerAI(status); } } -#else -__attribute__((naked)) -u8 sub_803C434(u8 a1) -{ - asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - bl GetBankIdentity\n\ - movs r1, 0x1\n\ - movs r6, 0x1\n\ - adds r4, r6, 0\n\ - ands r4, r0\n\ - eors r4, r1\n\ - adds r5, r4, 0\n\ - ldr r0, _0803C45C\n\ - ldrh r1, [r0]\n\ - adds r0, r6, 0\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0803C460\n\ - adds r0, r4, 0\n\ - b _0803C4AA\n\ - .align 2, 0\n\ -_0803C45C: .4byte gBattleTypeFlags\n\ -_0803C460:\n\ - movs r0, 0\n\ - bl CountAliveMons\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x1\n\ - bls _0803C484\n\ - bl Random\n\ - adds r1, r6, 0\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - bne _0803C480\n\ - movs r0, 0x2\n\ - eors r0, r4\n\ - b _0803C4AA\n\ -_0803C480:\n\ - adds r0, r4, 0\n\ - b _0803C4AA\n\ -_0803C484:\n\ - ldr r0, _0803C49C\n\ - ldrb r1, [r0]\n\ - ldr r2, _0803C4A0\n\ - lsls r0, r4, 2\n\ - adds r0, r2\n\ - ldr r0, [r0]\n\ - ands r1, r0\n\ - cmp r1, 0\n\ - bne _0803C4A4\n\ - adds r0, r4, 0\n\ - b _0803C4AA\n\ - .align 2, 0\n\ -_0803C49C: .4byte gAbsentBankFlags\n\ -_0803C4A0: .4byte gBitTable\n\ -_0803C4A4:\n\ - movs r0, 0x2\n\ - eors r5, r0\n\ - adds r0, r5, 0\n\ -_0803C4AA:\n\ - bl GetBankByPlayerAI\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - pop {r4-r6}\n\ - pop {r1}\n\ - bx r1\n\ - .syntax divided\n"); -} -#endif u8 GetMonGender(struct Pokemon *mon) { -- cgit v1.2.3 From 5cfb890e9351b737786ce263b081599513a99ae6 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Sun, 27 Aug 2017 17:18:31 -0500 Subject: tabs to spaces --- src/battle_3.c | 5566 ++++++++++++++++----------------- src/battle_controller_linkopponent2.c | 112 +- src/battle_controller_linkpartner.c | 114 +- src/battle_controller_opponent.c | 114 +- src/battle_controller_safari.c | 114 +- src/battle_controller_wally.c | 114 +- src/battle_transition.c | 66 +- src/berry_blender.c | 502 +-- src/berry_tag_screen.c | 108 +- src/de_rom_8040FE0.c | 202 +- src/egg_hatch.c | 112 +- src/hall_of_fame.c | 44 +- src/item_menu.c | 346 +- src/menu.c | 140 +- src/option_menu.c | 102 +- src/pokeblock_feed.c | 408 +-- src/rotating_gate.c | 350 +-- src/script_menu.c | 272 +- src/title_screen.c | 184 +- 19 files changed, 4485 insertions(+), 4485 deletions(-) (limited to 'src') diff --git a/src/battle_3.c b/src/battle_3.c index 9bb9e333f..f04e722c4 100644 --- a/src/battle_3.c +++ b/src/battle_3.c @@ -1506,11 +1506,11 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) if (gBankAttacker >= gNoOfAllBanks) gBankAttacker = bank; switch (gLastUsedAbility) - { - case 0xFF: //weather from overworld + { + case 0xFF: //weather from overworld //_08018586 - switch (weather_get_current()) - { + switch (weather_get_current()) + { case 3: case 5: case 13: @@ -1540,34 +1540,34 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) effect++; } break; - } - if (effect) + } + if (effect) { gBattleCommunication[MULTISTRING_CHOOSER] = weather_get_current(); b_push_move_exec(gUnknown_081D901D); } - break; - case ABILITY_DRIZZLE: + break; + case ABILITY_DRIZZLE: //_08018680 - if (!(gBattleWeather & WEATHER_RAIN_PERMANENT)) + if (!(gBattleWeather & WEATHER_RAIN_PERMANENT)) { gBattleWeather = (WEATHER_RAIN_PERMANENT | WEATHER_RAIN_TEMPORARY); b_push_move_exec(BattleScript_DrizzleActivates); BATTLE_STRUCT->scriptingActive = bank; effect++; } - break; - case ABILITY_SAND_STREAM: + break; + case ABILITY_SAND_STREAM: //_080186B8 - if (!(gBattleWeather & WEATHER_SANDSTORM_PERMANENT)) + if (!(gBattleWeather & WEATHER_SANDSTORM_PERMANENT)) { gBattleWeather = (WEATHER_SANDSTORM_PERMANENT | WEATHER_SANDSTORM_TEMPORARY); b_push_move_exec(BattleScript_SandstreamActivates); BATTLE_STRUCT->scriptingActive = bank; effect++; } - break; - case ABILITY_DROUGHT: + break; + case ABILITY_DROUGHT: //_080186F0 if (!(gBattleWeather & WEATHER_SUN_PERMANENT)) { @@ -1576,16 +1576,16 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) BATTLE_STRUCT->scriptingActive = bank; effect++; } - break; - case ABILITY_INTIMIDATE: + break; + case ABILITY_INTIMIDATE: //_08018728 if (!(gSpecialStatuses[bank].intimidatedPoke)) { gStatuses3[bank] |= STATUS3_INTIMIDATE_POKES; gSpecialStatuses[bank].intimidatedPoke = 1; } - break; - case ABILITY_FORECAST: + break; + case ABILITY_FORECAST: //_0801875C effect = CastformDataTypeChange(bank); if (effect != 0) @@ -1594,22 +1594,22 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) BATTLE_STRUCT->scriptingActive = bank; BATTLE_STRUCT->castformToChangeInto = effect - 1; } - break; - case ABILITY_TRACE: + break; + case ABILITY_TRACE: //_080187A0 - if (!(gSpecialStatuses[bank].traced)) + if (!(gSpecialStatuses[bank].traced)) { gStatuses3[bank] |= STATUS3_TRACE; gSpecialStatuses[bank].traced = 1; } - break; - case ABILITY_CLOUD_NINE: - case ABILITY_AIR_LOCK: + break; + case ABILITY_CLOUD_NINE: + case ABILITY_AIR_LOCK: //_080187DC - { - u8 i; + { + u8 i; - for (i = 0; i < gNoOfAllBanks; i++) + for (i = 0; i < gNoOfAllBanks; i++) { // TODO: i should be in r6 here //asm("":::"r4","r5"); @@ -1622,10 +1622,10 @@ u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) break; } } - } - break; - } - break; + } + break; + } + break; case ABILITYEFFECT_ENDTURN: // 1 //_08018814 if (gBattleMons[bank].hp != 0) @@ -2271,391 +2271,391 @@ __attribute__((naked)) u8 AbilityBattleEffects(u8 caseID, u8 bank, u8 ability, u8 special, u16 moveArg) { asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x28\n\ - ldr r4, [sp, 0x48]\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x4]\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - mov r10, r1\n\ - lsls r2, 24\n\ - lsrs r6, r2, 24\n\ - lsls r3, 24\n\ - lsrs r3, 24\n\ - mov r8, r3\n\ - lsls r4, 16\n\ - lsrs r4, 16\n\ - movs r0, 0\n\ - mov r9, r0\n\ - ldr r5, _08018380 @ =gBankAttacker\n\ - ldr r1, _08018384 @ =gNoOfAllBanks\n\ - ldrb r0, [r5]\n\ - ldrb r1, [r1]\n\ - cmp r0, r1\n\ - bcc _08018360\n\ - mov r1, r10\n\ - strb r1, [r5]\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x28\n\ + ldr r4, [sp, 0x48]\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + str r0, [sp, 0x4]\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + mov r10, r1\n\ + lsls r2, 24\n\ + lsrs r6, r2, 24\n\ + lsls r3, 24\n\ + lsrs r3, 24\n\ + mov r8, r3\n\ + lsls r4, 16\n\ + lsrs r4, 16\n\ + movs r0, 0\n\ + mov r9, r0\n\ + ldr r5, _08018380 @ =gBankAttacker\n\ + ldr r1, _08018384 @ =gNoOfAllBanks\n\ + ldrb r0, [r5]\n\ + ldrb r1, [r1]\n\ + cmp r0, r1\n\ + bcc _08018360\n\ + mov r1, r10\n\ + strb r1, [r5]\n\ _08018360:\n\ - ldrb r0, [r5]\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _08018390\n\ - ldr r1, _08018388 @ =gBattlePartyID\n\ - ldrb r0, [r5]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r1, [r0]\n\ - movs r0, 0x64\n\ - muls r1, r0\n\ - ldr r0, _0801838C @ =gPlayerParty\n\ - b _080183A0\n\ - .align 2, 0\n\ + ldrb r0, [r5]\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + bne _08018390\n\ + ldr r1, _08018388 @ =gBattlePartyID\n\ + ldrb r0, [r5]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r1, [r0]\n\ + movs r0, 0x64\n\ + muls r1, r0\n\ + ldr r0, _0801838C @ =gPlayerParty\n\ + b _080183A0\n\ + .align 2, 0\n\ _08018380: .4byte gBankAttacker\n\ _08018384: .4byte gNoOfAllBanks\n\ _08018388: .4byte gBattlePartyID\n\ _0801838C: .4byte gPlayerParty\n\ _08018390:\n\ - ldr r1, _080183D0 @ =gBattlePartyID\n\ - ldrb r0, [r5]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r1, [r0]\n\ - movs r0, 0x64\n\ - muls r1, r0\n\ - ldr r0, _080183D4 @ =gEnemyParty\n\ + ldr r1, _080183D0 @ =gBattlePartyID\n\ + ldrb r0, [r5]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r1, [r0]\n\ + movs r0, 0x64\n\ + muls r1, r0\n\ + ldr r0, _080183D4 @ =gEnemyParty\n\ _080183A0:\n\ - adds r7, r1, r0\n\ - ldr r5, _080183D8 @ =gBankTarget\n\ - ldr r1, _080183DC @ =gNoOfAllBanks\n\ - ldrb r0, [r5]\n\ - ldrb r1, [r1]\n\ - cmp r0, r1\n\ - bcc _080183B2\n\ - mov r2, r10\n\ - strb r2, [r5]\n\ + adds r7, r1, r0\n\ + ldr r5, _080183D8 @ =gBankTarget\n\ + ldr r1, _080183DC @ =gNoOfAllBanks\n\ + ldrb r0, [r5]\n\ + ldrb r1, [r1]\n\ + cmp r0, r1\n\ + bcc _080183B2\n\ + mov r2, r10\n\ + strb r2, [r5]\n\ _080183B2:\n\ - ldrb r0, [r5]\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - bne _080183E4\n\ - ldr r1, _080183D0 @ =gBattlePartyID\n\ - ldrb r0, [r5]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r1, [r0]\n\ - movs r0, 0x64\n\ - muls r1, r0\n\ - ldr r0, _080183E0 @ =gPlayerParty\n\ - b _080183F4\n\ - .align 2, 0\n\ + ldrb r0, [r5]\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + bne _080183E4\n\ + ldr r1, _080183D0 @ =gBattlePartyID\n\ + ldrb r0, [r5]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r1, [r0]\n\ + movs r0, 0x64\n\ + muls r1, r0\n\ + ldr r0, _080183E0 @ =gPlayerParty\n\ + b _080183F4\n\ + .align 2, 0\n\ _080183D0: .4byte gBattlePartyID\n\ _080183D4: .4byte gEnemyParty\n\ _080183D8: .4byte gBankTarget\n\ _080183DC: .4byte gNoOfAllBanks\n\ _080183E0: .4byte gPlayerParty\n\ _080183E4:\n\ - ldr r1, _08018444 @ =gBattlePartyID\n\ - ldrb r0, [r5]\n\ - lsls r0, 1\n\ - adds r0, r1\n\ - ldrh r1, [r0]\n\ - movs r0, 0x64\n\ - muls r1, r0\n\ - ldr r0, _08018448 @ =gEnemyParty\n\ + ldr r1, _08018444 @ =gBattlePartyID\n\ + ldrb r0, [r5]\n\ + lsls r0, 1\n\ + adds r0, r1\n\ + ldrh r1, [r0]\n\ + movs r0, 0x64\n\ + muls r1, r0\n\ + ldr r0, _08018448 @ =gEnemyParty\n\ _080183F4:\n\ - adds r5, r1, r0\n\ - adds r0, r7, 0\n\ - movs r1, 0xB\n\ - bl GetMonData\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x8]\n\ - adds r0, r7, 0\n\ - movs r1, 0\n\ - bl GetMonData\n\ - str r0, [sp, 0x10]\n\ - adds r0, r5, 0\n\ - movs r1, 0xB\n\ - bl GetMonData\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0xC]\n\ - adds r0, r5, 0\n\ - movs r1, 0\n\ - bl GetMonData\n\ - str r0, [sp, 0x14]\n\ - ldr r0, _0801844C @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r0, 0x80\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018436\n\ - bl _08019F92\n\ + adds r5, r1, r0\n\ + adds r0, r7, 0\n\ + movs r1, 0xB\n\ + bl GetMonData\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x8]\n\ + adds r0, r7, 0\n\ + movs r1, 0\n\ + bl GetMonData\n\ + str r0, [sp, 0x10]\n\ + adds r0, r5, 0\n\ + movs r1, 0xB\n\ + bl GetMonData\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0xC]\n\ + adds r0, r5, 0\n\ + movs r1, 0\n\ + bl GetMonData\n\ + str r0, [sp, 0x14]\n\ + ldr r0, _0801844C @ =gBattleTypeFlags\n\ + ldrh r1, [r0]\n\ + movs r0, 0x80\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018436\n\ + bl _08019F92\n\ _08018436:\n\ - mov r3, r8\n\ - cmp r3, 0\n\ - beq _08018454\n\ - ldr r0, _08018450 @ =gLastUsedAbility\n\ - strb r3, [r0]\n\ - mov r8, r0\n\ - b _0801846A\n\ - .align 2, 0\n\ + mov r3, r8\n\ + cmp r3, 0\n\ + beq _08018454\n\ + ldr r0, _08018450 @ =gLastUsedAbility\n\ + strb r3, [r0]\n\ + mov r8, r0\n\ + b _0801846A\n\ + .align 2, 0\n\ _08018444: .4byte gBattlePartyID\n\ _08018448: .4byte gEnemyParty\n\ _0801844C: .4byte gBattleTypeFlags\n\ _08018450: .4byte gLastUsedAbility\n\ _08018454:\n\ - ldr r2, _08018474 @ =gLastUsedAbility\n\ - ldr r1, _08018478 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r5, r10\n\ - muls r5, r0\n\ - adds r0, r5, 0\n\ - adds r0, r1\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - strb r0, [r2]\n\ - mov r8, r2\n\ + ldr r2, _08018474 @ =gLastUsedAbility\n\ + ldr r1, _08018478 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r5, r10\n\ + muls r5, r0\n\ + adds r0, r5, 0\n\ + adds r0, r1\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + strb r0, [r2]\n\ + mov r8, r2\n\ _0801846A:\n\ - cmp r4, 0\n\ - beq _0801847C\n\ - adds r3, r4, 0\n\ - b _08018480\n\ - .align 2, 0\n\ + cmp r4, 0\n\ + beq _0801847C\n\ + adds r3, r4, 0\n\ + b _08018480\n\ + .align 2, 0\n\ _08018474: .4byte gLastUsedAbility\n\ _08018478: .4byte gBattleMons\n\ _0801847C:\n\ - ldr r0, _08018494 @ =gCurrentMove\n\ - ldrh r3, [r0]\n\ + ldr r0, _08018494 @ =gCurrentMove\n\ + ldrh r3, [r0]\n\ _08018480:\n\ - ldr r1, _08018498 @ =0x02000000\n\ - ldr r2, _0801849C @ =0x0001601c\n\ - adds r0, r1, r2\n\ - ldrb r0, [r0]\n\ - adds r7, r1, 0\n\ - cmp r0, 0\n\ - beq _080184A0\n\ - movs r4, 0x3F\n\ - ands r4, r0\n\ - b _080184AC\n\ - .align 2, 0\n\ + ldr r1, _08018498 @ =0x02000000\n\ + ldr r2, _0801849C @ =0x0001601c\n\ + adds r0, r1, r2\n\ + ldrb r0, [r0]\n\ + adds r7, r1, 0\n\ + cmp r0, 0\n\ + beq _080184A0\n\ + movs r4, 0x3F\n\ + ands r4, r0\n\ + b _080184AC\n\ + .align 2, 0\n\ _08018494: .4byte gCurrentMove\n\ _08018498: .4byte 0x02000000\n\ _0801849C: .4byte 0x0001601c\n\ _080184A0:\n\ - ldr r1, _080184C0 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r4, [r0, 0x2]\n\ + ldr r1, _080184C0 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r4, [r0, 0x2]\n\ _080184AC:\n\ - ldr r5, [sp, 0x4]\n\ - cmp r5, 0x13\n\ - bls _080184B6\n\ - bl _08019F76\n\ + ldr r5, [sp, 0x4]\n\ + cmp r5, 0x13\n\ + bls _080184B6\n\ + bl _08019F76\n\ _080184B6:\n\ - lsls r0, r5, 2\n\ - ldr r1, _080184C4 @ =_080184C8\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ + lsls r0, r5, 2\n\ + ldr r1, _080184C4 @ =_080184C8\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ _080184C0: .4byte gBattleMoves\n\ _080184C4: .4byte _080184C8\n\ - .align 2, 0\n\ + .align 2, 0\n\ _080184C8:\n\ - .4byte _08018518\n\ - .4byte _08018814\n\ - .4byte _08018A40\n\ - .4byte _08018AD8\n\ - .4byte _08018CF0\n\ - .4byte _08019448\n\ - .4byte _080197B4\n\ - .4byte _08019804\n\ - .4byte _08019880\n\ - .4byte _080198FC\n\ - .4byte _08019B1C\n\ - .4byte _08019940\n\ - .4byte _08019B60\n\ - .4byte _08019BBC\n\ - .4byte _08019C18\n\ - .4byte _08019D18\n\ - .4byte _08019D5C\n\ - .4byte _08019DB8\n\ - .4byte _08019F44\n\ - .4byte _08019CD4\n\ + .4byte _08018518\n\ + .4byte _08018814\n\ + .4byte _08018A40\n\ + .4byte _08018AD8\n\ + .4byte _08018CF0\n\ + .4byte _08019448\n\ + .4byte _080197B4\n\ + .4byte _08019804\n\ + .4byte _08019880\n\ + .4byte _080198FC\n\ + .4byte _08019B1C\n\ + .4byte _08019940\n\ + .4byte _08019B60\n\ + .4byte _08019BBC\n\ + .4byte _08019C18\n\ + .4byte _08019D18\n\ + .4byte _08019D5C\n\ + .4byte _08019DB8\n\ + .4byte _08019F44\n\ + .4byte _08019CD4\n\ _08018518:\n\ - ldr r2, _0801854C @ =gBankAttacker\n\ - ldr r0, _08018550 @ =gNoOfAllBanks\n\ - ldrb r1, [r2]\n\ - adds r5, r0, 0\n\ - ldrb r0, [r5]\n\ - cmp r1, r0\n\ - bcc _0801852A\n\ - mov r1, r10\n\ - strb r1, [r2]\n\ + ldr r2, _0801854C @ =gBankAttacker\n\ + ldr r0, _08018550 @ =gNoOfAllBanks\n\ + ldrb r1, [r2]\n\ + adds r5, r0, 0\n\ + ldrb r0, [r5]\n\ + cmp r1, r0\n\ + bcc _0801852A\n\ + mov r1, r10\n\ + strb r1, [r2]\n\ _0801852A:\n\ - mov r2, r8\n\ - ldrb r0, [r2]\n\ - cmp r0, 0x2D\n\ - bne _08018534\n\ - b _080186B8\n\ + mov r2, r8\n\ + ldrb r0, [r2]\n\ + cmp r0, 0x2D\n\ + bne _08018534\n\ + b _080186B8\n\ _08018534:\n\ - cmp r0, 0x2D\n\ - bgt _08018564\n\ - cmp r0, 0xD\n\ - bne _0801853E\n\ - b _080187DC\n\ + cmp r0, 0x2D\n\ + bgt _08018564\n\ + cmp r0, 0xD\n\ + bne _0801853E\n\ + b _080187DC\n\ _0801853E:\n\ - cmp r0, 0xD\n\ - bgt _08018554\n\ - cmp r0, 0x2\n\ - bne _08018548\n\ - b _08018680\n\ + cmp r0, 0xD\n\ + bgt _08018554\n\ + cmp r0, 0x2\n\ + bne _08018548\n\ + b _08018680\n\ _08018548:\n\ - bl _08019F76\n\ - .align 2, 0\n\ + bl _08019F76\n\ + .align 2, 0\n\ _0801854C: .4byte gBankAttacker\n\ _08018550: .4byte gNoOfAllBanks\n\ _08018554:\n\ - cmp r0, 0x16\n\ - bne _0801855A\n\ - b _08018728\n\ + cmp r0, 0x16\n\ + bne _0801855A\n\ + b _08018728\n\ _0801855A:\n\ - cmp r0, 0x24\n\ - bne _08018560\n\ - b _080187A0\n\ + cmp r0, 0x24\n\ + bne _08018560\n\ + b _080187A0\n\ _08018560:\n\ - bl _08019F76\n\ + bl _08019F76\n\ _08018564:\n\ - cmp r0, 0x46\n\ - bne _0801856A\n\ - b _080186F0\n\ + cmp r0, 0x46\n\ + bne _0801856A\n\ + b _080186F0\n\ _0801856A:\n\ - cmp r0, 0x46\n\ - bgt _08018578\n\ - cmp r0, 0x3B\n\ - bne _08018574\n\ - b _0801875C\n\ + cmp r0, 0x46\n\ + bgt _08018578\n\ + cmp r0, 0x3B\n\ + bne _08018574\n\ + b _0801875C\n\ _08018574:\n\ - bl _08019F76\n\ + bl _08019F76\n\ _08018578:\n\ - cmp r0, 0x4D\n\ - bne _0801857E\n\ - b _080187DC\n\ + cmp r0, 0x4D\n\ + bne _0801857E\n\ + b _080187DC\n\ _0801857E:\n\ - cmp r0, 0xFF\n\ - beq _08018586\n\ - bl _08019F76\n\ + cmp r0, 0xFF\n\ + beq _08018586\n\ + bl _08019F76\n\ _08018586:\n\ - bl weather_get_current\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - subs r0, 0x3\n\ - cmp r0, 0xA\n\ - bhi _0801864C\n\ - lsls r0, 2\n\ - ldr r1, _080185A0 @ =_080185A4\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ + bl weather_get_current\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + subs r0, 0x3\n\ + cmp r0, 0xA\n\ + bhi _0801864C\n\ + lsls r0, 2\n\ + ldr r1, _080185A0 @ =_080185A4\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ _080185A0: .4byte _080185A4\n\ - .align 2, 0\n\ + .align 2, 0\n\ _080185A4:\n\ - .4byte _080185D0\n\ - .4byte _0801864C\n\ - .4byte _080185D0\n\ - .4byte _0801864C\n\ - .4byte _0801864C\n\ - .4byte _080185F8\n\ - .4byte _0801864C\n\ - .4byte _0801864C\n\ - .4byte _0801864C\n\ - .4byte _08018620\n\ - .4byte _080185D0\n\ + .4byte _080185D0\n\ + .4byte _0801864C\n\ + .4byte _080185D0\n\ + .4byte _0801864C\n\ + .4byte _0801864C\n\ + .4byte _080185F8\n\ + .4byte _0801864C\n\ + .4byte _0801864C\n\ + .4byte _0801864C\n\ + .4byte _08018620\n\ + .4byte _080185D0\n\ _080185D0:\n\ - ldr r2, _080185EC @ =gBattleWeather\n\ - ldrh r1, [r2]\n\ - movs r0, 0x7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801864C\n\ - movs r0, 0x5\n\ - strh r0, [r2]\n\ - ldr r0, _080185F0 @ =0x02000000\n\ - ldr r3, _080185F4 @ =0x000160a4\n\ - adds r2, r0, r3\n\ - movs r1, 0xA\n\ - b _08018638\n\ - .align 2, 0\n\ + ldr r2, _080185EC @ =gBattleWeather\n\ + ldrh r1, [r2]\n\ + movs r0, 0x7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801864C\n\ + movs r0, 0x5\n\ + strh r0, [r2]\n\ + ldr r0, _080185F0 @ =0x02000000\n\ + ldr r3, _080185F4 @ =0x000160a4\n\ + adds r2, r0, r3\n\ + movs r1, 0xA\n\ + b _08018638\n\ + .align 2, 0\n\ _080185EC: .4byte gBattleWeather\n\ _080185F0: .4byte 0x02000000\n\ _080185F4: .4byte 0x000160a4\n\ _080185F8:\n\ - ldr r3, _08018614 @ =gBattleWeather\n\ - ldrh r1, [r3]\n\ - movs r2, 0x18\n\ - adds r0, r2, 0\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801864C\n\ - strh r2, [r3]\n\ - ldr r0, _08018618 @ =0x02000000\n\ - ldr r3, _0801861C @ =0x000160a4\n\ - adds r2, r0, r3\n\ - movs r1, 0xC\n\ - b _08018638\n\ - .align 2, 0\n\ + ldr r3, _08018614 @ =gBattleWeather\n\ + ldrh r1, [r3]\n\ + movs r2, 0x18\n\ + adds r0, r2, 0\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801864C\n\ + strh r2, [r3]\n\ + ldr r0, _08018618 @ =0x02000000\n\ + ldr r3, _0801861C @ =0x000160a4\n\ + adds r2, r0, r3\n\ + movs r1, 0xC\n\ + b _08018638\n\ + .align 2, 0\n\ _08018614: .4byte gBattleWeather\n\ _08018618: .4byte 0x02000000\n\ _0801861C: .4byte 0x000160a4\n\ _08018620:\n\ - ldr r3, _08018668 @ =gBattleWeather\n\ - ldrh r1, [r3]\n\ - movs r2, 0x60\n\ - adds r0, r2, 0\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801864C\n\ - strh r2, [r3]\n\ - ldr r0, _0801866C @ =0x02000000\n\ - ldr r3, _08018670 @ =0x000160a4\n\ - adds r2, r0, r3\n\ - movs r1, 0xB\n\ + ldr r3, _08018668 @ =gBattleWeather\n\ + ldrh r1, [r3]\n\ + movs r2, 0x60\n\ + adds r0, r2, 0\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801864C\n\ + strh r2, [r3]\n\ + ldr r0, _0801866C @ =0x02000000\n\ + ldr r3, _08018670 @ =0x000160a4\n\ + adds r2, r0, r3\n\ + movs r1, 0xB\n\ _08018638:\n\ - strb r1, [r2]\n\ - ldr r5, _08018674 @ =0x00016003\n\ - adds r0, r5\n\ - mov r1, r10\n\ - strb r1, [r0]\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + strb r1, [r2]\n\ + ldr r5, _08018674 @ =0x00016003\n\ + adds r0, r5\n\ + mov r1, r10\n\ + strb r1, [r0]\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _0801864C:\n\ - mov r2, r9\n\ - cmp r2, 0\n\ - bne _08018656\n\ - bl _08019F92\n\ + mov r2, r9\n\ + cmp r2, 0\n\ + bne _08018656\n\ + bl _08019F92\n\ _08018656:\n\ - bl weather_get_current\n\ - ldr r1, _08018678 @ =gBattleCommunication\n\ - strb r0, [r1, 0x5]\n\ - ldr r0, _0801867C @ =gUnknown_081D901D\n\ - bl b_push_move_exec\n\ - bl _08019F76\n\ - .align 2, 0\n\ + bl weather_get_current\n\ + ldr r1, _08018678 @ =gBattleCommunication\n\ + strb r0, [r1, 0x5]\n\ + ldr r0, _0801867C @ =gUnknown_081D901D\n\ + bl b_push_move_exec\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018668: .4byte gBattleWeather\n\ _0801866C: .4byte 0x02000000\n\ _08018670: .4byte 0x000160a4\n\ @@ -2663,367 +2663,367 @@ _08018674: .4byte 0x00016003\n\ _08018678: .4byte gBattleCommunication\n\ _0801867C: .4byte gUnknown_081D901D\n\ _08018680:\n\ - ldr r2, _080186A8 @ =gBattleWeather\n\ - ldrh r1, [r2]\n\ - movs r0, 0x4\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018690\n\ - bl _08019F76\n\ + ldr r2, _080186A8 @ =gBattleWeather\n\ + ldrh r1, [r2]\n\ + movs r0, 0x4\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018690\n\ + bl _08019F76\n\ _08018690:\n\ - movs r0, 0x5\n\ - strh r0, [r2]\n\ - ldr r0, _080186AC @ =BattleScript_DrizzleActivates\n\ - bl b_push_move_exec\n\ - ldr r0, _080186B0 @ =0x02000000\n\ - ldr r3, _080186B4 @ =0x00016003\n\ - adds r0, r3\n\ - mov r5, r10\n\ - strb r5, [r0]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + movs r0, 0x5\n\ + strh r0, [r2]\n\ + ldr r0, _080186AC @ =BattleScript_DrizzleActivates\n\ + bl b_push_move_exec\n\ + ldr r0, _080186B0 @ =0x02000000\n\ + ldr r3, _080186B4 @ =0x00016003\n\ + adds r0, r3\n\ + mov r5, r10\n\ + strb r5, [r0]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080186A8: .4byte gBattleWeather\n\ _080186AC: .4byte BattleScript_DrizzleActivates\n\ _080186B0: .4byte 0x02000000\n\ _080186B4: .4byte 0x00016003\n\ _080186B8:\n\ - ldr r2, _080186E0 @ =gBattleWeather\n\ - ldrh r1, [r2]\n\ - movs r0, 0x10\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080186C8\n\ - bl _08019F76\n\ + ldr r2, _080186E0 @ =gBattleWeather\n\ + ldrh r1, [r2]\n\ + movs r0, 0x10\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080186C8\n\ + bl _08019F76\n\ _080186C8:\n\ - movs r0, 0x18\n\ - strh r0, [r2]\n\ - ldr r0, _080186E4 @ =BattleScript_SandstreamActivates\n\ - bl b_push_move_exec\n\ - ldr r0, _080186E8 @ =0x02000000\n\ - ldr r1, _080186EC @ =0x00016003\n\ - adds r0, r1\n\ - mov r2, r10\n\ - strb r2, [r0]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + movs r0, 0x18\n\ + strh r0, [r2]\n\ + ldr r0, _080186E4 @ =BattleScript_SandstreamActivates\n\ + bl b_push_move_exec\n\ + ldr r0, _080186E8 @ =0x02000000\n\ + ldr r1, _080186EC @ =0x00016003\n\ + adds r0, r1\n\ + mov r2, r10\n\ + strb r2, [r0]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080186E0: .4byte gBattleWeather\n\ _080186E4: .4byte BattleScript_SandstreamActivates\n\ _080186E8: .4byte 0x02000000\n\ _080186EC: .4byte 0x00016003\n\ _080186F0:\n\ - ldr r2, _08018718 @ =gBattleWeather\n\ - ldrh r1, [r2]\n\ - movs r0, 0x40\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018700\n\ - bl _08019F76\n\ + ldr r2, _08018718 @ =gBattleWeather\n\ + ldrh r1, [r2]\n\ + movs r0, 0x40\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018700\n\ + bl _08019F76\n\ _08018700:\n\ - movs r0, 0x60\n\ - strh r0, [r2]\n\ - ldr r0, _0801871C @ =BattleScript_DroughtActivates\n\ - bl b_push_move_exec\n\ - ldr r0, _08018720 @ =0x02000000\n\ - ldr r3, _08018724 @ =0x00016003\n\ - adds r0, r3\n\ - mov r5, r10\n\ - strb r5, [r0]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + movs r0, 0x60\n\ + strh r0, [r2]\n\ + ldr r0, _0801871C @ =BattleScript_DroughtActivates\n\ + bl b_push_move_exec\n\ + ldr r0, _08018720 @ =0x02000000\n\ + ldr r3, _08018724 @ =0x00016003\n\ + adds r0, r3\n\ + mov r5, r10\n\ + strb r5, [r0]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08018718: .4byte gBattleWeather\n\ _0801871C: .4byte BattleScript_DroughtActivates\n\ _08018720: .4byte 0x02000000\n\ _08018724: .4byte 0x00016003\n\ _08018728:\n\ - ldr r0, _08018754 @ =gSpecialStatuses\n\ - mov r1, r10\n\ - lsls r2, r1, 2\n\ - adds r1, r2, r1\n\ - lsls r1, 2\n\ - adds r3, r1, r0\n\ - ldrb r0, [r3]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018740\n\ - bl _08019F76\n\ + ldr r0, _08018754 @ =gSpecialStatuses\n\ + mov r1, r10\n\ + lsls r2, r1, 2\n\ + adds r1, r2, r1\n\ + lsls r1, 2\n\ + adds r3, r1, r0\n\ + ldrb r0, [r3]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018740\n\ + bl _08019F76\n\ _08018740:\n\ - ldr r1, _08018758 @ =gStatuses3\n\ - adds r1, r2, r1\n\ - ldr r0, [r1]\n\ - movs r2, 0x80\n\ - lsls r2, 12\n\ - orrs r0, r2\n\ - str r0, [r1]\n\ - ldrb r0, [r3]\n\ - movs r1, 0x8\n\ - b _080187CA\n\ - .align 2, 0\n\ + ldr r1, _08018758 @ =gStatuses3\n\ + adds r1, r2, r1\n\ + ldr r0, [r1]\n\ + movs r2, 0x80\n\ + lsls r2, 12\n\ + orrs r0, r2\n\ + str r0, [r1]\n\ + ldrb r0, [r3]\n\ + movs r1, 0x8\n\ + b _080187CA\n\ + .align 2, 0\n\ _08018754: .4byte gSpecialStatuses\n\ _08018758: .4byte gStatuses3\n\ _0801875C:\n\ - mov r0, r10\n\ - bl CastformDataTypeChange\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ - cmp r0, 0\n\ - bne _08018770\n\ - bl _08019F92\n\ + mov r0, r10\n\ + bl CastformDataTypeChange\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ + cmp r0, 0\n\ + bne _08018770\n\ + bl _08019F92\n\ _08018770:\n\ - ldr r0, _08018790 @ =BattleScript_CastformChange\n\ - bl b_push_move_exec\n\ - ldr r0, _08018794 @ =0x02000000\n\ - ldr r2, _08018798 @ =0x00016003\n\ - adds r1, r0, r2\n\ - mov r3, r10\n\ - strb r3, [r1]\n\ - mov r1, r9\n\ - subs r1, 0x1\n\ - ldr r5, _0801879C @ =0x0001609b\n\ - adds r0, r5\n\ - strb r1, [r0]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + ldr r0, _08018790 @ =BattleScript_CastformChange\n\ + bl b_push_move_exec\n\ + ldr r0, _08018794 @ =0x02000000\n\ + ldr r2, _08018798 @ =0x00016003\n\ + adds r1, r0, r2\n\ + mov r3, r10\n\ + strb r3, [r1]\n\ + mov r1, r9\n\ + subs r1, 0x1\n\ + ldr r5, _0801879C @ =0x0001609b\n\ + adds r0, r5\n\ + strb r1, [r0]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018790: .4byte BattleScript_CastformChange\n\ _08018794: .4byte 0x02000000\n\ _08018798: .4byte 0x00016003\n\ _0801879C: .4byte 0x0001609b\n\ _080187A0:\n\ - ldr r0, _080187D4 @ =gSpecialStatuses\n\ - mov r1, r10\n\ - lsls r2, r1, 2\n\ - adds r1, r2, r1\n\ - lsls r1, 2\n\ - adds r3, r1, r0\n\ - ldrb r0, [r3]\n\ - lsls r0, 27\n\ - cmp r0, 0\n\ - bge _080187B8\n\ - bl _08019F76\n\ + ldr r0, _080187D4 @ =gSpecialStatuses\n\ + mov r1, r10\n\ + lsls r2, r1, 2\n\ + adds r1, r2, r1\n\ + lsls r1, 2\n\ + adds r3, r1, r0\n\ + ldrb r0, [r3]\n\ + lsls r0, 27\n\ + cmp r0, 0\n\ + bge _080187B8\n\ + bl _08019F76\n\ _080187B8:\n\ - ldr r1, _080187D8 @ =gStatuses3\n\ - adds r1, r2, r1\n\ - ldr r0, [r1]\n\ - movs r2, 0x80\n\ - lsls r2, 13\n\ - orrs r0, r2\n\ - str r0, [r1]\n\ - ldrb r0, [r3]\n\ - movs r1, 0x10\n\ + ldr r1, _080187D8 @ =gStatuses3\n\ + adds r1, r2, r1\n\ + ldr r0, [r1]\n\ + movs r2, 0x80\n\ + lsls r2, 13\n\ + orrs r0, r2\n\ + str r0, [r1]\n\ + ldrb r0, [r3]\n\ + movs r1, 0x10\n\ _080187CA:\n\ - orrs r0, r1\n\ - strb r0, [r3]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + orrs r0, r1\n\ + strb r0, [r3]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _080187D4: .4byte gSpecialStatuses\n\ _080187D8: .4byte gStatuses3\n\ _080187DC:\n\ - movs r6, 0\n\ - ldrb r5, [r5]\n\ - cmp r6, r5\n\ - bcc _080187E8\n\ - bl _08019F76\n\ + movs r6, 0\n\ + ldrb r5, [r5]\n\ + cmp r6, r5\n\ + bcc _080187E8\n\ + bl _08019F76\n\ _080187E8:\n\ - adds r0, r6, 0\n\ - bl CastformDataTypeChange\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ - cmp r0, 0\n\ - beq _080187FC\n\ - bl _08019E14\n\ + adds r0, r6, 0\n\ + bl CastformDataTypeChange\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ + cmp r0, 0\n\ + beq _080187FC\n\ + bl _08019E14\n\ _080187FC:\n\ - adds r0, r6, 0x1\n\ - lsls r0, 24\n\ - lsrs r6, r0, 24\n\ - ldr r0, _08018810 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r6, r0\n\ - bcc _080187E8\n\ - bl _08019F76\n\ - .align 2, 0\n\ + adds r0, r6, 0x1\n\ + lsls r0, 24\n\ + lsrs r6, r0, 24\n\ + ldr r0, _08018810 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r6, r0\n\ + bcc _080187E8\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018810: .4byte gNoOfAllBanks\n\ _08018814:\n\ - ldr r2, _08018844 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r1, r10\n\ - muls r1, r0\n\ - adds r4, r1, r2\n\ - ldrh r0, [r4, 0x28]\n\ - cmp r0, 0\n\ - bne _08018828\n\ - bl _08019F76\n\ + ldr r2, _08018844 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r1, r10\n\ + muls r1, r0\n\ + adds r4, r1, r2\n\ + ldrh r0, [r4, 0x28]\n\ + cmp r0, 0\n\ + bne _08018828\n\ + bl _08019F76\n\ _08018828:\n\ - ldr r0, _08018848 @ =gBankAttacker\n\ - mov r3, r10\n\ - strb r3, [r0]\n\ - mov r3, r8\n\ - ldrb r5, [r3]\n\ - cmp r5, 0x2C\n\ - beq _0801885A\n\ - cmp r5, 0x2C\n\ - bgt _0801884C\n\ - cmp r5, 0x3\n\ - bne _08018840\n\ - b _080189B8\n\ + ldr r0, _08018848 @ =gBankAttacker\n\ + mov r3, r10\n\ + strb r3, [r0]\n\ + mov r3, r8\n\ + ldrb r5, [r3]\n\ + cmp r5, 0x2C\n\ + beq _0801885A\n\ + cmp r5, 0x2C\n\ + bgt _0801884C\n\ + cmp r5, 0x3\n\ + bne _08018840\n\ + b _080189B8\n\ _08018840:\n\ - bl _08019F76\n\ - .align 2, 0\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018844: .4byte gBattleMons\n\ _08018848: .4byte gBankAttacker\n\ _0801884C:\n\ - cmp r5, 0x36\n\ - bne _08018852\n\ - b _08018A18\n\ + cmp r5, 0x36\n\ + bne _08018852\n\ + b _08018A18\n\ _08018852:\n\ - cmp r5, 0x3D\n\ - beq _080188DC\n\ - bl _08019F76\n\ + cmp r5, 0x3D\n\ + beq _080188DC\n\ + bl _08019F76\n\ _0801885A:\n\ - movs r0, 0\n\ - str r0, [sp]\n\ - movs r0, 0x13\n\ - movs r1, 0\n\ - movs r2, 0xD\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0\n\ - beq _08018876\n\ - bl _08019F76\n\ + movs r0, 0\n\ + str r0, [sp]\n\ + movs r0, 0x13\n\ + movs r1, 0\n\ + movs r2, 0xD\n\ + movs r3, 0\n\ + bl AbilityBattleEffects\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0\n\ + beq _08018876\n\ + bl _08019F76\n\ _08018876:\n\ - str r0, [sp]\n\ - movs r0, 0x13\n\ - movs r1, 0\n\ - movs r2, 0x4D\n\ - movs r3, 0\n\ - bl AbilityBattleEffects\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _0801888E\n\ - bl _08019F76\n\ + str r0, [sp]\n\ + movs r0, 0x13\n\ + movs r1, 0\n\ + movs r2, 0x4D\n\ + movs r3, 0\n\ + bl AbilityBattleEffects\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + beq _0801888E\n\ + bl _08019F76\n\ _0801888E:\n\ - ldr r0, _080188D0 @ =gBattleWeather\n\ - ldrh r1, [r0]\n\ - movs r0, 0x7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801889E\n\ - bl _08019F76\n\ + ldr r0, _080188D0 @ =gBattleWeather\n\ + ldrh r1, [r0]\n\ + movs r0, 0x7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801889E\n\ + bl _08019F76\n\ _0801889E:\n\ - ldrh r0, [r4, 0x2C]\n\ - ldrh r1, [r4, 0x28]\n\ - cmp r0, r1\n\ - bhi _080188AA\n\ - bl _08019F76\n\ + ldrh r0, [r4, 0x2C]\n\ + ldrh r1, [r4, 0x28]\n\ + cmp r0, r1\n\ + bhi _080188AA\n\ + bl _08019F76\n\ _080188AA:\n\ - mov r2, r8\n\ - strb r5, [r2]\n\ - ldr r0, _080188D4 @ =BattleScript_RainDishActivates\n\ - bl b_push_move_exec\n\ - ldr r1, _080188D8 @ =gBattleMoveDamage\n\ - ldrh r0, [r4, 0x2C]\n\ - lsrs r0, 4\n\ - str r0, [r1]\n\ - cmp r0, 0\n\ - bne _080188C4\n\ - movs r0, 0x1\n\ - str r0, [r1]\n\ + mov r2, r8\n\ + strb r5, [r2]\n\ + ldr r0, _080188D4 @ =BattleScript_RainDishActivates\n\ + bl b_push_move_exec\n\ + ldr r1, _080188D8 @ =gBattleMoveDamage\n\ + ldrh r0, [r4, 0x2C]\n\ + lsrs r0, 4\n\ + str r0, [r1]\n\ + cmp r0, 0\n\ + bne _080188C4\n\ + movs r0, 0x1\n\ + str r0, [r1]\n\ _080188C4:\n\ - ldr r0, [r1]\n\ - negs r0, r0\n\ - str r0, [r1]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldr r0, [r1]\n\ + negs r0, r0\n\ + str r0, [r1]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080188D0: .4byte gBattleWeather\n\ _080188D4: .4byte BattleScript_RainDishActivates\n\ _080188D8: .4byte gBattleMoveDamage\n\ _080188DC:\n\ - adds r0, r2, 0\n\ - adds r0, 0x4C\n\ - adds r5, r1, r0\n\ - ldrb r0, [r5]\n\ - cmp r0, 0\n\ - bne _080188EC\n\ - bl _08019F76\n\ + adds r0, r2, 0\n\ + adds r0, 0x4C\n\ + adds r5, r1, r0\n\ + ldrb r0, [r5]\n\ + cmp r0, 0\n\ + bne _080188EC\n\ + bl _08019F76\n\ _080188EC:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0x3\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - lsrs r4, r0, 16\n\ - cmp r4, 0\n\ - beq _08018906\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0x3\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + lsrs r4, r0, 16\n\ + cmp r4, 0\n\ + beq _08018906\n\ + bl _08019F76\n\ _08018906:\n\ - ldr r0, [r5]\n\ - movs r1, 0x88\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018918\n\ - ldr r0, _08018990 @ =gBattleTextBuff1\n\ - ldr r1, _08018994 @ =gStatusConditionString_PoisonJpn\n\ - bl StringCopy\n\ + ldr r0, [r5]\n\ + movs r1, 0x88\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018918\n\ + ldr r0, _08018990 @ =gBattleTextBuff1\n\ + ldr r1, _08018994 @ =gStatusConditionString_PoisonJpn\n\ + bl StringCopy\n\ _08018918:\n\ - ldr r0, [r5]\n\ - movs r1, 0x7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0801892A\n\ - ldr r0, _08018990 @ =gBattleTextBuff1\n\ - ldr r1, _08018998 @ =gStatusConditionString_SleepJpn\n\ - bl StringCopy\n\ + ldr r0, [r5]\n\ + movs r1, 0x7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _0801892A\n\ + ldr r0, _08018990 @ =gBattleTextBuff1\n\ + ldr r1, _08018998 @ =gStatusConditionString_SleepJpn\n\ + bl StringCopy\n\ _0801892A:\n\ - ldr r0, [r5]\n\ - movs r1, 0x40\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0801893C\n\ - ldr r0, _08018990 @ =gBattleTextBuff1\n\ - ldr r1, _0801899C @ =gStatusConditionString_ParalysisJpn\n\ - bl StringCopy\n\ + ldr r0, [r5]\n\ + movs r1, 0x40\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _0801893C\n\ + ldr r0, _08018990 @ =gBattleTextBuff1\n\ + ldr r1, _0801899C @ =gStatusConditionString_ParalysisJpn\n\ + bl StringCopy\n\ _0801893C:\n\ - ldr r0, [r5]\n\ - movs r1, 0x10\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0801894E\n\ - ldr r0, _08018990 @ =gBattleTextBuff1\n\ - ldr r1, _080189A0 @ =gStatusConditionString_BurnJpn\n\ - bl StringCopy\n\ + ldr r0, [r5]\n\ + movs r1, 0x10\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _0801894E\n\ + ldr r0, _08018990 @ =gBattleTextBuff1\n\ + ldr r1, _080189A0 @ =gStatusConditionString_BurnJpn\n\ + bl StringCopy\n\ _0801894E:\n\ - ldr r0, [r5]\n\ - movs r1, 0x20\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018960\n\ - ldr r0, _08018990 @ =gBattleTextBuff1\n\ - ldr r1, _080189A4 @ =gStatusConditionString_IceJpn\n\ - bl StringCopy\n\ + ldr r0, [r5]\n\ + movs r1, 0x20\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018960\n\ + ldr r0, _08018990 @ =gBattleTextBuff1\n\ + ldr r1, _080189A4 @ =gStatusConditionString_IceJpn\n\ + bl StringCopy\n\ _08018960:\n\ - str r4, [r5]\n\ - ldr r0, _080189A8 @ =0x02000000\n\ - ldr r4, _080189AC @ =gActiveBank\n\ - mov r3, r10\n\ - strb r3, [r4]\n\ - ldr r1, _080189B0 @ =0x00016003\n\ - adds r0, r1\n\ - strb r3, [r0]\n\ - ldr r0, _080189B4 @ =BattleScript_ShedSkinActivates\n\ - bl b_push_move_exec\n\ - str r5, [sp]\n\ - movs r0, 0\n\ - movs r1, 0x28\n\ - movs r2, 0\n\ - movs r3, 0x4\n\ - bl EmitSetAttributes\n\ - ldrb r0, [r4]\n\ - bl MarkBufferBankForExecution\n\ - bl _08019F22\n\ - .align 2, 0\n\ + str r4, [r5]\n\ + ldr r0, _080189A8 @ =0x02000000\n\ + ldr r4, _080189AC @ =gActiveBank\n\ + mov r3, r10\n\ + strb r3, [r4]\n\ + ldr r1, _080189B0 @ =0x00016003\n\ + adds r0, r1\n\ + strb r3, [r0]\n\ + ldr r0, _080189B4 @ =BattleScript_ShedSkinActivates\n\ + bl b_push_move_exec\n\ + str r5, [sp]\n\ + movs r0, 0\n\ + movs r1, 0x28\n\ + movs r2, 0\n\ + movs r3, 0x4\n\ + bl EmitSetAttributes\n\ + ldrb r0, [r4]\n\ + bl MarkBufferBankForExecution\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08018990: .4byte gBattleTextBuff1\n\ _08018994: .4byte gStatusConditionString_PoisonJpn\n\ _08018998: .4byte gStatusConditionString_SleepJpn\n\ @@ -3035,132 +3035,132 @@ _080189AC: .4byte gActiveBank\n\ _080189B0: .4byte 0x00016003\n\ _080189B4: .4byte BattleScript_ShedSkinActivates\n\ _080189B8:\n\ - ldrb r2, [r4, 0x1B]\n\ - movs r0, 0x1B\n\ - ldrsb r0, [r4, r0]\n\ - cmp r0, 0xB\n\ - ble _080189C6\n\ - bl _08019F76\n\ + ldrb r2, [r4, 0x1B]\n\ + movs r0, 0x1B\n\ + ldrsb r0, [r4, r0]\n\ + cmp r0, 0xB\n\ + ble _080189C6\n\ + bl _08019F76\n\ _080189C6:\n\ - ldr r0, _08018A04 @ =gDisableStructs\n\ - mov r3, r10\n\ - lsls r1, r3, 3\n\ - subs r1, r3\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x16]\n\ - cmp r0, 0x2\n\ - bne _080189DC\n\ - bl _08019F76\n\ + ldr r0, _08018A04 @ =gDisableStructs\n\ + mov r3, r10\n\ + lsls r1, r3, 3\n\ + subs r1, r3\n\ + lsls r1, 2\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x16]\n\ + cmp r0, 0x2\n\ + bne _080189DC\n\ + bl _08019F76\n\ _080189DC:\n\ - adds r0, r2, 0x1\n\ - movs r2, 0\n\ - strb r0, [r4, 0x1B]\n\ - ldr r5, _08018A08 @ =0x000160a4\n\ - adds r1, r7, r5\n\ - movs r0, 0x11\n\ - strb r0, [r1]\n\ - ldr r1, _08018A0C @ =0x000160a5\n\ - adds r0, r7, r1\n\ - strb r2, [r0]\n\ - ldr r0, _08018A10 @ =BattleScript_SpeedBoostActivates\n\ - bl b_push_move_exec\n\ - ldr r2, _08018A14 @ =0x00016003\n\ - adds r0, r7, r2\n\ - mov r3, r10\n\ - strb r3, [r0]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + adds r0, r2, 0x1\n\ + movs r2, 0\n\ + strb r0, [r4, 0x1B]\n\ + ldr r5, _08018A08 @ =0x000160a4\n\ + adds r1, r7, r5\n\ + movs r0, 0x11\n\ + strb r0, [r1]\n\ + ldr r1, _08018A0C @ =0x000160a5\n\ + adds r0, r7, r1\n\ + strb r2, [r0]\n\ + ldr r0, _08018A10 @ =BattleScript_SpeedBoostActivates\n\ + bl b_push_move_exec\n\ + ldr r2, _08018A14 @ =0x00016003\n\ + adds r0, r7, r2\n\ + mov r3, r10\n\ + strb r3, [r0]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08018A04: .4byte gDisableStructs\n\ _08018A08: .4byte 0x000160a4\n\ _08018A0C: .4byte 0x000160a5\n\ _08018A10: .4byte BattleScript_SpeedBoostActivates\n\ _08018A14: .4byte 0x00016003\n\ _08018A18:\n\ - ldr r2, _08018A3C @ =gDisableStructs\n\ - ldrb r0, [r0]\n\ - lsls r1, r0, 3\n\ - subs r1, r0\n\ - lsls r1, 2\n\ - adds r1, r2\n\ - ldrb r3, [r1, 0x18]\n\ - lsls r0, r3, 31\n\ - lsrs r0, 31\n\ - movs r2, 0x1\n\ - eors r2, r0\n\ - movs r0, 0x2\n\ - negs r0, r0\n\ - ands r0, r3\n\ - orrs r0, r2\n\ - strb r0, [r1, 0x18]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + ldr r2, _08018A3C @ =gDisableStructs\n\ + ldrb r0, [r0]\n\ + lsls r1, r0, 3\n\ + subs r1, r0\n\ + lsls r1, 2\n\ + adds r1, r2\n\ + ldrb r3, [r1, 0x18]\n\ + lsls r0, r3, 31\n\ + lsrs r0, 31\n\ + movs r2, 0x1\n\ + eors r2, r0\n\ + movs r0, 0x2\n\ + negs r0, r0\n\ + ands r0, r3\n\ + orrs r0, r2\n\ + strb r0, [r1, 0x18]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018A3C: .4byte gDisableStructs\n\ _08018A40:\n\ - mov r5, r8\n\ - ldrb r0, [r5]\n\ - cmp r0, 0x2B\n\ - beq _08018A4C\n\ - bl _08019F76\n\ + mov r5, r8\n\ + ldrb r0, [r5]\n\ + cmp r0, 0x2B\n\ + beq _08018A4C\n\ + bl _08019F76\n\ _08018A4C:\n\ - movs r4, 0\n\ - ldr r0, _08018ABC @ =gSoundMovesTable\n\ - ldrh r2, [r0]\n\ - ldr r5, _08018AC0 @ =0x0000ffff\n\ - adds r1, r0, 0\n\ - cmp r2, r5\n\ - bne _08018A5E\n\ - bl _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08018ABC @ =gSoundMovesTable\n\ + ldrh r2, [r0]\n\ + ldr r5, _08018AC0 @ =0x0000ffff\n\ + adds r1, r0, 0\n\ + cmp r2, r5\n\ + bne _08018A5E\n\ + bl _08019F76\n\ _08018A5E:\n\ - cmp r2, r3\n\ - beq _08018A76\n\ - adds r2, r1, 0\n\ + cmp r2, r3\n\ + beq _08018A76\n\ + adds r2, r1, 0\n\ _08018A64:\n\ - adds r2, 0x2\n\ - adds r4, 0x1\n\ - ldrh r0, [r2]\n\ - cmp r0, r5\n\ - bne _08018A72\n\ - bl _08019F76\n\ + adds r2, 0x2\n\ + adds r4, 0x1\n\ + ldrh r0, [r2]\n\ + cmp r0, r5\n\ + bne _08018A72\n\ + bl _08019F76\n\ _08018A72:\n\ - cmp r0, r3\n\ - bne _08018A64\n\ + cmp r0, r3\n\ + bne _08018A64\n\ _08018A76:\n\ - lsls r0, r4, 1\n\ - adds r0, r1\n\ - ldrh r1, [r0]\n\ - ldr r0, _08018AC0 @ =0x0000ffff\n\ - cmp r1, r0\n\ - bne _08018A86\n\ - bl _08019F76\n\ + lsls r0, r4, 1\n\ + adds r0, r1\n\ + ldrh r1, [r0]\n\ + ldr r0, _08018AC0 @ =0x0000ffff\n\ + cmp r1, r0\n\ + bne _08018A86\n\ + bl _08019F76\n\ _08018A86:\n\ - ldr r1, _08018AC4 @ =gBattleMons\n\ - ldr r0, _08018AC8 @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r1, 0x50\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x80\n\ - lsls r1, 5\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018AAC\n\ - ldr r0, _08018ACC @ =gHitMarker\n\ - ldr r1, [r0]\n\ - movs r2, 0x80\n\ - lsls r2, 4\n\ - orrs r1, r2\n\ - str r1, [r0]\n\ + ldr r1, _08018AC4 @ =gBattleMons\n\ + ldr r0, _08018AC8 @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r1, 0x50\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x80\n\ + lsls r1, 5\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018AAC\n\ + ldr r0, _08018ACC @ =gHitMarker\n\ + ldr r1, [r0]\n\ + movs r2, 0x80\n\ + lsls r2, 4\n\ + orrs r1, r2\n\ + str r1, [r0]\n\ _08018AAC:\n\ - ldr r1, _08018AD0 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018AD4 @ =BattleScript_SoundproofProtected\n\ - str r0, [r1]\n\ - movs r0, 0x1\n\ - mov r9, r0\n\ - bl _08019F7C\n\ - .align 2, 0\n\ + ldr r1, _08018AD0 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018AD4 @ =BattleScript_SoundproofProtected\n\ + str r0, [r1]\n\ + movs r0, 0x1\n\ + mov r9, r0\n\ + bl _08019F7C\n\ + .align 2, 0\n\ _08018ABC: .4byte gSoundMovesTable\n\ _08018AC0: .4byte 0x0000ffff\n\ _08018AC4: .4byte gBattleMons\n\ @@ -3169,150 +3169,150 @@ _08018ACC: .4byte gHitMarker\n\ _08018AD0: .4byte gBattlescriptCurrInstr\n\ _08018AD4: .4byte BattleScript_SoundproofProtected\n\ _08018AD8:\n\ - cmp r3, 0\n\ - bne _08018AE0\n\ - bl _08019F76\n\ + cmp r3, 0\n\ + bne _08018AE0\n\ + bl _08019F76\n\ _08018AE0:\n\ - mov r1, r8\n\ - ldrb r0, [r1]\n\ - cmp r0, 0xB\n\ - beq _08018B50\n\ - cmp r0, 0xB\n\ - bgt _08018AF2\n\ - cmp r0, 0xA\n\ - beq _08018AF8\n\ - b _08018C6A\n\ + mov r1, r8\n\ + ldrb r0, [r1]\n\ + cmp r0, 0xB\n\ + beq _08018B50\n\ + cmp r0, 0xB\n\ + bgt _08018AF2\n\ + cmp r0, 0xA\n\ + beq _08018AF8\n\ + b _08018C6A\n\ _08018AF2:\n\ - cmp r0, 0x12\n\ - beq _08018BA8\n\ - b _08018C6A\n\ + cmp r0, 0x12\n\ + beq _08018BA8\n\ + b _08018C6A\n\ _08018AF8:\n\ - cmp r4, 0xD\n\ - beq _08018AFE\n\ - b _08018C6A\n\ + cmp r4, 0xD\n\ + beq _08018AFE\n\ + b _08018C6A\n\ _08018AFE:\n\ - ldr r0, _08018B28 @ =gBattleMoves\n\ - lsls r1, r3, 1\n\ - adds r1, r3\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - cmp r0, 0\n\ - bne _08018B10\n\ - b _08018C6A\n\ + ldr r0, _08018B28 @ =gBattleMoves\n\ + lsls r1, r3, 1\n\ + adds r1, r3\n\ + lsls r1, 2\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + cmp r0, 0\n\ + bne _08018B10\n\ + b _08018C6A\n\ _08018B10:\n\ - ldr r1, _08018B2C @ =gProtectStructs\n\ - ldr r0, _08018B30 @ =gBankAttacker\n\ - ldrb r0, [r0]\n\ - lsls r0, 4\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018B3C\n\ - ldr r1, _08018B34 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018B38 @ =BattleScript_MoveHPDrain\n\ - b _08018B40\n\ - .align 2, 0\n\ + ldr r1, _08018B2C @ =gProtectStructs\n\ + ldr r0, _08018B30 @ =gBankAttacker\n\ + ldrb r0, [r0]\n\ + lsls r0, 4\n\ + adds r0, r1\n\ + ldrb r0, [r0, 0x2]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018B3C\n\ + ldr r1, _08018B34 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018B38 @ =BattleScript_MoveHPDrain\n\ + b _08018B40\n\ + .align 2, 0\n\ _08018B28: .4byte gBattleMoves\n\ _08018B2C: .4byte gProtectStructs\n\ _08018B30: .4byte gBankAttacker\n\ _08018B34: .4byte gBattlescriptCurrInstr\n\ _08018B38: .4byte BattleScript_MoveHPDrain\n\ _08018B3C:\n\ - ldr r1, _08018B48 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018B4C @ =BattleScript_MoveHPDrain_PPLoss\n\ + ldr r1, _08018B48 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018B4C @ =BattleScript_MoveHPDrain_PPLoss\n\ _08018B40:\n\ - str r0, [r1]\n\ - movs r2, 0x1\n\ - b _08018C68\n\ - .align 2, 0\n\ + str r0, [r1]\n\ + movs r2, 0x1\n\ + b _08018C68\n\ + .align 2, 0\n\ _08018B48: .4byte gBattlescriptCurrInstr\n\ _08018B4C: .4byte BattleScript_MoveHPDrain_PPLoss\n\ _08018B50:\n\ - cmp r4, 0xB\n\ - beq _08018B56\n\ - b _08018C6A\n\ + cmp r4, 0xB\n\ + beq _08018B56\n\ + b _08018C6A\n\ _08018B56:\n\ - ldr r0, _08018B80 @ =gBattleMoves\n\ - lsls r1, r3, 1\n\ - adds r1, r3\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - cmp r0, 0\n\ - bne _08018B68\n\ - b _08018C6A\n\ + ldr r0, _08018B80 @ =gBattleMoves\n\ + lsls r1, r3, 1\n\ + adds r1, r3\n\ + lsls r1, 2\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + cmp r0, 0\n\ + bne _08018B68\n\ + b _08018C6A\n\ _08018B68:\n\ - ldr r1, _08018B84 @ =gProtectStructs\n\ - ldr r0, _08018B88 @ =gBankAttacker\n\ - ldrb r0, [r0]\n\ - lsls r0, 4\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018B94\n\ - ldr r1, _08018B8C @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018B90 @ =BattleScript_MoveHPDrain\n\ - b _08018B98\n\ - .align 2, 0\n\ + ldr r1, _08018B84 @ =gProtectStructs\n\ + ldr r0, _08018B88 @ =gBankAttacker\n\ + ldrb r0, [r0]\n\ + lsls r0, 4\n\ + adds r0, r1\n\ + ldrb r0, [r0, 0x2]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018B94\n\ + ldr r1, _08018B8C @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018B90 @ =BattleScript_MoveHPDrain\n\ + b _08018B98\n\ + .align 2, 0\n\ _08018B80: .4byte gBattleMoves\n\ _08018B84: .4byte gProtectStructs\n\ _08018B88: .4byte gBankAttacker\n\ _08018B8C: .4byte gBattlescriptCurrInstr\n\ _08018B90: .4byte BattleScript_MoveHPDrain\n\ _08018B94:\n\ - ldr r1, _08018BA0 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018BA4 @ =BattleScript_MoveHPDrain_PPLoss\n\ + ldr r1, _08018BA0 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018BA4 @ =BattleScript_MoveHPDrain_PPLoss\n\ _08018B98:\n\ - str r0, [r1]\n\ - movs r3, 0x1\n\ - mov r9, r3\n\ - b _08018C6A\n\ - .align 2, 0\n\ + str r0, [r1]\n\ + movs r3, 0x1\n\ + mov r9, r3\n\ + b _08018C6A\n\ + .align 2, 0\n\ _08018BA0: .4byte gBattlescriptCurrInstr\n\ _08018BA4: .4byte BattleScript_MoveHPDrain_PPLoss\n\ _08018BA8:\n\ - cmp r4, 0xA\n\ - bne _08018C6A\n\ - ldr r1, _08018BF4 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r5, r10\n\ - muls r5, r0\n\ - adds r0, r5, 0\n\ - adds r1, 0x4C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x20\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08018C6A\n\ - ldr r2, _08018BF8 @ =0x02017100\n\ - mov r0, r10\n\ - lsls r1, r0, 2\n\ - adds r0, r1, r2\n\ - ldr r3, [r0]\n\ - movs r4, 0x1\n\ - ands r3, r4\n\ - adds r5, r1, 0\n\ - cmp r3, 0\n\ - bne _08018C30\n\ - ldr r0, _08018BFC @ =gBattleCommunication\n\ - strb r3, [r0, 0x5]\n\ - ldr r1, _08018C00 @ =gProtectStructs\n\ - ldr r0, _08018C04 @ =gBankAttacker\n\ - ldrb r0, [r0]\n\ - lsls r0, 4\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018C10\n\ - ldr r1, _08018C08 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018C0C @ =BattleScript_FlashFireBoost\n\ - b _08018C14\n\ - .align 2, 0\n\ + cmp r4, 0xA\n\ + bne _08018C6A\n\ + ldr r1, _08018BF4 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r5, r10\n\ + muls r5, r0\n\ + adds r0, r5, 0\n\ + adds r1, 0x4C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x20\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _08018C6A\n\ + ldr r2, _08018BF8 @ =0x02017100\n\ + mov r0, r10\n\ + lsls r1, r0, 2\n\ + adds r0, r1, r2\n\ + ldr r3, [r0]\n\ + movs r4, 0x1\n\ + ands r3, r4\n\ + adds r5, r1, 0\n\ + cmp r3, 0\n\ + bne _08018C30\n\ + ldr r0, _08018BFC @ =gBattleCommunication\n\ + strb r3, [r0, 0x5]\n\ + ldr r1, _08018C00 @ =gProtectStructs\n\ + ldr r0, _08018C04 @ =gBankAttacker\n\ + ldrb r0, [r0]\n\ + lsls r0, 4\n\ + adds r0, r1\n\ + ldrb r0, [r0, 0x2]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018C10\n\ + ldr r1, _08018C08 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018C0C @ =BattleScript_FlashFireBoost\n\ + b _08018C14\n\ + .align 2, 0\n\ _08018BF4: .4byte gBattleMons\n\ _08018BF8: .4byte 0x02017100\n\ _08018BFC: .4byte gBattleCommunication\n\ @@ -3321,80 +3321,80 @@ _08018C04: .4byte gBankAttacker\n\ _08018C08: .4byte gBattlescriptCurrInstr\n\ _08018C0C: .4byte BattleScript_FlashFireBoost\n\ _08018C10:\n\ - ldr r1, _08018C28 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018C2C @ =BattleScript_FlashFireBoost_PPLoss\n\ + ldr r1, _08018C28 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018C2C @ =BattleScript_FlashFireBoost_PPLoss\n\ _08018C14:\n\ - str r0, [r1]\n\ - adds r0, r5, r2\n\ - ldr r1, [r0]\n\ - movs r2, 0x1\n\ - orrs r1, r2\n\ - str r1, [r0]\n\ - movs r1, 0x2\n\ - mov r9, r1\n\ - b _08018C6A\n\ - .align 2, 0\n\ + str r0, [r1]\n\ + adds r0, r5, r2\n\ + ldr r1, [r0]\n\ + movs r2, 0x1\n\ + orrs r1, r2\n\ + str r1, [r0]\n\ + movs r1, 0x2\n\ + mov r9, r1\n\ + b _08018C6A\n\ + .align 2, 0\n\ _08018C28: .4byte gBattlescriptCurrInstr\n\ _08018C2C: .4byte BattleScript_FlashFireBoost_PPLoss\n\ _08018C30:\n\ - ldr r0, _08018C4C @ =gBattleCommunication\n\ - strb r4, [r0, 0x5]\n\ - ldr r1, _08018C50 @ =gProtectStructs\n\ - ldr r0, _08018C54 @ =gBankAttacker\n\ - ldrb r0, [r0]\n\ - lsls r0, 4\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018C60\n\ - ldr r1, _08018C58 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018C5C @ =BattleScript_FlashFireBoost\n\ - b _08018C64\n\ - .align 2, 0\n\ + ldr r0, _08018C4C @ =gBattleCommunication\n\ + strb r4, [r0, 0x5]\n\ + ldr r1, _08018C50 @ =gProtectStructs\n\ + ldr r0, _08018C54 @ =gBankAttacker\n\ + ldrb r0, [r0]\n\ + lsls r0, 4\n\ + adds r0, r1\n\ + ldrb r0, [r0, 0x2]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018C60\n\ + ldr r1, _08018C58 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018C5C @ =BattleScript_FlashFireBoost\n\ + b _08018C64\n\ + .align 2, 0\n\ _08018C4C: .4byte gBattleCommunication\n\ _08018C50: .4byte gProtectStructs\n\ _08018C54: .4byte gBankAttacker\n\ _08018C58: .4byte gBattlescriptCurrInstr\n\ _08018C5C: .4byte BattleScript_FlashFireBoost\n\ _08018C60:\n\ - ldr r1, _08018CA4 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018CA8 @ =BattleScript_FlashFireBoost_PPLoss\n\ + ldr r1, _08018CA4 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018CA8 @ =BattleScript_FlashFireBoost_PPLoss\n\ _08018C64:\n\ - str r0, [r1]\n\ - movs r2, 0x2\n\ + str r0, [r1]\n\ + movs r2, 0x2\n\ _08018C68:\n\ - mov r9, r2\n\ + mov r9, r2\n\ _08018C6A:\n\ - mov r3, r9\n\ - cmp r3, 0x1\n\ - beq _08018C74\n\ - bl _08019F76\n\ + mov r3, r9\n\ + cmp r3, 0x1\n\ + beq _08018C74\n\ + bl _08019F76\n\ _08018C74:\n\ - ldr r1, _08018CAC @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r5, r10\n\ - muls r5, r0\n\ - adds r0, r5, 0\n\ - adds r1, r0, r1\n\ - ldrh r0, [r1, 0x2C]\n\ - ldrh r2, [r1, 0x28]\n\ - cmp r0, r2\n\ - bne _08018CD0\n\ - ldr r1, _08018CB0 @ =gProtectStructs\n\ - ldr r0, _08018CB4 @ =gBankAttacker\n\ - ldrb r0, [r0]\n\ - lsls r0, 4\n\ - adds r0, r1\n\ - ldrb r0, [r0, 0x2]\n\ - lsls r0, 28\n\ - cmp r0, 0\n\ - bge _08018CBC\n\ - ldr r1, _08018CA4 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018CB8 @ =BattleScript_MoveHPDrain_FullHP\n\ - str r0, [r1]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + ldr r1, _08018CAC @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r5, r10\n\ + muls r5, r0\n\ + adds r0, r5, 0\n\ + adds r1, r0, r1\n\ + ldrh r0, [r1, 0x2C]\n\ + ldrh r2, [r1, 0x28]\n\ + cmp r0, r2\n\ + bne _08018CD0\n\ + ldr r1, _08018CB0 @ =gProtectStructs\n\ + ldr r0, _08018CB4 @ =gBankAttacker\n\ + ldrb r0, [r0]\n\ + lsls r0, 4\n\ + adds r0, r1\n\ + ldrb r0, [r0, 0x2]\n\ + lsls r0, 28\n\ + cmp r0, 0\n\ + bge _08018CBC\n\ + ldr r1, _08018CA4 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018CB8 @ =BattleScript_MoveHPDrain_FullHP\n\ + str r0, [r1]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018CA4: .4byte gBattlescriptCurrInstr\n\ _08018CA8: .4byte BattleScript_FlashFireBoost_PPLoss\n\ _08018CAC: .4byte gBattleMons\n\ @@ -3402,178 +3402,178 @@ _08018CB0: .4byte gProtectStructs\n\ _08018CB4: .4byte gBankAttacker\n\ _08018CB8: .4byte BattleScript_MoveHPDrain_FullHP\n\ _08018CBC:\n\ - ldr r1, _08018CC8 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018CCC @ =BattleScript_MoveHPDrain_FullHP_PPLoss\n\ - str r0, [r1]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + ldr r1, _08018CC8 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018CCC @ =BattleScript_MoveHPDrain_FullHP_PPLoss\n\ + str r0, [r1]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018CC8: .4byte gBattlescriptCurrInstr\n\ _08018CCC: .4byte BattleScript_MoveHPDrain_FullHP_PPLoss\n\ _08018CD0:\n\ - ldr r2, _08018CEC @ =gBattleMoveDamage\n\ - ldrh r0, [r1, 0x2C]\n\ - lsrs r0, 2\n\ - str r0, [r2]\n\ - cmp r0, 0\n\ - bne _08018CE0\n\ - mov r3, r9\n\ - str r3, [r2]\n\ + ldr r2, _08018CEC @ =gBattleMoveDamage\n\ + ldrh r0, [r1, 0x2C]\n\ + lsrs r0, 2\n\ + str r0, [r2]\n\ + cmp r0, 0\n\ + bne _08018CE0\n\ + mov r3, r9\n\ + str r3, [r2]\n\ _08018CE0:\n\ - ldr r0, [r2]\n\ - negs r0, r0\n\ - str r0, [r2]\n\ - bl _08019F76\n\ - .align 2, 0\n\ + ldr r0, [r2]\n\ + negs r0, r0\n\ + str r0, [r2]\n\ + bl _08019F76\n\ + .align 2, 0\n\ _08018CEC: .4byte gBattleMoveDamage\n\ _08018CF0:\n\ - mov r5, r8\n\ - ldrb r0, [r5]\n\ - subs r0, 0x9\n\ - cmp r0, 0x2F\n\ - bls _08018CFE\n\ - bl _08019F76\n\ + mov r5, r8\n\ + ldrb r0, [r5]\n\ + subs r0, 0x9\n\ + cmp r0, 0x2F\n\ + bls _08018CFE\n\ + bl _08019F76\n\ _08018CFE:\n\ - lsls r0, 2\n\ - ldr r1, _08018D08 @ =_08018D0C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ + lsls r0, 2\n\ + ldr r1, _08018D08 @ =_08018D0C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ _08018D08: .4byte _08018D0C\n\ - .align 2, 0\n\ + .align 2, 0\n\ _08018D0C:\n\ - .4byte _08019128\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08018DCC\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08018E94\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08018F54\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _0801904C\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019204\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _08019F76\n\ - .4byte _080192E0\n\ + .4byte _08019128\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08018DCC\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08018E94\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08018F54\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _0801904C\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019204\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _08019F76\n\ + .4byte _080192E0\n\ _08018DCC:\n\ - ldr r0, _08018E74 @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018DDC\n\ - bl _08019F76\n\ + ldr r0, _08018E74 @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018DDC\n\ + bl _08019F76\n\ _08018DDC:\n\ - cmp r3, 0xA5\n\ - bne _08018DE4\n\ - bl _08019F76\n\ + cmp r3, 0xA5\n\ + bne _08018DE4\n\ + bl _08019F76\n\ _08018DE4:\n\ - ldr r0, _08018E78 @ =gBattleMoves\n\ - lsls r1, r3, 1\n\ - adds r1, r3\n\ - lsls r1, 2\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - cmp r0, 0\n\ - bne _08018DF8\n\ - bl _08019F76\n\ + ldr r0, _08018E78 @ =gBattleMoves\n\ + lsls r1, r3, 1\n\ + adds r1, r3\n\ + lsls r1, 2\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + cmp r0, 0\n\ + bne _08018DF8\n\ + bl _08019F76\n\ _08018DF8:\n\ - ldr r2, _08018E7C @ =gSpecialStatuses\n\ - ldr r0, _08018E80 @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018E20\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018E20\n\ - bl _08019F76\n\ + ldr r2, _08018E7C @ =gSpecialStatuses\n\ + ldr r0, _08018E80 @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018E20\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018E20\n\ + bl _08019F76\n\ _08018E20:\n\ - ldr r1, _08018E84 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r2, r10\n\ - muls r2, r0\n\ - adds r0, r2, 0\n\ - adds r1, r0, r1\n\ - adds r3, r1, 0\n\ - adds r3, 0x21\n\ - ldrb r0, [r3]\n\ - cmp r0, r4\n\ - bne _08018E3A\n\ - bl _08019F76\n\ + ldr r1, _08018E84 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r2, r10\n\ + muls r2, r0\n\ + adds r0, r2, 0\n\ + adds r1, r0, r1\n\ + adds r3, r1, 0\n\ + adds r3, 0x21\n\ + ldrb r0, [r3]\n\ + cmp r0, r4\n\ + bne _08018E3A\n\ + bl _08019F76\n\ _08018E3A:\n\ - adds r2, r1, 0\n\ - adds r2, 0x22\n\ - ldrb r0, [r2]\n\ - cmp r0, r4\n\ - bne _08018E48\n\ - bl _08019F76\n\ + adds r2, r1, 0\n\ + adds r2, 0x22\n\ + ldrb r0, [r2]\n\ + cmp r0, r4\n\ + bne _08018E48\n\ + bl _08019F76\n\ _08018E48:\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - bne _08018E52\n\ - bl _08019F76\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + bne _08018E52\n\ + bl _08019F76\n\ _08018E52:\n\ - strb r4, [r3]\n\ - strb r4, [r2]\n\ - ldr r1, _08018E88 @ =gBattleTextBuff1\n\ - movs r0, 0xFD\n\ - strb r0, [r1]\n\ - movs r0, 0x3\n\ - strb r0, [r1, 0x1]\n\ - strb r4, [r1, 0x2]\n\ - movs r0, 0xFF\n\ - strb r0, [r1, 0x3]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08018E8C @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018E90 @ =BattleScript_ColorChangeActivates\n\ - str r0, [r1]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + strb r4, [r3]\n\ + strb r4, [r2]\n\ + ldr r1, _08018E88 @ =gBattleTextBuff1\n\ + movs r0, 0xFD\n\ + strb r0, [r1]\n\ + movs r0, 0x3\n\ + strb r0, [r1, 0x1]\n\ + strb r4, [r1, 0x2]\n\ + movs r0, 0xFF\n\ + strb r0, [r1, 0x3]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08018E8C @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018E90 @ =BattleScript_ColorChangeActivates\n\ + str r0, [r1]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08018E74: .4byte gBattleMoveFlags\n\ _08018E78: .4byte gBattleMoves\n\ _08018E7C: .4byte gSpecialStatuses\n\ @@ -3583,81 +3583,81 @@ _08018E88: .4byte gBattleTextBuff1\n\ _08018E8C: .4byte gBattlescriptCurrInstr\n\ _08018E90: .4byte BattleScript_ColorChangeActivates\n\ _08018E94:\n\ - ldr r0, _08018F2C @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018EA4\n\ - bl _08019F76\n\ + ldr r0, _08018F2C @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018EA4\n\ + bl _08019F76\n\ _08018EA4:\n\ - ldr r1, _08018F30 @ =gBattleMons\n\ - ldr r0, _08018F34 @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r4, r0, r1\n\ - ldrh r0, [r4, 0x28]\n\ - cmp r0, 0\n\ - bne _08018EBA\n\ - bl _08019F76\n\ + ldr r1, _08018F30 @ =gBattleMons\n\ + ldr r0, _08018F34 @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r4, r0, r1\n\ + ldrh r0, [r4, 0x28]\n\ + cmp r0, 0\n\ + bne _08018EBA\n\ + bl _08019F76\n\ _08018EBA:\n\ - ldr r0, _08018F38 @ =gProtectStructs\n\ - lsls r1, r2, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _08018ECC\n\ - bl _08019F76\n\ + ldr r0, _08018F38 @ =gProtectStructs\n\ + lsls r1, r2, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _08018ECC\n\ + bl _08019F76\n\ _08018ECC:\n\ - ldr r2, _08018F3C @ =gSpecialStatuses\n\ - ldr r0, _08018F40 @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018EF4\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018EF4\n\ - bl _08019F76\n\ + ldr r2, _08018F3C @ =gSpecialStatuses\n\ + ldr r0, _08018F40 @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018EF4\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018EF4\n\ + bl _08019F76\n\ _08018EF4:\n\ - ldr r1, _08018F44 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r2, 0x1\n\ - adds r0, r2, 0\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08018F0E\n\ - bl _08019F76\n\ + ldr r1, _08018F44 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r2, 0x1\n\ + adds r0, r2, 0\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _08018F0E\n\ + bl _08019F76\n\ _08018F0E:\n\ - ldr r1, _08018F48 @ =gBattleMoveDamage\n\ - ldrh r0, [r4, 0x2C]\n\ - lsrs r0, 4\n\ - str r0, [r1]\n\ - cmp r0, 0\n\ - bne _08018F1C\n\ - str r2, [r1]\n\ + ldr r1, _08018F48 @ =gBattleMoveDamage\n\ + ldrh r0, [r4, 0x2C]\n\ + lsrs r0, 4\n\ + str r0, [r1]\n\ + cmp r0, 0\n\ + bne _08018F1C\n\ + str r2, [r1]\n\ _08018F1C:\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08018F4C @ =gBattlescriptCurrInstr\n\ - ldr r0, _08018F50 @ =BattleScript_RoughSkinActivates\n\ - str r0, [r1]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08018F4C @ =gBattlescriptCurrInstr\n\ + ldr r0, _08018F50 @ =BattleScript_RoughSkinActivates\n\ + str r0, [r1]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08018F2C: .4byte gBattleMoveFlags\n\ _08018F30: .4byte gBattleMons\n\ _08018F34: .4byte gBankAttacker\n\ @@ -3669,106 +3669,106 @@ _08018F48: .4byte gBattleMoveDamage\n\ _08018F4C: .4byte gBattlescriptCurrInstr\n\ _08018F50: .4byte BattleScript_RoughSkinActivates\n\ _08018F54:\n\ - ldr r0, _08019020 @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08018F64\n\ - bl _08019F76\n\ + ldr r0, _08019020 @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08018F64\n\ + bl _08019F76\n\ _08018F64:\n\ - ldr r1, _08019024 @ =gBattleMons\n\ - ldr r0, _08019028 @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r0, r1\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _08018F7A\n\ - bl _08019F76\n\ + ldr r1, _08019024 @ =gBattleMons\n\ + ldr r0, _08019028 @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r0, r1\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _08018F7A\n\ + bl _08019F76\n\ _08018F7A:\n\ - ldr r0, _0801902C @ =gProtectStructs\n\ - lsls r1, r2, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _08018F8C\n\ - bl _08019F76\n\ + ldr r0, _0801902C @ =gProtectStructs\n\ + lsls r1, r2, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _08018F8C\n\ + bl _08019F76\n\ _08018F8C:\n\ - ldr r2, _08019030 @ =gSpecialStatuses\n\ - ldr r0, _08019034 @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018FB4\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08018FB4\n\ - bl _08019F76\n\ + ldr r2, _08019030 @ =gSpecialStatuses\n\ + ldr r0, _08019034 @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018FB4\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08018FB4\n\ + bl _08019F76\n\ _08018FB4:\n\ - ldr r1, _08019038 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08018FCC\n\ - bl _08019F76\n\ + ldr r1, _08019038 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _08018FCC\n\ + bl _08019F76\n\ _08018FCC:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0xA\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - beq _08018FE4\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0xA\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + beq _08018FE4\n\ + bl _08019F76\n\ _08018FE4:\n\ - ldr r5, _0801903C @ =gBattleCommunication\n\ - movs r4, 0x3\n\ + ldr r5, _0801903C @ =gBattleCommunication\n\ + movs r4, 0x3\n\ _08018FE8:\n\ - bl Random\n\ - ands r0, r4\n\ - strb r0, [r5, 0x3]\n\ - cmp r0, 0\n\ - beq _08018FE8\n\ - ldr r1, _0801903C @ =gBattleCommunication\n\ - ldrb r0, [r1, 0x3]\n\ - cmp r0, 0x3\n\ - bne _08019000\n\ - adds r0, 0x2\n\ - strb r0, [r1, 0x3]\n\ + bl Random\n\ + ands r0, r4\n\ + strb r0, [r5, 0x3]\n\ + cmp r0, 0\n\ + beq _08018FE8\n\ + ldr r1, _0801903C @ =gBattleCommunication\n\ + ldrb r0, [r1, 0x3]\n\ + cmp r0, 0x3\n\ + bne _08019000\n\ + adds r0, 0x2\n\ + strb r0, [r1, 0x3]\n\ _08019000:\n\ - ldrb r0, [r1, 0x3]\n\ - adds r0, 0x40\n\ - strb r0, [r1, 0x3]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08019040 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08019044 @ =BattleScript_ApplySecondaryEffect\n\ - str r0, [r1]\n\ - ldr r2, _08019048 @ =gHitMarker\n\ - ldr r0, [r2]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r2]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldrb r0, [r1, 0x3]\n\ + adds r0, 0x40\n\ + strb r0, [r1, 0x3]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08019040 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08019044 @ =BattleScript_ApplySecondaryEffect\n\ + str r0, [r1]\n\ + ldr r2, _08019048 @ =gHitMarker\n\ + ldr r0, [r2]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r2]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08019020: .4byte gBattleMoveFlags\n\ _08019024: .4byte gBattleMons\n\ _08019028: .4byte gBankAttacker\n\ @@ -3781,91 +3781,91 @@ _08019040: .4byte gBattlescriptCurrInstr\n\ _08019044: .4byte BattleScript_ApplySecondaryEffect\n\ _08019048: .4byte gHitMarker\n\ _0801904C:\n\ - ldr r0, _080190FC @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _0801905C\n\ - bl _08019F76\n\ + ldr r0, _080190FC @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _0801905C\n\ + bl _08019F76\n\ _0801905C:\n\ - ldr r1, _08019100 @ =gBattleMons\n\ - ldr r0, _08019104 @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r0, r1\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _08019072\n\ - bl _08019F76\n\ + ldr r1, _08019100 @ =gBattleMons\n\ + ldr r0, _08019104 @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r0, r1\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _08019072\n\ + bl _08019F76\n\ _08019072:\n\ - ldr r0, _08019108 @ =gProtectStructs\n\ - lsls r1, r2, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _08019084\n\ - bl _08019F76\n\ + ldr r0, _08019108 @ =gProtectStructs\n\ + lsls r1, r2, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _08019084\n\ + bl _08019F76\n\ _08019084:\n\ - ldr r2, _0801910C @ =gSpecialStatuses\n\ - ldr r0, _08019110 @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _080190AC\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _080190AC\n\ - bl _08019F76\n\ + ldr r2, _0801910C @ =gSpecialStatuses\n\ + ldr r0, _08019110 @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _080190AC\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _080190AC\n\ + bl _08019F76\n\ _080190AC:\n\ - ldr r1, _08019114 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080190C4\n\ - bl _08019F76\n\ + ldr r1, _08019114 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080190C4\n\ + bl _08019F76\n\ _080190C4:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0x3\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - beq _080190DC\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0x3\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + beq _080190DC\n\ + bl _08019F76\n\ _080190DC:\n\ - ldr r1, _08019118 @ =gBattleCommunication\n\ - movs r0, 0x42\n\ - strb r0, [r1, 0x3]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _0801911C @ =gBattlescriptCurrInstr\n\ - ldr r0, _08019120 @ =BattleScript_ApplySecondaryEffect\n\ - str r0, [r1]\n\ - ldr r2, _08019124 @ =gHitMarker\n\ - ldr r0, [r2]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r2]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldr r1, _08019118 @ =gBattleCommunication\n\ + movs r0, 0x42\n\ + strb r0, [r1, 0x3]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _0801911C @ =gBattlescriptCurrInstr\n\ + ldr r0, _08019120 @ =BattleScript_ApplySecondaryEffect\n\ + str r0, [r1]\n\ + ldr r2, _08019124 @ =gHitMarker\n\ + ldr r0, [r2]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r2]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080190FC: .4byte gBattleMoveFlags\n\ _08019100: .4byte gBattleMons\n\ _08019104: .4byte gBankAttacker\n\ @@ -3878,91 +3878,91 @@ _0801911C: .4byte gBattlescriptCurrInstr\n\ _08019120: .4byte BattleScript_ApplySecondaryEffect\n\ _08019124: .4byte gHitMarker\n\ _08019128:\n\ - ldr r0, _080191D8 @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08019138\n\ - bl _08019F76\n\ + ldr r0, _080191D8 @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08019138\n\ + bl _08019F76\n\ _08019138:\n\ - ldr r1, _080191DC @ =gBattleMons\n\ - ldr r0, _080191E0 @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r0, r1\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _0801914E\n\ - bl _08019F76\n\ + ldr r1, _080191DC @ =gBattleMons\n\ + ldr r0, _080191E0 @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r0, r1\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _0801914E\n\ + bl _08019F76\n\ _0801914E:\n\ - ldr r0, _080191E4 @ =gProtectStructs\n\ - lsls r1, r2, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _08019160\n\ - bl _08019F76\n\ + ldr r0, _080191E4 @ =gProtectStructs\n\ + lsls r1, r2, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _08019160\n\ + bl _08019F76\n\ _08019160:\n\ - ldr r2, _080191E8 @ =gSpecialStatuses\n\ - ldr r0, _080191EC @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08019188\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _08019188\n\ - bl _08019F76\n\ + ldr r2, _080191E8 @ =gSpecialStatuses\n\ + ldr r0, _080191EC @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08019188\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _08019188\n\ + bl _08019F76\n\ _08019188:\n\ - ldr r1, _080191F0 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080191A0\n\ - bl _08019F76\n\ + ldr r1, _080191F0 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080191A0\n\ + bl _08019F76\n\ _080191A0:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0x3\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - beq _080191B8\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0x3\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + beq _080191B8\n\ + bl _08019F76\n\ _080191B8:\n\ - ldr r1, _080191F4 @ =gBattleCommunication\n\ - movs r0, 0x45\n\ - strb r0, [r1, 0x3]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _080191F8 @ =gBattlescriptCurrInstr\n\ - ldr r0, _080191FC @ =BattleScript_ApplySecondaryEffect\n\ - str r0, [r1]\n\ - ldr r2, _08019200 @ =gHitMarker\n\ - ldr r0, [r2]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r2]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldr r1, _080191F4 @ =gBattleCommunication\n\ + movs r0, 0x45\n\ + strb r0, [r1, 0x3]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _080191F8 @ =gBattlescriptCurrInstr\n\ + ldr r0, _080191FC @ =BattleScript_ApplySecondaryEffect\n\ + str r0, [r1]\n\ + ldr r2, _08019200 @ =gHitMarker\n\ + ldr r0, [r2]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r2]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080191D8: .4byte gBattleMoveFlags\n\ _080191DC: .4byte gBattleMons\n\ _080191E0: .4byte gBankAttacker\n\ @@ -3975,91 +3975,91 @@ _080191F8: .4byte gBattlescriptCurrInstr\n\ _080191FC: .4byte BattleScript_ApplySecondaryEffect\n\ _08019200: .4byte gHitMarker\n\ _08019204:\n\ - ldr r0, _080192B4 @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _08019214\n\ - bl _08019F76\n\ + ldr r0, _080192B4 @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _08019214\n\ + bl _08019F76\n\ _08019214:\n\ - ldr r1, _080192B8 @ =gBattleMons\n\ - ldr r0, _080192BC @ =gBankAttacker\n\ - ldrb r2, [r0]\n\ - movs r0, 0x58\n\ - muls r0, r2\n\ - adds r0, r1\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _0801922A\n\ - bl _08019F76\n\ + ldr r1, _080192B8 @ =gBattleMons\n\ + ldr r0, _080192BC @ =gBankAttacker\n\ + ldrb r2, [r0]\n\ + movs r0, 0x58\n\ + muls r0, r2\n\ + adds r0, r1\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _0801922A\n\ + bl _08019F76\n\ _0801922A:\n\ - ldr r0, _080192C0 @ =gProtectStructs\n\ - lsls r1, r2, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _0801923C\n\ - bl _08019F76\n\ + ldr r0, _080192C0 @ =gProtectStructs\n\ + lsls r1, r2, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _0801923C\n\ + bl _08019F76\n\ _0801923C:\n\ - ldr r1, _080192C4 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08019254\n\ - bl _08019F76\n\ + ldr r1, _080192C4 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _08019254\n\ + bl _08019F76\n\ _08019254:\n\ - ldr r2, _080192C8 @ =gSpecialStatuses\n\ - ldr r0, _080192CC @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r1, r0, 2\n\ - adds r0, r2, 0\n\ - adds r0, 0x8\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _0801927C\n\ - adds r0, r2, 0\n\ - adds r0, 0xC\n\ - adds r0, r1, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _0801927C\n\ - bl _08019F76\n\ + ldr r2, _080192C8 @ =gSpecialStatuses\n\ + ldr r0, _080192CC @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r1, r0, 2\n\ + adds r0, r2, 0\n\ + adds r0, 0x8\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _0801927C\n\ + adds r0, r2, 0\n\ + adds r0, 0xC\n\ + adds r0, r1, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _0801927C\n\ + bl _08019F76\n\ _0801927C:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0x3\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - beq _08019294\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0x3\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + beq _08019294\n\ + bl _08019F76\n\ _08019294:\n\ - ldr r1, _080192D0 @ =gBattleCommunication\n\ - movs r0, 0x43\n\ - strb r0, [r1, 0x3]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _080192D4 @ =gBattlescriptCurrInstr\n\ - ldr r0, _080192D8 @ =BattleScript_ApplySecondaryEffect\n\ - str r0, [r1]\n\ - ldr r2, _080192DC @ =gHitMarker\n\ - ldr r0, [r2]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r2]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldr r1, _080192D0 @ =gBattleCommunication\n\ + movs r0, 0x43\n\ + strb r0, [r1, 0x3]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _080192D4 @ =gBattlescriptCurrInstr\n\ + ldr r0, _080192D8 @ =BattleScript_ApplySecondaryEffect\n\ + str r0, [r1]\n\ + ldr r2, _080192DC @ =gHitMarker\n\ + ldr r0, [r2]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r2]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _080192B4: .4byte gBattleMoveFlags\n\ _080192B8: .4byte gBattleMons\n\ _080192BC: .4byte gBankAttacker\n\ @@ -4072,159 +4072,159 @@ _080192D4: .4byte gBattlescriptCurrInstr\n\ _080192D8: .4byte BattleScript_ApplySecondaryEffect\n\ _080192DC: .4byte gHitMarker\n\ _080192E0:\n\ - ldr r0, _08019420 @ =gBattleMoveFlags\n\ - ldrb r1, [r0]\n\ - movs r0, 0x29\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080192F0\n\ - bl _08019F76\n\ + ldr r0, _08019420 @ =gBattleMoveFlags\n\ + ldrb r1, [r0]\n\ + movs r0, 0x29\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080192F0\n\ + bl _08019F76\n\ _080192F0:\n\ - ldr r5, _08019424 @ =gBattleMons\n\ - ldr r7, _08019428 @ =gBankAttacker\n\ - ldrb r1, [r7]\n\ - movs r6, 0x58\n\ - adds r0, r1, 0\n\ - muls r0, r6\n\ - adds r0, r5\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _08019308\n\ - bl _08019F76\n\ + ldr r5, _08019424 @ =gBattleMons\n\ + ldr r7, _08019428 @ =gBankAttacker\n\ + ldrb r1, [r7]\n\ + movs r6, 0x58\n\ + adds r0, r1, 0\n\ + muls r0, r6\n\ + adds r0, r5\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _08019308\n\ + bl _08019F76\n\ _08019308:\n\ - ldr r0, _0801942C @ =gProtectStructs\n\ - lsls r1, 4\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x1]\n\ - lsls r0, 31\n\ - cmp r0, 0\n\ - beq _0801931A\n\ - bl _08019F76\n\ + ldr r0, _0801942C @ =gProtectStructs\n\ + lsls r1, 4\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x1]\n\ + lsls r0, 31\n\ + cmp r0, 0\n\ + beq _0801931A\n\ + bl _08019F76\n\ _0801931A:\n\ - ldr r1, _08019430 @ =gBattleMoves\n\ - lsls r0, r3, 1\n\ - adds r0, r3\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r1, [r0, 0x8]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _08019332\n\ - bl _08019F76\n\ + ldr r1, _08019430 @ =gBattleMoves\n\ + lsls r0, r3, 1\n\ + adds r0, r3\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r1, [r0, 0x8]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _08019332\n\ + bl _08019F76\n\ _08019332:\n\ - ldr r3, _08019434 @ =gSpecialStatuses\n\ - ldr r0, _08019438 @ =gBankTarget\n\ - mov r8, r0\n\ - ldrb r1, [r0]\n\ - lsls r0, r1, 2\n\ - adds r0, r1\n\ - lsls r2, r0, 2\n\ - adds r0, r3, 0\n\ - adds r0, 0x8\n\ - adds r0, r2, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _0801935C\n\ - adds r0, r3, 0\n\ - adds r0, 0xC\n\ - adds r0, r2, r0\n\ - ldr r0, [r0]\n\ - cmp r0, 0\n\ - bne _0801935C\n\ - bl _08019F76\n\ + ldr r3, _08019434 @ =gSpecialStatuses\n\ + ldr r0, _08019438 @ =gBankTarget\n\ + mov r8, r0\n\ + ldrb r1, [r0]\n\ + lsls r0, r1, 2\n\ + adds r0, r1\n\ + lsls r2, r0, 2\n\ + adds r0, r3, 0\n\ + adds r0, 0x8\n\ + adds r0, r2, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _0801935C\n\ + adds r0, r3, 0\n\ + adds r0, 0xC\n\ + adds r0, r2, r0\n\ + ldr r0, [r0]\n\ + cmp r0, 0\n\ + bne _0801935C\n\ + bl _08019F76\n\ _0801935C:\n\ - adds r0, r1, 0\n\ - muls r0, r6\n\ - adds r0, r5\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - bne _0801936C\n\ - bl _08019F76\n\ + adds r0, r1, 0\n\ + muls r0, r6\n\ + adds r0, r5\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + bne _0801936C\n\ + bl _08019F76\n\ _0801936C:\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0x3\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - beq _08019384\n\ - bl _08019F76\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0x3\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + beq _08019384\n\ + bl _08019F76\n\ _08019384:\n\ - ldrb r0, [r7]\n\ - muls r0, r6\n\ - adds r0, r5\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0xC\n\ - bne _08019396\n\ - bl _08019F76\n\ + ldrb r0, [r7]\n\ + muls r0, r6\n\ + adds r0, r5\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0xC\n\ + bne _08019396\n\ + bl _08019F76\n\ _08019396:\n\ - ldr r0, [sp, 0x8]\n\ - ldr r1, [sp, 0x10]\n\ - bl GetGenderFromSpeciesAndPersonality\n\ - adds r4, r0, 0\n\ - ldr r0, [sp, 0xC]\n\ - ldr r1, [sp, 0x14]\n\ - bl GetGenderFromSpeciesAndPersonality\n\ - lsls r4, 24\n\ - lsls r0, 24\n\ - cmp r4, r0\n\ - bne _080193B4\n\ - bl _08019F76\n\ + ldr r0, [sp, 0x8]\n\ + ldr r1, [sp, 0x10]\n\ + bl GetGenderFromSpeciesAndPersonality\n\ + adds r4, r0, 0\n\ + ldr r0, [sp, 0xC]\n\ + ldr r1, [sp, 0x14]\n\ + bl GetGenderFromSpeciesAndPersonality\n\ + lsls r4, 24\n\ + lsls r0, 24\n\ + cmp r4, r0\n\ + bne _080193B4\n\ + bl _08019F76\n\ _080193B4:\n\ - ldrb r0, [r7]\n\ - muls r0, r6\n\ - adds r4, r5, 0\n\ - adds r4, 0x50\n\ - adds r0, r4\n\ - ldr r0, [r0]\n\ - movs r1, 0xF0\n\ - lsls r1, 12\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080193CE\n\ - bl _08019F76\n\ + ldrb r0, [r7]\n\ + muls r0, r6\n\ + adds r4, r5, 0\n\ + adds r4, 0x50\n\ + adds r0, r4\n\ + ldr r0, [r0]\n\ + movs r1, 0xF0\n\ + lsls r1, 12\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080193CE\n\ + bl _08019F76\n\ _080193CE:\n\ - ldr r0, [sp, 0x8]\n\ - ldr r1, [sp, 0x10]\n\ - bl GetGenderFromSpeciesAndPersonality\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0xFF\n\ - bne _080193E2\n\ - bl _08019F76\n\ + ldr r0, [sp, 0x8]\n\ + ldr r1, [sp, 0x10]\n\ + bl GetGenderFromSpeciesAndPersonality\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0xFF\n\ + bne _080193E2\n\ + bl _08019F76\n\ _080193E2:\n\ - ldr r0, [sp, 0xC]\n\ - ldr r1, [sp, 0x14]\n\ - bl GetGenderFromSpeciesAndPersonality\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0xFF\n\ - bne _080193F6\n\ - bl _08019F76\n\ + ldr r0, [sp, 0xC]\n\ + ldr r1, [sp, 0x14]\n\ + bl GetGenderFromSpeciesAndPersonality\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0xFF\n\ + bne _080193F6\n\ + bl _08019F76\n\ _080193F6:\n\ - ldrb r0, [r7]\n\ - adds r2, r0, 0\n\ - muls r2, r6\n\ - adds r2, r4\n\ - ldr r1, _0801943C @ =gBitTable\n\ - mov r3, r8\n\ - ldrb r0, [r3]\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldr r1, [r0]\n\ - lsls r1, 16\n\ - ldr r0, [r2]\n\ - orrs r0, r1\n\ - str r0, [r2]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08019440 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08019444 @ =BattleScript_CuteCharmActivates\n\ - str r0, [r1]\n\ - bl _08019F22\n\ - .align 2, 0\n\ + ldrb r0, [r7]\n\ + adds r2, r0, 0\n\ + muls r2, r6\n\ + adds r2, r4\n\ + ldr r1, _0801943C @ =gBitTable\n\ + mov r3, r8\n\ + ldrb r0, [r3]\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldr r1, [r0]\n\ + lsls r1, 16\n\ + ldr r0, [r2]\n\ + orrs r0, r1\n\ + str r0, [r2]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08019440 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08019444 @ =BattleScript_CuteCharmActivates\n\ + str r0, [r1]\n\ + bl _08019F22\n\ + .align 2, 0\n\ _08019420: .4byte gBattleMoveFlags\n\ _08019424: .4byte gBattleMons\n\ _08019428: .4byte gBankAttacker\n\ @@ -4236,347 +4236,347 @@ _0801943C: .4byte gBitTable\n\ _08019440: .4byte gBattlescriptCurrInstr\n\ _08019444: .4byte BattleScript_CuteCharmActivates\n\ _08019448:\n\ - movs r5, 0\n\ - mov r10, r5\n\ - ldr r0, _0801947C @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r10, r0\n\ - bcc _08019458\n\ - bl _08019F76\n\ + movs r5, 0\n\ + mov r10, r5\n\ + ldr r0, _0801947C @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r10, r0\n\ + bcc _08019458\n\ + bl _08019F76\n\ _08019458:\n\ - ldr r1, _08019480 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r2, r10\n\ - muls r2, r0\n\ - adds r0, r2, 0\n\ - adds r0, r1\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - subs r0, 0x7\n\ - adds r2, r1, 0\n\ - cmp r0, 0x41\n\ - bls _08019472\n\ - b _080196D6\n\ + ldr r1, _08019480 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r2, r10\n\ + muls r2, r0\n\ + adds r0, r2, 0\n\ + adds r0, r1\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + subs r0, 0x7\n\ + adds r2, r1, 0\n\ + cmp r0, 0x41\n\ + bls _08019472\n\ + b _080196D6\n\ _08019472:\n\ - lsls r0, 2\n\ - ldr r1, _08019484 @ =_08019488\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - mov pc, r0\n\ - .align 2, 0\n\ + lsls r0, 2\n\ + ldr r1, _08019484 @ =_08019488\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + mov pc, r0\n\ + .align 2, 0\n\ _0801947C: .4byte gNoOfAllBanks\n\ _08019480: .4byte gBattleMons\n\ _08019484: .4byte _08019488\n\ - .align 2, 0\n\ + .align 2, 0\n\ _08019488:\n\ - .4byte _080195EC\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196B0\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _08019614\n\ - .4byte _080196D6\n\ - .4byte _08019590\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080195BC\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _08019680\n\ - .4byte _08019650\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _080196D6\n\ - .4byte _08019614\n\ + .4byte _080195EC\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196B0\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _08019614\n\ + .4byte _080196D6\n\ + .4byte _08019590\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080195BC\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _08019680\n\ + .4byte _08019650\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _080196D6\n\ + .4byte _08019614\n\ _08019590:\n\ - movs r0, 0x58\n\ - mov r3, r10\n\ - muls r3, r0\n\ - adds r0, r3, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x4C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - ldr r1, _080195B0 @ =0x00000f88\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080195AA\n\ - b _080196D6\n\ + movs r0, 0x58\n\ + mov r3, r10\n\ + muls r3, r0\n\ + adds r0, r3, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x4C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + ldr r1, _080195B0 @ =0x00000f88\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080195AA\n\ + b _080196D6\n\ _080195AA:\n\ - ldr r0, _080195B4 @ =gBattleTextBuff1\n\ - ldr r1, _080195B8 @ =gStatusConditionString_PoisonJpn\n\ - b _0801969C\n\ - .align 2, 0\n\ + ldr r0, _080195B4 @ =gBattleTextBuff1\n\ + ldr r1, _080195B8 @ =gStatusConditionString_PoisonJpn\n\ + b _0801969C\n\ + .align 2, 0\n\ _080195B0: .4byte 0x00000f88\n\ _080195B4: .4byte gBattleTextBuff1\n\ _080195B8: .4byte gStatusConditionString_PoisonJpn\n\ _080195BC:\n\ - movs r0, 0x58\n\ - mov r1, r10\n\ - muls r1, r0\n\ - adds r0, r1, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x50\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080195D6\n\ - b _080196D6\n\ + movs r0, 0x58\n\ + mov r1, r10\n\ + muls r1, r0\n\ + adds r0, r1, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x50\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080195D6\n\ + b _080196D6\n\ _080195D6:\n\ - ldr r0, _080195E4 @ =gBattleTextBuff1\n\ - ldr r1, _080195E8 @ =gStatusConditionString_ConfusionJpn\n\ - bl StringCopy\n\ - movs r2, 0x2\n\ - mov r9, r2\n\ - b _080196DC\n\ - .align 2, 0\n\ + ldr r0, _080195E4 @ =gBattleTextBuff1\n\ + ldr r1, _080195E8 @ =gStatusConditionString_ConfusionJpn\n\ + bl StringCopy\n\ + movs r2, 0x2\n\ + mov r9, r2\n\ + b _080196DC\n\ + .align 2, 0\n\ _080195E4: .4byte gBattleTextBuff1\n\ _080195E8: .4byte gStatusConditionString_ConfusionJpn\n\ _080195EC:\n\ - movs r0, 0x58\n\ - mov r3, r10\n\ - muls r3, r0\n\ - adds r0, r3, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x4C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x40\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080196D6\n\ - ldr r0, _0801960C @ =gBattleTextBuff1\n\ - ldr r1, _08019610 @ =gStatusConditionString_ParalysisJpn\n\ - b _0801969C\n\ - .align 2, 0\n\ + movs r0, 0x58\n\ + mov r3, r10\n\ + muls r3, r0\n\ + adds r0, r3, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x4C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x40\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080196D6\n\ + ldr r0, _0801960C @ =gBattleTextBuff1\n\ + ldr r1, _08019610 @ =gStatusConditionString_ParalysisJpn\n\ + b _0801969C\n\ + .align 2, 0\n\ _0801960C: .4byte gBattleTextBuff1\n\ _08019610: .4byte gStatusConditionString_ParalysisJpn\n\ _08019614:\n\ - movs r0, 0x58\n\ - mov r3, r10\n\ - muls r3, r0\n\ - adds r0, r2, 0\n\ - adds r0, 0x4C\n\ - adds r0, r3, r0\n\ - ldr r0, [r0]\n\ - movs r1, 0x7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080196D6\n\ - adds r2, 0x50\n\ - adds r2, r3, r2\n\ - ldr r0, [r2]\n\ - ldr r1, _08019644 @ =0xf7ffffff\n\ - ands r0, r1\n\ - str r0, [r2]\n\ - ldr r0, _08019648 @ =gBattleTextBuff1\n\ - ldr r1, _0801964C @ =gStatusConditionString_SleepJpn\n\ - bl StringCopy\n\ - movs r0, 0x1\n\ - mov r9, r0\n\ - b _080196DC\n\ - .align 2, 0\n\ + movs r0, 0x58\n\ + mov r3, r10\n\ + muls r3, r0\n\ + adds r0, r2, 0\n\ + adds r0, 0x4C\n\ + adds r0, r3, r0\n\ + ldr r0, [r0]\n\ + movs r1, 0x7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080196D6\n\ + adds r2, 0x50\n\ + adds r2, r3, r2\n\ + ldr r0, [r2]\n\ + ldr r1, _08019644 @ =0xf7ffffff\n\ + ands r0, r1\n\ + str r0, [r2]\n\ + ldr r0, _08019648 @ =gBattleTextBuff1\n\ + ldr r1, _0801964C @ =gStatusConditionString_SleepJpn\n\ + bl StringCopy\n\ + movs r0, 0x1\n\ + mov r9, r0\n\ + b _080196DC\n\ + .align 2, 0\n\ _08019644: .4byte 0xf7ffffff\n\ _08019648: .4byte gBattleTextBuff1\n\ _0801964C: .4byte gStatusConditionString_SleepJpn\n\ _08019650:\n\ - movs r0, 0x58\n\ - mov r1, r10\n\ - muls r1, r0\n\ - adds r0, r1, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x4C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x10\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080196D6\n\ - ldr r0, _08019678 @ =gBattleTextBuff1\n\ - ldr r1, _0801967C @ =gStatusConditionString_BurnJpn\n\ - bl StringCopy\n\ - movs r2, 0x1\n\ - mov r9, r2\n\ - b _080196DC\n\ - .align 2, 0\n\ + movs r0, 0x58\n\ + mov r1, r10\n\ + muls r1, r0\n\ + adds r0, r1, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x4C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x10\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080196D6\n\ + ldr r0, _08019678 @ =gBattleTextBuff1\n\ + ldr r1, _0801967C @ =gStatusConditionString_BurnJpn\n\ + bl StringCopy\n\ + movs r2, 0x1\n\ + mov r9, r2\n\ + b _080196DC\n\ + .align 2, 0\n\ _08019678: .4byte gBattleTextBuff1\n\ _0801967C: .4byte gStatusConditionString_BurnJpn\n\ _08019680:\n\ - movs r0, 0x58\n\ - mov r3, r10\n\ - muls r3, r0\n\ - adds r0, r3, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x4C\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0x20\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080196D6\n\ - ldr r0, _080196A8 @ =gBattleTextBuff1\n\ - ldr r1, _080196AC @ =gStatusConditionString_IceJpn\n\ + movs r0, 0x58\n\ + mov r3, r10\n\ + muls r3, r0\n\ + adds r0, r3, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x4C\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0x20\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080196D6\n\ + ldr r0, _080196A8 @ =gBattleTextBuff1\n\ + ldr r1, _080196AC @ =gStatusConditionString_IceJpn\n\ _0801969C:\n\ - bl StringCopy\n\ - movs r5, 0x1\n\ - mov r9, r5\n\ - b _080196DC\n\ - .align 2, 0\n\ + bl StringCopy\n\ + movs r5, 0x1\n\ + mov r9, r5\n\ + b _080196DC\n\ + .align 2, 0\n\ _080196A8: .4byte gBattleTextBuff1\n\ _080196AC: .4byte gStatusConditionString_IceJpn\n\ _080196B0:\n\ - movs r0, 0x58\n\ - mov r1, r10\n\ - muls r1, r0\n\ - adds r0, r1, 0\n\ - adds r1, r2, 0\n\ - adds r1, 0x50\n\ - adds r0, r1\n\ - ldr r0, [r0]\n\ - movs r1, 0xF0\n\ - lsls r1, 12\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080196D6\n\ - ldr r0, _080196EC @ =gBattleTextBuff1\n\ - ldr r1, _080196F0 @ =gStatusConditionString_LoveJpn\n\ - bl StringCopy\n\ - movs r2, 0x3\n\ - mov r9, r2\n\ + movs r0, 0x58\n\ + mov r1, r10\n\ + muls r1, r0\n\ + adds r0, r1, 0\n\ + adds r1, r2, 0\n\ + adds r1, 0x50\n\ + adds r0, r1\n\ + ldr r0, [r0]\n\ + movs r1, 0xF0\n\ + lsls r1, 12\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080196D6\n\ + ldr r0, _080196EC @ =gBattleTextBuff1\n\ + ldr r1, _080196F0 @ =gStatusConditionString_LoveJpn\n\ + bl StringCopy\n\ + movs r2, 0x3\n\ + mov r9, r2\n\ _080196D6:\n\ - mov r3, r9\n\ - cmp r3, 0\n\ - beq _08019798\n\ + mov r3, r9\n\ + cmp r3, 0\n\ + beq _08019798\n\ _080196DC:\n\ - mov r5, r9\n\ - cmp r5, 0x2\n\ - beq _08019710\n\ - cmp r5, 0x2\n\ - bgt _080196F4\n\ - cmp r5, 0x1\n\ - beq _080196FC\n\ - b _0801973C\n\ - .align 2, 0\n\ + mov r5, r9\n\ + cmp r5, 0x2\n\ + beq _08019710\n\ + cmp r5, 0x2\n\ + bgt _080196F4\n\ + cmp r5, 0x1\n\ + beq _080196FC\n\ + b _0801973C\n\ + .align 2, 0\n\ _080196EC: .4byte gBattleTextBuff1\n\ _080196F0: .4byte gStatusConditionString_LoveJpn\n\ _080196F4:\n\ - mov r0, r9\n\ - cmp r0, 0x3\n\ - beq _08019728\n\ - b _0801973C\n\ + mov r0, r9\n\ + cmp r0, 0x3\n\ + beq _08019728\n\ + b _0801973C\n\ _080196FC:\n\ - ldr r1, _0801970C @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r2, r10\n\ - muls r2, r0\n\ - adds r1, 0x4C\n\ - adds r2, r1\n\ - movs r0, 0\n\ - b _0801973A\n\ - .align 2, 0\n\ + ldr r1, _0801970C @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r2, r10\n\ + muls r2, r0\n\ + adds r1, 0x4C\n\ + adds r2, r1\n\ + movs r0, 0\n\ + b _0801973A\n\ + .align 2, 0\n\ _0801970C: .4byte gBattleMons\n\ _08019710:\n\ - ldr r1, _08019724 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r2, r10\n\ - muls r2, r0\n\ - adds r1, 0x50\n\ - adds r2, r1\n\ - ldr r0, [r2]\n\ - movs r1, 0x8\n\ - negs r1, r1\n\ - b _08019738\n\ - .align 2, 0\n\ + ldr r1, _08019724 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r2, r10\n\ + muls r2, r0\n\ + adds r1, 0x50\n\ + adds r2, r1\n\ + ldr r0, [r2]\n\ + movs r1, 0x8\n\ + negs r1, r1\n\ + b _08019738\n\ + .align 2, 0\n\ _08019724: .4byte gBattleMons\n\ _08019728:\n\ - ldr r1, _08019778 @ =gBattleMons\n\ - movs r0, 0x58\n\ - mov r2, r10\n\ - muls r2, r0\n\ - adds r1, 0x50\n\ - adds r2, r1\n\ - ldr r0, [r2]\n\ - ldr r1, _0801977C @ =0xfff0ffff\n\ + ldr r1, _08019778 @ =gBattleMons\n\ + movs r0, 0x58\n\ + mov r2, r10\n\ + muls r2, r0\n\ + adds r1, 0x50\n\ + adds r2, r1\n\ + ldr r0, [r2]\n\ + ldr r1, _0801977C @ =0xfff0ffff\n\ _08019738:\n\ - ands r0, r1\n\ + ands r0, r1\n\ _0801973A:\n\ - str r0, [r2]\n\ + str r0, [r2]\n\ _0801973C:\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08019780 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08019784 @ =gUnknown_081D9956\n\ - str r0, [r1]\n\ - ldr r0, _08019788 @ =0x02000000\n\ - ldr r1, _0801978C @ =0x00016003\n\ - adds r0, r1\n\ - mov r2, r10\n\ - strb r2, [r0]\n\ - ldr r4, _08019790 @ =gActiveBank\n\ - strb r2, [r4]\n\ - ldrb r1, [r4]\n\ - movs r0, 0x58\n\ - muls r0, r1\n\ - ldr r1, _08019794 @ =gUnknown_02024ACC\n\ - adds r0, r1\n\ - str r0, [sp]\n\ - movs r0, 0\n\ - movs r1, 0x28\n\ - movs r2, 0\n\ - movs r3, 0x4\n\ - bl EmitSetAttributes\n\ - ldrb r0, [r4]\n\ - bl MarkBufferBankForExecution\n\ - bl _08019F92\n\ - .align 2, 0\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08019780 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08019784 @ =gUnknown_081D9956\n\ + str r0, [r1]\n\ + ldr r0, _08019788 @ =0x02000000\n\ + ldr r1, _0801978C @ =0x00016003\n\ + adds r0, r1\n\ + mov r2, r10\n\ + strb r2, [r0]\n\ + ldr r4, _08019790 @ =gActiveBank\n\ + strb r2, [r4]\n\ + ldrb r1, [r4]\n\ + movs r0, 0x58\n\ + muls r0, r1\n\ + ldr r1, _08019794 @ =gUnknown_02024ACC\n\ + adds r0, r1\n\ + str r0, [sp]\n\ + movs r0, 0\n\ + movs r1, 0x28\n\ + movs r2, 0\n\ + movs r3, 0x4\n\ + bl EmitSetAttributes\n\ + ldrb r0, [r4]\n\ + bl MarkBufferBankForExecution\n\ + bl _08019F92\n\ + .align 2, 0\n\ _08019778: .4byte gBattleMons\n\ _0801977C: .4byte 0xfff0ffff\n\ _08019780: .4byte gBattlescriptCurrInstr\n\ @@ -4586,112 +4586,112 @@ _0801978C: .4byte 0x00016003\n\ _08019790: .4byte gActiveBank\n\ _08019794: .4byte gUnknown_02024ACC\n\ _08019798:\n\ - mov r0, r10\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - ldr r0, _080197B0 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r10, r0\n\ - bcs _080197AC\n\ - b _08019458\n\ + mov r0, r10\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r10, r0\n\ + ldr r0, _080197B0 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r10, r0\n\ + bcs _080197AC\n\ + b _08019458\n\ _080197AC:\n\ - bl _08019F76\n\ - .align 2, 0\n\ + bl _08019F76\n\ + .align 2, 0\n\ _080197B0: .4byte gNoOfAllBanks\n\ _080197B4:\n\ - movs r3, 0\n\ - mov r10, r3\n\ - ldr r0, _080197FC @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r10, r0\n\ - bcc _080197C2\n\ - b _08019F76\n\ + movs r3, 0\n\ + mov r10, r3\n\ + ldr r0, _080197FC @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r10, r0\n\ + bcc _080197C2\n\ + b _08019F76\n\ _080197C2:\n\ - ldr r4, _08019800 @ =gBattleMons\n\ + ldr r4, _08019800 @ =gBattleMons\n\ _080197C4:\n\ - movs r0, 0x58\n\ - mov r5, r10\n\ - muls r5, r0\n\ - adds r0, r5, 0\n\ - adds r0, r4\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0x3B\n\ - bne _080197E8\n\ - mov r0, r10\n\ - bl CastformDataTypeChange\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ - cmp r0, 0\n\ - beq _080197E8\n\ - b _08019E40\n\ + movs r0, 0x58\n\ + mov r5, r10\n\ + muls r5, r0\n\ + adds r0, r5, 0\n\ + adds r0, r4\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0x3B\n\ + bne _080197E8\n\ + mov r0, r10\n\ + bl CastformDataTypeChange\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ + cmp r0, 0\n\ + beq _080197E8\n\ + b _08019E40\n\ _080197E8:\n\ - mov r0, r10\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - ldr r0, _080197FC @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r10, r0\n\ - bcc _080197C4\n\ - b _08019F76\n\ - .align 2, 0\n\ + mov r0, r10\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r10, r0\n\ + ldr r0, _080197FC @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r10, r0\n\ + bcc _080197C4\n\ + b _08019F76\n\ + .align 2, 0\n\ _080197FC: .4byte gNoOfAllBanks\n\ _08019800: .4byte gBattleMons\n\ _08019804:\n\ - mov r1, r8\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x1C\n\ - beq _0801980E\n\ - b _08019F76\n\ + mov r1, r8\n\ + ldrb r0, [r1]\n\ + cmp r0, 0x1C\n\ + beq _0801980E\n\ + b _08019F76\n\ _0801980E:\n\ - ldr r4, _08019860 @ =gHitMarker\n\ - ldr r1, [r4]\n\ - movs r0, 0x80\n\ - lsls r0, 7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801981E\n\ - b _08019F76\n\ + ldr r4, _08019860 @ =gHitMarker\n\ + ldr r1, [r4]\n\ + movs r0, 0x80\n\ + lsls r0, 7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801981E\n\ + b _08019F76\n\ _0801981E:\n\ - ldr r0, _08019864 @ =0xffffbfff\n\ - ands r1, r0\n\ - str r1, [r4]\n\ - ldr r3, _08019868 @ =0x000160ca\n\ - adds r2, r7, r3\n\ - ldrb r1, [r2]\n\ - movs r0, 0x3F\n\ - ands r0, r1\n\ - strb r0, [r2]\n\ - cmp r0, 0x6\n\ - bne _08019838\n\ - movs r0, 0x2\n\ - strb r0, [r2]\n\ + ldr r0, _08019864 @ =0xffffbfff\n\ + ands r1, r0\n\ + str r1, [r4]\n\ + ldr r3, _08019868 @ =0x000160ca\n\ + adds r2, r7, r3\n\ + ldrb r1, [r2]\n\ + movs r0, 0x3F\n\ + ands r0, r1\n\ + strb r0, [r2]\n\ + cmp r0, 0x6\n\ + bne _08019838\n\ + movs r0, 0x2\n\ + strb r0, [r2]\n\ _08019838:\n\ - ldr r1, _0801986C @ =gBattleCommunication\n\ - ldrb r0, [r2]\n\ - adds r0, 0x40\n\ - strb r0, [r1, 0x3]\n\ - ldr r0, _08019870 @ =gBankTarget\n\ - ldrb r1, [r0]\n\ - ldr r5, _08019874 @ =0x00016003\n\ - adds r0, r7, r5\n\ - strb r1, [r0]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08019878 @ =gBattlescriptCurrInstr\n\ - ldr r0, _0801987C @ =BattleScript_SynchronizeActivates\n\ - str r0, [r1]\n\ - ldr r0, [r4]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r4]\n\ - b _08019F22\n\ - .align 2, 0\n\ + ldr r1, _0801986C @ =gBattleCommunication\n\ + ldrb r0, [r2]\n\ + adds r0, 0x40\n\ + strb r0, [r1, 0x3]\n\ + ldr r0, _08019870 @ =gBankTarget\n\ + ldrb r1, [r0]\n\ + ldr r5, _08019874 @ =0x00016003\n\ + adds r0, r7, r5\n\ + strb r1, [r0]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08019878 @ =gBattlescriptCurrInstr\n\ + ldr r0, _0801987C @ =BattleScript_SynchronizeActivates\n\ + str r0, [r1]\n\ + ldr r0, [r4]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r4]\n\ + b _08019F22\n\ + .align 2, 0\n\ _08019860: .4byte gHitMarker\n\ _08019864: .4byte 0xffffbfff\n\ _08019868: .4byte 0x000160ca\n\ @@ -4701,54 +4701,54 @@ _08019874: .4byte 0x00016003\n\ _08019878: .4byte gBattlescriptCurrInstr\n\ _0801987C: .4byte BattleScript_SynchronizeActivates\n\ _08019880:\n\ - mov r1, r8\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x1C\n\ - beq _0801988A\n\ - b _08019F76\n\ + mov r1, r8\n\ + ldrb r0, [r1]\n\ + cmp r0, 0x1C\n\ + beq _0801988A\n\ + b _08019F76\n\ _0801988A:\n\ - ldr r4, _080198DC @ =gHitMarker\n\ - ldr r1, [r4]\n\ - movs r0, 0x80\n\ - lsls r0, 7\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _0801989A\n\ - b _08019F76\n\ + ldr r4, _080198DC @ =gHitMarker\n\ + ldr r1, [r4]\n\ + movs r0, 0x80\n\ + lsls r0, 7\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _0801989A\n\ + b _08019F76\n\ _0801989A:\n\ - ldr r0, _080198E0 @ =0xffffbfff\n\ - ands r1, r0\n\ - str r1, [r4]\n\ - ldr r3, _080198E4 @ =0x000160ca\n\ - adds r2, r7, r3\n\ - ldrb r1, [r2]\n\ - movs r0, 0x3F\n\ - ands r0, r1\n\ - strb r0, [r2]\n\ - cmp r0, 0x6\n\ - bne _080198B4\n\ - movs r0, 0x2\n\ - strb r0, [r2]\n\ + ldr r0, _080198E0 @ =0xffffbfff\n\ + ands r1, r0\n\ + str r1, [r4]\n\ + ldr r3, _080198E4 @ =0x000160ca\n\ + adds r2, r7, r3\n\ + ldrb r1, [r2]\n\ + movs r0, 0x3F\n\ + ands r0, r1\n\ + strb r0, [r2]\n\ + cmp r0, 0x6\n\ + bne _080198B4\n\ + movs r0, 0x2\n\ + strb r0, [r2]\n\ _080198B4:\n\ - ldr r1, _080198E8 @ =gBattleCommunication\n\ - ldrb r0, [r2]\n\ - strb r0, [r1, 0x3]\n\ - ldr r0, _080198EC @ =gBankAttacker\n\ - ldrb r1, [r0]\n\ - ldr r5, _080198F0 @ =0x00016003\n\ - adds r0, r7, r5\n\ - strb r1, [r0]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _080198F4 @ =gBattlescriptCurrInstr\n\ - ldr r0, _080198F8 @ =BattleScript_SynchronizeActivates\n\ - str r0, [r1]\n\ - ldr r0, [r4]\n\ - movs r1, 0x80\n\ - lsls r1, 6\n\ - orrs r0, r1\n\ - str r0, [r4]\n\ - b _08019F22\n\ - .align 2, 0\n\ + ldr r1, _080198E8 @ =gBattleCommunication\n\ + ldrb r0, [r2]\n\ + strb r0, [r1, 0x3]\n\ + ldr r0, _080198EC @ =gBankAttacker\n\ + ldrb r1, [r0]\n\ + ldr r5, _080198F0 @ =0x00016003\n\ + adds r0, r7, r5\n\ + strb r1, [r0]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _080198F4 @ =gBattlescriptCurrInstr\n\ + ldr r0, _080198F8 @ =BattleScript_SynchronizeActivates\n\ + str r0, [r1]\n\ + ldr r0, [r4]\n\ + movs r1, 0x80\n\ + lsls r1, 6\n\ + orrs r0, r1\n\ + str r0, [r4]\n\ + b _08019F22\n\ + .align 2, 0\n\ _080198DC: .4byte gHitMarker\n\ _080198E0: .4byte 0xffffbfff\n\ _080198E4: .4byte 0x000160ca\n\ @@ -4758,152 +4758,152 @@ _080198F0: .4byte 0x00016003\n\ _080198F4: .4byte gBattlescriptCurrInstr\n\ _080198F8: .4byte BattleScript_SynchronizeActivates\n\ _080198FC:\n\ - movs r4, 0\n\ - ldr r0, _08019934 @ =gNoOfAllBanks\n\ - ldrb r1, [r0]\n\ - cmp r4, r1\n\ - blt _08019908\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019934 @ =gNoOfAllBanks\n\ + ldrb r1, [r0]\n\ + cmp r4, r1\n\ + blt _08019908\n\ + b _08019F76\n\ _08019908:\n\ - ldr r0, _08019938 @ =gBattleMons\n\ - adds r5, r1, 0\n\ - ldr r2, _0801993C @ =gStatuses3\n\ - adds r3, r0, 0\n\ - adds r3, 0x20\n\ - movs r6, 0x80\n\ - lsls r6, 12\n\ + ldr r0, _08019938 @ =gBattleMons\n\ + adds r5, r1, 0\n\ + ldr r2, _0801993C @ =gStatuses3\n\ + adds r3, r0, 0\n\ + adds r3, 0x20\n\ + movs r6, 0x80\n\ + lsls r6, 12\n\ _08019916:\n\ - ldrb r1, [r3]\n\ - cmp r1, 0x16\n\ - bne _08019926\n\ - ldr r0, [r2]\n\ - ands r0, r6\n\ - cmp r0, 0\n\ - beq _08019926\n\ - b _08019E6C\n\ + ldrb r1, [r3]\n\ + cmp r1, 0x16\n\ + bne _08019926\n\ + ldr r0, [r2]\n\ + ands r0, r6\n\ + cmp r0, 0\n\ + beq _08019926\n\ + b _08019E6C\n\ _08019926:\n\ - adds r2, 0x4\n\ - adds r3, 0x58\n\ - adds r4, 0x1\n\ - cmp r4, r5\n\ - blt _08019916\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r2, 0x4\n\ + adds r3, 0x58\n\ + adds r4, 0x1\n\ + cmp r4, r5\n\ + blt _08019916\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019934: .4byte gNoOfAllBanks\n\ _08019938: .4byte gBattleMons\n\ _0801993C: .4byte gStatuses3\n\ _08019940:\n\ - movs r4, 0\n\ - ldr r0, _08019A1C @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _0801994C\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019A1C @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _0801994C\n\ + b _08019F76\n\ _0801994C:\n\ - ldr r0, _08019A20 @ =gActiveBank\n\ - mov r8, r0\n\ - ldr r1, _08019A24 @ =gBattleMons\n\ - adds r1, 0x20\n\ - str r1, [sp, 0x1C]\n\ - movs r2, 0\n\ - str r2, [sp, 0x20]\n\ + ldr r0, _08019A20 @ =gActiveBank\n\ + mov r8, r0\n\ + ldr r1, _08019A24 @ =gBattleMons\n\ + adds r1, 0x20\n\ + str r1, [sp, 0x1C]\n\ + movs r2, 0\n\ + str r2, [sp, 0x20]\n\ _0801995A:\n\ - ldr r3, [sp, 0x1C]\n\ - ldrb r0, [r3]\n\ - cmp r0, 0x24\n\ - beq _08019964\n\ - b _08019AF6\n\ + ldr r3, [sp, 0x1C]\n\ + ldrb r0, [r3]\n\ + cmp r0, 0x24\n\ + beq _08019964\n\ + b _08019AF6\n\ _08019964:\n\ - ldr r0, _08019A28 @ =gStatuses3\n\ - ldr r5, [sp, 0x20]\n\ - adds r0, r5, r0\n\ - ldr r1, [r0]\n\ - movs r0, 0x80\n\ - lsls r0, 13\n\ - ands r1, r0\n\ - str r5, [sp, 0x18]\n\ - cmp r1, 0\n\ - bne _0801997A\n\ - b _08019AF6\n\ + ldr r0, _08019A28 @ =gStatuses3\n\ + ldr r5, [sp, 0x20]\n\ + adds r0, r5, r0\n\ + ldr r1, [r0]\n\ + movs r0, 0x80\n\ + lsls r0, 13\n\ + ands r1, r0\n\ + str r5, [sp, 0x18]\n\ + cmp r1, 0\n\ + bne _0801997A\n\ + b _08019AF6\n\ _0801997A:\n\ - lsls r0, r4, 24\n\ - lsrs r0, 24\n\ - bl GetBankIdentity\n\ - movs r1, 0x1\n\ - adds r5, r0, 0\n\ - eors r5, r1\n\ - ands r5, r1\n\ - adds r0, r5, 0\n\ - bl GetBankByPlayerAI\n\ - lsls r0, 24\n\ - lsrs r6, r0, 24\n\ - adds r0, r5, 0x2\n\ - bl GetBankByPlayerAI\n\ - lsls r0, 24\n\ - lsrs r7, r0, 24\n\ - ldr r0, _08019A2C @ =gBattleTypeFlags\n\ - ldrh r1, [r0]\n\ - movs r2, 0x1\n\ - adds r0, r2, 0\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080199AE\n\ - b _08019ABC\n\ + lsls r0, r4, 24\n\ + lsrs r0, 24\n\ + bl GetBankIdentity\n\ + movs r1, 0x1\n\ + adds r5, r0, 0\n\ + eors r5, r1\n\ + ands r5, r1\n\ + adds r0, r5, 0\n\ + bl GetBankByPlayerAI\n\ + lsls r0, 24\n\ + lsrs r6, r0, 24\n\ + adds r0, r5, 0x2\n\ + bl GetBankByPlayerAI\n\ + lsls r0, 24\n\ + lsrs r7, r0, 24\n\ + ldr r0, _08019A2C @ =gBattleTypeFlags\n\ + ldrh r1, [r0]\n\ + movs r2, 0x1\n\ + adds r0, r2, 0\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080199AE\n\ + b _08019ABC\n\ _080199AE:\n\ - movs r1, 0x58\n\ - adds r0, r6, 0\n\ - muls r0, r1\n\ - ldr r3, _08019A24 @ =gBattleMons\n\ - adds r1, r0, r3\n\ - adds r0, r1, 0\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - beq _08019A78\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - beq _08019A34\n\ - movs r1, 0x58\n\ - adds r0, r7, 0\n\ - muls r0, r1\n\ - adds r1, r0, r3\n\ - adds r0, r1, 0\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - beq _08019A34\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - beq _08019A34\n\ - str r2, [sp, 0x24]\n\ - bl Random\n\ - ldr r2, [sp, 0x24]\n\ - adds r1, r2, 0\n\ - ands r1, r0\n\ - lsls r1, 1\n\ - orrs r5, r1\n\ - adds r0, r5, 0\n\ - bl GetBankByPlayerAI\n\ - mov r2, r8\n\ - strb r0, [r2]\n\ - ldrb r0, [r2]\n\ - movs r3, 0x58\n\ - muls r0, r3\n\ - ldr r5, _08019A24 @ =gBattleMons\n\ - adds r0, r5\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - ldr r1, [sp, 0x1C]\n\ - strb r0, [r1]\n\ - ldrb r0, [r2]\n\ - muls r0, r3\n\ - adds r0, r5\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - ldr r2, _08019A30 @ =gLastUsedAbility\n\ - strb r0, [r2]\n\ - b _08019AE4\n\ - .align 2, 0\n\ + movs r1, 0x58\n\ + adds r0, r6, 0\n\ + muls r0, r1\n\ + ldr r3, _08019A24 @ =gBattleMons\n\ + adds r1, r0, r3\n\ + adds r0, r1, 0\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0\n\ + beq _08019A78\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + beq _08019A34\n\ + movs r1, 0x58\n\ + adds r0, r7, 0\n\ + muls r0, r1\n\ + adds r1, r0, r3\n\ + adds r0, r1, 0\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0\n\ + beq _08019A34\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + beq _08019A34\n\ + str r2, [sp, 0x24]\n\ + bl Random\n\ + ldr r2, [sp, 0x24]\n\ + adds r1, r2, 0\n\ + ands r1, r0\n\ + lsls r1, 1\n\ + orrs r5, r1\n\ + adds r0, r5, 0\n\ + bl GetBankByPlayerAI\n\ + mov r2, r8\n\ + strb r0, [r2]\n\ + ldrb r0, [r2]\n\ + movs r3, 0x58\n\ + muls r0, r3\n\ + ldr r5, _08019A24 @ =gBattleMons\n\ + adds r0, r5\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + ldr r1, [sp, 0x1C]\n\ + strb r0, [r1]\n\ + ldrb r0, [r2]\n\ + muls r0, r3\n\ + adds r0, r5\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + ldr r2, _08019A30 @ =gLastUsedAbility\n\ + strb r0, [r2]\n\ + b _08019AE4\n\ + .align 2, 0\n\ _08019A1C: .4byte gNoOfAllBanks\n\ _08019A20: .4byte gActiveBank\n\ _08019A24: .4byte gBattleMons\n\ @@ -4911,609 +4911,609 @@ _08019A28: .4byte gStatuses3\n\ _08019A2C: .4byte gBattleTypeFlags\n\ _08019A30: .4byte gLastUsedAbility\n\ _08019A34:\n\ - ldr r3, _08019A74 @ =gBattleMons\n\ - movs r2, 0x58\n\ - adds r0, r6, 0\n\ - muls r0, r2\n\ - adds r1, r0, r3\n\ - adds r0, r1, 0\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - beq _08019A78\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - beq _08019A78\n\ - mov r5, r8\n\ - strb r6, [r5]\n\ - adds r1, r4, 0\n\ - muls r1, r2\n\ - adds r1, r3\n\ - ldrb r0, [r5]\n\ - muls r0, r2\n\ - adds r0, r3\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - adds r1, 0x20\n\ - strb r0, [r1]\n\ - ldrb r0, [r5]\n\ - muls r0, r2\n\ - adds r0, r3\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - b _08019AE0\n\ - .align 2, 0\n\ + ldr r3, _08019A74 @ =gBattleMons\n\ + movs r2, 0x58\n\ + adds r0, r6, 0\n\ + muls r0, r2\n\ + adds r1, r0, r3\n\ + adds r0, r1, 0\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0\n\ + beq _08019A78\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + beq _08019A78\n\ + mov r5, r8\n\ + strb r6, [r5]\n\ + adds r1, r4, 0\n\ + muls r1, r2\n\ + adds r1, r3\n\ + ldrb r0, [r5]\n\ + muls r0, r2\n\ + adds r0, r3\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + adds r1, 0x20\n\ + strb r0, [r1]\n\ + ldrb r0, [r5]\n\ + muls r0, r2\n\ + adds r0, r3\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + b _08019AE0\n\ + .align 2, 0\n\ _08019A74: .4byte gBattleMons\n\ _08019A78:\n\ - ldr r3, _08019AB8 @ =gBattleMons\n\ - movs r2, 0x58\n\ - adds r0, r7, 0\n\ - muls r0, r2\n\ - adds r1, r0, r3\n\ - adds r0, r1, 0\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - beq _08019AEE\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - beq _08019AEE\n\ - mov r5, r8\n\ - strb r7, [r5]\n\ - adds r1, r4, 0\n\ - muls r1, r2\n\ - adds r1, r3\n\ - ldrb r0, [r5]\n\ - muls r0, r2\n\ - adds r0, r3\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - adds r1, 0x20\n\ - strb r0, [r1]\n\ - ldrb r0, [r5]\n\ - muls r0, r2\n\ - adds r0, r3\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - b _08019AE0\n\ - .align 2, 0\n\ + ldr r3, _08019AB8 @ =gBattleMons\n\ + movs r2, 0x58\n\ + adds r0, r7, 0\n\ + muls r0, r2\n\ + adds r1, r0, r3\n\ + adds r0, r1, 0\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, 0\n\ + beq _08019AEE\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + beq _08019AEE\n\ + mov r5, r8\n\ + strb r7, [r5]\n\ + adds r1, r4, 0\n\ + muls r1, r2\n\ + adds r1, r3\n\ + ldrb r0, [r5]\n\ + muls r0, r2\n\ + adds r0, r3\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + adds r1, 0x20\n\ + strb r0, [r1]\n\ + ldrb r0, [r5]\n\ + muls r0, r2\n\ + adds r0, r3\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + b _08019AE0\n\ + .align 2, 0\n\ _08019AB8: .4byte gBattleMons\n\ _08019ABC:\n\ - mov r2, r8\n\ - strb r6, [r2]\n\ - movs r3, 0x58\n\ - adds r0, r6, 0\n\ - muls r0, r3\n\ - ldr r5, _08019B10 @ =gBattleMons\n\ - adds r0, r5\n\ - adds r2, r0, 0\n\ - adds r2, 0x20\n\ - ldrb r1, [r2]\n\ - cmp r1, 0\n\ - beq _08019AEE\n\ - ldrh r0, [r0, 0x28]\n\ - cmp r0, 0\n\ - beq _08019AEE\n\ - ldr r0, [sp, 0x1C]\n\ - strb r1, [r0]\n\ - ldrb r0, [r2]\n\ + mov r2, r8\n\ + strb r6, [r2]\n\ + movs r3, 0x58\n\ + adds r0, r6, 0\n\ + muls r0, r3\n\ + ldr r5, _08019B10 @ =gBattleMons\n\ + adds r0, r5\n\ + adds r2, r0, 0\n\ + adds r2, 0x20\n\ + ldrb r1, [r2]\n\ + cmp r1, 0\n\ + beq _08019AEE\n\ + ldrh r0, [r0, 0x28]\n\ + cmp r0, 0\n\ + beq _08019AEE\n\ + ldr r0, [sp, 0x1C]\n\ + strb r1, [r0]\n\ + ldrb r0, [r2]\n\ _08019AE0:\n\ - ldr r1, _08019B14 @ =gLastUsedAbility\n\ - strb r0, [r1]\n\ + ldr r1, _08019B14 @ =gLastUsedAbility\n\ + strb r0, [r1]\n\ _08019AE4:\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019AEE:\n\ - mov r2, r9\n\ - cmp r2, 0\n\ - beq _08019AF6\n\ - b _08019E88\n\ + mov r2, r9\n\ + cmp r2, 0\n\ + beq _08019AF6\n\ + b _08019E88\n\ _08019AF6:\n\ - ldr r3, [sp, 0x1C]\n\ - adds r3, 0x58\n\ - str r3, [sp, 0x1C]\n\ - ldr r5, [sp, 0x20]\n\ - adds r5, 0x4\n\ - str r5, [sp, 0x20]\n\ - adds r4, 0x1\n\ - ldr r0, _08019B18 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - bge _08019B0E\n\ - b _0801995A\n\ + ldr r3, [sp, 0x1C]\n\ + adds r3, 0x58\n\ + str r3, [sp, 0x1C]\n\ + ldr r5, [sp, 0x20]\n\ + adds r5, 0x4\n\ + str r5, [sp, 0x20]\n\ + adds r4, 0x1\n\ + ldr r0, _08019B18 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + bge _08019B0E\n\ + b _0801995A\n\ _08019B0E:\n\ - b _08019F76\n\ - .align 2, 0\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019B10: .4byte gBattleMons\n\ _08019B14: .4byte gLastUsedAbility\n\ _08019B18: .4byte gNoOfAllBanks\n\ _08019B1C:\n\ - movs r4, 0\n\ - ldr r0, _08019B54 @ =gNoOfAllBanks\n\ - ldrb r1, [r0]\n\ - cmp r4, r1\n\ - blt _08019B28\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019B54 @ =gNoOfAllBanks\n\ + ldrb r1, [r0]\n\ + cmp r4, r1\n\ + blt _08019B28\n\ + b _08019F76\n\ _08019B28:\n\ - ldr r0, _08019B58 @ =gBattleMons\n\ - adds r5, r1, 0\n\ - ldr r2, _08019B5C @ =gStatuses3\n\ - adds r3, r0, 0\n\ - adds r3, 0x20\n\ - movs r6, 0x80\n\ - lsls r6, 12\n\ + ldr r0, _08019B58 @ =gBattleMons\n\ + adds r5, r1, 0\n\ + ldr r2, _08019B5C @ =gStatuses3\n\ + adds r3, r0, 0\n\ + adds r3, 0x20\n\ + movs r6, 0x80\n\ + lsls r6, 12\n\ _08019B36:\n\ - ldrb r1, [r3]\n\ - cmp r1, 0x16\n\ - bne _08019B46\n\ - ldr r0, [r2]\n\ - ands r0, r6\n\ - cmp r0, 0\n\ - beq _08019B46\n\ - b _08019F04\n\ + ldrb r1, [r3]\n\ + cmp r1, 0x16\n\ + bne _08019B46\n\ + ldr r0, [r2]\n\ + ands r0, r6\n\ + cmp r0, 0\n\ + beq _08019B46\n\ + b _08019F04\n\ _08019B46:\n\ - adds r2, 0x4\n\ - adds r3, 0x58\n\ - adds r4, 0x1\n\ - cmp r4, r5\n\ - blt _08019B36\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r2, 0x4\n\ + adds r3, 0x58\n\ + adds r4, 0x1\n\ + cmp r4, r5\n\ + blt _08019B36\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019B54: .4byte gNoOfAllBanks\n\ _08019B58: .4byte gBattleMons\n\ _08019B5C: .4byte gStatuses3\n\ _08019B60:\n\ - mov r0, r10\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - movs r4, 0\n\ - ldr r0, _08019BB0 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019B76\n\ - b _08019F76\n\ + mov r0, r10\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + movs r4, 0\n\ + ldr r0, _08019BB0 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019B76\n\ + b _08019F76\n\ _08019B76:\n\ - ldr r7, _08019BB4 @ =gBattleMons\n\ + ldr r7, _08019BB4 @ =gBattleMons\n\ _08019B78:\n\ - lsls r0, r4, 24\n\ - lsrs r0, 24\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r3, r4, 0x1\n\ - cmp r0, r5\n\ - beq _08019BA2\n\ - movs r0, 0x58\n\ - muls r0, r4\n\ - adds r0, r7\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, r6\n\ - bne _08019BA2\n\ - ldr r0, _08019BB8 @ =gLastUsedAbility\n\ - strb r6, [r0]\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 24\n\ + lsrs r0, 24\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + adds r3, r4, 0x1\n\ + cmp r0, r5\n\ + beq _08019BA2\n\ + movs r0, 0x58\n\ + muls r0, r4\n\ + adds r0, r7\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, r6\n\ + bne _08019BA2\n\ + ldr r0, _08019BB8 @ =gLastUsedAbility\n\ + strb r6, [r0]\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019BA2:\n\ - adds r4, r3, 0\n\ - ldr r0, _08019BB0 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019B78\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + ldr r0, _08019BB0 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019B78\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019BB0: .4byte gNoOfAllBanks\n\ _08019BB4: .4byte gBattleMons\n\ _08019BB8: .4byte gLastUsedAbility\n\ _08019BBC:\n\ - mov r0, r10\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - movs r4, 0\n\ - ldr r0, _08019C0C @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019BD2\n\ - b _08019F76\n\ + mov r0, r10\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + movs r4, 0\n\ + ldr r0, _08019C0C @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019BD2\n\ + b _08019F76\n\ _08019BD2:\n\ - ldr r7, _08019C10 @ =gBattleMons\n\ + ldr r7, _08019C10 @ =gBattleMons\n\ _08019BD4:\n\ - lsls r0, r4, 24\n\ - lsrs r0, 24\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r3, r4, 0x1\n\ - cmp r0, r5\n\ - bne _08019BFE\n\ - movs r0, 0x58\n\ - muls r0, r4\n\ - adds r0, r7\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, r6\n\ - bne _08019BFE\n\ - ldr r0, _08019C14 @ =gLastUsedAbility\n\ - strb r6, [r0]\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 24\n\ + lsrs r0, 24\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + adds r3, r4, 0x1\n\ + cmp r0, r5\n\ + bne _08019BFE\n\ + movs r0, 0x58\n\ + muls r0, r4\n\ + adds r0, r7\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, r6\n\ + bne _08019BFE\n\ + ldr r0, _08019C14 @ =gLastUsedAbility\n\ + strb r6, [r0]\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019BFE:\n\ - adds r4, r3, 0\n\ - ldr r0, _08019C0C @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019BD4\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + ldr r0, _08019C0C @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019BD4\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019C0C: .4byte gNoOfAllBanks\n\ _08019C10: .4byte gBattleMons\n\ _08019C14: .4byte gLastUsedAbility\n\ _08019C18:\n\ - mov r1, r8\n\ - ldrb r0, [r1]\n\ - cmp r0, 0xFD\n\ - beq _08019C40\n\ - cmp r0, 0xFE\n\ - beq _08019C78\n\ - movs r4, 0\n\ - ldr r0, _08019C38 @ =gNoOfAllBanks\n\ - adds r5, r0, 0\n\ - ldrb r2, [r5]\n\ - cmp r4, r2\n\ - blt _08019C32\n\ - b _08019F76\n\ + mov r1, r8\n\ + ldrb r0, [r1]\n\ + cmp r0, 0xFD\n\ + beq _08019C40\n\ + cmp r0, 0xFE\n\ + beq _08019C78\n\ + movs r4, 0\n\ + ldr r0, _08019C38 @ =gNoOfAllBanks\n\ + adds r5, r0, 0\n\ + ldrb r2, [r5]\n\ + cmp r4, r2\n\ + blt _08019C32\n\ + b _08019F76\n\ _08019C32:\n\ - ldr r2, _08019C3C @ =gBattleMons\n\ - b _08019CB0\n\ - .align 2, 0\n\ + ldr r2, _08019C3C @ =gBattleMons\n\ + b _08019CB0\n\ + .align 2, 0\n\ _08019C38: .4byte gNoOfAllBanks\n\ _08019C3C: .4byte gBattleMons\n\ _08019C40:\n\ - movs r4, 0\n\ - ldr r0, _08019C70 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019C4C\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019C70 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019C4C\n\ + b _08019F76\n\ _08019C4C:\n\ - ldr r5, _08019C74 @ =gStatuses3\n\ - movs r2, 0x80\n\ - lsls r2, 9\n\ - adds r1, r0, 0\n\ + ldr r5, _08019C74 @ =gStatuses3\n\ + movs r2, 0x80\n\ + lsls r2, 9\n\ + adds r1, r0, 0\n\ _08019C54:\n\ - lsls r0, r4, 2\n\ - adds r0, r5\n\ - ldr r0, [r0]\n\ - ands r0, r2\n\ - adds r3, r4, 0x1\n\ - cmp r0, 0\n\ - beq _08019C68\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 2\n\ + adds r0, r5\n\ + ldr r0, [r0]\n\ + ands r0, r2\n\ + adds r3, r4, 0x1\n\ + cmp r0, 0\n\ + beq _08019C68\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019C68:\n\ - adds r4, r3, 0\n\ - cmp r4, r1\n\ - blt _08019C54\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + cmp r4, r1\n\ + blt _08019C54\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019C70: .4byte gNoOfAllBanks\n\ _08019C74: .4byte gStatuses3\n\ _08019C78:\n\ - movs r4, 0\n\ - ldr r0, _08019CA8 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019C84\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019CA8 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019C84\n\ + b _08019F76\n\ _08019C84:\n\ - ldr r5, _08019CAC @ =gStatuses3\n\ - movs r2, 0x80\n\ - lsls r2, 10\n\ - adds r1, r0, 0\n\ + ldr r5, _08019CAC @ =gStatuses3\n\ + movs r2, 0x80\n\ + lsls r2, 10\n\ + adds r1, r0, 0\n\ _08019C8C:\n\ - lsls r0, r4, 2\n\ - adds r0, r5\n\ - ldr r0, [r0]\n\ - ands r0, r2\n\ - adds r3, r4, 0x1\n\ - cmp r0, 0\n\ - beq _08019CA0\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 2\n\ + adds r0, r5\n\ + ldr r0, [r0]\n\ + ands r0, r2\n\ + adds r3, r4, 0x1\n\ + cmp r0, 0\n\ + beq _08019CA0\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019CA0:\n\ - adds r4, r3, 0\n\ - cmp r4, r1\n\ - blt _08019C8C\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + cmp r4, r1\n\ + blt _08019C8C\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019CA8: .4byte gNoOfAllBanks\n\ _08019CAC: .4byte gStatuses3\n\ _08019CB0:\n\ - movs r0, 0x58\n\ - muls r0, r4\n\ - adds r0, r2\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - adds r3, r4, 0x1\n\ - cmp r0, r6\n\ - bne _08019CCA\n\ - mov r0, r8\n\ - strb r6, [r0]\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + movs r0, 0x58\n\ + muls r0, r4\n\ + adds r0, r2\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + adds r3, r4, 0x1\n\ + cmp r0, r6\n\ + bne _08019CCA\n\ + mov r0, r8\n\ + strb r6, [r0]\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019CCA:\n\ - adds r4, r3, 0\n\ - ldrb r1, [r5]\n\ - cmp r4, r1\n\ - blt _08019CB0\n\ - b _08019F76\n\ + adds r4, r3, 0\n\ + ldrb r1, [r5]\n\ + cmp r4, r1\n\ + blt _08019CB0\n\ + b _08019F76\n\ _08019CD4:\n\ - movs r4, 0\n\ - ldr r0, _08019D10 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019CE0\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019D10 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019CE0\n\ + b _08019F76\n\ _08019CE0:\n\ - ldr r7, _08019D14 @ =gBattleMons\n\ - adds r2, r0, 0\n\ - movs r5, 0x58\n\ + ldr r7, _08019D14 @ =gBattleMons\n\ + adds r2, r0, 0\n\ + movs r5, 0x58\n\ _08019CE6:\n\ - adds r0, r4, 0\n\ - muls r0, r5\n\ - adds r1, r0, r7\n\ - adds r0, r1, 0\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - adds r3, r4, 0x1\n\ - cmp r0, r6\n\ - bne _08019D08\n\ - ldrh r0, [r1, 0x28]\n\ - cmp r0, 0\n\ - beq _08019D08\n\ - mov r0, r8\n\ - strb r6, [r0]\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + adds r0, r4, 0\n\ + muls r0, r5\n\ + adds r1, r0, r7\n\ + adds r0, r1, 0\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + adds r3, r4, 0x1\n\ + cmp r0, r6\n\ + bne _08019D08\n\ + ldrh r0, [r1, 0x28]\n\ + cmp r0, 0\n\ + beq _08019D08\n\ + mov r0, r8\n\ + strb r6, [r0]\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019D08:\n\ - adds r4, r3, 0\n\ - cmp r4, r2\n\ - blt _08019CE6\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + cmp r4, r2\n\ + blt _08019CE6\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019D10: .4byte gNoOfAllBanks\n\ _08019D14: .4byte gBattleMons\n\ _08019D18:\n\ - movs r4, 0\n\ - ldr r0, _08019D50 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019D24\n\ - b _08019F76\n\ + movs r4, 0\n\ + ldr r0, _08019D50 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019D24\n\ + b _08019F76\n\ _08019D24:\n\ - ldr r7, _08019D54 @ =gBattleMons\n\ - adds r1, r0, 0\n\ - movs r5, 0x58\n\ - ldr r2, _08019D58 @ =gLastUsedAbility\n\ + ldr r7, _08019D54 @ =gBattleMons\n\ + adds r1, r0, 0\n\ + movs r5, 0x58\n\ + ldr r2, _08019D58 @ =gLastUsedAbility\n\ _08019D2C:\n\ - adds r0, r4, 0\n\ - muls r0, r5\n\ - adds r0, r7\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - adds r3, r4, 0x1\n\ - cmp r0, r6\n\ - bne _08019D48\n\ - cmp r4, r10\n\ - beq _08019D48\n\ - strb r6, [r2]\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + adds r0, r4, 0\n\ + muls r0, r5\n\ + adds r0, r7\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + adds r3, r4, 0x1\n\ + cmp r0, r6\n\ + bne _08019D48\n\ + cmp r4, r10\n\ + beq _08019D48\n\ + strb r6, [r2]\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019D48:\n\ - adds r4, r3, 0\n\ - cmp r4, r1\n\ - blt _08019D2C\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, r3, 0\n\ + cmp r4, r1\n\ + blt _08019D2C\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019D50: .4byte gNoOfAllBanks\n\ _08019D54: .4byte gBattleMons\n\ _08019D58: .4byte gLastUsedAbility\n\ _08019D5C:\n\ - mov r0, r10\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - movs r4, 0\n\ - ldr r0, _08019DAC @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019D72\n\ - b _08019F76\n\ + mov r0, r10\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + movs r4, 0\n\ + ldr r0, _08019DAC @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019D72\n\ + b _08019F76\n\ _08019D72:\n\ - ldr r7, _08019DB0 @ =gBattleMons\n\ + ldr r7, _08019DB0 @ =gBattleMons\n\ _08019D74:\n\ - lsls r0, r4, 24\n\ - lsrs r0, 24\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, r5\n\ - beq _08019DA0\n\ - movs r0, 0x58\n\ - muls r0, r4\n\ - adds r0, r7\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, r6\n\ - bne _08019DA0\n\ - ldr r0, _08019DB4 @ =gLastUsedAbility\n\ - strb r6, [r0]\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 24\n\ + lsrs r0, 24\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, r5\n\ + beq _08019DA0\n\ + movs r0, 0x58\n\ + muls r0, r4\n\ + adds r0, r7\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, r6\n\ + bne _08019DA0\n\ + ldr r0, _08019DB4 @ =gLastUsedAbility\n\ + strb r6, [r0]\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019DA0:\n\ - adds r4, 0x1\n\ - ldr r0, _08019DAC @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019D74\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, 0x1\n\ + ldr r0, _08019DAC @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019D74\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019DAC: .4byte gNoOfAllBanks\n\ _08019DB0: .4byte gBattleMons\n\ _08019DB4: .4byte gLastUsedAbility\n\ _08019DB8:\n\ - mov r0, r10\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - movs r4, 0\n\ - ldr r0, _08019E08 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019DCE\n\ - b _08019F76\n\ + mov r0, r10\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + movs r4, 0\n\ + ldr r0, _08019E08 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019DCE\n\ + b _08019F76\n\ _08019DCE:\n\ - ldr r7, _08019E0C @ =gBattleMons\n\ + ldr r7, _08019E0C @ =gBattleMons\n\ _08019DD0:\n\ - lsls r0, r4, 24\n\ - lsrs r0, 24\n\ - bl GetBankSide\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, r5\n\ - bne _08019DFC\n\ - movs r0, 0x58\n\ - muls r0, r4\n\ - adds r0, r7\n\ - adds r0, 0x20\n\ - ldrb r0, [r0]\n\ - cmp r0, r6\n\ - bne _08019DFC\n\ - ldr r0, _08019E10 @ =gLastUsedAbility\n\ - strb r6, [r0]\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + lsls r0, r4, 24\n\ + lsrs r0, 24\n\ + bl GetBankSide\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, r5\n\ + bne _08019DFC\n\ + movs r0, 0x58\n\ + muls r0, r4\n\ + adds r0, r7\n\ + adds r0, 0x20\n\ + ldrb r0, [r0]\n\ + cmp r0, r6\n\ + bne _08019DFC\n\ + ldr r0, _08019E10 @ =gLastUsedAbility\n\ + strb r6, [r0]\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019DFC:\n\ - adds r4, 0x1\n\ - ldr r0, _08019E08 @ =gNoOfAllBanks\n\ - ldrb r0, [r0]\n\ - cmp r4, r0\n\ - blt _08019DD0\n\ - b _08019F76\n\ - .align 2, 0\n\ + adds r4, 0x1\n\ + ldr r0, _08019E08 @ =gNoOfAllBanks\n\ + ldrb r0, [r0]\n\ + cmp r4, r0\n\ + blt _08019DD0\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019E08: .4byte gNoOfAllBanks\n\ _08019E0C: .4byte gBattleMons\n\ _08019E10: .4byte gLastUsedAbility\n\ _08019E14:\n\ - ldr r0, _08019E30 @ =BattleScript_CastformChange\n\ - bl b_push_move_exec\n\ - ldr r0, _08019E34 @ =0x02000000\n\ - ldr r2, _08019E38 @ =0x00016003\n\ - adds r1, r0, r2\n\ - strb r6, [r1]\n\ - mov r1, r9\n\ - subs r1, 0x1\n\ - ldr r3, _08019E3C @ =0x0001609b\n\ - adds r0, r3\n\ - strb r1, [r0]\n\ - b _08019F76\n\ - .align 2, 0\n\ + ldr r0, _08019E30 @ =BattleScript_CastformChange\n\ + bl b_push_move_exec\n\ + ldr r0, _08019E34 @ =0x02000000\n\ + ldr r2, _08019E38 @ =0x00016003\n\ + adds r1, r0, r2\n\ + strb r6, [r1]\n\ + mov r1, r9\n\ + subs r1, 0x1\n\ + ldr r3, _08019E3C @ =0x0001609b\n\ + adds r0, r3\n\ + strb r1, [r0]\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019E30: .4byte BattleScript_CastformChange\n\ _08019E34: .4byte 0x02000000\n\ _08019E38: .4byte 0x00016003\n\ _08019E3C: .4byte 0x0001609b\n\ _08019E40:\n\ - ldr r0, _08019E5C @ =BattleScript_CastformChange\n\ - bl b_push_move_exec\n\ - ldr r0, _08019E60 @ =0x02000000\n\ - ldr r5, _08019E64 @ =0x00016003\n\ - adds r1, r0, r5\n\ - mov r2, r10\n\ - strb r2, [r1]\n\ - mov r1, r9\n\ - subs r1, 0x1\n\ - ldr r3, _08019E68 @ =0x0001609b\n\ - adds r0, r3\n\ - strb r1, [r0]\n\ - b _08019F92\n\ - .align 2, 0\n\ + ldr r0, _08019E5C @ =BattleScript_CastformChange\n\ + bl b_push_move_exec\n\ + ldr r0, _08019E60 @ =0x02000000\n\ + ldr r5, _08019E64 @ =0x00016003\n\ + adds r1, r0, r5\n\ + mov r2, r10\n\ + strb r2, [r1]\n\ + mov r1, r9\n\ + subs r1, 0x1\n\ + ldr r3, _08019E68 @ =0x0001609b\n\ + adds r0, r3\n\ + strb r1, [r0]\n\ + b _08019F92\n\ + .align 2, 0\n\ _08019E5C: .4byte BattleScript_CastformChange\n\ _08019E60: .4byte 0x02000000\n\ _08019E64: .4byte 0x00016003\n\ _08019E68: .4byte 0x0001609b\n\ _08019E6C:\n\ - mov r5, r8\n\ - strb r1, [r5]\n\ - ldr r0, [r2]\n\ - ldr r1, _08019E80 @ =0xfff7ffff\n\ - ands r0, r1\n\ - str r0, [r2]\n\ - ldr r0, _08019E84 @ =gUnknown_081D978C\n\ - bl b_push_move_exec\n\ - b _08019F1A\n\ - .align 2, 0\n\ + mov r5, r8\n\ + strb r1, [r5]\n\ + ldr r0, [r2]\n\ + ldr r1, _08019E80 @ =0xfff7ffff\n\ + ands r0, r1\n\ + str r0, [r2]\n\ + ldr r0, _08019E84 @ =gUnknown_081D978C\n\ + bl b_push_move_exec\n\ + b _08019F1A\n\ + .align 2, 0\n\ _08019E80: .4byte 0xfff7ffff\n\ _08019E84: .4byte gUnknown_081D978C\n\ _08019E88:\n\ - ldr r0, _08019EDC @ =BattleScript_TraceActivates\n\ - bl b_push_move_exec\n\ - ldr r1, _08019EE0 @ =gStatuses3\n\ - ldr r2, [sp, 0x18]\n\ - adds r1, r2, r1\n\ - ldr r0, [r1]\n\ - ldr r2, _08019EE4 @ =0xffefffff\n\ - ands r0, r2\n\ - str r0, [r1]\n\ - ldr r0, _08019EE8 @ =0x02000000\n\ - ldr r3, _08019EEC @ =0x00016003\n\ - adds r0, r3\n\ - strb r4, [r0]\n\ - ldr r1, _08019EF0 @ =gBattleTextBuff1\n\ - movs r4, 0xFD\n\ - strb r4, [r1]\n\ - movs r0, 0x4\n\ - strb r0, [r1, 0x1]\n\ - ldr r2, _08019EF4 @ =gActiveBank\n\ - ldrb r0, [r2]\n\ - strb r0, [r1, 0x2]\n\ - ldr r3, _08019EF8 @ =gBattlePartyID\n\ - ldrb r0, [r2]\n\ - lsls r0, 1\n\ - adds r0, r3\n\ - ldrh r0, [r0]\n\ - strb r0, [r1, 0x3]\n\ - movs r0, 0xFF\n\ - strb r0, [r1, 0x4]\n\ - ldr r1, _08019EFC @ =gBattleTextBuff2\n\ - strb r4, [r1]\n\ - movs r0, 0x9\n\ - strb r0, [r1, 0x1]\n\ - ldr r0, _08019F00 @ =gLastUsedAbility\n\ - ldrb r0, [r0]\n\ - strb r0, [r1, 0x2]\n\ - movs r0, 0x1\n\ - negs r0, r0\n\ - strb r0, [r1, 0x3]\n\ - b _08019F76\n\ - .align 2, 0\n\ + ldr r0, _08019EDC @ =BattleScript_TraceActivates\n\ + bl b_push_move_exec\n\ + ldr r1, _08019EE0 @ =gStatuses3\n\ + ldr r2, [sp, 0x18]\n\ + adds r1, r2, r1\n\ + ldr r0, [r1]\n\ + ldr r2, _08019EE4 @ =0xffefffff\n\ + ands r0, r2\n\ + str r0, [r1]\n\ + ldr r0, _08019EE8 @ =0x02000000\n\ + ldr r3, _08019EEC @ =0x00016003\n\ + adds r0, r3\n\ + strb r4, [r0]\n\ + ldr r1, _08019EF0 @ =gBattleTextBuff1\n\ + movs r4, 0xFD\n\ + strb r4, [r1]\n\ + movs r0, 0x4\n\ + strb r0, [r1, 0x1]\n\ + ldr r2, _08019EF4 @ =gActiveBank\n\ + ldrb r0, [r2]\n\ + strb r0, [r1, 0x2]\n\ + ldr r3, _08019EF8 @ =gBattlePartyID\n\ + ldrb r0, [r2]\n\ + lsls r0, 1\n\ + adds r0, r3\n\ + ldrh r0, [r0]\n\ + strb r0, [r1, 0x3]\n\ + movs r0, 0xFF\n\ + strb r0, [r1, 0x4]\n\ + ldr r1, _08019EFC @ =gBattleTextBuff2\n\ + strb r4, [r1]\n\ + movs r0, 0x9\n\ + strb r0, [r1, 0x1]\n\ + ldr r0, _08019F00 @ =gLastUsedAbility\n\ + ldrb r0, [r0]\n\ + strb r0, [r1, 0x2]\n\ + movs r0, 0x1\n\ + negs r0, r0\n\ + strb r0, [r1, 0x3]\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019EDC: .4byte BattleScript_TraceActivates\n\ _08019EE0: .4byte gStatuses3\n\ _08019EE4: .4byte 0xffefffff\n\ @@ -5525,88 +5525,88 @@ _08019EF8: .4byte gBattlePartyID\n\ _08019EFC: .4byte gBattleTextBuff2\n\ _08019F00: .4byte gLastUsedAbility\n\ _08019F04:\n\ - mov r5, r8\n\ - strb r1, [r5]\n\ - ldr r0, [r2]\n\ - ldr r1, _08019F30 @ =0xfff7ffff\n\ - ands r0, r1\n\ - str r0, [r2]\n\ - bl b_movescr_stack_push_cursor\n\ - ldr r1, _08019F34 @ =gBattlescriptCurrInstr\n\ - ldr r0, _08019F38 @ =gUnknown_081D9795\n\ - str r0, [r1]\n\ + mov r5, r8\n\ + strb r1, [r5]\n\ + ldr r0, [r2]\n\ + ldr r1, _08019F30 @ =0xfff7ffff\n\ + ands r0, r1\n\ + str r0, [r2]\n\ + bl b_movescr_stack_push_cursor\n\ + ldr r1, _08019F34 @ =gBattlescriptCurrInstr\n\ + ldr r0, _08019F38 @ =gUnknown_081D9795\n\ + str r0, [r1]\n\ _08019F1A:\n\ - ldr r0, _08019F3C @ =0x02000000\n\ - ldr r1, _08019F40 @ =0x000160dd\n\ - adds r0, r1\n\ - strb r4, [r0]\n\ + ldr r0, _08019F3C @ =0x02000000\n\ + ldr r1, _08019F40 @ =0x000160dd\n\ + adds r0, r1\n\ + strb r4, [r0]\n\ _08019F22:\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ - b _08019F76\n\ - .align 2, 0\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ + b _08019F76\n\ + .align 2, 0\n\ _08019F30: .4byte 0xfff7ffff\n\ _08019F34: .4byte gBattlescriptCurrInstr\n\ _08019F38: .4byte gUnknown_081D9795\n\ _08019F3C: .4byte 0x02000000\n\ _08019F40: .4byte 0x000160dd\n\ _08019F44:\n\ - movs r4, 0\n\ - ldr r0, _08019FA4 @ =gNoOfAllBanks\n\ - ldrb r1, [r0]\n\ - cmp r4, r1\n\ - bge _08019F76\n\ - ldr r0, _08019FA8 @ =gBattleMons\n\ - adds r2, r1, 0\n\ - adds r1, r0, 0\n\ - adds r1, 0x20\n\ - ldr r3, _08019FAC @ =gLastUsedAbility\n\ + movs r4, 0\n\ + ldr r0, _08019FA4 @ =gNoOfAllBanks\n\ + ldrb r1, [r0]\n\ + cmp r4, r1\n\ + bge _08019F76\n\ + ldr r0, _08019FA8 @ =gBattleMons\n\ + adds r2, r1, 0\n\ + adds r1, r0, 0\n\ + adds r1, 0x20\n\ + ldr r3, _08019FAC @ =gLastUsedAbility\n\ _08019F58:\n\ - ldrb r0, [r1]\n\ - cmp r0, r6\n\ - bne _08019F6E\n\ - cmp r4, r10\n\ - beq _08019F6E\n\ - strb r6, [r3]\n\ - mov r0, r9\n\ - adds r0, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - mov r9, r0\n\ + ldrb r0, [r1]\n\ + cmp r0, r6\n\ + bne _08019F6E\n\ + cmp r4, r10\n\ + beq _08019F6E\n\ + strb r6, [r3]\n\ + mov r0, r9\n\ + adds r0, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + mov r9, r0\n\ _08019F6E:\n\ - adds r1, 0x58\n\ - adds r4, 0x1\n\ - cmp r4, r2\n\ - blt _08019F58\n\ + adds r1, 0x58\n\ + adds r4, 0x1\n\ + cmp r4, r2\n\ + blt _08019F58\n\ _08019F76:\n\ - mov r2, r9\n\ - cmp r2, 0\n\ - beq _08019F92\n\ + mov r2, r9\n\ + cmp r2, 0\n\ + beq _08019F92\n\ _08019F7C:\n\ - ldr r3, [sp, 0x4]\n\ - cmp r3, 0xB\n\ - bhi _08019F92\n\ - ldr r1, _08019FAC @ =gLastUsedAbility\n\ - ldrb r0, [r1]\n\ - cmp r0, 0xFF\n\ - beq _08019F92\n\ - adds r1, r0, 0\n\ - mov r0, r10\n\ - bl RecordAbilityBattle\n\ + ldr r3, [sp, 0x4]\n\ + cmp r3, 0xB\n\ + bhi _08019F92\n\ + ldr r1, _08019FAC @ =gLastUsedAbility\n\ + ldrb r0, [r1]\n\ + cmp r0, 0xFF\n\ + beq _08019F92\n\ + adds r1, r0, 0\n\ + mov r0, r10\n\ + bl RecordAbilityBattle\n\ _08019F92:\n\ - mov r0, r9\n\ - add sp, 0x28\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\n\ - .align 2, 0\n\ + mov r0, r9\n\ + add sp, 0x28\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\n\ + .align 2, 0\n\ _08019FA4: .4byte gNoOfAllBanks\n\ _08019FA8: .4byte gBattleMons\n\ _08019FAC: .4byte gLastUsedAbility\n\ diff --git a/src/battle_controller_linkopponent2.c b/src/battle_controller_linkopponent2.c index 2ca7c7970..59030cd6e 100644 --- a/src/battle_controller_linkopponent2.c +++ b/src/battle_controller_linkopponent2.c @@ -174,62 +174,62 @@ typedef void (*BattleBufferCmd) (void); const BattleBufferCmd gLinkOpponentBufferCommands[] = { LinkOpponentHandleGetAttributes, - LinkOpponentHandlecmd1, - LinkOpponentHandleSetAttributes, - LinkOpponentHandlecmd3, - LinkOpponentHandleLoadPokeSprite, - LinkOpponentHandleSendOutPoke, - LinkOpponentHandleReturnPokeToBall, - LinkOpponentHandleTrainerThrow, - LinkOpponentHandleTrainerSlide, - LinkOpponentHandleTrainerSlideBack, - LinkOpponentHandlecmd10, - LinkOpponentHandlecmd11, - LinkOpponentHandlecmd12, - LinkOpponentHandleBallThrow, - LinkOpponentHandlePuase, - LinkOpponentHandleMoveAnimation, - LinkOpponentHandlePrintString, - LinkOpponentHandlePrintStringPlayerOnly, - LinkOpponentHandlecmd18, - LinkOpponentHandlecmd19, - LinkOpponentHandlecmd20, - LinkOpponentHandleOpenBag, - LinkOpponentHandlecmd22, - LinkOpponentHandlecmd23, - LinkOpponentHandleHealthBarUpdate, - LinkOpponentHandleExpBarUpdate, - LinkOpponentHandleStatusIconUpdate, - LinkOpponentHandleStatusAnimation, - LinkOpponentHandleStatusXor, - LinkOpponentHandlecmd29, - LinkOpponentHandleDMATransfer, - LinkOpponentHandlecmd31, - LinkOpponentHandlecmd32, - LinkOpponentHandlecmd33, - LinkOpponentHandlecmd34, - LinkOpponentHandlecmd35, - LinkOpponentHandlecmd36, - LinkOpponentHandlecmd37, - LinkOpponentHandlecmd38, - LinkOpponentHandlecmd39, - LinkOpponentHandlecmd40, - LinkOpponentHandleHitAnimation, - LinkOpponentHandlecmd42, - LinkOpponentHandleEffectivenessSound, - LinkOpponentHandlecmd44, - LinkOpponentHandleFaintingCry, - LinkOpponentHandleIntroSlide, - LinkOpponentHandleTrainerBallThrow, - LinkOpponentHandlecmd48, - LinkOpponentHandlecmd49, - LinkOpponentHandlecmd50, - LinkOpponentHandleSpriteInvisibility, - LinkOpponentHandleBattleAnimation, - LinkOpponentHandleLinkStandbyMsg, - LinkOpponentHandleResetActionMoveSelection, - LinkOpponentHandlecmd55, - LinkOpponentHandlecmd56 + LinkOpponentHandlecmd1, + LinkOpponentHandleSetAttributes, + LinkOpponentHandlecmd3, + LinkOpponentHandleLoadPokeSprite, + LinkOpponentHandleSendOutPoke, + LinkOpponentHandleReturnPokeToBall, + LinkOpponentHandleTrainerThrow, + LinkOpponentHandleTrainerSlide, + LinkOpponentHandleTrainerSlideBack, + LinkOpponentHandlecmd10, + LinkOpponentHandlecmd11, + LinkOpponentHandlecmd12, + LinkOpponentHandleBallThrow, + LinkOpponentHandlePuase, + LinkOpponentHandleMoveAnimation, + LinkOpponentHandlePrintString, + LinkOpponentHandlePrintStringPlayerOnly, + LinkOpponentHandlecmd18, + LinkOpponentHandlecmd19, + LinkOpponentHandlecmd20, + LinkOpponentHandleOpenBag, + LinkOpponentHandlecmd22, + LinkOpponentHandlecmd23, + LinkOpponentHandleHealthBarUpdate, + LinkOpponentHandleExpBarUpdate, + LinkOpponentHandleStatusIconUpdate, + LinkOpponentHandleStatusAnimation, + LinkOpponentHandleStatusXor, + LinkOpponentHandlecmd29, + LinkOpponentHandleDMATransfer, + LinkOpponentHandlecmd31, + LinkOpponentHandlecmd32, + LinkOpponentHandlecmd33, + LinkOpponentHandlecmd34, + LinkOpponentHandlecmd35, + LinkOpponentHandlecmd36, + LinkOpponentHandlecmd37, + LinkOpponentHandlecmd38, + LinkOpponentHandlecmd39, + LinkOpponentHandlecmd40, + LinkOpponentHandleHitAnimation, + LinkOpponentHandlecmd42, + LinkOpponentHandleEffectivenessSound, + LinkOpponentHandlecmd44, + LinkOpponentHandleFaintingCry, + LinkOpponentHandleIntroSlide, + LinkOpponentHandleTrainerBallThrow, + LinkOpponentHandlecmd48, + LinkOpponentHandlecmd49, + LinkOpponentHandlecmd50, + LinkOpponentHandleSpriteInvisibility, + LinkOpponentHandleBattleAnimation, + LinkOpponentHandleLinkStandbyMsg, + LinkOpponentHandleResetActionMoveSelection, + LinkOpponentHandlecmd55, + LinkOpponentHandlecmd56 }; // code diff --git a/src/battle_controller_linkpartner.c b/src/battle_controller_linkpartner.c index 7fd5261aa..95022eaaf 100644 --- a/src/battle_controller_linkpartner.c +++ b/src/battle_controller_linkpartner.c @@ -185,63 +185,63 @@ void LinkPartnerHandlecmd56(void); typedef void (*BattleBufferCmd) (void); static const BattleBufferCmd gLinkPartnerBufferCommands[] = { - LinkPartnerHandleGetAttributes, - LinkPartnerHandlecmd1, - LinkPartnerHandleSetAttributes, - LinkPartnerHandlecmd3, - LinkPartnerHandleLoadPokeSprite, - LinkPartnerHandleSendOutPoke, - LinkPartnerHandleReturnPokeToBall, - LinkPartnerHandleTrainerThrow, - LinkPartnerHandleTrainerSlide, - LinkPartnerHandleTrainerSlideBack, - LinkPartnerHandlecmd10, - LinkPartnerHandlecmd11, - LinkPartnerHandlecmd12, - LinkPartnerHandleBallThrow, - LinkPartnerHandlePuase, - LinkPartnerHandleMoveAnimation, - LinkPartnerHandlePrintString, - LinkPartnerHandlePrintStringPlayerOnly, - LinkPartnerHandlecmd18, - LinkPartnerHandlecmd19, - LinkPartnerHandlecmd20, - LinkPartnerHandleOpenBag, - LinkPartnerHandlecmd22, - LinkPartnerHandlecmd23, - LinkPartnerHandleHealthBarUpdate, - LinkPartnerHandleExpBarUpdate, - LinkPartnerHandleStatusIconUpdate, - LinkPartnerHandleStatusAnimation, - LinkPartnerHandleStatusXor, - LinkPartnerHandlecmd29, - LinkPartnerHandleDMATransfer, - LinkPartnerHandlecmd31, - LinkPartnerHandlecmd32, - LinkPartnerHandlecmd33, - LinkPartnerHandlecmd34, - LinkPartnerHandlecmd35, - LinkPartnerHandlecmd36, - LinkPartnerHandlecmd37, - LinkPartnerHandlecmd38, - LinkPartnerHandlecmd39, - LinkPartnerHandlecmd40, - LinkPartnerHandleHitAnimation, - LinkPartnerHandlecmd42, - LinkPartnerHandleEffectivenessSound, - LinkPartnerHandlecmd44, - LinkPartnerHandleFaintingCry, - LinkPartnerHandleIntroSlide, - LinkPartnerHandleTrainerBallThrow, - LinkPartnerHandlecmd48, - LinkPartnerHandlecmd49, - LinkPartnerHandlecmd50, - LinkPartnerHandleSpriteInvisibility, - LinkPartnerHandleBattleAnimation, - LinkPartnerHandleLinkStandbyMsg, - LinkPartnerHandleResetActionMoveSelection, - LinkPartnerHandlecmd55, - LinkPartnerHandlecmd56, + LinkPartnerHandleGetAttributes, + LinkPartnerHandlecmd1, + LinkPartnerHandleSetAttributes, + LinkPartnerHandlecmd3, + LinkPartnerHandleLoadPokeSprite, + LinkPartnerHandleSendOutPoke, + LinkPartnerHandleReturnPokeToBall, + LinkPartnerHandleTrainerThrow, + LinkPartnerHandleTrainerSlide, + LinkPartnerHandleTrainerSlideBack, + LinkPartnerHandlecmd10, + LinkPartnerHandlecmd11, + LinkPartnerHandlecmd12, + LinkPartnerHandleBallThrow, + LinkPartnerHandlePuase, + LinkPartnerHandleMoveAnimation, + LinkPartnerHandlePrintString, + LinkPartnerHandlePrintStringPlayerOnly, + LinkPartnerHandlecmd18, + LinkPartnerHandlecmd19, + LinkPartnerHandlecmd20, + LinkPartnerHandleOpenBag, + LinkPartnerHandlecmd22, + LinkPartnerHandlecmd23, + LinkPartnerHandleHealthBarUpdate, + LinkPartnerHandleExpBarUpdate, + LinkPartnerHandleStatusIconUpdate, + LinkPartnerHandleStatusAnimation, + LinkPartnerHandleStatusXor, + LinkPartnerHandlecmd29, + LinkPartnerHandleDMATransfer, + LinkPartnerHandlecmd31, + LinkPartnerHandlecmd32, + LinkPartnerHandlecmd33, + LinkPartnerHandlecmd34, + LinkPartnerHandlecmd35, + LinkPartnerHandlecmd36, + LinkPartnerHandlecmd37, + LinkPartnerHandlecmd38, + LinkPartnerHandlecmd39, + LinkPartnerHandlecmd40, + LinkPartnerHandleHitAnimation, + LinkPartnerHandlecmd42, + LinkPartnerHandleEffectivenessSound, + LinkPartnerHandlecmd44, + LinkPartnerHandleFaintingCry, + LinkPartnerHandleIntroSlide, + LinkPartnerHandleTrainerBallThrow, + LinkPartnerHandlecmd48, + LinkPartnerHandlecmd49, + LinkPartnerHandlecmd50, + LinkPartnerHandleSpriteInvisibility, + LinkPartnerHandleBattleAnimation, + LinkPartnerHandleLinkStandbyMsg, + LinkPartnerHandleResetActionMoveSelection, + LinkPartnerHandlecmd55, + LinkPartnerHandlecmd56, }; // code starts here diff --git a/src/battle_controller_opponent.c b/src/battle_controller_opponent.c index abfa3fef2..dd8c62cce 100644 --- a/src/battle_controller_opponent.c +++ b/src/battle_controller_opponent.c @@ -193,63 +193,63 @@ void OpponentHandlecmd56(void); typedef void (*BattleBufferCmd) (void); static const BattleBufferCmd gOpponentBufferCommands[] = { - OpponentHandleGetAttributes, - OpponentHandlecmd1, - OpponentHandleSetAttributes, - OpponentHandlecmd3, - OpponentHandleLoadPokeSprite, - OpponentHandleSendOutPoke, - OpponentHandleReturnPokeToBall, - OpponentHandleTrainerThrow, - OpponentHandleTrainerSlide, - OpponentHandleTrainerSlideBack, - OpponentHandlecmd10, - OpponentHandlecmd11, - OpponentHandlecmd12, - OpponentHandleBallThrow, - OpponentHandlePuase, - OpponentHandleMoveAnimation, - OpponentHandlePrintString, - OpponentHandlePrintStringPlayerOnly, - OpponentHandlecmd18, - OpponentHandlecmd19, - OpponentHandlecmd20, - OpponentHandleOpenBag, - OpponentHandlecmd22, - OpponentHandlecmd23, - OpponentHandleHealthBarUpdate, - OpponentHandleExpBarUpdate, - OpponentHandleStatusIconUpdate, - OpponentHandleStatusAnimation, - OpponentHandleStatusXor, - OpponentHandlecmd29, - OpponentHandleDMATransfer, - OpponentHandlecmd31, - OpponentHandlecmd32, - OpponentHandlecmd33, - OpponentHandlecmd34, - OpponentHandlecmd35, - OpponentHandlecmd36, - OpponentHandlecmd37, - OpponentHandlecmd38, - OpponentHandlecmd39, - OpponentHandlecmd40, - OpponentHandleHitAnimation, - OpponentHandlecmd42, - OpponentHandleEffectivenessSound, - OpponentHandlecmd44, - OpponentHandleFaintingCry, - OpponentHandleIntroSlide, - OpponentHandleTrainerBallThrow, - OpponentHandlecmd48, - OpponentHandlecmd49, - OpponentHandlecmd50, - OpponentHandleSpriteInvisibility, - OpponentHandleBattleAnimation, - OpponentHandleLinkStandbyMsg, - OpponentHandleResetActionMoveSelection, - OpponentHandlecmd55, - OpponentHandlecmd56, + OpponentHandleGetAttributes, + OpponentHandlecmd1, + OpponentHandleSetAttributes, + OpponentHandlecmd3, + OpponentHandleLoadPokeSprite, + OpponentHandleSendOutPoke, + OpponentHandleReturnPokeToBall, + OpponentHandleTrainerThrow, + OpponentHandleTrainerSlide, + OpponentHandleTrainerSlideBack, + OpponentHandlecmd10, + OpponentHandlecmd11, + OpponentHandlecmd12, + OpponentHandleBallThrow, + OpponentHandlePuase, + OpponentHandleMoveAnimation, + OpponentHandlePrintString, + OpponentHandlePrintStringPlayerOnly, + OpponentHandlecmd18, + OpponentHandlecmd19, + OpponentHandlecmd20, + OpponentHandleOpenBag, + OpponentHandlecmd22, + OpponentHandlecmd23, + OpponentHandleHealthBarUpdate, + OpponentHandleExpBarUpdate, + OpponentHandleStatusIconUpdate, + OpponentHandleStatusAnimation, + OpponentHandleStatusXor, + OpponentHandlecmd29, + OpponentHandleDMATransfer, + OpponentHandlecmd31, + OpponentHandlecmd32, + OpponentHandlecmd33, + OpponentHandlecmd34, + OpponentHandlecmd35, + OpponentHandlecmd36, + OpponentHandlecmd37, + OpponentHandlecmd38, + OpponentHandlecmd39, + OpponentHandlecmd40, + OpponentHandleHitAnimation, + OpponentHandlecmd42, + OpponentHandleEffectivenessSound, + OpponentHandlecmd44, + OpponentHandleFaintingCry, + OpponentHandleIntroSlide, + OpponentHandleTrainerBallThrow, + OpponentHandlecmd48, + OpponentHandlecmd49, + OpponentHandlecmd50, + OpponentHandleSpriteInvisibility, + OpponentHandleBattleAnimation, + OpponentHandleLinkStandbyMsg, + OpponentHandleResetActionMoveSelection, + OpponentHandlecmd55, + OpponentHandlecmd56, }; static const u8 sUnknownBytes[] = {0xB0, 0xB0, 0xC8, 0x98, 0x28, 0x28, 0x28, 0x20}; diff --git a/src/battle_controller_safari.c b/src/battle_controller_safari.c index 46e34589a..e84969b4f 100644 --- a/src/battle_controller_safari.c +++ b/src/battle_controller_safari.c @@ -86,63 +86,63 @@ void SafariHandlecmd56(void); typedef void (*BattleBufferCmd) (void); const BattleBufferCmd gSafariBufferCommands[] = { - SafariHandleGetAttributes, - SafariHandlecmd1, - SafariHandleSetAttributes, - SafariHandlecmd3, - SafariHandleLoadPokeSprite, - SafariHandleSendOutPoke, - SafariHandleReturnPokeToBall, - SafariHandleTrainerThrow, - SafariHandleTrainerSlide, - SafariHandleTrainerSlideBack, - SafariHandlecmd10, - SafariHandlecmd11, - SafariHandlecmd12, - SafariHandleBallThrow, - SafariHandlePuase, - SafariHandleMoveAnimation, - SafariHandlePrintString, - SafariHandlePrintStringPlayerOnly, - SafariHandlecmd18, - SafariHandlecmd19, - SafariHandlecmd20, - SafariHandleOpenBag, - SafariHandlecmd22, - SafariHandlecmd23, - SafariHandleHealthBarUpdate, - SafariHandleExpBarUpdate, - SafariHandleStatusIconUpdate, - SafariHandleStatusAnimation, - SafariHandleStatusXor, - SafariHandlecmd29, - SafariHandleDMATransfer, - SafariHandlecmd31, - SafariHandlecmd32, - SafariHandlecmd33, - SafariHandlecmd34, - SafariHandlecmd35, - SafariHandlecmd36, - SafariHandlecmd37, - SafariHandlecmd38, - SafariHandlecmd39, - SafariHandlecmd40, - SafariHandleHitAnimation, - SafariHandlecmd42, - SafariHandleEffectivenessSound, - SafariHandlecmd44, - SafariHandleFaintingCry, - SafariHandleIntroSlide, - SafariHandleTrainerBallThrow, - SafariHandlecmd48, - SafariHandlecmd49, - SafariHandlecmd50, - SafariHandleSpriteInvisibility, - SafariHandleBattleAnimation, - SafariHandleLinkStandbyMsg, - SafariHandleResetActionMoveSelection, - SafariHandlecmd55, - SafariHandlecmd56, + SafariHandleGetAttributes, + SafariHandlecmd1, + SafariHandleSetAttributes, + SafariHandlecmd3, + SafariHandleLoadPokeSprite, + SafariHandleSendOutPoke, + SafariHandleReturnPokeToBall, + SafariHandleTrainerThrow, + SafariHandleTrainerSlide, + SafariHandleTrainerSlideBack, + SafariHandlecmd10, + SafariHandlecmd11, + SafariHandlecmd12, + SafariHandleBallThrow, + SafariHandlePuase, + SafariHandleMoveAnimation, + SafariHandlePrintString, + SafariHandlePrintStringPlayerOnly, + SafariHandlecmd18, + SafariHandlecmd19, + SafariHandlecmd20, + SafariHandleOpenBag, + SafariHandlecmd22, + SafariHandlecmd23, + SafariHandleHealthBarUpdate, + SafariHandleExpBarUpdate, + SafariHandleStatusIconUpdate, + SafariHandleStatusAnimation, + SafariHandleStatusXor, + SafariHandlecmd29, + SafariHandleDMATransfer, + SafariHandlecmd31, + SafariHandlecmd32, + SafariHandlecmd33, + SafariHandlecmd34, + SafariHandlecmd35, + SafariHandlecmd36, + SafariHandlecmd37, + SafariHandlecmd38, + SafariHandlecmd39, + SafariHandlecmd40, + SafariHandleHitAnimation, + SafariHandlecmd42, + SafariHandleEffectivenessSound, + SafariHandlecmd44, + SafariHandleFaintingCry, + SafariHandleIntroSlide, + SafariHandleTrainerBallThrow, + SafariHandlecmd48, + SafariHandlecmd49, + SafariHandlecmd50, + SafariHandleSpriteInvisibility, + SafariHandleBattleAnimation, + SafariHandleLinkStandbyMsg, + SafariHandleResetActionMoveSelection, + SafariHandlecmd55, + SafariHandlecmd56, }; // code diff --git a/src/battle_controller_wally.c b/src/battle_controller_wally.c index e4b593df7..f2cf5bbb4 100644 --- a/src/battle_controller_wally.c +++ b/src/battle_controller_wally.c @@ -171,63 +171,63 @@ void WallyHandlecmd56(void); typedef void (*BattleBufferCmd) (void); static const BattleBufferCmd gWallyBufferCommands[] = { - WallyHandleGetAttributes, - WallyHandlecmd1, - WallyHandleSetAttributes, - WallyHandlecmd3, - WallyHandleLoadPokeSprite, - WallyHandleSendOutPoke, - WallyHandleReturnPokeToBall, - WallyHandleTrainerThrow, - WallyHandleTrainerSlide, - WallyHandleTrainerSlideBack, - WallyHandlecmd10, - WallyHandlecmd11, - WallyHandlecmd12, - WallyHandleBallThrow, - WallyHandlePuase, - WallyHandleMoveAnimation, - WallyHandlePrintString, - WallyHandlePrintStringPlayerOnly, - WallyHandlecmd18, - WallyHandlecmd19, - WallyHandlecmd20, - WallyHandleOpenBag, - WallyHandlecmd22, - WallyHandlecmd23, - WallyHandleHealthBarUpdate, - WallyHandleExpBarUpdate, - WallyHandleStatusIconUpdate, - WallyHandleStatusAnimation, - WallyHandleStatusXor, - WallyHandlecmd29, - WallyHandleDMATransfer, - WallyHandlecmd31, - WallyHandlecmd32, - WallyHandlecmd33, - WallyHandlecmd34, - WallyHandlecmd35, - WallyHandlecmd36, - WallyHandlecmd37, - WallyHandlecmd38, - WallyHandlecmd39, - WallyHandlecmd40, - WallyHandleHitAnimation, - WallyHandlecmd42, - WallyHandleEffectivenessSound, - WallyHandlecmd44, - WallyHandleFaintingCry, - WallyHandleIntroSlide, - WallyHandleTrainerBallThrow, - WallyHandlecmd48, - WallyHandlecmd49, - WallyHandlecmd50, - WallyHandleSpriteInvisibility, - WallyHandleBattleAnimation, - WallyHandleLinkStandbyMsg, - WallyHandleResetActionMoveSelection, - WallyHandlecmd55, - WallyHandlecmd56, + WallyHandleGetAttributes, + WallyHandlecmd1, + WallyHandleSetAttributes, + WallyHandlecmd3, + WallyHandleLoadPokeSprite, + WallyHandleSendOutPoke, + WallyHandleReturnPokeToBall, + WallyHandleTrainerThrow, + WallyHandleTrainerSlide, + WallyHandleTrainerSlideBack, + WallyHandlecmd10, + WallyHandlecmd11, + WallyHandlecmd12, + WallyHandleBallThrow, + WallyHandlePuase, + WallyHandleMoveAnimation, + WallyHandlePrintString, + WallyHandlePrintStringPlayerOnly, + WallyHandlecmd18, + WallyHandlecmd19, + WallyHandlecmd20, + WallyHandleOpenBag, + WallyHandlecmd22, + WallyHandlecmd23, + WallyHandleHealthBarUpdate, + WallyHandleExpBarUpdate, + WallyHandleStatusIconUpdate, + WallyHandleStatusAnimation, + WallyHandleStatusXor, + WallyHandlecmd29, + WallyHandleDMATransfer, + WallyHandlecmd31, + WallyHandlecmd32, + WallyHandlecmd33, + WallyHandlecmd34, + WallyHandlecmd35, + WallyHandlecmd36, + WallyHandlecmd37, + WallyHandlecmd38, + WallyHandlecmd39, + WallyHandlecmd40, + WallyHandleHitAnimation, + WallyHandlecmd42, + WallyHandleEffectivenessSound, + WallyHandlecmd44, + WallyHandleFaintingCry, + WallyHandleIntroSlide, + WallyHandleTrainerBallThrow, + WallyHandlecmd48, + WallyHandlecmd49, + WallyHandlecmd50, + WallyHandleSpriteInvisibility, + WallyHandleBattleAnimation, + WallyHandleLinkStandbyMsg, + WallyHandleResetActionMoveSelection, + WallyHandlecmd55, + WallyHandlecmd56, }; // code diff --git a/src/battle_transition.c b/src/battle_transition.c index 395a38df1..1cacb8857 100644 --- a/src/battle_transition.c +++ b/src/battle_transition.c @@ -253,8 +253,8 @@ static const TransitionState sPhase2_Transition_BigPokeball_Funcs[] = static const TransitionState sPhase2_Transition_PokeballsTrail_Funcs[] = { Phase2_Transition_PokeballsTrail_Func1, - Phase2_Transition_PokeballsTrail_Func2, - Phase2_Transition_PokeballsTrail_Func3 + Phase2_Transition_PokeballsTrail_Func2, + Phase2_Transition_PokeballsTrail_Func3 }; static const s16 sUnknown_083FD7E4[2] = {-16, 256}; @@ -264,25 +264,25 @@ static const s16 sUnknown_083FD7F2[2] = {8, -8}; static const TransitionState sPhase2_Transition_Clockwise_BlackFade_Funcs[] = { Phase2_Transition_Clockwise_BlackFade_Func1, - Phase2_Transition_Clockwise_BlackFade_Func2, - Phase2_Transition_Clockwise_BlackFade_Func3, - Phase2_Transition_Clockwise_BlackFade_Func4, - Phase2_Transition_Clockwise_BlackFade_Func5, - Phase2_Transition_Clockwise_BlackFade_Func6, - Phase2_Transition_Clockwise_BlackFade_Func7 + Phase2_Transition_Clockwise_BlackFade_Func2, + Phase2_Transition_Clockwise_BlackFade_Func3, + Phase2_Transition_Clockwise_BlackFade_Func4, + Phase2_Transition_Clockwise_BlackFade_Func5, + Phase2_Transition_Clockwise_BlackFade_Func6, + Phase2_Transition_Clockwise_BlackFade_Func7 }; static const TransitionState sPhase2_Transition_Ripple_Funcs[] = { Phase2_Transition_Ripple_Func1, - Phase2_Transition_Ripple_Func2 + Phase2_Transition_Ripple_Func2 }; static const TransitionState sPhase2_Transition_Wave_Funcs[] = { Phase2_Transition_Wave_Func1, - Phase2_Transition_Wave_Func2, - Phase2_Transition_Wave_Func3 + Phase2_Transition_Wave_Func2, + Phase2_Transition_Wave_Func3 }; static const TransitionState sPhase2_Mugshot_Transition_Funcs[] = @@ -320,12 +320,12 @@ static const s16 sMugshotsOpponentCoords[MUGSHOTS_NO][2] = static const TransitionSpriteCallback sUnknown_083FD880[] = { sub_811C934, - sub_811C938, - sub_811C984, - sub_811C9B8, - sub_811C934, - sub_811C9E4, - sub_811C934 + sub_811C938, + sub_811C984, + sub_811C9B8, + sub_811C934, + sub_811C9E4, + sub_811C934 }; static const s16 sUnknown_083FD89C[2] = {12, -12}; @@ -334,17 +334,17 @@ static const s16 sUnknown_083FD8A0[2] = {-1, 1}; static const TransitionState sPhase2_Transition_Slice_Funcs[] = { Phase2_Transition_Slice_Func1, - Phase2_Transition_Slice_Func2, - Phase2_Transition_Slice_Func3 + Phase2_Transition_Slice_Func2, + Phase2_Transition_Slice_Func3 }; static const TransitionState sPhase2_Transition_WhiteFade_Funcs[] = { Phase2_Transition_WhiteFade_Func1, - Phase2_Transition_WhiteFade_Func2, - Phase2_Transition_WhiteFade_Func3, - Phase2_Transition_WhiteFade_Func4, - Phase2_Transition_WhiteFade_Func5 + Phase2_Transition_WhiteFade_Func2, + Phase2_Transition_WhiteFade_Func3, + Phase2_Transition_WhiteFade_Func4, + Phase2_Transition_WhiteFade_Func5 }; static const s16 sUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; @@ -352,17 +352,17 @@ static const s16 sUnknown_083FD8C4[8] = {0, 20, 15, 40, 10, 25, 35, 5}; static const TransitionState sPhase2_Transition_GridSquares_Funcs[] = { Phase2_Transition_GridSquares_Func1, - Phase2_Transition_GridSquares_Func2, - Phase2_Transition_GridSquares_Func3 + Phase2_Transition_GridSquares_Func2, + Phase2_Transition_GridSquares_Func3 }; static const TransitionState sPhase2_Transition_Shards_Funcs[] = { Phase2_Transition_Shards_Func1, - Phase2_Transition_Shards_Func2, - Phase2_Transition_Shards_Func3, - Phase2_Transition_Shards_Func4, - Phase2_Transition_Shards_Func5 + Phase2_Transition_Shards_Func2, + Phase2_Transition_Shards_Func3, + Phase2_Transition_Shards_Func4, + Phase2_Transition_Shards_Func5 }; static const s16 sUnknown_083FD8F4[][5] = @@ -507,10 +507,10 @@ static const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may static const u16 * const sOpponentMugshotsPals[MUGSHOTS_NO] = { sMugshotPal_Sydney, - sMugshotPal_Phoebe, - sMugshotPal_Glacia, - sMugshotPal_Drake, - sMugshotPal_Steven + sMugshotPal_Phoebe, + sMugshotPal_Glacia, + sMugshotPal_Drake, + sMugshotPal_Steven }; static const u16 * const sPlayerMugshotsPals[2] = diff --git a/src/berry_blender.c b/src/berry_blender.c index f54c6271d..029d352df 100644 --- a/src/berry_blender.c +++ b/src/berry_blender.c @@ -2156,223 +2156,223 @@ __attribute__((naked)) static void Blender_CalculatePokeblock(struct BlenderBerry* berries, struct Pokeblock* pokeblock, u8 a2, u8* flavours, u16 a4) { asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0x10\n\ - str r0, [sp]\n\ - mov r8, r1\n\ - str r3, [sp, 0x4]\n\ - ldr r0, [sp, 0x30]\n\ - lsls r2, 24\n\ - lsrs r2, 24\n\ - mov r9, r2\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x8]\n\ - ldr r7, _080505DC @ =gUnknown_03000510\n\ - adds r2, r7, 0\n\ - movs r1, 0\n\ - adds r0, r7, 0\n\ - adds r0, 0xA\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0x10\n\ + str r0, [sp]\n\ + mov r8, r1\n\ + str r3, [sp, 0x4]\n\ + ldr r0, [sp, 0x30]\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + mov r9, r2\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x8]\n\ + ldr r7, _080505DC @ =gUnknown_03000510\n\ + adds r2, r7, 0\n\ + movs r1, 0\n\ + adds r0, r7, 0\n\ + adds r0, 0xA\n\ _0805054A:\n\ - strh r1, [r0]\n\ - subs r0, 0x2\n\ - cmp r0, r2\n\ - bge _0805054A\n\ - movs r6, 0\n\ - cmp r6, r9\n\ - bge _08050580\n\ - ldr r0, _080505DC @ =gUnknown_03000510\n\ - mov r12, r0\n\ - ldr r5, [sp]\n\ - adds r5, 0x9\n\ + strh r1, [r0]\n\ + subs r0, 0x2\n\ + cmp r0, r2\n\ + bge _0805054A\n\ + movs r6, 0\n\ + cmp r6, r9\n\ + bge _08050580\n\ + ldr r0, _080505DC @ =gUnknown_03000510\n\ + mov r12, r0\n\ + ldr r5, [sp]\n\ + adds r5, 0x9\n\ _08050560:\n\ - movs r3, 0\n\ - adds r4, r5, 0\n\ - mov r2, r12\n\ + movs r3, 0\n\ + adds r4, r5, 0\n\ + mov r2, r12\n\ _08050566:\n\ - adds r1, r4, r3\n\ - ldrh r0, [r2]\n\ - ldrb r1, [r1]\n\ - adds r0, r1\n\ - strh r0, [r2]\n\ - adds r2, 0x2\n\ - adds r3, 0x1\n\ - cmp r3, 0x5\n\ - ble _08050566\n\ - adds r5, 0x10\n\ - adds r6, 0x1\n\ - cmp r6, r9\n\ - blt _08050560\n\ + adds r1, r4, r3\n\ + ldrh r0, [r2]\n\ + ldrb r1, [r1]\n\ + adds r0, r1\n\ + strh r0, [r2]\n\ + adds r2, 0x2\n\ + adds r3, 0x1\n\ + cmp r3, 0x5\n\ + ble _08050566\n\ + adds r5, 0x10\n\ + adds r6, 0x1\n\ + cmp r6, r9\n\ + blt _08050560\n\ _08050580:\n\ - movs r1, 0\n\ - ldrsh r3, [r7, r1]\n\ - ldrh r0, [r7]\n\ - ldrh r1, [r7, 0x2]\n\ - subs r0, r1\n\ - strh r0, [r7]\n\ - ldrh r0, [r7, 0x4]\n\ - subs r1, r0\n\ - strh r1, [r7, 0x2]\n\ - ldrh r1, [r7, 0x6]\n\ - subs r0, r1\n\ - strh r0, [r7, 0x4]\n\ - ldrh r0, [r7, 0x8]\n\ - subs r1, r0\n\ - strh r1, [r7, 0x6]\n\ - subs r0, r3\n\ - strh r0, [r7, 0x8]\n\ - movs r3, 0\n\ - movs r2, 0\n\ - adds r1, r7, 0\n\ - movs r6, 0x4\n\ + movs r1, 0\n\ + ldrsh r3, [r7, r1]\n\ + ldrh r0, [r7]\n\ + ldrh r1, [r7, 0x2]\n\ + subs r0, r1\n\ + strh r0, [r7]\n\ + ldrh r0, [r7, 0x4]\n\ + subs r1, r0\n\ + strh r1, [r7, 0x2]\n\ + ldrh r1, [r7, 0x6]\n\ + subs r0, r1\n\ + strh r0, [r7, 0x4]\n\ + ldrh r0, [r7, 0x8]\n\ + subs r1, r0\n\ + strh r1, [r7, 0x6]\n\ + subs r0, r3\n\ + strh r0, [r7, 0x8]\n\ + movs r3, 0\n\ + movs r2, 0\n\ + adds r1, r7, 0\n\ + movs r6, 0x4\n\ _080505AA:\n\ - movs r4, 0\n\ - ldrsh r0, [r1, r4]\n\ - cmp r0, 0\n\ - bge _080505B6\n\ - strh r2, [r1]\n\ - adds r3, 0x1\n\ + movs r4, 0\n\ + ldrsh r0, [r1, r4]\n\ + cmp r0, 0\n\ + bge _080505B6\n\ + strh r2, [r1]\n\ + adds r3, 0x1\n\ _080505B6:\n\ - adds r1, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _080505AA\n\ - lsls r0, r3, 24\n\ - lsrs r0, 24\n\ - mov r10, r0\n\ - movs r4, 0\n\ - ldr r1, _080505DC @ =gUnknown_03000510\n\ - movs r6, 0x4\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505AA\n\ + lsls r0, r3, 24\n\ + lsrs r0, 24\n\ + mov r10, r0\n\ + movs r4, 0\n\ + ldr r1, _080505DC @ =gUnknown_03000510\n\ + movs r6, 0x4\n\ _080505CA:\n\ - ldrh r2, [r1]\n\ - movs r5, 0\n\ - ldrsh r0, [r1, r5]\n\ - cmp r0, 0\n\ - ble _080505E4\n\ - cmp r0, r3\n\ - bge _080505E0\n\ - strh r4, [r1]\n\ - b _080505E4\n\ - .align 2, 0\n\ + ldrh r2, [r1]\n\ + movs r5, 0\n\ + ldrsh r0, [r1, r5]\n\ + cmp r0, 0\n\ + ble _080505E4\n\ + cmp r0, r3\n\ + bge _080505E0\n\ + strh r4, [r1]\n\ + b _080505E4\n\ + .align 2, 0\n\ _080505DC: .4byte gUnknown_03000510\n\ _080505E0:\n\ - subs r0, r2, r3\n\ - strh r0, [r1]\n\ + subs r0, r2, r3\n\ + strh r0, [r1]\n\ _080505E4:\n\ - adds r1, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _080505CA\n\ - ldr r1, _080506C4 @ =gUnknown_03000510\n\ - ldr r2, _080506C8 @ =gUnknown_03000530\n\ - movs r6, 0x4\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505CA\n\ + ldr r1, _080506C4 @ =gUnknown_03000510\n\ + ldr r2, _080506C8 @ =gUnknown_03000530\n\ + movs r6, 0x4\n\ _080505F2:\n\ - movs r3, 0\n\ - ldrsh r0, [r1, r3]\n\ - stm r2!, {r0}\n\ - adds r1, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _080505F2\n\ - ldr r1, _080506CC @ =0x0000014d\n\ - ldr r0, [sp, 0x8]\n\ - bl __udivsi3\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - adds r3, r0, 0\n\ - adds r3, 0x64\n\ - ldr r4, _080506D0 @ =gUnknown_0300055C\n\ - str r3, [r4]\n\ - movs r6, 0x4\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + stm r2!, {r0}\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080505F2\n\ + ldr r1, _080506CC @ =0x0000014d\n\ + ldr r0, [sp, 0x8]\n\ + bl __udivsi3\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + adds r3, r0, 0\n\ + adds r3, 0x64\n\ + ldr r4, _080506D0 @ =gUnknown_0300055C\n\ + str r3, [r4]\n\ + movs r6, 0x4\n\ _08050616:\n\ - movs r0, 0\n\ - ldrsh r5, [r7, r0]\n\ - adds r0, r5, 0\n\ - muls r0, r3\n\ - movs r1, 0xA\n\ - str r3, [sp, 0xC]\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - movs r1, 0xA\n\ - bl __modsi3\n\ - adds r4, r0, 0\n\ - adds r0, r5, 0\n\ - movs r1, 0xA\n\ - bl __divsi3\n\ - adds r5, r0, 0\n\ - ldr r3, [sp, 0xC]\n\ - cmp r4, 0x4\n\ - ble _08050642\n\ - adds r5, 0x1\n\ + movs r0, 0\n\ + ldrsh r5, [r7, r0]\n\ + adds r0, r5, 0\n\ + muls r0, r3\n\ + movs r1, 0xA\n\ + str r3, [sp, 0xC]\n\ + bl __divsi3\n\ + adds r5, r0, 0\n\ + movs r1, 0xA\n\ + bl __modsi3\n\ + adds r4, r0, 0\n\ + adds r0, r5, 0\n\ + movs r1, 0xA\n\ + bl __divsi3\n\ + adds r5, r0, 0\n\ + ldr r3, [sp, 0xC]\n\ + cmp r4, 0x4\n\ + ble _08050642\n\ + adds r5, 0x1\n\ _08050642:\n\ - strh r5, [r7]\n\ - adds r7, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _08050616\n\ - ldr r1, _080506C4 @ =gUnknown_03000510\n\ - ldr r2, _080506D4 @ =gUnknown_03000548\n\ - movs r6, 0x4\n\ + strh r5, [r7]\n\ + adds r7, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _08050616\n\ + ldr r1, _080506C4 @ =gUnknown_03000510\n\ + ldr r2, _080506D4 @ =gUnknown_03000548\n\ + movs r6, 0x4\n\ _08050652:\n\ - movs r3, 0\n\ - ldrsh r0, [r1, r3]\n\ - stm r2!, {r0}\n\ - adds r1, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _08050652\n\ - ldr r4, _080506C4 @ =gUnknown_03000510\n\ - ldr r0, [sp]\n\ - adds r1, r4, 0\n\ - mov r2, r9\n\ - mov r3, r10\n\ - bl Blender_GetPokeblockColor\n\ - mov r5, r8\n\ - strb r0, [r5]\n\ - movs r1, 0xA\n\ - ldrsh r0, [r4, r1]\n\ - mov r1, r9\n\ - bl __divsi3\n\ - mov r3, r9\n\ - subs r0, r3\n\ - strh r0, [r4, 0xA]\n\ - lsls r0, 16\n\ - cmp r0, 0\n\ - bge _0805068C\n\ - movs r0, 0\n\ - strh r0, [r4, 0xA]\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + stm r2!, {r0}\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _08050652\n\ + ldr r4, _080506C4 @ =gUnknown_03000510\n\ + ldr r0, [sp]\n\ + adds r1, r4, 0\n\ + mov r2, r9\n\ + mov r3, r10\n\ + bl Blender_GetPokeblockColor\n\ + mov r5, r8\n\ + strb r0, [r5]\n\ + movs r1, 0xA\n\ + ldrsh r0, [r4, r1]\n\ + mov r1, r9\n\ + bl __divsi3\n\ + mov r3, r9\n\ + subs r0, r3\n\ + strh r0, [r4, 0xA]\n\ + lsls r0, 16\n\ + cmp r0, 0\n\ + bge _0805068C\n\ + movs r0, 0\n\ + strh r0, [r4, 0xA]\n\ _0805068C:\n\ - mov r5, r8\n\ - ldrb r0, [r5]\n\ - cmp r0, 0xC\n\ - bne _080506E6\n\ - bl Random\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - movs r1, 0xA\n\ - bl __umodsi3\n\ - lsls r0, 16\n\ - lsrs r3, r0, 16\n\ - movs r6, 0\n\ - ldr r0, _080506D8 @ =gUnknown_082165DF\n\ - adds r0, r3, r0\n\ - ldrb r0, [r0]\n\ - adds r1, r4, 0\n\ - movs r4, 0x1\n\ - movs r3, 0x2\n\ + mov r5, r8\n\ + ldrb r0, [r5]\n\ + cmp r0, 0xC\n\ + bne _080506E6\n\ + bl Random\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + movs r1, 0xA\n\ + bl __umodsi3\n\ + lsls r0, 16\n\ + lsrs r3, r0, 16\n\ + movs r6, 0\n\ + ldr r0, _080506D8 @ =gUnknown_082165DF\n\ + adds r0, r3, r0\n\ + ldrb r0, [r0]\n\ + adds r1, r4, 0\n\ + movs r4, 0x1\n\ + movs r3, 0x2\n\ _080506B4:\n\ - adds r2, r0, 0\n\ - asrs r2, r6\n\ - ands r2, r4\n\ - cmp r2, 0\n\ - beq _080506DC\n\ - strh r3, [r1]\n\ - b _080506DE\n\ - .align 2, 0\n\ + adds r2, r0, 0\n\ + asrs r2, r6\n\ + ands r2, r4\n\ + cmp r2, 0\n\ + beq _080506DC\n\ + strh r3, [r1]\n\ + b _080506DE\n\ + .align 2, 0\n\ _080506C4: .4byte gUnknown_03000510\n\ _080506C8: .4byte gUnknown_03000530\n\ _080506CC: .4byte 0x0000014d\n\ @@ -2380,61 +2380,61 @@ _080506D0: .4byte gUnknown_0300055C\n\ _080506D4: .4byte gUnknown_03000548\n\ _080506D8: .4byte gUnknown_082165DF\n\ _080506DC:\n\ - strh r2, [r1]\n\ + strh r2, [r1]\n\ _080506DE:\n\ - adds r1, 0x2\n\ - adds r6, 0x1\n\ - cmp r6, 0x4\n\ - ble _080506B4\n\ + adds r1, 0x2\n\ + adds r6, 0x1\n\ + cmp r6, 0x4\n\ + ble _080506B4\n\ _080506E6:\n\ - ldr r7, _08050740 @ =gUnknown_03000510\n\ - movs r2, 0xFF\n\ - adds r1, r7, 0\n\ - movs r6, 0x5\n\ + ldr r7, _08050740 @ =gUnknown_03000510\n\ + movs r2, 0xFF\n\ + adds r1, r7, 0\n\ + movs r6, 0x5\n\ _080506EE:\n\ - movs r3, 0\n\ - ldrsh r0, [r1, r3]\n\ - cmp r0, 0xFF\n\ - ble _080506F8\n\ - strh r2, [r1]\n\ + movs r3, 0\n\ + ldrsh r0, [r1, r3]\n\ + cmp r0, 0xFF\n\ + ble _080506F8\n\ + strh r2, [r1]\n\ _080506F8:\n\ - adds r1, 0x2\n\ - subs r6, 0x1\n\ - cmp r6, 0\n\ - bge _080506EE\n\ - ldrh r0, [r7]\n\ - mov r4, r8\n\ - strb r0, [r4, 0x1]\n\ - ldrh r0, [r7, 0x2]\n\ - strb r0, [r4, 0x2]\n\ - ldrh r0, [r7, 0x4]\n\ - strb r0, [r4, 0x3]\n\ - ldrh r0, [r7, 0x6]\n\ - strb r0, [r4, 0x4]\n\ - ldrh r0, [r7, 0x8]\n\ - strb r0, [r4, 0x5]\n\ - ldrh r0, [r7, 0xA]\n\ - strb r0, [r4, 0x6]\n\ - movs r6, 0\n\ - adds r2, r7, 0\n\ + adds r1, 0x2\n\ + subs r6, 0x1\n\ + cmp r6, 0\n\ + bge _080506EE\n\ + ldrh r0, [r7]\n\ + mov r4, r8\n\ + strb r0, [r4, 0x1]\n\ + ldrh r0, [r7, 0x2]\n\ + strb r0, [r4, 0x2]\n\ + ldrh r0, [r7, 0x4]\n\ + strb r0, [r4, 0x3]\n\ + ldrh r0, [r7, 0x6]\n\ + strb r0, [r4, 0x4]\n\ + ldrh r0, [r7, 0x8]\n\ + strb r0, [r4, 0x5]\n\ + ldrh r0, [r7, 0xA]\n\ + strb r0, [r4, 0x6]\n\ + movs r6, 0\n\ + adds r2, r7, 0\n\ _0805071E:\n\ - ldr r5, [sp, 0x4]\n\ - adds r1, r5, r6\n\ - ldrh r0, [r2]\n\ - strb r0, [r1]\n\ - adds r2, 0x2\n\ - adds r6, 0x1\n\ - cmp r6, 0x5\n\ - ble _0805071E\n\ - add sp, 0x10\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ + ldr r5, [sp, 0x4]\n\ + adds r1, r5, r6\n\ + ldrh r0, [r2]\n\ + strb r0, [r1]\n\ + adds r2, 0x2\n\ + adds r6, 0x1\n\ + cmp r6, 0x5\n\ + ble _0805071E\n\ + add sp, 0x10\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ _08050740: .4byte gUnknown_03000510\n\ .syntax divided"); } diff --git a/src/berry_tag_screen.c b/src/berry_tag_screen.c index 50db5388c..a965f386c 100644 --- a/src/berry_tag_screen.c +++ b/src/berry_tag_screen.c @@ -363,30 +363,30 @@ static void sub_81466A0(void) static void sub_81466E8(u8 taskId, s8 direction) { - u8 berryPocket = 3; - s16 *data = gTasks[taskId].data; - - if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos == 0 - && direction < 0) - return; - if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + 1 == gBagPocketScrollStates[berryPocket].numSlots - && direction > 0) - return; - - PlaySE(SE_SELECT); - if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + direction < 0) - data[1] = -(gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos); - else if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + direction >= gBagPocketScrollStates[berryPocket].numSlots) - data[1] = gBagPocketScrollStates[berryPocket].numSlots - gBagPocketScrollStates[berryPocket].scrollTop - gBagPocketScrollStates[berryPocket].cursorPos - 1; - else - data[1] = direction; - - gTasks[taskId].func = sub_8146798; - - if (direction < 0) - data[0] = -16; - else - data[0] = 16; + u8 berryPocket = 3; + s16 *data = gTasks[taskId].data; + + if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos == 0 + && direction < 0) + return; + if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + 1 == gBagPocketScrollStates[berryPocket].numSlots + && direction > 0) + return; + + PlaySE(SE_SELECT); + if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + direction < 0) + data[1] = -(gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos); + else if (gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos + direction >= gBagPocketScrollStates[berryPocket].numSlots) + data[1] = gBagPocketScrollStates[berryPocket].numSlots - gBagPocketScrollStates[berryPocket].scrollTop - gBagPocketScrollStates[berryPocket].cursorPos - 1; + else + data[1] = direction; + + gTasks[taskId].func = sub_8146798; + + if (direction < 0) + data[0] = -16; + else + data[0] = 16; } @@ -411,36 +411,36 @@ static void sub_8146798(u8 taskId) static void sub_8146810(s8 berry) { - u8 berryPocket = 3; - - if (berry > 0) - { - if (gBagPocketScrollStates[berryPocket].cursorPos + berry > 7) - { - gBagPocketScrollStates[berryPocket].scrollTop += gBagPocketScrollStates[berryPocket].cursorPos - 7 + berry; - gBagPocketScrollStates[berryPocket].cursorPos = 7; - } - else - { - gBagPocketScrollStates[berryPocket].cursorPos += berry; - } - } - else - { - if (gBagPocketScrollStates[berryPocket].cursorPos + berry < 0) - { - gBagPocketScrollStates[berryPocket].scrollTop += gBagPocketScrollStates[berryPocket].cursorPos + berry; - gBagPocketScrollStates[berryPocket].cursorPos = 0; - } - else - { - gBagPocketScrollStates[berryPocket].cursorPos += berry; - } - } - gScriptItemId = gCurrentBagPocketItemSlots[gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos].itemId; - DestroySprite(&gSprites[gUnknown_0203932C]); - sub_81466A0(); - sub_80A7DD4(); + u8 berryPocket = 3; + + if (berry > 0) + { + if (gBagPocketScrollStates[berryPocket].cursorPos + berry > 7) + { + gBagPocketScrollStates[berryPocket].scrollTop += gBagPocketScrollStates[berryPocket].cursorPos - 7 + berry; + gBagPocketScrollStates[berryPocket].cursorPos = 7; + } + else + { + gBagPocketScrollStates[berryPocket].cursorPos += berry; + } + } + else + { + if (gBagPocketScrollStates[berryPocket].cursorPos + berry < 0) + { + gBagPocketScrollStates[berryPocket].scrollTop += gBagPocketScrollStates[berryPocket].cursorPos + berry; + gBagPocketScrollStates[berryPocket].cursorPos = 0; + } + else + { + gBagPocketScrollStates[berryPocket].cursorPos += berry; + } + } + gScriptItemId = gCurrentBagPocketItemSlots[gBagPocketScrollStates[berryPocket].scrollTop + gBagPocketScrollStates[berryPocket].cursorPos].itemId; + DestroySprite(&gSprites[gUnknown_0203932C]); + sub_81466A0(); + sub_80A7DD4(); } static void sub_81468BC(void) diff --git a/src/de_rom_8040FE0.c b/src/de_rom_8040FE0.c index c618ebdb2..eebcc1437 100644 --- a/src/de_rom_8040FE0.c +++ b/src/de_rom_8040FE0.c @@ -142,124 +142,124 @@ u8 *de_sub_8041024(s32 arg0, u32 arg1) { __attribute__((naked)) void de_sub_8041024(void) { asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - adds r2, r0, 0\n\ - adds r6, r1, 0\n\ - movs r0, 0x80\n\ - lsls r0, 3\n\ - cmp r2, r0\n\ - beq _0804104A\n\ - cmp r2, r0\n\ - bgt _08041040\n\ - movs r0, 0x80\n\ - lsls r0, 1\n\ - cmp r2, r0\n\ - beq _08041064\n\ - b _0804109C\n\ + push {r4-r6,lr}\n\ + adds r2, r0, 0\n\ + adds r6, r1, 0\n\ + movs r0, 0x80\n\ + lsls r0, 3\n\ + cmp r2, r0\n\ + beq _0804104A\n\ + cmp r2, r0\n\ + bgt _08041040\n\ + movs r0, 0x80\n\ + lsls r0, 1\n\ + cmp r2, r0\n\ + beq _08041064\n\ + b _0804109C\n\ _08041040:\n\ - movs r0, 0x80\n\ - lsls r0, 4\n\ - cmp r2, r0\n\ - beq _08041086\n\ - b _0804109C\n\ + movs r0, 0x80\n\ + lsls r0, 4\n\ + cmp r2, r0\n\ + beq _08041086\n\ + b _0804109C\n\ _0804104A:\n\ - bl GetSecretBaseTrainerNameIndex\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - ldr r0, _08041060 @ =0x02017000\n\ - ldrb r0, [r0, 0x1]\n\ - lsls r0, 27\n\ - lsrs r2, r0, 31\n\ - cmp r5, 0x1A\n\ - beq _080410B8\n\ - b _080410F8\n\ - .align 2, 0\n\ + bl GetSecretBaseTrainerNameIndex\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + ldr r0, _08041060 @ =0x02017000\n\ + ldrb r0, [r0, 0x1]\n\ + lsls r0, 27\n\ + lsrs r2, r0, 31\n\ + cmp r5, 0x1A\n\ + beq _080410B8\n\ + b _080410F8\n\ + .align 2, 0\n\ _08041060: .4byte 0x02017000\n\ _08041064:\n\ - bl de_sub_81364AC\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - bl get_trainer_class_name_index\n\ + bl de_sub_81364AC\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + bl get_trainer_class_name_index\n\ _08041070:\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ - cmp r4, 0x1E\n\ - beq _08041094\n\ - adds r0, r4, 0\n\ - subs r0, 0x3D\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - cmp r0, 0x2\n\ - bls _080410CC\n\ - b _080410F8\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ + cmp r4, 0x1E\n\ + beq _08041094\n\ + adds r0, r4, 0\n\ + subs r0, 0x3D\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + cmp r0, 0x2\n\ + bls _080410CC\n\ + b _080410F8\n\ _08041086:\n\ - bl de_sub_81364F8\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - bl sub_8135FD8\n\ - b _08041070\n\ + bl de_sub_81364F8\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + bl sub_8135FD8\n\ + b _08041070\n\ _08041094:\n\ - movs r0, 0x1\n\ - bl de_sub_8040FE0\n\ - b _08041102\n\ + movs r0, 0x1\n\ + bl de_sub_8040FE0\n\ + b _08041102\n\ _0804109C:\n\ - ldr r1, _080410C0 @ =gTrainers\n\ - lsls r4, r6, 2\n\ - adds r0, r4, r6\n\ - lsls r0, 3\n\ - adds r0, r1\n\ - ldrb r5, [r0, 0x1]\n\ - lsls r0, r6, 16\n\ - lsrs r0, 16\n\ - bl sub_803FC58\n\ - lsls r0, 24\n\ - lsrs r2, r0, 24\n\ - cmp r5, 0x1A\n\ - bne _080410C4\n\ + ldr r1, _080410C0 @ =gTrainers\n\ + lsls r4, r6, 2\n\ + adds r0, r4, r6\n\ + lsls r0, 3\n\ + adds r0, r1\n\ + ldrb r5, [r0, 0x1]\n\ + lsls r0, r6, 16\n\ + lsrs r0, 16\n\ + bl sub_803FC58\n\ + lsls r0, 24\n\ + lsrs r2, r0, 24\n\ + cmp r5, 0x1A\n\ + bne _080410C4\n\ _080410B8:\n\ - adds r0, r2, 0\n\ - bl de_sub_8040FE0\n\ - b _08041102\n\ - .align 2, 0\n\ + adds r0, r2, 0\n\ + bl de_sub_8040FE0\n\ + b _08041102\n\ + .align 2, 0\n\ _080410C0: .4byte gTrainers\n\ _080410C4:\n\ - cmp r5, 0x2E\n\ - bne _080410D4\n\ - cmp r2, 0x1\n\ - bne _080410D4\n\ + cmp r5, 0x2E\n\ + bne _080410D4\n\ + cmp r2, 0x1\n\ + bne _080410D4\n\ _080410CC:\n\ - movs r0, 0x1\n\ - bl de_sub_8040FF4\n\ - b _08041102\n\ + movs r0, 0x1\n\ + bl de_sub_8040FF4\n\ + b _08041102\n\ _080410D4:\n\ - cmp r5, 0x19\n\ - bne _080410F8\n\ - ldr r0, _080410F4 @ =gTrainers\n\ - adds r1, r4, r6\n\ - lsls r1, 3\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x18]\n\ - movs r2, 0\n\ - cmp r0, 0x1\n\ - bne _080410EA\n\ - movs r2, 0x1\n\ + cmp r5, 0x19\n\ + bne _080410F8\n\ + ldr r0, _080410F4 @ =gTrainers\n\ + adds r1, r4, r6\n\ + lsls r1, 3\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x18]\n\ + movs r2, 0\n\ + cmp r0, 0x1\n\ + bne _080410EA\n\ + movs r2, 0x1\n\ _080410EA:\n\ - adds r0, r2, 0\n\ - bl de_sub_804100C\n\ - b _08041102\n\ - .align 2, 0\n\ + adds r0, r2, 0\n\ + bl de_sub_804100C\n\ + b _08041102\n\ + .align 2, 0\n\ _080410F4: .4byte gTrainers\n\ _080410F8:\n\ - movs r0, 0xD\n\ - adds r1, r5, 0\n\ - muls r1, r0\n\ - ldr r0, _08041108 @ =gTrainerClassNames\n\ - adds r0, r1, r0\n\ + movs r0, 0xD\n\ + adds r1, r5, 0\n\ + muls r1, r0\n\ + ldr r0, _08041108 @ =gTrainerClassNames\n\ + adds r0, r1, r0\n\ _08041102:\n\ - pop {r4-r6}\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ + pop {r4-r6}\n\ + pop {r1}\n\ + bx r1\n\ + .align 2, 0\n\ _08041108: .4byte gTrainerClassNames\n\ .syntax divided\n"); } diff --git a/src/egg_hatch.c b/src/egg_hatch.c index 2b68d83e8..aa3d45250 100644 --- a/src/egg_hatch.c +++ b/src/egg_hatch.c @@ -323,69 +323,69 @@ __attribute__((naked)) static bool8 sub_8042ABC(void* a, u8 b) { asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - sub sp, 0x20\n\ - adds r5, r0, 0\n\ - lsls r4, r1, 24\n\ - lsrs r4, 24\n\ - lsls r0, r4, 2\n\ - adds r0, r4\n\ - lsls r0, 4\n\ - adds r0, r5, r0\n\ - mov r1, sp\n\ - bl GetBoxMonNick\n\ - lsls r0, r4, 3\n\ - subs r0, r4\n\ - lsls r1, r0, 3\n\ - adds r0, r5, r1\n\ - adds r0, 0xC0\n\ - ldrh r0, [r0]\n\ - cmp r0, 0\n\ - beq _08042B40\n\ - adds r0, r1, 0\n\ - adds r0, 0xA0\n\ - adds r5, r0\n\ - adds r6, r5, 0\n\ - adds r6, 0x2C\n\ - mov r0, sp\n\ - adds r1, r6, 0\n\ - bl StringCompareWithoutExtCtrlCodes\n\ - cmp r0, 0\n\ - bne _08042B08\n\ - ldr r0, _08042B30 @ =gSaveBlock2\n\ - adds r1, r5, 0\n\ - adds r1, 0x24\n\ - bl StringCompareWithoutExtCtrlCodes\n\ - cmp r0, 0\n\ - beq _08042B40\n\ + push {r4-r6,lr}\n\ + sub sp, 0x20\n\ + adds r5, r0, 0\n\ + lsls r4, r1, 24\n\ + lsrs r4, 24\n\ + lsls r0, r4, 2\n\ + adds r0, r4\n\ + lsls r0, 4\n\ + adds r0, r5, r0\n\ + mov r1, sp\n\ + bl GetBoxMonNick\n\ + lsls r0, r4, 3\n\ + subs r0, r4\n\ + lsls r1, r0, 3\n\ + adds r0, r5, r1\n\ + adds r0, 0xC0\n\ + ldrh r0, [r0]\n\ + cmp r0, 0\n\ + beq _08042B40\n\ + adds r0, r1, 0\n\ + adds r0, 0xA0\n\ + adds r5, r0\n\ + adds r6, r5, 0\n\ + adds r6, 0x2C\n\ + mov r0, sp\n\ + adds r1, r6, 0\n\ + bl StringCompareWithoutExtCtrlCodes\n\ + cmp r0, 0\n\ + bne _08042B08\n\ + ldr r0, _08042B30 @ =gSaveBlock2\n\ + adds r1, r5, 0\n\ + adds r1, 0x24\n\ + bl StringCompareWithoutExtCtrlCodes\n\ + cmp r0, 0\n\ + beq _08042B40\n\ _08042B08:\n\ - ldr r0, _08042B34 @ =gStringVar1\n\ - mov r1, sp\n\ - bl StringCopy\n\ - ldr r4, _08042B38 @ =gStringVar2\n\ - adds r1, r5, 0\n\ - adds r1, 0x24\n\ - adds r0, r4, 0\n\ - bl StringCopy\n\ - ldr r0, _08042B3C @ =gStringVar3\n\ - adds r1, r6, 0\n\ - bl StringCopy\n\ - adds r0, r4, 0\n\ - bl SanitizeNameString\n\ - movs r0, 0x1\n\ - b _08042B42\n\ - .align 2, 0\n\ + ldr r0, _08042B34 @ =gStringVar1\n\ + mov r1, sp\n\ + bl StringCopy\n\ + ldr r4, _08042B38 @ =gStringVar2\n\ + adds r1, r5, 0\n\ + adds r1, 0x24\n\ + adds r0, r4, 0\n\ + bl StringCopy\n\ + ldr r0, _08042B3C @ =gStringVar3\n\ + adds r1, r6, 0\n\ + bl StringCopy\n\ + adds r0, r4, 0\n\ + bl SanitizeNameString\n\ + movs r0, 0x1\n\ + b _08042B42\n\ + .align 2, 0\n\ _08042B30: .4byte gSaveBlock2\n\ _08042B34: .4byte gStringVar1\n\ _08042B38: .4byte gStringVar2\n\ _08042B3C: .4byte gStringVar3\n\ _08042B40:\n\ - movs r0, 0\n\ + movs r0, 0\n\ _08042B42:\n\ - add sp, 0x20\n\ - pop {r4-r6}\n\ - pop {r1}\n\ - bx r1\n\ + add sp, 0x20\n\ + pop {r4-r6}\n\ + pop {r1}\n\ + bx r1\n\ .syntax divided"); } diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c index a04f9d65b..78909e289 100644 --- a/src/hall_of_fame.c +++ b/src/hall_of_fame.c @@ -224,12 +224,12 @@ static const struct SpriteFrameImage sSpriteImageTable_840B67C[] = static const struct SpriteFrameImage* const sUnknown_0840B69C[7] = { sSpriteImageTable_840B5BC, - sSpriteImageTable_840B5DC, - sSpriteImageTable_840B5FC, - sSpriteImageTable_840B61C, - sSpriteImageTable_840B63C, - sSpriteImageTable_840B65C, - sSpriteImageTable_840B67C + sSpriteImageTable_840B5DC, + sSpriteImageTable_840B5FC, + sSpriteImageTable_840B61C, + sSpriteImageTable_840B63C, + sSpriteImageTable_840B65C, + sSpriteImageTable_840B67C }; static const struct SpriteTemplate sUnknown_0840B6B8 = @@ -365,22 +365,22 @@ static const union AnimCmd sSpriteAnim_840B758[] = static const union AnimCmd* const sSpriteAnimTable_840B760[] = { sSpriteAnim_840B6D8, - sSpriteAnim_840B6E0, - sSpriteAnim_840B6E8, - sSpriteAnim_840B6F0, - sSpriteAnim_840B6F8, - sSpriteAnim_840B700, - sSpriteAnim_840B708, - sSpriteAnim_840B710, - sSpriteAnim_840B718, - sSpriteAnim_840B720, - sSpriteAnim_840B728, - sSpriteAnim_840B730, - sSpriteAnim_840B738, - sSpriteAnim_840B740, - sSpriteAnim_840B748, - sSpriteAnim_840B750, - sSpriteAnim_840B758 + sSpriteAnim_840B6E0, + sSpriteAnim_840B6E8, + sSpriteAnim_840B6F0, + sSpriteAnim_840B6F8, + sSpriteAnim_840B700, + sSpriteAnim_840B708, + sSpriteAnim_840B710, + sSpriteAnim_840B718, + sSpriteAnim_840B720, + sSpriteAnim_840B728, + sSpriteAnim_840B730, + sSpriteAnim_840B738, + sSpriteAnim_840B740, + sSpriteAnim_840B748, + sSpriteAnim_840B750, + sSpriteAnim_840B758 }; static const struct SpriteTemplate sSpriteTemplate_840B7A4 = diff --git a/src/item_menu.c b/src/item_menu.c index fdc47ad67..4436bdfbe 100644 --- a/src/item_menu.c +++ b/src/item_menu.c @@ -2313,164 +2313,164 @@ __attribute__((naked)) static void sub_80A5600(u8 taskId) { asm(".syntax unified\n\ - push {r4,r5,lr}\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - movs r5, 0\n\ - ldr r2, _080A563C @ =gMain\n\ - ldrh r0, [r2, 0x30]\n\ - movs r1, 0xF0\n\ - ands r1, r0\n\ - cmp r1, 0x40\n\ - bne _080A5648\n\ - ldr r4, _080A5640 @ =sPopupMenuSelection\n\ - ldrb r0, [r4]\n\ - cmp r0, 0\n\ - bne _080A561E\n\ - b _080A5736\n\ + push {r4,r5,lr}\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + movs r5, 0\n\ + ldr r2, _080A563C @ =gMain\n\ + ldrh r0, [r2, 0x30]\n\ + movs r1, 0xF0\n\ + ands r1, r0\n\ + cmp r1, 0x40\n\ + bne _080A5648\n\ + ldr r4, _080A5640 @ =sPopupMenuSelection\n\ + ldrb r0, [r4]\n\ + cmp r0, 0\n\ + bne _080A561E\n\ + b _080A5736\n\ _080A561E:\n\ - adds r1, r0, 0\n\ - ldr r0, _080A5644 @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - adds r1, r0\n\ - subs r1, 0x1\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x8\n\ - bne _080A5630\n\ - b _080A5736\n\ + adds r1, r0, 0\n\ + ldr r0, _080A5644 @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + adds r1, r0\n\ + subs r1, 0x1\n\ + ldrb r0, [r1]\n\ + cmp r0, 0x8\n\ + bne _080A5630\n\ + b _080A5736\n\ _080A5630:\n\ - movs r0, 0x5\n\ - bl PlaySE\n\ - movs r0, 0x1\n\ - negs r0, r0\n\ - b _080A56D2\n\ - .align 2, 0\n\ + movs r0, 0x5\n\ + bl PlaySE\n\ + movs r0, 0x1\n\ + negs r0, r0\n\ + b _080A56D2\n\ + .align 2, 0\n\ _080A563C: .4byte gMain\n\ _080A5640: .4byte sPopupMenuSelection\n\ _080A5644: .4byte sPopupMenuActionList\n\ _080A5648:\n\ - cmp r1, 0x80\n\ - bne _080A5680\n\ - ldr r4, _080A5674 @ =sPopupMenuSelection\n\ - ldrb r1, [r4]\n\ - ldr r0, _080A5678 @ =gUnknown_02038564\n\ - ldrb r0, [r0]\n\ - subs r0, 0x1\n\ - cmp r1, r0\n\ - beq _080A5736\n\ - cmp r1, 0x2\n\ - beq _080A5736\n\ - ldr r0, _080A567C @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - adds r0, r1, r0\n\ - ldrb r0, [r0, 0x1]\n\ - cmp r0, 0x8\n\ - beq _080A5736\n\ - movs r0, 0x5\n\ - bl PlaySE\n\ - movs r0, 0x1\n\ - b _080A56D2\n\ - .align 2, 0\n\ + cmp r1, 0x80\n\ + bne _080A5680\n\ + ldr r4, _080A5674 @ =sPopupMenuSelection\n\ + ldrb r1, [r4]\n\ + ldr r0, _080A5678 @ =gUnknown_02038564\n\ + ldrb r0, [r0]\n\ + subs r0, 0x1\n\ + cmp r1, r0\n\ + beq _080A5736\n\ + cmp r1, 0x2\n\ + beq _080A5736\n\ + ldr r0, _080A567C @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + adds r0, r1, r0\n\ + ldrb r0, [r0, 0x1]\n\ + cmp r0, 0x8\n\ + beq _080A5736\n\ + movs r0, 0x5\n\ + bl PlaySE\n\ + movs r0, 0x1\n\ + b _080A56D2\n\ + .align 2, 0\n\ _080A5674: .4byte sPopupMenuSelection\n\ _080A5678: .4byte gUnknown_02038564\n\ _080A567C: .4byte sPopupMenuActionList\n\ _080A5680:\n\ - cmp r1, 0x20\n\ - bne _080A56B0\n\ - ldr r4, _080A56A8 @ =sPopupMenuSelection\n\ - ldrb r0, [r4]\n\ - cmp r0, 0x2\n\ - bls _080A5736\n\ - adds r1, r0, 0\n\ - ldr r0, _080A56AC @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - adds r1, r0\n\ - subs r1, 0x3\n\ - ldrb r0, [r1]\n\ - cmp r0, 0x8\n\ - beq _080A5736\n\ - movs r0, 0x5\n\ - bl PlaySE\n\ - movs r0, 0x3\n\ - negs r0, r0\n\ - b _080A56D2\n\ - .align 2, 0\n\ + cmp r1, 0x20\n\ + bne _080A56B0\n\ + ldr r4, _080A56A8 @ =sPopupMenuSelection\n\ + ldrb r0, [r4]\n\ + cmp r0, 0x2\n\ + bls _080A5736\n\ + adds r1, r0, 0\n\ + ldr r0, _080A56AC @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + adds r1, r0\n\ + subs r1, 0x3\n\ + ldrb r0, [r1]\n\ + cmp r0, 0x8\n\ + beq _080A5736\n\ + movs r0, 0x5\n\ + bl PlaySE\n\ + movs r0, 0x3\n\ + negs r0, r0\n\ + b _080A56D2\n\ + .align 2, 0\n\ _080A56A8: .4byte sPopupMenuSelection\n\ _080A56AC: .4byte sPopupMenuActionList\n\ _080A56B0:\n\ - cmp r1, 0x10\n\ - bne _080A56E4\n\ - ldr r4, _080A56DC @ =sPopupMenuSelection\n\ - ldrb r0, [r4]\n\ - cmp r0, 0x2\n\ - bhi _080A5736\n\ - adds r1, r0, 0\n\ - ldr r0, _080A56E0 @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - adds r1, r0\n\ - ldrb r0, [r1, 0x3]\n\ - cmp r0, 0x8\n\ - beq _080A5736\n\ - movs r0, 0x5\n\ - bl PlaySE\n\ - movs r0, 0x3\n\ + cmp r1, 0x10\n\ + bne _080A56E4\n\ + ldr r4, _080A56DC @ =sPopupMenuSelection\n\ + ldrb r0, [r4]\n\ + cmp r0, 0x2\n\ + bhi _080A5736\n\ + adds r1, r0, 0\n\ + ldr r0, _080A56E0 @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + adds r1, r0\n\ + ldrb r0, [r1, 0x3]\n\ + cmp r0, 0x8\n\ + beq _080A5736\n\ + movs r0, 0x5\n\ + bl PlaySE\n\ + movs r0, 0x3\n\ _080A56D2:\n\ - bl MoveMenuCursor3\n\ - strb r0, [r4]\n\ - b _080A5736\n\ - .align 2, 0\n\ + bl MoveMenuCursor3\n\ + strb r0, [r4]\n\ + b _080A5736\n\ + .align 2, 0\n\ _080A56DC: .4byte sPopupMenuSelection\n\ _080A56E0: .4byte sPopupMenuActionList\n\ _080A56E4:\n\ - ldrh r1, [r2, 0x2E]\n\ - movs r0, 0x1\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - bne _080A5768\n\ - movs r0, 0x2\n\ - ands r0, r1\n\ - cmp r0, 0\n\ - beq _080A5736\n\ - ldr r1, _080A574C @ =gTasks\n\ - lsls r0, r4, 2\n\ - adds r0, r4\n\ - lsls r0, 3\n\ - adds r0, r1\n\ - strh r5, [r0, 0x1C]\n\ - ldr r1, _080A5750 @ =gBagPocketScrollStates\n\ - ldr r0, _080A5754 @ =sCurrentBagPocket\n\ - ldrb r0, [r0]\n\ - lsls r0, 24\n\ - asrs r0, 24\n\ - lsls r0, 2\n\ - adds r0, r1\n\ - ldrb r2, [r0]\n\ - adds r0, r4, 0\n\ - adds r1, r2, 0\n\ - bl sub_80A48E8\n\ - ldr r0, _080A5758 @ =gBGTilemapBuffers + 0x800\n\ - bl sub_80A4DA4\n\ - ldr r1, _080A575C @ =sItemPopupMenuActions\n\ - ldr r0, _080A5760 @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - ldrb r0, [r0, 0x5]\n\ - lsls r0, 3\n\ - adds r1, 0x4\n\ - adds r0, r1\n\ - ldr r5, [r0]\n\ - adds r0, r4, 0\n\ - bl _call_via_r5\n\ + ldrh r1, [r2, 0x2E]\n\ + movs r0, 0x1\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + bne _080A5768\n\ + movs r0, 0x2\n\ + ands r0, r1\n\ + cmp r0, 0\n\ + beq _080A5736\n\ + ldr r1, _080A574C @ =gTasks\n\ + lsls r0, r4, 2\n\ + adds r0, r4\n\ + lsls r0, 3\n\ + adds r0, r1\n\ + strh r5, [r0, 0x1C]\n\ + ldr r1, _080A5750 @ =gBagPocketScrollStates\n\ + ldr r0, _080A5754 @ =sCurrentBagPocket\n\ + ldrb r0, [r0]\n\ + lsls r0, 24\n\ + asrs r0, 24\n\ + lsls r0, 2\n\ + adds r0, r1\n\ + ldrb r2, [r0]\n\ + adds r0, r4, 0\n\ + adds r1, r2, 0\n\ + bl sub_80A48E8\n\ + ldr r0, _080A5758 @ =gBGTilemapBuffers + 0x800\n\ + bl sub_80A4DA4\n\ + ldr r1, _080A575C @ =sItemPopupMenuActions\n\ + ldr r0, _080A5760 @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + ldrb r0, [r0, 0x5]\n\ + lsls r0, 3\n\ + adds r1, 0x4\n\ + adds r0, r1\n\ + ldr r5, [r0]\n\ + adds r0, r4, 0\n\ + bl _call_via_r5\n\ _080A5736:\n\ - cmp r5, 0\n\ - bne _080A57BE\n\ - ldr r0, _080A5764 @ =sPopupMenuSelection\n\ - ldrb r0, [r0]\n\ - cmp r0, 0\n\ - bne _080A57AC\n\ - movs r0, 0xC\n\ - bl sub_8072DDC\n\ - b _080A57BE\n\ - .align 2, 0\n\ + cmp r5, 0\n\ + bne _080A57BE\n\ + ldr r0, _080A5764 @ =sPopupMenuSelection\n\ + ldrb r0, [r0]\n\ + cmp r0, 0\n\ + bne _080A57AC\n\ + movs r0, 0xC\n\ + bl sub_8072DDC\n\ + b _080A57BE\n\ + .align 2, 0\n\ _080A574C: .4byte gTasks\n\ _080A5750: .4byte gBagPocketScrollStates\n\ _080A5754: .4byte sCurrentBagPocket\n\ @@ -2479,47 +2479,47 @@ _080A575C: .4byte sItemPopupMenuActions\n\ _080A5760: .4byte sPopupMenuActionList\n\ _080A5764: .4byte sPopupMenuSelection\n\ _080A5768:\n\ - ldr r1, _080A5798 @ =gTasks\n\ - lsls r0, r4, 2\n\ - adds r0, r4\n\ - lsls r0, 3\n\ - adds r0, r1\n\ - strh r5, [r0, 0x1C]\n\ - ldr r0, _080A579C @ =gBGTilemapBuffers + 0x800\n\ - bl sub_80A4DA4\n\ - ldr r1, _080A57A0 @ =sItemPopupMenuActions\n\ - ldr r0, _080A57A4 @ =sPopupMenuSelection\n\ - ldrb r2, [r0]\n\ - ldr r0, _080A57A8 @ =sPopupMenuActionList\n\ - ldr r0, [r0]\n\ - adds r0, r2\n\ - ldrb r0, [r0]\n\ - lsls r0, 3\n\ - adds r1, 0x4\n\ - adds r0, r1\n\ - ldr r5, [r0]\n\ - adds r0, r4, 0\n\ - bl _call_via_r5\n\ - b _080A5736\n\ - .align 2, 0\n\ + ldr r1, _080A5798 @ =gTasks\n\ + lsls r0, r4, 2\n\ + adds r0, r4\n\ + lsls r0, 3\n\ + adds r0, r1\n\ + strh r5, [r0, 0x1C]\n\ + ldr r0, _080A579C @ =gBGTilemapBuffers + 0x800\n\ + bl sub_80A4DA4\n\ + ldr r1, _080A57A0 @ =sItemPopupMenuActions\n\ + ldr r0, _080A57A4 @ =sPopupMenuSelection\n\ + ldrb r2, [r0]\n\ + ldr r0, _080A57A8 @ =sPopupMenuActionList\n\ + ldr r0, [r0]\n\ + adds r0, r2\n\ + ldrb r0, [r0]\n\ + lsls r0, 3\n\ + adds r1, 0x4\n\ + adds r0, r1\n\ + ldr r5, [r0]\n\ + adds r0, r4, 0\n\ + bl _call_via_r5\n\ + b _080A5736\n\ + .align 2, 0\n\ _080A5798: .4byte gTasks\n\ _080A579C: .4byte gBGTilemapBuffers + 0x800\n\ _080A57A0: .4byte sItemPopupMenuActions\n\ _080A57A4: .4byte sPopupMenuSelection\n\ _080A57A8: .4byte sPopupMenuActionList\n\ _080A57AC:\n\ - cmp r0, 0x2\n\ - bhi _080A57B8\n\ - movs r0, 0x2F\n\ - bl sub_8072DCC\n\ - b _080A57BE\n\ + cmp r0, 0x2\n\ + bhi _080A57B8\n\ + movs r0, 0x2F\n\ + bl sub_8072DCC\n\ + b _080A57BE\n\ _080A57B8:\n\ - movs r0, 0x30\n\ - bl sub_8072DCC\n\ + movs r0, 0x30\n\ + bl sub_8072DCC\n\ _080A57BE:\n\ - pop {r4,r5}\n\ - pop {r0}\n\ - bx r0\n\ + pop {r4,r5}\n\ + pop {r0}\n\ + bx r0\n\ .syntax divided\n"); } diff --git a/src/menu.c b/src/menu.c index ef458124b..1096fa0bd 100644 --- a/src/menu.c +++ b/src/menu.c @@ -630,82 +630,82 @@ __attribute__((naked)) int sub_8072AB0(const u8 *str, u8 left, u16 top, u8 width, u8 height, u32 a6) { asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - sub sp, 0x10\n\ - mov r12, r0\n\ - ldr r0, [sp, 0x24]\n\ - ldr r4, [sp, 0x28]\n\ - str r4, [sp, 0xC]\n\ - lsls r1, 24\n\ - lsrs r5, r1, 24\n\ - lsls r2, 16\n\ - lsrs r4, r2, 16\n\ - lsls r3, 24\n\ - lsrs r6, r3, 24\n\ - lsls r0, 24\n\ - lsrs r7, r0, 24\n\ - ldr r0, _08072AF8 @ =gMenuWindowPtr\n\ - ldr r0, [r0]\n\ - ldr r1, _08072AFC @ =gMenuTextTileOffset\n\ - ldrh r3, [r1]\n\ - str r5, [sp]\n\ - str r4, [sp, 0x4]\n\ - str r6, [sp, 0x8]\n\ - movs r1, 0\n\ - mov r2, r12\n\ - bl sub_8004FD0\n\ - adds r1, r0, 0\n\ - lsls r1, 24\n\ - lsrs r2, r1, 24\n\ - movs r3, 0x7\n\ - ands r3, r5\n\ - cmp r3, 0\n\ - bne _08072B00\n\ - adds r1, r6, 0x7\n\ - asrs r1, 3\n\ - subs r1, 0x1\n\ - b _08072B0C\n\ - .align 2, 0\n\ + push {r4-r7,lr}\n\ + sub sp, 0x10\n\ + mov r12, r0\n\ + ldr r0, [sp, 0x24]\n\ + ldr r4, [sp, 0x28]\n\ + str r4, [sp, 0xC]\n\ + lsls r1, 24\n\ + lsrs r5, r1, 24\n\ + lsls r2, 16\n\ + lsrs r4, r2, 16\n\ + lsls r3, 24\n\ + lsrs r6, r3, 24\n\ + lsls r0, 24\n\ + lsrs r7, r0, 24\n\ + ldr r0, _08072AF8 @ =gMenuWindowPtr\n\ + ldr r0, [r0]\n\ + ldr r1, _08072AFC @ =gMenuTextTileOffset\n\ + ldrh r3, [r1]\n\ + str r5, [sp]\n\ + str r4, [sp, 0x4]\n\ + str r6, [sp, 0x8]\n\ + movs r1, 0\n\ + mov r2, r12\n\ + bl sub_8004FD0\n\ + adds r1, r0, 0\n\ + lsls r1, 24\n\ + lsrs r2, r1, 24\n\ + movs r3, 0x7\n\ + ands r3, r5\n\ + cmp r3, 0\n\ + bne _08072B00\n\ + adds r1, r6, 0x7\n\ + asrs r1, 3\n\ + subs r1, 0x1\n\ + b _08072B0C\n\ + .align 2, 0\n\ _08072AF8: .4byte gMenuWindowPtr\n\ _08072AFC: .4byte gMenuTextTileOffset\n\ _08072B00:\n\ - adds r3, r6, r3\n\ - subs r1, r3, 0x1\n\ - cmp r1, 0\n\ - bge _08072B0A\n\ - adds r1, r3, 0x6\n\ + adds r3, r6, r3\n\ + subs r1, r3, 0x1\n\ + cmp r1, 0\n\ + bge _08072B0A\n\ + adds r1, r3, 0x6\n\ _08072B0A:\n\ - asrs r1, 3\n\ + asrs r1, 3\n\ _08072B0C:\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - adds r6, r1, 0\n\ - lsrs r5, 3\n\ - adds r1, r7, 0x7\n\ - asrs r1, 3\n\ - lsls r1, 24\n\ - lsrs r7, r1, 24\n\ - lsrs r4, 3\n\ - cmp r2, r7\n\ - bcs _08072B3E\n\ - lsls r1, r2, 1\n\ - adds r1, r4, r1\n\ - lsls r1, 24\n\ - lsrs r1, 24\n\ - adds r2, r5, r6\n\ - lsls r2, 24\n\ - lsrs r2, 24\n\ - adds r3, r7, r4\n\ - subs r3, 0x1\n\ - lsls r3, 24\n\ - lsrs r3, 24\n\ - adds r0, r5, 0\n\ - bl MenuFillWindowRectWithBlankTile\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + adds r6, r1, 0\n\ + lsrs r5, 3\n\ + adds r1, r7, 0x7\n\ + asrs r1, 3\n\ + lsls r1, 24\n\ + lsrs r7, r1, 24\n\ + lsrs r4, 3\n\ + cmp r2, r7\n\ + bcs _08072B3E\n\ + lsls r1, r2, 1\n\ + adds r1, r4, r1\n\ + lsls r1, 24\n\ + lsrs r1, 24\n\ + adds r2, r5, r6\n\ + lsls r2, 24\n\ + lsrs r2, 24\n\ + adds r3, r7, r4\n\ + subs r3, 0x1\n\ + lsls r3, 24\n\ + lsrs r3, 24\n\ + adds r0, r5, 0\n\ + bl MenuFillWindowRectWithBlankTile\n\ _08072B3E:\n\ - add sp, 0x10\n\ - pop {r4-r7}\n\ - pop {r1}\n\ - bx r1\n\ + add sp, 0x10\n\ + pop {r4-r7}\n\ + pop {r1}\n\ + bx r1\n\ .syntax divided\n"); } #endif diff --git a/src/option_menu.c b/src/option_menu.c index 7f8d76528..dfc49b035 100644 --- a/src/option_menu.c +++ b/src/option_menu.c @@ -486,61 +486,61 @@ __attribute__((naked)) static void FrameType_DrawChoices(u8 selection) { asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - sub sp, 0x10\n\ - lsls r0, 24\n\ - movs r1, 0x80\n\ - lsls r1, 17\n\ - adds r0, r1\n\ - lsrs r5, r0, 24\n\ - ldr r1, _0808C368 @ =gSystemText_Type\n\ - mov r0, sp\n\ - bl StringCopy\n\ - ldr r1, _0808C36C @ =gSystemText_Terminator\n\ - mov r0, sp\n\ - bl StringAppend\n\ - adds r4, r0, 0\n\ - adds r0, r5, 0\n\ - movs r1, 0xA\n\ - bl __udivsi3\n\ - adds r1, r0, 0\n\ - lsls r0, r1, 24\n\ - lsrs r6, r0, 24\n\ - cmp r6, 0\n\ - beq _0808C370\n\ - adds r0, r1, 0\n\ - adds r0, 0xA1\n\ - strb r0, [r4]\n\ - adds r4, 0x1\n\ - adds r0, r5, 0\n\ - movs r1, 0xA\n\ - bl __umodsi3\n\ - adds r0, 0xA1\n\ - strb r0, [r4]\n\ - b _0808C380\n\ - .align 2, 0\n\ + push {r4-r6,lr}\n\ + sub sp, 0x10\n\ + lsls r0, 24\n\ + movs r1, 0x80\n\ + lsls r1, 17\n\ + adds r0, r1\n\ + lsrs r5, r0, 24\n\ + ldr r1, _0808C368 @ =gSystemText_Type\n\ + mov r0, sp\n\ + bl StringCopy\n\ + ldr r1, _0808C36C @ =gSystemText_Terminator\n\ + mov r0, sp\n\ + bl StringAppend\n\ + adds r4, r0, 0\n\ + adds r0, r5, 0\n\ + movs r1, 0xA\n\ + bl __udivsi3\n\ + adds r1, r0, 0\n\ + lsls r0, r1, 24\n\ + lsrs r6, r0, 24\n\ + cmp r6, 0\n\ + beq _0808C370\n\ + adds r0, r1, 0\n\ + adds r0, 0xA1\n\ + strb r0, [r4]\n\ + adds r4, 0x1\n\ + adds r0, r5, 0\n\ + movs r1, 0xA\n\ + bl __umodsi3\n\ + adds r0, 0xA1\n\ + strb r0, [r4]\n\ + b _0808C380\n\ + .align 2, 0\n\ _0808C368: .4byte gSystemText_Type\n\ _0808C36C: .4byte gSystemText_Terminator\n\ _0808C370:\n\ - adds r0, r5, 0\n\ - movs r1, 0xA\n\ - bl __umodsi3\n\ - adds r0, 0xA1\n\ - strb r0, [r4]\n\ - adds r4, 0x1\n\ - strb r6, [r4]\n\ + adds r0, r5, 0\n\ + movs r1, 0xA\n\ + bl __umodsi3\n\ + adds r0, 0xA1\n\ + strb r0, [r4]\n\ + adds r4, 0x1\n\ + strb r6, [r4]\n\ _0808C380:\n\ - adds r4, 0x1\n\ - movs r0, 0xFF\n\ - strb r0, [r4]\n\ - mov r0, sp\n\ - movs r1, 0xF\n\ - movs r2, 0xF\n\ - bl MenuPrint\n\ - add sp, 0x10\n\ - pop {r4-r6}\n\ - pop {r0}\n\ - bx r0\n\ + adds r4, 0x1\n\ + movs r0, 0xFF\n\ + strb r0, [r4]\n\ + mov r0, sp\n\ + movs r1, 0xF\n\ + movs r2, 0xF\n\ + bl MenuPrint\n\ + add sp, 0x10\n\ + pop {r4-r6}\n\ + pop {r0}\n\ + bx r0\n\ .syntax divided\n"); } #endif diff --git a/src/pokeblock_feed.c b/src/pokeblock_feed.c index 8dc2f47de..db4db55a7 100644 --- a/src/pokeblock_feed.c +++ b/src/pokeblock_feed.c @@ -121,109 +121,109 @@ static const u8 sNatureToMonPokeblockAnim[][2] = static const s16 sMonPokeblockAnims[][10] = { // HARDY - { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, - { 0, 4, 0, 16, 24, 0, 0, 0, 12, 0}, - { 0, 4, 0, 32, 32, 0, 0, 0, 16, 1}, - - // LONELY - { 0, 3, 6, 0, 48, 0, 0, 0, 24, 1}, - - // BRAVE - { 64, 16, -24, 0, 32, 0, 0, 0, 0, 1}, - - // ADAMANT - { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, - { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, - { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, - { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, - { 0, 4, -16, 0, 4, 0, 16, 0, 0, 1}, - - // NAUGHTY - { 0, 3, 6, 0, 12, 0, 0, 0, 6, 0}, - { 0, 3, -6, 0, 12, 0, 0, 0, 6, 0}, - { 0, 16, 16, 0, 45, 1, 0, 0, 0, 1}, - - // BOLD - { 0, 16, 0, 24, 32, 0, 0, 0, 16, 0}, - { 0, 16, 0, 23, 32, 0, 0, 0, 16, 1}, - - // DOCILE - { 0, 0, 0, 0, 80, 0, 0, 0, 0, 1}, - - // RELAXED - { 0, 2, 8, 0, 32, 0, 0, 0, 0, 0}, - { 0, 2, -8, 0, 32, 0, 0, 0, 0, 1}, - - // IMPISH - { 0, 32, 2, 1, 48, 1, 0, 0, 24, 1}, - - // LAX - { 0, 2, 16, 16, 128, 0, 0, 0, 0, 1}, - - // TIMID - { 0, 2, -8, 0, 48, 0, -24, 0, 0, 0}, - { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, - { 64, 32, 2, 0, 36, 0, 0, 0, 0, 0}, - { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, - { 0, 2, 8, 0, 48, 0, 24, 0, 0, 1}, - - // HASTY - { 64, 24, 16, 0, 32, 0, 0, 0, 0, 0}, - { 0, 28, 2, 1, 32, 1, 0, 0, 16, 1}, - - // SERIOUS - { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, - - // JOLLY - { 64, 16, -16, 2, 48, 0, 0, 0, 32, 1}, - - // NAIVE - { 0, 12, -8, 4, 24, 0, 8, 0, 12, 0}, - { 0, 12, 8, 8, 24, 0, -16, 0, 12, 0}, - { 0, 12, -8, 16, 24, 0, 16, 0, 12, 0}, - { 0, 12, 8, 28, 24, 0, -8, 0, 12, 1}, - - // MODEST - { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, - { 64, 16, -4, 0, 32, 0, 0, 0, 0, 0}, - { 0, 0, 0, 0, 8, 0, 0, 0, 0, 1}, - - // MILD - { 128, 4, 0, 8, 64, 0, 0, 0, 0, 1}, - - // QUIET - { 0, 2, 16, 0, 48, 0, 0, 0, 0, 0}, - { 128, 2, 16, 0, 48, 0, 0, 0, 0, 1}, - - // BASHFUL - { 0, 2, -4, 0, 48, 0, -48, 0, 0, 0}, - { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, - { 0, 2, 8, 0, 24, 0, 48, 0, 0, 1}, - - // RASH - { 64, 4, 64, 58, 52, 0, -88, 0, 0, 0}, - { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, - { 0, 24, 80, 0, 32, 0, 88, 0, 0, 1}, - - // CALM - { 0, 2, 16, 4, 64, 0, 0, 0, 0, 1}, - - // GENTLE - { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, - - // SASSY - { 0, 0, 0, 0, 42, 0, 0, 0, 0, 1}, - - // CAREFUL - { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, - { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, - { 0, 4, 0, 12, 24, 0, 0, 0, 12, 0}, - { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, - { 0, 4, 0, 4, 24, 0, 0, 0, 12, 1}, - - // QUIRKY - { 0, 4, 16, 12, 64, 0, 0, 0, 0, 0}, - { 0, -4, 16, 12, 64, 0, 0, 0, 0, 1}, + { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, + { 0, 4, 0, 16, 24, 0, 0, 0, 12, 0}, + { 0, 4, 0, 32, 32, 0, 0, 0, 16, 1}, + + // LONELY + { 0, 3, 6, 0, 48, 0, 0, 0, 24, 1}, + + // BRAVE + { 64, 16, -24, 0, 32, 0, 0, 0, 0, 1}, + + // ADAMANT + { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, + { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, + { 0, 4, 8, 0, 16, 0, -8, 0, 0, 0}, + { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0}, + { 0, 4, -16, 0, 4, 0, 16, 0, 0, 1}, + + // NAUGHTY + { 0, 3, 6, 0, 12, 0, 0, 0, 6, 0}, + { 0, 3, -6, 0, 12, 0, 0, 0, 6, 0}, + { 0, 16, 16, 0, 45, 1, 0, 0, 0, 1}, + + // BOLD + { 0, 16, 0, 24, 32, 0, 0, 0, 16, 0}, + { 0, 16, 0, 23, 32, 0, 0, 0, 16, 1}, + + // DOCILE + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 1}, + + // RELAXED + { 0, 2, 8, 0, 32, 0, 0, 0, 0, 0}, + { 0, 2, -8, 0, 32, 0, 0, 0, 0, 1}, + + // IMPISH + { 0, 32, 2, 1, 48, 1, 0, 0, 24, 1}, + + // LAX + { 0, 2, 16, 16, 128, 0, 0, 0, 0, 1}, + + // TIMID + { 0, 2, -8, 0, 48, 0, -24, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 64, 32, 2, 0, 36, 0, 0, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 0, 2, 8, 0, 48, 0, 24, 0, 0, 1}, + + // HASTY + { 64, 24, 16, 0, 32, 0, 0, 0, 0, 0}, + { 0, 28, 2, 1, 32, 1, 0, 0, 16, 1}, + + // SERIOUS + { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, + + // JOLLY + { 64, 16, -16, 2, 48, 0, 0, 0, 32, 1}, + + // NAIVE + { 0, 12, -8, 4, 24, 0, 8, 0, 12, 0}, + { 0, 12, 8, 8, 24, 0, -16, 0, 12, 0}, + { 0, 12, -8, 16, 24, 0, 16, 0, 12, 0}, + { 0, 12, 8, 28, 24, 0, -8, 0, 12, 1}, + + // MODEST + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 0}, + { 64, 16, -4, 0, 32, 0, 0, 0, 0, 0}, + { 0, 0, 0, 0, 8, 0, 0, 0, 0, 1}, + + // MILD + { 128, 4, 0, 8, 64, 0, 0, 0, 0, 1}, + + // QUIET + { 0, 2, 16, 0, 48, 0, 0, 0, 0, 0}, + { 128, 2, 16, 0, 48, 0, 0, 0, 0, 1}, + + // BASHFUL + { 0, 2, -4, 0, 48, 0, -48, 0, 0, 0}, + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, + { 0, 2, 8, 0, 24, 0, 48, 0, 0, 1}, + + // RASH + { 64, 4, 64, 58, 52, 0, -88, 0, 0, 0}, + { 0, 0, 0, 0, 80, 0, 0, 0, 0, 0}, + { 0, 24, 80, 0, 32, 0, 88, 0, 0, 1}, + + // CALM + { 0, 2, 16, 4, 64, 0, 0, 0, 0, 1}, + + // GENTLE + { 0, 0, 0, 0, 32, 0, 0, 0, 0, 1}, + + // SASSY + { 0, 0, 0, 0, 42, 0, 0, 0, 0, 1}, + + // CAREFUL + { 0, 4, 0, 8, 24, 0, 0, 0, 12, 0}, + { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, + { 0, 4, 0, 12, 24, 0, 0, 0, 12, 0}, + { 0, 0, 0, 0, 12, 0, 0, 0, 0, 0}, + { 0, 4, 0, 4, 24, 0, 0, 0, 12, 1}, + + // QUIRKY + { 0, 4, 16, 12, 64, 0, 0, 0, 0, 0}, + { 0, -4, 16, 12, 64, 0, 0, 0, 0, 1}, }; static const union AffineAnimCmd sSpriteAffineAnim_8411E90[] = @@ -251,130 +251,130 @@ static const union AffineAnimCmd sSpriteAffineAnim_8411EC0[] = static const union AffineAnimCmd sSpriteAffineAnim_8411EE8[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411F08[] = { - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 16), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411F30[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411F50[] = { - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411F78[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411F98[] = { - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 32), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 8), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411FC0[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8411FE0[] = { - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, -1, 4), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 4), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8412008[] = { - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8412028[] = { - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), - AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 1, 24), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 16), + AFFINEANIMCMD_FRAME(0x0, 0x0, -12, 2), + AFFINEANIMCMD_END }; static const union AffineAnimCmd *const sSpriteAffineAnimTable_8412050[] = { - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411EA0, - sSpriteAffineAnim_8411EE8, - sSpriteAffineAnim_8411F30, - sSpriteAffineAnim_8411F78, - sSpriteAffineAnim_8411FC0, - sSpriteAffineAnim_8412008, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411EC0, - sSpriteAffineAnim_8411F08, - sSpriteAffineAnim_8411F50, - sSpriteAffineAnim_8411F98, - sSpriteAffineAnim_8411FE0, - sSpriteAffineAnim_8412028, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, - sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411EA0, + sSpriteAffineAnim_8411EE8, + sSpriteAffineAnim_8411F30, + sSpriteAffineAnim_8411F78, + sSpriteAffineAnim_8411FC0, + sSpriteAffineAnim_8412008, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411EC0, + sSpriteAffineAnim_8411F08, + sSpriteAffineAnim_8411F50, + sSpriteAffineAnim_8411F98, + sSpriteAffineAnim_8411FE0, + sSpriteAffineAnim_8412028, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, + sSpriteAffineAnim_8411E90, }; static const u8* const sPokeblocksPals[] = { gPokeblockRed_Pal, - gPokeblockBlue_Pal, - gPokeblockPink_Pal, - gPokeblockGreen_Pal, - gPokeblockYellow_Pal, - gPokeblockPurple_Pal, - gPokeblockIndigo_Pal, - gPokeblockBrown_Pal, - gPokeblockLiteBlue_Pal, - gPokeblockOlive_Pal, - gPokeblockGray_Pal, - gPokeblockBlack_Pal, - gPokeblockWhite_Pal, - gPokeblockGold_Pal + gPokeblockBlue_Pal, + gPokeblockPink_Pal, + gPokeblockGreen_Pal, + gPokeblockYellow_Pal, + gPokeblockPurple_Pal, + gPokeblockIndigo_Pal, + gPokeblockBrown_Pal, + gPokeblockLiteBlue_Pal, + gPokeblockOlive_Pal, + gPokeblockGray_Pal, + gPokeblockBlack_Pal, + gPokeblockWhite_Pal, + gPokeblockGold_Pal }; static const union AffineAnimCmd sSpriteAffineAnim_84120DC[] = @@ -391,31 +391,31 @@ static const union AffineAnimCmd *const sSpriteAffineAnimTable_84120EC[] = static const union AffineAnimCmd sSpriteAffineAnim_84120F0[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 16, 1), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_END }; static const union AffineAnimCmd sSpriteAffineAnim_8412148[] = { AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), - AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), - AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), - AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), - AFFINEANIMCMD_END + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, 0, 8), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(0x0, 0x0, -16, 1), + AFFINEANIMCMD_FRAME(-0x100, 0x100, 0, 0), + AFFINEANIMCMD_END }; static const union AffineAnimCmd *const sSpriteAffineAnimTable_84121A0[] = @@ -464,8 +464,8 @@ static const union AnimCmd *const sThrownPokeblockAnimTable[] = static const union AffineAnimCmd sSpriteAffineAnim_84121C0[] = { AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), - AFFINEANIMCMD_FRAME(-8, -8, 0, 1), - AFFINEANIMCMD_JUMP(1) + AFFINEANIMCMD_FRAME(-8, -8, 0, 1), + AFFINEANIMCMD_JUMP(1) }; static const union AffineAnimCmd *const sThrownPokeblockAffineAnimTable[] = diff --git a/src/rotating_gate.c b/src/rotating_gate.c index bb3c31dfc..b88add469 100644 --- a/src/rotating_gate.c +++ b/src/rotating_gate.c @@ -881,115 +881,115 @@ static int RotatingGate_CanRotate(u8 gateId, int rotationDirection) __attribute__((naked)) static int RotatingGate_CanRotate(u8 a, int puzzleType) { asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - sub sp, 0xC\n\ - lsls r0, 24\n\ - lsrs r4, r0, 24\n\ - cmp r1, 0x1\n\ - bne _080C7EAC\n\ - ldr r0, _080C7EA8 @ =sRotatingGate_ArmPositionsAntiClockwiseRotation\n\ - mov r10, r0\n\ - b _080C7EB8\n\ - .align 2, 0\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + sub sp, 0xC\n\ + lsls r0, 24\n\ + lsrs r4, r0, 24\n\ + cmp r1, 0x1\n\ + bne _080C7EAC\n\ + ldr r0, _080C7EA8 @ =sRotatingGate_ArmPositionsAntiClockwiseRotation\n\ + mov r10, r0\n\ + b _080C7EB8\n\ + .align 2, 0\n\ _080C7EA8: .4byte sRotatingGate_ArmPositionsAntiClockwiseRotation\n\ _080C7EAC:\n\ - cmp r1, 0x2\n\ - beq _080C7EB4\n\ + cmp r1, 0x2\n\ + beq _080C7EB4\n\ _080C7EB0:\n\ - movs r0, 0\n\ - b _080C7F48\n\ + movs r0, 0\n\ + b _080C7F48\n\ _080C7EB4:\n\ - ldr r1, _080C7F58 @ =sRotatingGate_ArmPositionsClockwiseRotation\n\ - mov r10, r1\n\ + ldr r1, _080C7F58 @ =sRotatingGate_ArmPositionsClockwiseRotation\n\ + mov r10, r1\n\ _080C7EB8:\n\ - adds r0, r4, 0\n\ - bl RotatingGate_GetGateOrientation\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp]\n\ - ldr r0, _080C7F5C @ =gRotatingGate_PuzzleConfig\n\ - ldr r1, [r0]\n\ - lsls r0, r4, 3\n\ - adds r0, r1\n\ - ldrb r2, [r0, 0x4]\n\ - ldrh r1, [r0]\n\ - adds r1, 0x7\n\ - ldrh r0, [r0, 0x2]\n\ - adds r0, 0x7\n\ - movs r3, 0\n\ - lsls r2, 3\n\ - str r2, [sp, 0x4]\n\ - lsls r1, 16\n\ - asrs r1, 16\n\ - mov r9, r1\n\ - lsls r0, 16\n\ - asrs r0, 16\n\ - mov r8, r0\n\ + adds r0, r4, 0\n\ + bl RotatingGate_GetGateOrientation\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + str r0, [sp]\n\ + ldr r0, _080C7F5C @ =gRotatingGate_PuzzleConfig\n\ + ldr r1, [r0]\n\ + lsls r0, r4, 3\n\ + adds r0, r1\n\ + ldrb r2, [r0, 0x4]\n\ + ldrh r1, [r0]\n\ + adds r1, 0x7\n\ + ldrh r0, [r0, 0x2]\n\ + adds r0, 0x7\n\ + movs r3, 0\n\ + lsls r2, 3\n\ + str r2, [sp, 0x4]\n\ + lsls r1, 16\n\ + asrs r1, 16\n\ + mov r9, r1\n\ + lsls r0, 16\n\ + asrs r0, 16\n\ + mov r8, r0\n\ _080C7EE8:\n\ - movs r6, 0\n\ - ldr r2, [sp]\n\ - adds r7, r2, r3\n\ - lsls r0, r3, 1\n\ - adds r5, r7, 0\n\ - ldr r1, [sp, 0x4]\n\ - adds r0, r1\n\ - ldr r2, _080C7F60 @ =sRotatingGate_ArmLayout\n\ - adds r4, r0, r2\n\ + movs r6, 0\n\ + ldr r2, [sp]\n\ + adds r7, r2, r3\n\ + lsls r0, r3, 1\n\ + adds r5, r7, 0\n\ + ldr r1, [sp, 0x4]\n\ + adds r0, r1\n\ + ldr r2, _080C7F60 @ =sRotatingGate_ArmLayout\n\ + adds r4, r0, r2\n\ _080C7EFA:\n\ - adds r0, r5, 0\n\ - cmp r5, 0\n\ - bge _080C7F02\n\ - adds r0, r7, 0x3\n\ + adds r0, r5, 0\n\ + cmp r5, 0\n\ + bge _080C7F02\n\ + adds r0, r7, 0x3\n\ _080C7F02:\n\ - asrs r0, 2\n\ - lsls r0, 2\n\ - subs r0, r5, r0\n\ - lsls r0, 1\n\ - adds r0, r6\n\ - lsls r0, 24\n\ - lsrs r1, r0, 24\n\ - ldrb r0, [r4]\n\ - cmp r0, 0\n\ - beq _080C7F38\n\ - lsls r1, 2\n\ - add r1, r10\n\ - movs r0, 0\n\ - ldrsb r0, [r1, r0]\n\ - add r0, r9\n\ - ldrb r1, [r1, 0x1]\n\ - lsls r1, 24\n\ - asrs r1, 24\n\ - add r1, r8\n\ - str r3, [sp, 0x8]\n\ - bl MapGridIsImpassableAt\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - ldr r3, [sp, 0x8]\n\ - cmp r0, 0x1\n\ - beq _080C7EB0\n\ + asrs r0, 2\n\ + lsls r0, 2\n\ + subs r0, r5, r0\n\ + lsls r0, 1\n\ + adds r0, r6\n\ + lsls r0, 24\n\ + lsrs r1, r0, 24\n\ + ldrb r0, [r4]\n\ + cmp r0, 0\n\ + beq _080C7F38\n\ + lsls r1, 2\n\ + add r1, r10\n\ + movs r0, 0\n\ + ldrsb r0, [r1, r0]\n\ + add r0, r9\n\ + ldrb r1, [r1, 0x1]\n\ + lsls r1, 24\n\ + asrs r1, 24\n\ + add r1, r8\n\ + str r3, [sp, 0x8]\n\ + bl MapGridIsImpassableAt\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + ldr r3, [sp, 0x8]\n\ + cmp r0, 0x1\n\ + beq _080C7EB0\n\ _080C7F38:\n\ - adds r4, 0x1\n\ - adds r6, 0x1\n\ - cmp r6, 0x1\n\ - ble _080C7EFA\n\ - adds r3, 0x1\n\ - cmp r3, 0x3\n\ - ble _080C7EE8\n\ - movs r0, 0x1\n\ + adds r4, 0x1\n\ + adds r6, 0x1\n\ + cmp r6, 0x1\n\ + ble _080C7EFA\n\ + adds r3, 0x1\n\ + cmp r3, 0x3\n\ + ble _080C7EE8\n\ + movs r0, 0x1\n\ _080C7F48:\n\ - add sp, 0xC\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\n\ - .align 2, 0\n\ + add sp, 0xC\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\n\ + .align 2, 0\n\ _080C7F58: .4byte sRotatingGate_ArmPositionsClockwiseRotation\n\ _080C7F5C: .4byte gRotatingGate_PuzzleConfig\n\ _080C7F60: .4byte sRotatingGate_ArmLayout\n\ @@ -1016,45 +1016,45 @@ static int RotatingGate_HasArm(u8 gateId, u8 armInfo) __attribute__((naked)) static int RotatingGate_HasArm(u8 a, u8 b) { asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - adds r4, r1, 0\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r6, r0, 0\n\ - lsls r4, 24\n\ - lsrs r5, r4, 24\n\ - lsrs r4, 25\n\ - movs r0, 0x1\n\ - ands r5, r0\n\ - adds r0, r6, 0\n\ - bl RotatingGate_GetGateOrientation\n\ - subs r4, r0\n\ - adds r1, r4, 0x4\n\ - adds r0, r1, 0\n\ - cmp r1, 0\n\ - bge _080C7F8A\n\ - adds r0, r4, 0x7\n\ + push {r4-r6,lr}\n\ + adds r4, r1, 0\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + adds r6, r0, 0\n\ + lsls r4, 24\n\ + lsrs r5, r4, 24\n\ + lsrs r4, 25\n\ + movs r0, 0x1\n\ + ands r5, r0\n\ + adds r0, r6, 0\n\ + bl RotatingGate_GetGateOrientation\n\ + subs r4, r0\n\ + adds r1, r4, 0x4\n\ + adds r0, r1, 0\n\ + cmp r1, 0\n\ + bge _080C7F8A\n\ + adds r0, r4, 0x7\n\ _080C7F8A:\n\ - asrs r0, 2\n\ - lsls r0, 2\n\ - subs r0, r1, r0\n\ - ldr r1, _080C7FB0 @ =gRotatingGate_PuzzleConfig\n\ - ldr r2, [r1]\n\ - lsls r1, r6, 3\n\ - adds r1, r2\n\ - ldrb r1, [r1, 0x4]\n\ - ldr r2, _080C7FB4 @ =sRotatingGate_ArmLayout\n\ - lsls r0, 24\n\ - asrs r0, 23\n\ - adds r0, r5\n\ - lsls r1, 3\n\ - adds r0, r1\n\ - adds r0, r2\n\ - ldrb r0, [r0]\n\ - pop {r4-r6}\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ + asrs r0, 2\n\ + lsls r0, 2\n\ + subs r0, r1, r0\n\ + ldr r1, _080C7FB0 @ =gRotatingGate_PuzzleConfig\n\ + ldr r2, [r1]\n\ + lsls r1, r6, 3\n\ + adds r1, r2\n\ + ldrb r1, [r1, 0x4]\n\ + ldr r2, _080C7FB4 @ =sRotatingGate_ArmLayout\n\ + lsls r0, 24\n\ + asrs r0, 23\n\ + adds r0, r5\n\ + lsls r1, 3\n\ + adds r0, r1\n\ + adds r0, r2\n\ + ldrb r0, [r0]\n\ + pop {r4-r6}\n\ + pop {r1}\n\ + bx r1\n\ + .align 2, 0\n\ _080C7FB0: .4byte gRotatingGate_PuzzleConfig\n\ _080C7FB4: .4byte sRotatingGate_ArmLayout\n\ .syntax divided\n"); @@ -1095,53 +1095,53 @@ static u8 RotatingGate_GetRotationInfo(u8 direction, s16 x, s16 y) __attribute__((naked)) static u8 RotatingGate_GetRotationInfo(u8 a, s16 b, s16 c) { asm(".syntax unified\n\ - push {lr}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r3, r0, 0\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - lsls r2, 16\n\ - lsrs r2, 16\n\ - cmp r0, 0x2\n\ - bne _080C8008\n\ - ldr r3, _080C8004 @ =sRotatingGate_RotationInfoNorth\n\ - b _080C802A\n\ - .align 2, 0\n\ + push {lr}\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + adds r3, r0, 0\n\ + lsls r1, 16\n\ + lsrs r1, 16\n\ + lsls r2, 16\n\ + lsrs r2, 16\n\ + cmp r0, 0x2\n\ + bne _080C8008\n\ + ldr r3, _080C8004 @ =sRotatingGate_RotationInfoNorth\n\ + b _080C802A\n\ + .align 2, 0\n\ _080C8004: .4byte sRotatingGate_RotationInfoNorth\n\ _080C8008:\n\ - cmp r0, 0x1\n\ - bne _080C8014\n\ - ldr r3, _080C8010 @ =sRotatingGate_RotationInfoSouth\n\ - b _080C802A\n\ - .align 2, 0\n\ + cmp r0, 0x1\n\ + bne _080C8014\n\ + ldr r3, _080C8010 @ =sRotatingGate_RotationInfoSouth\n\ + b _080C802A\n\ + .align 2, 0\n\ _080C8010: .4byte sRotatingGate_RotationInfoSouth\n\ _080C8014:\n\ - cmp r0, 0x3\n\ - bne _080C8020\n\ - ldr r3, _080C801C @ =sRotatingGate_RotationInfoWest\n\ - b _080C802A\n\ - .align 2, 0\n\ + cmp r0, 0x3\n\ + bne _080C8020\n\ + ldr r3, _080C801C @ =sRotatingGate_RotationInfoWest\n\ + b _080C802A\n\ + .align 2, 0\n\ _080C801C: .4byte sRotatingGate_RotationInfoWest\n\ _080C8020:\n\ - cmp r3, 0x4\n\ - beq _080C8028\n\ - movs r0, 0xFF\n\ - b _080C8038\n\ + cmp r3, 0x4\n\ + beq _080C8028\n\ + movs r0, 0xFF\n\ + b _080C8038\n\ _080C8028:\n\ - ldr r3, _080C803C @ =sRotatingGate_RotationInfoEast\n\ + ldr r3, _080C803C @ =sRotatingGate_RotationInfoEast\n\ _080C802A:\n\ - lsls r0, r2, 16\n\ - lsls r1, 16\n\ - asrs r1, 16\n\ - asrs r0, 14\n\ - adds r0, r1\n\ - adds r0, r3, r0\n\ - ldrb r0, [r0]\n\ + lsls r0, r2, 16\n\ + lsls r1, 16\n\ + asrs r1, 16\n\ + asrs r0, 14\n\ + adds r0, r1\n\ + adds r0, r3, r0\n\ + ldrb r0, [r0]\n\ _080C8038:\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ + pop {r1}\n\ + bx r1\n\ + .align 2, 0\n\ _080C803C: .4byte sRotatingGate_RotationInfoEast\n\ .syntax divided\n"); } diff --git a/src/script_menu.c b/src/script_menu.c index f4ac55fb9..6e1a12a60 100644 --- a/src/script_menu.c +++ b/src/script_menu.c @@ -901,162 +901,162 @@ void CreatePCMenu(void) #elif GERMAN __attribute__((naked)) void CreatePCMenu(void) { - asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - sub sp, 0x18\n\ - ldr r0, _080B5748 @ =0x0000084b\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _080B5750\n\ - ldr r0, _080B574C @ =gPCText_LanettesPC\n\ - b _080B5752\n\ - .align 2, 0\n\ + asm(".syntax unified\n\ + push {r4-r7,lr}\n\ + sub sp, 0x18\n\ + ldr r0, _080B5748 @ =0x0000084b\n\ + bl FlagGet\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + beq _080B5750\n\ + ldr r0, _080B574C @ =gPCText_LanettesPC\n\ + b _080B5752\n\ + .align 2, 0\n\ _080B5748: .4byte 0x0000084b\n\ _080B574C: .4byte gPCText_LanettesPC\n\ _080B5750:\n\ - ldr r0, _080B57E8 @ =gPCText_SomeonesPC\n\ + ldr r0, _080B57E8 @ =gPCText_SomeonesPC\n\ _080B5752:\n\ - bl GetStringWidthInTilesForScriptMenu\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x8]\n\ - movs r4, 0x1\n\ - ldr r0, _080B57EC @ =gPCText_PlayersPC\n\ - bl GetStringWidthInTilesForScriptMenu\n\ - lsls r1, r4, 2\n\ - add r1, sp\n\ - adds r1, 0x8\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [r1]\n\ - ldr r0, _080B57F0 @ =gPCText_LogOff\n\ - bl GetStringWidthInTilesForScriptMenu\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x10]\n\ - movs r4, 0x3\n\ - ldr r0, _080B57F4 @ =0x00000804\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _080B5798\n\ - ldr r0, _080B57F8 @ =gPCText_HallOfFame\n\ - bl GetStringWidthInTilesForScriptMenu\n\ - lsls r0, 16\n\ - lsrs r0, 16\n\ - str r0, [sp, 0x14]\n\ - movs r4, 0x4\n\ + bl GetStringWidthInTilesForScriptMenu\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x8]\n\ + movs r4, 0x1\n\ + ldr r0, _080B57EC @ =gPCText_PlayersPC\n\ + bl GetStringWidthInTilesForScriptMenu\n\ + lsls r1, r4, 2\n\ + add r1, sp\n\ + adds r1, 0x8\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [r1]\n\ + ldr r0, _080B57F0 @ =gPCText_LogOff\n\ + bl GetStringWidthInTilesForScriptMenu\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x10]\n\ + movs r4, 0x3\n\ + ldr r0, _080B57F4 @ =0x00000804\n\ + bl FlagGet\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + beq _080B5798\n\ + ldr r0, _080B57F8 @ =gPCText_HallOfFame\n\ + bl GetStringWidthInTilesForScriptMenu\n\ + lsls r0, 16\n\ + lsrs r0, 16\n\ + str r0, [sp, 0x14]\n\ + movs r4, 0x4\n\ _080B5798:\n\ - movs r5, 0\n\ - cmp r5, r4\n\ - bge _080B57B4\n\ - add r2, sp, 0x8\n\ - adds r1, r4, 0\n\ + movs r5, 0\n\ + cmp r5, r4\n\ + bge _080B57B4\n\ + add r2, sp, 0x8\n\ + adds r1, r4, 0\n\ _080B57A2:\n\ - ldr r0, [r2]\n\ - cmp r5, r0\n\ - bge _080B57AC\n\ - lsls r0, 24\n\ - lsrs r5, r0, 24\n\ + ldr r0, [r2]\n\ + cmp r5, r0\n\ + bge _080B57AC\n\ + lsls r0, 24\n\ + lsrs r5, r0, 24\n\ _080B57AC:\n\ - adds r2, 0x4\n\ - subs r1, 0x1\n\ - cmp r1, 0\n\ - bne _080B57A2\n\ + adds r2, 0x4\n\ + subs r1, 0x1\n\ + cmp r1, 0\n\ + bne _080B57A2\n\ _080B57B4:\n\ - ldr r0, _080B57F4 @ =0x00000804\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _080B57FC\n\ - movs r7, 0x4\n\ - adds r4, r5, 0x2\n\ - lsls r2, r4, 24\n\ - lsrs r2, 24\n\ - movs r0, 0\n\ - movs r1, 0\n\ - movs r3, 0x9\n\ - bl MenuDrawTextWindow\n\ - ldr r0, _080B57F8 @ =gPCText_HallOfFame\n\ - movs r1, 0x1\n\ - movs r2, 0x5\n\ - bl MenuPrint\n\ - ldr r0, _080B57F0 @ =gPCText_LogOff\n\ - movs r1, 0x1\n\ - movs r2, 0x7\n\ - bl MenuPrint\n\ - b _080B5818\n\ - .align 2, 0\n\ + ldr r0, _080B57F4 @ =0x00000804\n\ + bl FlagGet\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + beq _080B57FC\n\ + movs r7, 0x4\n\ + adds r4, r5, 0x2\n\ + lsls r2, r4, 24\n\ + lsrs r2, 24\n\ + movs r0, 0\n\ + movs r1, 0\n\ + movs r3, 0x9\n\ + bl MenuDrawTextWindow\n\ + ldr r0, _080B57F8 @ =gPCText_HallOfFame\n\ + movs r1, 0x1\n\ + movs r2, 0x5\n\ + bl MenuPrint\n\ + ldr r0, _080B57F0 @ =gPCText_LogOff\n\ + movs r1, 0x1\n\ + movs r2, 0x7\n\ + bl MenuPrint\n\ + b _080B5818\n\ + .align 2, 0\n\ _080B57E8: .4byte gPCText_SomeonesPC\n\ _080B57EC: .4byte gPCText_PlayersPC\n\ _080B57F0: .4byte gPCText_LogOff\n\ _080B57F4: .4byte 0x00000804\n\ _080B57F8: .4byte gPCText_HallOfFame\n\ _080B57FC:\n\ - movs r7, 0x3\n\ - adds r4, r5, 0x2\n\ - lsls r2, r4, 24\n\ - lsrs r2, 24\n\ - movs r0, 0\n\ - movs r1, 0\n\ - movs r3, 0x7\n\ - bl MenuDrawTextWindow\n\ - ldr r0, _080B5834 @ =gPCText_LogOff\n\ - movs r1, 0x1\n\ - movs r2, 0x5\n\ - bl MenuPrint\n\ + movs r7, 0x3\n\ + adds r4, r5, 0x2\n\ + lsls r2, r4, 24\n\ + lsrs r2, 24\n\ + movs r0, 0\n\ + movs r1, 0\n\ + movs r3, 0x7\n\ + bl MenuDrawTextWindow\n\ + ldr r0, _080B5834 @ =gPCText_LogOff\n\ + movs r1, 0x1\n\ + movs r2, 0x5\n\ + bl MenuPrint\n\ _080B5818:\n\ - adds r6, r4, 0\n\ - ldr r0, _080B5838 @ =0x0000084b\n\ - bl FlagGet\n\ - lsls r0, 24\n\ - cmp r0, 0\n\ - beq _080B5840\n\ - ldr r0, _080B583C @ =gPCText_LanettesPC\n\ - movs r1, 0x1\n\ - movs r2, 0x1\n\ - bl MenuPrint\n\ - b _080B584A\n\ - .align 2, 0\n\ + adds r6, r4, 0\n\ + ldr r0, _080B5838 @ =0x0000084b\n\ + bl FlagGet\n\ + lsls r0, 24\n\ + cmp r0, 0\n\ + beq _080B5840\n\ + ldr r0, _080B583C @ =gPCText_LanettesPC\n\ + movs r1, 0x1\n\ + movs r2, 0x1\n\ + bl MenuPrint\n\ + b _080B584A\n\ + .align 2, 0\n\ _080B5834: .4byte gPCText_LogOff\n\ _080B5838: .4byte 0x0000084b\n\ _080B583C: .4byte gPCText_LanettesPC\n\ _080B5840:\n\ - ldr r0, _080B5888 @ =gPCText_SomeonesPC\n\ - movs r1, 0x1\n\ - movs r2, 0x1\n\ - bl MenuPrint\n\ + ldr r0, _080B5888 @ =gPCText_SomeonesPC\n\ + movs r1, 0x1\n\ + movs r2, 0x1\n\ + bl MenuPrint\n\ _080B584A:\n\ - ldr r0, _080B588C @ =gPCText_PlayersPC\n\ - movs r1, 0x1\n\ - movs r2, 0x3\n\ - bl MenuPrint\n\ - movs r4, 0\n\ - str r4, [sp]\n\ - adds r0, r5, 0x1\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - str r0, [sp, 0x4]\n\ - movs r0, 0\n\ - movs r1, 0x1\n\ - movs r2, 0x1\n\ - adds r3, r7, 0\n\ - bl InitMenu\n\ - lsls r2, r6, 24\n\ - lsrs r2, 24\n\ - lsls r3, r7, 1\n\ - adds r3, 0x1\n\ - str r4, [sp]\n\ - str r7, [sp, 0x4]\n\ - movs r0, 0\n\ - movs r1, 0\n\ - bl sub_80B5230\n\ - add sp, 0x18\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ + ldr r0, _080B588C @ =gPCText_PlayersPC\n\ + movs r1, 0x1\n\ + movs r2, 0x3\n\ + bl MenuPrint\n\ + movs r4, 0\n\ + str r4, [sp]\n\ + adds r0, r5, 0x1\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + str r0, [sp, 0x4]\n\ + movs r0, 0\n\ + movs r1, 0x1\n\ + movs r2, 0x1\n\ + adds r3, r7, 0\n\ + bl InitMenu\n\ + lsls r2, r6, 24\n\ + lsrs r2, 24\n\ + lsls r3, r7, 1\n\ + adds r3, 0x1\n\ + str r4, [sp]\n\ + str r7, [sp, 0x4]\n\ + movs r0, 0\n\ + movs r1, 0\n\ + bl sub_80B5230\n\ + add sp, 0x18\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ _080B5888: .4byte gPCText_SomeonesPC\n\ _080B588C: .4byte gPCText_PlayersPC\n\ .syntax divided\n"); diff --git a/src/title_screen.c b/src/title_screen.c index ab0f1d505..2503b0654 100644 --- a/src/title_screen.c +++ b/src/title_screen.c @@ -437,99 +437,99 @@ __attribute__((naked)) static void CreatePressStartBanner(s16 x, s16 y) { asm(".syntax unified\n\ - push {r4-r7,lr}\n\ - mov r7, r10\n\ - mov r6, r9\n\ - mov r5, r8\n\ - push {r5-r7}\n\ - lsls r0, 16\n\ - ldr r2, _0807C3AC @ =0xffe00000\n\ - adds r0, r2\n\ - lsrs r0, 16\n\ - movs r6, 0\n\ - lsls r1, 16\n\ - mov r10, r1\n\ - mov r8, r10\n\ + push {r4-r7,lr}\n\ + mov r7, r10\n\ + mov r6, r9\n\ + mov r5, r8\n\ + push {r5-r7}\n\ + lsls r0, 16\n\ + ldr r2, _0807C3AC @ =0xffe00000\n\ + adds r0, r2\n\ + lsrs r0, 16\n\ + movs r6, 0\n\ + lsls r1, 16\n\ + mov r10, r1\n\ + mov r8, r10\n\ _0807C302:\n\ - lsls r5, r0, 16\n\ - asrs r5, 16\n\ - ldr r0, _0807C3B0 @ =sStartCopyrightBannerSpriteTemplate\n\ - adds r1, r5, 0\n\ - mov r3, r8\n\ - asrs r2, r3, 16\n\ - movs r3, 0\n\ - bl CreateSprite\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - lsls r4, r0, 4\n\ - adds r4, r0\n\ - lsls r4, 2\n\ - ldr r0, _0807C3B4 @ =gSprites\n\ - mov r9, r0\n\ - add r4, r9\n\ - adds r0, r4, 0\n\ - adds r1, r6, 0\n\ - bl StartSpriteAnim\n\ - movs r7, 0x1\n\ - strh r7, [r4, 0x2E]\n\ - adds r0, r6, 0x1\n\ - lsls r0, 24\n\ - lsrs r6, r0, 24\n\ - adds r5, 0x20\n\ - lsls r5, 16\n\ - lsrs r0, r5, 16\n\ - cmp r6, 0x2\n\ - bls _0807C302\n\ - ldr r1, _0807C3B0 @ =sStartCopyrightBannerSpriteTemplate\n\ - mov r8, r1\n\ - lsls r5, r0, 16\n\ - asrs r5, 16\n\ - mov r2, r10\n\ - asrs r6, r2, 16\n\ - mov r0, r8\n\ - adds r1, r5, 0\n\ - adds r2, r6, 0\n\ - movs r3, 0\n\ - bl CreateSprite\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - lsls r4, r0, 4\n\ - adds r4, r0\n\ - lsls r4, 2\n\ - add r4, r9\n\ - adds r0, r4, 0\n\ - movs r1, 0x8\n\ - bl StartSpriteAnim\n\ - strh r7, [r4, 0x2E]\n\ - subs r5, 0x60\n\ - lsls r5, 16\n\ - asrs r5, 16\n\ - subs r6, 0x8\n\ - lsls r6, 16\n\ - asrs r6, 16\n\ - mov r0, r8\n\ - adds r1, r5, 0\n\ - adds r2, r6, 0\n\ - movs r3, 0\n\ - bl CreateSprite\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - lsls r4, r0, 4\n\ - adds r4, r0\n\ - lsls r4, 2\n\ - add r4, r9\n\ - adds r0, r4, 0\n\ - movs r1, 0x9\n\ - bl StartSpriteAnim\n\ - strh r7, [r4, 0x2E]\n\ - pop {r3-r5}\n\ - mov r8, r3\n\ - mov r9, r4\n\ - mov r10, r5\n\ - pop {r4-r7}\n\ - pop {r0}\n\ - bx r0\n\ - .align 2, 0\n\ + lsls r5, r0, 16\n\ + asrs r5, 16\n\ + ldr r0, _0807C3B0 @ =sStartCopyrightBannerSpriteTemplate\n\ + adds r1, r5, 0\n\ + mov r3, r8\n\ + asrs r2, r3, 16\n\ + movs r3, 0\n\ + bl CreateSprite\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + lsls r4, r0, 4\n\ + adds r4, r0\n\ + lsls r4, 2\n\ + ldr r0, _0807C3B4 @ =gSprites\n\ + mov r9, r0\n\ + add r4, r9\n\ + adds r0, r4, 0\n\ + adds r1, r6, 0\n\ + bl StartSpriteAnim\n\ + movs r7, 0x1\n\ + strh r7, [r4, 0x2E]\n\ + adds r0, r6, 0x1\n\ + lsls r0, 24\n\ + lsrs r6, r0, 24\n\ + adds r5, 0x20\n\ + lsls r5, 16\n\ + lsrs r0, r5, 16\n\ + cmp r6, 0x2\n\ + bls _0807C302\n\ + ldr r1, _0807C3B0 @ =sStartCopyrightBannerSpriteTemplate\n\ + mov r8, r1\n\ + lsls r5, r0, 16\n\ + asrs r5, 16\n\ + mov r2, r10\n\ + asrs r6, r2, 16\n\ + mov r0, r8\n\ + adds r1, r5, 0\n\ + adds r2, r6, 0\n\ + movs r3, 0\n\ + bl CreateSprite\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + lsls r4, r0, 4\n\ + adds r4, r0\n\ + lsls r4, 2\n\ + add r4, r9\n\ + adds r0, r4, 0\n\ + movs r1, 0x8\n\ + bl StartSpriteAnim\n\ + strh r7, [r4, 0x2E]\n\ + subs r5, 0x60\n\ + lsls r5, 16\n\ + asrs r5, 16\n\ + subs r6, 0x8\n\ + lsls r6, 16\n\ + asrs r6, 16\n\ + mov r0, r8\n\ + adds r1, r5, 0\n\ + adds r2, r6, 0\n\ + movs r3, 0\n\ + bl CreateSprite\n\ + lsls r0, 24\n\ + lsrs r0, 24\n\ + lsls r4, r0, 4\n\ + adds r4, r0\n\ + lsls r4, 2\n\ + add r4, r9\n\ + adds r0, r4, 0\n\ + movs r1, 0x9\n\ + bl StartSpriteAnim\n\ + strh r7, [r4, 0x2E]\n\ + pop {r3-r5}\n\ + mov r8, r3\n\ + mov r9, r4\n\ + mov r10, r5\n\ + pop {r4-r7}\n\ + pop {r0}\n\ + bx r0\n\ + .align 2, 0\n\ _0807C3AC: .4byte 0xffe00000\n\ _0807C3B0: .4byte sStartCopyrightBannerSpriteTemplate\n\ _0807C3B4: .4byte gSprites\n\ -- cgit v1.2.3 From 5c90a1968245ba7d9f1c6c589ae0880d2a05447d Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Mon, 28 Aug 2017 16:29:50 -0500 Subject: fix some nonmatching functions in rotating_gate.c --- src/rotating_gate.c | 513 ++++++++++++++++++++++------------------------------ 1 file changed, 220 insertions(+), 293 deletions(-) (limited to 'src') diff --git a/src/rotating_gate.c b/src/rotating_gate.c index b88add469..e8ab7e1bf 100644 --- a/src/rotating_gate.c +++ b/src/rotating_gate.c @@ -12,11 +12,11 @@ #define ROTATING_GATE_PUZZLE_MAX 14 #define GATE_ARM_MAX_LENGTH 2 -#define GATE_ROTATION(rotationDirection, arm, longArm) \ +#define GATE_ROT(rotationDirection, arm, longArm) \ ((rotationDirection & 15) << 4) | ((arm & 7) << 1) | (longArm & 1) -#define GATE_ROTATION_CLOCKWISE(arm, longArm) GATE_ROTATION(ROTATE_CLOCKWISE, arm, longArm) -#define GATE_ROTATION_ANTICLOCKWISE(arm, longArm) GATE_ROTATION(ROTATE_ANTICLOCKWISE, arm, longArm) -#define GATE_ROTATION_NONE 255 +#define GATE_ROT_CW(arm, longArm) GATE_ROT(ROTATE_CLOCKWISE, arm, longArm) +#define GATE_ROT_ACW(arm, longArm) GATE_ROT(ROTATE_ANTICLOCKWISE, arm, longArm) +#define GATE_ROT_NONE 255 static void SpriteCallback_RotatingGate(struct Sprite *sprite); static u8 RotatingGate_CreateGate(u8 gateId, s16 deltaX, s16 deltaY); @@ -181,7 +181,8 @@ enum struct RotatingGatePuzzle { - struct Coords16 pos; + s16 x; + s16 y; u8 shape; u8 orientation; }; @@ -193,32 +194,34 @@ struct Coords8 }; // Fortree -static const struct RotatingGatePuzzle sRotatingGate_FortreePuzzleConfig[] = { - { { 12, 5 }, GATE_SHAPE_L4, GATE_ORIENTATION_0 }, - { { 14, 7 }, GATE_SHAPE_L4, GATE_ORIENTATION_270 }, - { { 16, 4 }, GATE_SHAPE_T2, GATE_ORIENTATION_90 }, - { { 15, 14 }, GATE_SHAPE_L2, GATE_ORIENTATION_0 }, - { { 18, 13 }, GATE_SHAPE_T1, GATE_ORIENTATION_180 }, - { { 8, 20 }, GATE_SHAPE_T1, GATE_ORIENTATION_180 }, - { { 16, 20 }, GATE_SHAPE_T4, GATE_ORIENTATION_90 }, +static const struct RotatingGatePuzzle sRotatingGate_FortreePuzzleConfig[] = +{ + {12, 5, GATE_SHAPE_L4, GATE_ORIENTATION_0}, + {14, 7, GATE_SHAPE_L4, GATE_ORIENTATION_270}, + {16, 4, GATE_SHAPE_T2, GATE_ORIENTATION_90}, + {15, 14, GATE_SHAPE_L2, GATE_ORIENTATION_0}, + {18, 13, GATE_SHAPE_T1, GATE_ORIENTATION_180}, + { 8, 20, GATE_SHAPE_T1, GATE_ORIENTATION_180}, + {16, 20, GATE_SHAPE_T4, GATE_ORIENTATION_90}, }; // Trickhouse -static const struct RotatingGatePuzzle sRotatingGate_TrickHousePuzzleConfig[] = { - { { 13, 3 }, GATE_SHAPE_T1, GATE_ORIENTATION_270 }, - { { 12, 6 }, GATE_SHAPE_T1, GATE_ORIENTATION_180 }, - { { 3, 6 }, GATE_SHAPE_T1, GATE_ORIENTATION_180 }, - { { 3, 9 }, GATE_SHAPE_T2, GATE_ORIENTATION_270 }, - { { 8, 8 }, GATE_SHAPE_L1, GATE_ORIENTATION_90 }, - { { 2, 12 }, GATE_SHAPE_T3, GATE_ORIENTATION_180 }, - { { 9, 13 }, GATE_SHAPE_L2, GATE_ORIENTATION_0 }, - { { 3, 14 }, GATE_SHAPE_L3, GATE_ORIENTATION_90 }, - { { 9, 15 }, GATE_SHAPE_L4, GATE_ORIENTATION_180 }, - { { 3, 18 }, GATE_SHAPE_T2, GATE_ORIENTATION_180 }, - { { 2, 19 }, GATE_SHAPE_T1, GATE_ORIENTATION_0 }, - { { 5, 21 }, GATE_SHAPE_L1, GATE_ORIENTATION_0 }, - { { 9, 19 }, GATE_SHAPE_L4, GATE_ORIENTATION_270 }, - { { 12, 20 }, GATE_SHAPE_T1, GATE_ORIENTATION_90 }, +static const struct RotatingGatePuzzle sRotatingGate_TrickHousePuzzleConfig[] = +{ + {13, 3, GATE_SHAPE_T1, GATE_ORIENTATION_270}, + {12, 6, GATE_SHAPE_T1, GATE_ORIENTATION_180}, + { 3, 6, GATE_SHAPE_T1, GATE_ORIENTATION_180}, + { 3, 9, GATE_SHAPE_T2, GATE_ORIENTATION_270}, + { 8, 8, GATE_SHAPE_L1, GATE_ORIENTATION_90}, + { 2, 12, GATE_SHAPE_T3, GATE_ORIENTATION_180}, + { 9, 13, GATE_SHAPE_L2, GATE_ORIENTATION_0}, + { 3, 14, GATE_SHAPE_L3, GATE_ORIENTATION_90}, + { 9, 15, GATE_SHAPE_L4, GATE_ORIENTATION_180}, + { 3, 18, GATE_SHAPE_T2, GATE_ORIENTATION_180}, + { 2, 19, GATE_SHAPE_T1, GATE_ORIENTATION_0}, + { 5, 21, GATE_SHAPE_L1, GATE_ORIENTATION_0}, + { 9, 19, GATE_SHAPE_L4, GATE_ORIENTATION_270}, + {12, 20, GATE_SHAPE_T1, GATE_ORIENTATION_90}, }; static const u8 sRotatingGateTiles_1[] = INCBIN_U8("graphics/rotating_gates/1.4bpp"); @@ -230,7 +233,8 @@ static const u8 sRotatingGateTiles_7[] = INCBIN_U8("graphics/rotating_gates/7.4b static const u8 sRotatingGateTiles_0[] = INCBIN_U8("graphics/rotating_gates/0.4bpp"); static const u8 sRotatingGateTiles_4[] = INCBIN_U8("graphics/rotating_gates/4.4bpp"); -static const struct OamData sOamData_RotatingGateLarge = { +static const struct OamData sOamData_RotatingGateLarge = +{ .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, .objMode = 0, @@ -246,7 +250,8 @@ static const struct OamData sOamData_RotatingGateLarge = { .affineParam = 0, }; -static const struct OamData sOamData_RotatingGateRegular = { +static const struct OamData sOamData_RotatingGateRegular = +{ .y = 0, .affineMode = ST_OAM_AFFINE_NORMAL, .objMode = 0, @@ -262,145 +267,178 @@ static const struct OamData sOamData_RotatingGateRegular = { .affineParam = 0, }; -static const struct SpriteSheet sRotatingGatesGraphicsTable[] = { - { sRotatingGateTiles_0, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L1 }, - { sRotatingGateTiles_1, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L2 }, - { sRotatingGateTiles_2, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L3 }, - { sRotatingGateTiles_3, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L4 }, - { sRotatingGateTiles_4, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T1 }, - { sRotatingGateTiles_5, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T2 }, - { sRotatingGateTiles_6, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T3 }, - { sRotatingGateTiles_7, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T4 }, - { NULL }, +static const struct SpriteSheet sRotatingGatesGraphicsTable[] = +{ + {sRotatingGateTiles_0, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L1}, + {sRotatingGateTiles_1, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L2}, + {sRotatingGateTiles_2, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L3}, + {sRotatingGateTiles_3, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_L4}, + {sRotatingGateTiles_4, 0x200, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T1}, + {sRotatingGateTiles_5, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T2}, + {sRotatingGateTiles_6, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T3}, + {sRotatingGateTiles_7, 0x800, ROTATING_GATE_TILE_TAG + GATE_SHAPE_T4}, + {NULL}, }; -static const union AnimCmd sSpriteAnim_RotatingGateLarge[] = { - ANIMCMD_FRAME(0, 0), ANIMCMD_END, +static const union AnimCmd sSpriteAnim_RotatingGateLarge[] = +{ + ANIMCMD_FRAME(0, 0), + ANIMCMD_END, }; -static const union AnimCmd sSpriteAnim_RotatingGateRegular[] = { +static const union AnimCmd sSpriteAnim_RotatingGateRegular[] = +{ ANIMCMD_FRAME(0, 0), ANIMCMD_END, }; -static const union AnimCmd *const sSpriteAnimTable_RotatingGateLarge[] = { +static const union AnimCmd *const sSpriteAnimTable_RotatingGateLarge[] = +{ sSpriteAnim_RotatingGateLarge, }; -static const union AnimCmd *const sSpriteAnimTable_RotatingGateRegular[] = { +static const union AnimCmd *const sSpriteAnimTable_RotatingGateRegular[] = +{ sSpriteAnim_RotatingGateRegular, }; -static const union AffineAnimCmd sSpriteAffineAnim_Rotated0[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_JUMP(0), +static const union AffineAnimCmd sSpriteAffineAnim_Rotated0[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd sSpriteAffineAnim_Rotated90[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_JUMP(0), +static const union AffineAnimCmd sSpriteAffineAnim_Rotated90[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), + AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd sSpriteAffineAnim_Rotated180[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), AFFINEANIMCMD_JUMP(0), +static const union AffineAnimCmd sSpriteAffineAnim_Rotated180[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), + AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd sSpriteAffineAnim_Rotated270[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), AFFINEANIMCMD_JUMP(0), +static const union AffineAnimCmd sSpriteAffineAnim_Rotated270[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), + AFFINEANIMCMD_JUMP(0), }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 4, 16), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise0to90Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise90to180Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise180to270Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingClockwise270to360Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, -8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270Faster[] = { - AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8), AFFINEANIMCMD_END, +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise360to270Faster[] = +{ + AFFINEANIMCMD_FRAME(0x100, 0x100, 0, 0), + AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8), + AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise270to180Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, 64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise180to90Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -128, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0Faster[] = { +static const union AffineAnimCmd sSpriteAffineAnim_RotatingAnticlockwise90to0Faster[] = +{ AFFINEANIMCMD_FRAME(0x100, 0x100, -64, 0), AFFINEANIMCMD_FRAME(0x0, 0x0, 8, 8), AFFINEANIMCMD_END, }; -static const union AffineAnimCmd *const sSpriteAffineAnimTable_RotatingGate[] = { +static const union AffineAnimCmd *const sSpriteAffineAnimTable_RotatingGate[] = +{ sSpriteAffineAnim_Rotated0, sSpriteAffineAnim_Rotated90, sSpriteAffineAnim_Rotated180, @@ -423,7 +461,8 @@ static const union AffineAnimCmd *const sSpriteAffineAnimTable_RotatingGate[] = sSpriteAffineAnim_RotatingClockwise270to360Faster, }; -static const struct SpriteTemplate sSpriteTemplate_RotatingGateLarge = { +static const struct SpriteTemplate sSpriteTemplate_RotatingGateLarge = +{ .tileTag = ROTATING_GATE_TILE_TAG, .paletteTag = 0xFFFF, .oam = &sOamData_RotatingGateLarge, @@ -433,7 +472,8 @@ static const struct SpriteTemplate sSpriteTemplate_RotatingGateLarge = { .callback = SpriteCallback_RotatingGate, }; -static const struct SpriteTemplate sSpriteTemplate_RotatingGateRegular = { +static const struct SpriteTemplate sSpriteTemplate_RotatingGateRegular = +{ .tileTag = ROTATING_GATE_TILE_TAG, .paletteTag = 0xFFFF, .oam = &sOamData_RotatingGateRegular, @@ -449,62 +489,36 @@ static const struct SpriteTemplate sSpriteTemplate_RotatingGateRegular = { // given direction. This information is compared against the gate // "arm" layout to see if there is an arm at the position in order to // produce the final rotation. -static const u8 sRotatingGate_RotationInfoNorth[4][4] = { - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, - { GATE_ROTATION_CLOCKWISE(GATE_ARM_WEST, 1), - GATE_ROTATION_CLOCKWISE(GATE_ARM_WEST, 0), - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_EAST, 0), - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_EAST, 1) }, - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, +static const u8 sRotatingGate_RotationInfoNorth[4 * 4] = +{ + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_CW(GATE_ARM_WEST, 1), GATE_ROT_CW(GATE_ARM_WEST, 0), GATE_ROT_ACW(GATE_ARM_EAST, 0), GATE_ROT_ACW(GATE_ARM_EAST, 1), + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, }; -static const u8 sRotatingGate_RotationInfoSouth[4][4] = { - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, - { GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_WEST, 1), - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_WEST, 0), - GATE_ROTATION_CLOCKWISE(GATE_ARM_EAST, 0), - GATE_ROTATION_CLOCKWISE(GATE_ARM_EAST, 1) }, - { GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE, GATE_ROTATION_NONE }, +static const u8 sRotatingGate_RotationInfoSouth[4 * 4] = +{ + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_ACW(GATE_ARM_WEST, 1), GATE_ROT_ACW(GATE_ARM_WEST, 0), GATE_ROT_CW(GATE_ARM_EAST, 0), GATE_ROT_CW(GATE_ARM_EAST, 1), + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_NONE, }; -static const u8 sRotatingGate_RotationInfoWest[4][4] = { - { GATE_ROTATION_NONE, - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_NORTH, 1), - GATE_ROTATION_NONE, - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_NORTH, 0), - GATE_ROTATION_NONE, - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_CLOCKWISE(GATE_ARM_SOUTH, 0), - GATE_ROTATION_NONE, - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_CLOCKWISE(GATE_ARM_SOUTH, 1), - GATE_ROTATION_NONE, - GATE_ROTATION_NONE }, +static const u8 sRotatingGate_RotationInfoWest[4 * 4] = +{ + GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_NORTH, 1), GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_NORTH, 0), GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_SOUTH, 0), GATE_ROT_NONE, GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_SOUTH, 1), GATE_ROT_NONE, GATE_ROT_NONE, }; -static const u8 sRotatingGate_RotationInfoEast[4][4] = { - { GATE_ROTATION_NONE, - GATE_ROTATION_NONE, - GATE_ROTATION_CLOCKWISE(GATE_ARM_NORTH, 1), - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_NONE, - GATE_ROTATION_CLOCKWISE(GATE_ARM_NORTH, 0), - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_NONE, - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_SOUTH, 0), - GATE_ROTATION_NONE }, - { GATE_ROTATION_NONE, - GATE_ROTATION_NONE, - GATE_ROTATION_ANTICLOCKWISE(GATE_ARM_SOUTH, 1), - GATE_ROTATION_NONE }, +static const u8 sRotatingGate_RotationInfoEast[4 * 4] = +{ + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_NORTH, 1), GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_CW(GATE_ARM_NORTH, 0), GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_SOUTH, 0), GATE_ROT_NONE, + GATE_ROT_NONE, GATE_ROT_NONE, GATE_ROT_ACW(GATE_ARM_SOUTH, 1), GATE_ROT_NONE, }; // These tables describe the relative coordinate positions the arms @@ -519,49 +533,86 @@ static const struct Coords8 sRotatingGate_ArmPositionsAntiClockwiseRotation[] = // Describes where the gates "arms" are in the order north, east, south, west. // These are adjusted using the current orientation to perform collision checking -static const u8 sRotatingGate_ArmLayout[][GATE_ARM_WEST + 1][GATE_ARM_MAX_LENGTH] = { +static const u8 sRotatingGate_ArmLayout[][4 * 2] = +{ // L-shape gates { - { 1, 0 }, { 1, 0 }, { 0, 0 }, { 0, 0 }, + 1, 0, + 1, 0, + 0, 0, + 0, 0, }, { - { 1, 1 }, { 1, 0 }, { 0, 0 }, { 0, 0 }, + 1, 1, + 1, 0, + 0, 0, + 0, 0, }, { - { 1, 0 }, { 1, 1 }, { 0, 0 }, { 0, 0 }, + 1, 0, + 1, 1, + 0, 0, + 0, 0, }, { - { 1, 1 }, { 1, 1 }, { 0, 0 }, { 0, 0 }, + 1, 1, + 1, 1, + 0, 0, + 0, 0, }, // T-shape gates { - { 1, 0 }, { 1, 0 }, { 1, 0 }, { 0, 0 }, + 1, 0, + 1, 0, + 1, 0, + 0, 0, }, { - { 1, 1 }, { 1, 0 }, { 1, 0 }, { 0, 0 }, + 1, 1, + 1, 0, + 1, 0, + 0, 0, }, { - { 1, 0 }, { 1, 1 }, { 1, 0 }, { 0, 0 }, + 1, 0, + 1, 1, + 1, 0, + 0, 0, }, { - { 1, 0 }, { 1, 0 }, { 1, 1 }, { 0, 0 }, + 1, 0, + 1, 0, + 1, 1, + 0, 0, }, // Unused T-shape gates // These have 2-3 long arms and cannot actually be used anywhere // since configuration for them is missing from the other tables. { - { 1, 1 }, { 1, 1 }, { 1, 0 }, { 0, 0 }, + 1, 1, + 1, 1, + 1, 0, + 0, 0, }, { - { 1, 1 }, { 1, 0 }, { 1, 1 }, { 0, 0 }, + 1, 1, + 1, 0, + 1, 1, + 0, 0, }, { - { 1, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 }, + 1, 0, + 1, 1, + 1, 1, + 0, 0, }, { - { 1, 1 }, { 1, 1 }, { 1, 1 }, { 0, 0 }, + 1, 1, + 1, 1, + 1, 1, + 0, 0, }, }; @@ -675,8 +726,8 @@ static void RotatingGate_CreateGatesWithinViewport(s16 deltaX, s16 deltaY) for (i = 0; i < gRotatingGate_PuzzleCount; i++) { - x3 = gRotatingGate_PuzzleConfig[i].pos.x + 7; - y3 = gRotatingGate_PuzzleConfig[i].pos.y + 7; + x3 = gRotatingGate_PuzzleConfig[i].x + 7; + y3 = gRotatingGate_PuzzleConfig[i].y + 7; if (y <= y3 && y2 >= y3 && x <= x3 && x2 >= x3 && gRotatingGate_GateSpriteIds[i] == MAX_SPRITES) @@ -697,24 +748,18 @@ static u8 RotatingGate_CreateGate(u8 gateId, s16 deltaX, s16 deltaY) gate = &gRotatingGate_PuzzleConfig[gateId]; if (gate->shape == GATE_SHAPE_L1 || gate->shape == GATE_SHAPE_T1) - { template = sSpriteTemplate_RotatingGateRegular; - } else - { template = sSpriteTemplate_RotatingGateLarge; - } template.tileTag = gate->shape + ROTATING_GATE_TILE_TAG; spriteId = CreateSprite(&template, 0, 0, 0x94); if (spriteId == MAX_SPRITES) - { return MAX_SPRITES; - } - x = gate->pos.x + 7; - y = gate->pos.y + 7; + x = gate->x + 7; + y = gate->y + 7; sprite = &gSprites[spriteId]; sprite->data0 = gateId; @@ -769,7 +814,7 @@ static void RotatingGate_HideGatesOutsideViewport(struct Sprite *sprite) u16 y; s16 y2; - sprite->invisible = 0; + sprite->invisible = FALSE; x = sprite->pos1.x + sprite->pos2.x + sprite->centerToCornerVecX + gSpriteCoordOffsetX; y = sprite->pos1.y + sprite->pos2.y + sprite->centerToCornerVecY + gSpriteCoordOffsetY; @@ -778,12 +823,12 @@ static void RotatingGate_HideGatesOutsideViewport(struct Sprite *sprite) if ((s16)x > DISPLAY_WIDTH + 0x10 - 1 || x2 < -0x10) { - sprite->invisible = 1; + sprite->invisible = TRUE; } if ((s16)y > DISPLAY_HEIGHT + 0x10 - 1 || y2 < -0x10) { - sprite->invisible = 1; + sprite->invisible = TRUE; } } @@ -811,8 +856,8 @@ static void RotatingGate_DestroyGatesOutsideViewport(void) for (i = 0; i < gRotatingGate_PuzzleCount; i++) { - xGate = gRotatingGate_PuzzleConfig[i].pos.x + 7; - yGate = gRotatingGate_PuzzleConfig[i].pos.y + 7; + xGate = gRotatingGate_PuzzleConfig[i].x + 7; + yGate = gRotatingGate_PuzzleConfig[i].y + 7; if (gRotatingGate_GateSpriteIds[i] == MAX_SPRITES) continue; @@ -851,8 +896,8 @@ static int RotatingGate_CanRotate(u8 gateId, int rotationDirection) orientation = RotatingGate_GetGateOrientation(gateId); shape = gRotatingGate_PuzzleConfig[gateId].shape; - x = gRotatingGate_PuzzleConfig[gateId].pos.x + 7; - y = gRotatingGate_PuzzleConfig[gateId].pos.y + 7; + x = gRotatingGate_PuzzleConfig[gateId].x + 7; + y = gRotatingGate_PuzzleConfig[gateId].y + 7; // Loop through the gate's "arms" clockwise (north, south, east, west) for (i = GATE_ARM_NORTH; i <= GATE_ARM_WEST; i++) @@ -878,7 +923,8 @@ static int RotatingGate_CanRotate(u8 gateId, int rotationDirection) return 1; } #else -__attribute__((naked)) static int RotatingGate_CanRotate(u8 a, int puzzleType) +__attribute__((naked)) +static int RotatingGate_CanRotate(u8 a, int puzzleType) { asm(".syntax unified\n\ push {r4-r7,lr}\n\ @@ -997,7 +1043,6 @@ _080C7F60: .4byte sRotatingGate_ArmLayout\n\ } #endif -#ifdef NONMATCHING static int RotatingGate_HasArm(u8 gateId, u8 armInfo) { int isLongArm; @@ -1010,56 +1055,8 @@ static int RotatingGate_HasArm(u8 gateId, u8 armInfo) armOrientation = (arm - RotatingGate_GetGateOrientation(gateId) + 4) % 4; shape = gRotatingGate_PuzzleConfig[gateId].shape; - return sRotatingGate_ArmLayout[shape][armOrientation][isLongArm]; + return sRotatingGate_ArmLayout[shape][armOrientation * 2 + isLongArm]; } -#else -__attribute__((naked)) static int RotatingGate_HasArm(u8 a, u8 b) -{ - asm(".syntax unified\n\ - push {r4-r6,lr}\n\ - adds r4, r1, 0\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r6, r0, 0\n\ - lsls r4, 24\n\ - lsrs r5, r4, 24\n\ - lsrs r4, 25\n\ - movs r0, 0x1\n\ - ands r5, r0\n\ - adds r0, r6, 0\n\ - bl RotatingGate_GetGateOrientation\n\ - subs r4, r0\n\ - adds r1, r4, 0x4\n\ - adds r0, r1, 0\n\ - cmp r1, 0\n\ - bge _080C7F8A\n\ - adds r0, r4, 0x7\n\ -_080C7F8A:\n\ - asrs r0, 2\n\ - lsls r0, 2\n\ - subs r0, r1, r0\n\ - ldr r1, _080C7FB0 @ =gRotatingGate_PuzzleConfig\n\ - ldr r2, [r1]\n\ - lsls r1, r6, 3\n\ - adds r1, r2\n\ - ldrb r1, [r1, 0x4]\n\ - ldr r2, _080C7FB4 @ =sRotatingGate_ArmLayout\n\ - lsls r0, 24\n\ - asrs r0, 23\n\ - adds r0, r5\n\ - lsls r1, 3\n\ - adds r0, r1\n\ - adds r0, r2\n\ - ldrb r0, [r0]\n\ - pop {r4-r6}\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ -_080C7FB0: .4byte gRotatingGate_PuzzleConfig\n\ -_080C7FB4: .4byte sRotatingGate_ArmLayout\n\ -.syntax divided\n"); -} -#endif static void RotatingGate_TriggerRotationAnimation(u8 gateId, int rotationDirection) { @@ -1073,79 +1070,23 @@ static void RotatingGate_TriggerRotationAnimation(u8 gateId, int rotationDirecti } } -#ifdef NONMATCHING static u8 RotatingGate_GetRotationInfo(u8 direction, s16 x, s16 y) { - register const u8(*ptr)[][4] asm("r3"); + register const u8 *ptr; if (direction == DIR_NORTH) - ptr = &sRotatingGate_RotationInfoNorth; + ptr = sRotatingGate_RotationInfoNorth; else if (direction == DIR_SOUTH) - ptr = &sRotatingGate_RotationInfoSouth; + ptr = sRotatingGate_RotationInfoSouth; else if (direction == DIR_WEST) - ptr = &sRotatingGate_RotationInfoWest; + ptr = sRotatingGate_RotationInfoWest; else if (direction == DIR_EAST) - ptr = &sRotatingGate_RotationInfoEast; + ptr = sRotatingGate_RotationInfoEast; else - return GATE_ROTATION_NONE; + return GATE_ROT_NONE; - return (*ptr)[y][x]; + return ptr[y * 4 + x]; } -#else -__attribute__((naked)) static u8 RotatingGate_GetRotationInfo(u8 a, s16 b, s16 c) -{ - asm(".syntax unified\n\ - push {lr}\n\ - lsls r0, 24\n\ - lsrs r0, 24\n\ - adds r3, r0, 0\n\ - lsls r1, 16\n\ - lsrs r1, 16\n\ - lsls r2, 16\n\ - lsrs r2, 16\n\ - cmp r0, 0x2\n\ - bne _080C8008\n\ - ldr r3, _080C8004 @ =sRotatingGate_RotationInfoNorth\n\ - b _080C802A\n\ - .align 2, 0\n\ -_080C8004: .4byte sRotatingGate_RotationInfoNorth\n\ -_080C8008:\n\ - cmp r0, 0x1\n\ - bne _080C8014\n\ - ldr r3, _080C8010 @ =sRotatingGate_RotationInfoSouth\n\ - b _080C802A\n\ - .align 2, 0\n\ -_080C8010: .4byte sRotatingGate_RotationInfoSouth\n\ -_080C8014:\n\ - cmp r0, 0x3\n\ - bne _080C8020\n\ - ldr r3, _080C801C @ =sRotatingGate_RotationInfoWest\n\ - b _080C802A\n\ - .align 2, 0\n\ -_080C801C: .4byte sRotatingGate_RotationInfoWest\n\ -_080C8020:\n\ - cmp r3, 0x4\n\ - beq _080C8028\n\ - movs r0, 0xFF\n\ - b _080C8038\n\ -_080C8028:\n\ - ldr r3, _080C803C @ =sRotatingGate_RotationInfoEast\n\ -_080C802A:\n\ - lsls r0, r2, 16\n\ - lsls r1, 16\n\ - asrs r1, 16\n\ - asrs r0, 14\n\ - adds r0, r1\n\ - adds r0, r3, r0\n\ - ldrb r0, [r0]\n\ -_080C8038:\n\ - pop {r1}\n\ - bx r1\n\ - .align 2, 0\n\ -_080C803C: .4byte sRotatingGate_RotationInfoEast\n\ -.syntax divided\n"); -} -#endif void RotatingGate_InitPuzzle(void) { @@ -1178,36 +1119,24 @@ void RotatingGate_InitPuzzleAndGraphics(void) bool8 CheckForRotatingGatePuzzleCollision(u8 direction, s16 x, s16 y) { int i; - s16 gateX; - s16 gateY; - register u32 rotationInfo asm("r0"); - int rotationDirection; - int armInfo; - s16 centerX; - s16 centerY; if (!GetCurrentMapRotatingGatePuzzleType()) - { - return 0; - } - + return FALSE; for (i = 0; i < gRotatingGate_PuzzleCount; i++) { - gateX = gRotatingGate_PuzzleConfig[i].pos.x + 7; - gateY = gRotatingGate_PuzzleConfig[i].pos.y + 7; + s16 gateX = gRotatingGate_PuzzleConfig[i].x + 7; + s16 gateY = gRotatingGate_PuzzleConfig[i].y + 7; if (gateX - 2 <= x && x <= gateX + 1 && gateY - 2 <= y && y <= gateY + 1) { - centerX = x - gateX + 2; - centerY = y - gateY + 2; - rotationInfo = RotatingGate_GetRotationInfo(direction, centerX, centerY); + s16 centerX = x - gateX + 2; + s16 centerY = y - gateY + 2; + u8 rotationInfo = RotatingGate_GetRotationInfo(direction, centerX, centerY); - if (rotationInfo != GATE_ROTATION_NONE) + if (rotationInfo != GATE_ROT_NONE) { - rotationDirection = rotationInfo >> 4; - armInfo = rotationInfo & 0xF; - - asm("" ::"r"(armInfo)); + u8 rotationDirection = ((rotationInfo & 0xF0) >> 4); + u8 armInfo = rotationInfo & 0xF; if (RotatingGate_HasArm(i, armInfo)) { @@ -1215,14 +1144,12 @@ bool8 CheckForRotatingGatePuzzleCollision(u8 direction, s16 x, s16 y) { RotatingGate_TriggerRotationAnimation(i, rotationDirection); RotatingGate_RotateInDirection(i, rotationDirection); - return 0; + return FALSE; } - - return 1; + return TRUE; } } } } - - return 0; + return FALSE; } -- cgit v1.2.3 From 51f791219e055aa4989c77e1373075bd71bf4b60 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Mon, 28 Aug 2017 16:58:30 -0500 Subject: fix PlayCryInternal (thanks, ProjectRevoTPP) --- src/pokemon_3.c | 2 +- src/sound.c | 59 +++++++++++++++++++++------------------------------------ 2 files changed, 23 insertions(+), 38 deletions(-) (limited to 'src') diff --git a/src/pokemon_3.c b/src/pokemon_3.c index e449af0a1..d7cc39546 100644 --- a/src/pokemon_3.c +++ b/src/pokemon_3.c @@ -457,7 +457,7 @@ u16 HoennToNationalOrder(u16 hoennNum) return gHoennToNationalOrder[hoennNum - 1]; } -u32 SpeciesToCryId(u16 species) +u16 SpeciesToCryId(u16 species) { if (species <= 250) return species; diff --git a/src/sound.c b/src/sound.c index 8d23b7d7a..91f5e06a3 100644 --- a/src/sound.c +++ b/src/sound.c @@ -4,6 +4,7 @@ #include "battle.h" #include "m4a.h" #include "main.h" +#include "pokemon.h" #include "songs.h" #include "task.h" @@ -13,9 +14,6 @@ struct Fanfare u16 duration; }; -// FIXME: different prototype than definition -u32 SpeciesToCryId(u32); - extern u16 gBattleTypeFlags; static EWRAM_DATA struct MusicPlayerInfo *gMPlay_PokemonCry = NULL; @@ -355,21 +353,9 @@ void PlayCry5(u16 species, u8 mode) RestoreBGMVolumeAfterPokemonCry(); } -#define GET_CRY_PTR(a, b)\ -{\ - struct ToneData *tone;\ - if (v0)\ - tone = &a[index];\ - else\ - tone = &b[index];\ - gMPlay_PokemonCry = SetPokemonCryTone(tone);\ - break;\ -} - static void PlayCryInternal(u16 species, s8 pan, s8 volume, u8 priority, u8 mode) { - u32 cryId; - u32 v0; + bool32 v0; u32 release; u32 length; u32 pitch; @@ -378,10 +364,7 @@ static void PlayCryInternal(u16 species, s8 pan, s8 volume, u8 priority, u8 mode u8 table; species--; - - cryId = species; - - v0 = 0; + v0 = FALSE; release = 0; length = 140; pitch = 15360; @@ -427,26 +410,28 @@ static void PlayCryInternal(u16 species, s8 pan, s8 volume, u8 priority, u8 mode SetPokemonCryChorus(chorus); SetPokemonCryPriority(priority); - asm(""); - asm(""); - asm(""); - asm(""); - asm(""); - asm(""); - asm(""); - - cryId = SpeciesToCryId(cryId); - index = 0x7F; - asm("" ::: "r0"); - index &= cryId; - table = cryId >> 7; + species = SpeciesToCryId(species); + index = species & 0x7F; + table = species >> 7; switch (table) { - case 0: GET_CRY_PTR(voicegroup_84537C0, voicegroup_8452590); - case 1: GET_CRY_PTR(voicegroup_8453DC0, voicegroup_8452B90); - case 2: GET_CRY_PTR(voicegroup_84543C0, voicegroup_8453190); - case 3: GET_CRY_PTR(voicegroup_84549C0, voicegroup_8453790); + case 0: + gMPlay_PokemonCry = SetPokemonCryTone( + v0 ? &voicegroup_84537C0[index] : &voicegroup_8452590[index]); + break; + case 1: + gMPlay_PokemonCry = SetPokemonCryTone( + v0 ? &voicegroup_8453DC0[index] : &voicegroup_8452B90[index]); + break; + case 2: + gMPlay_PokemonCry = SetPokemonCryTone( + v0 ? &voicegroup_84543C0[index] : &voicegroup_8453190[index]); + break; + case 3: + gMPlay_PokemonCry = SetPokemonCryTone( + v0 ? &voicegroup_84549C0[index] : &voicegroup_8453790[index]); + break; } } -- cgit v1.2.3 From d7a6ff0e4dab0c96ac49975a0695014bff2b9654 Mon Sep 17 00:00:00 2001 From: camthesaxman Date: Mon, 28 Aug 2017 20:19:29 -0500 Subject: get sub_814A958 closer --- src/menu_cursor.c | 103 ++++++++++++++++++++++++++---------------------------- 1 file changed, 49 insertions(+), 54 deletions(-) (limited to 'src') diff --git a/src/menu_cursor.c b/src/menu_cursor.c index 64ab36573..d43be2a2f 100644 --- a/src/menu_cursor.c +++ b/src/menu_cursor.c @@ -186,73 +186,67 @@ void sub_814A904(void) return; } +#if ENGLISH #ifdef NONMATCHING // Fix pls -void sub_814A958(u8 a1) +void sub_814A958(u8 a) { - struct Subsprite *cursub; - u8 v2; // r7@1 - s16 v3; // r2@1 - s32 v5; // r0@1 - s32 v6; // r3@1 - s32 v7; // r5@3 - int v8; // r7@9 - s16 negone; - - cursub = &gMenuCursorSubsprites[0]; - negone = -1; - cursub = (struct Subsprite){0,2}; - cursub->x = negone; - cursub++; - - v2 = 1; - v3 = 1; - v5 = (a1 - 1) << 0x10; - v6 = v5 >> 0x10; - if ((v5 >> 0x10) > 7) + u8 r7; + struct Subsprite *r4 = &gMenuCursorSubsprites[0]; + s16 r2 = -1; + s32 _a = a; + s16 r5; + s16 i; + + *r4 = (struct Subsprite){.x = 0, .y = 0, .shape = 2, .size = 0, .tileOffset = 0, .priority = 0}; + r4->x = r2; + r4++; + r7 = 1; + r2 = 1; + r5 = a; + i = r5; + while ((i -= r2) >= 8) { - do + if (i > 0x1F) { - if (v6 > 0x1F) + *r4 = gUnknown_0842F780; + r4->x = r2; + r2 += 32; + r5 = a; + } + //_0814A9D4 + else + { + r5 = a; + if (_a > 0x27 && i > 8) { - *cursub = gUnknown_0842F780; - cursub->x = v3; - v3 = ((v3 << 16) + 0x200000) >> 16; - v7 = a1 << 16; + *r4 = gUnknown_0842F780; + r4->x = (r2 - 32) + (i & ~7); + r2 += i & 0x18; } + //_0814AA0A else { - v7 = a1 << 16; - if (a1 <= 0x27 || v6 <= 0x8) - { - *cursub = gUnknown_0842F788; - cursub->x = v3; - v3 = ((v3 << 16) + 0x80000) >> 16; - } - else - { - *cursub = gUnknown_0842F780; - cursub->x = v3 - 0x20 + (v6 & 0xFFF8); - v3 = (v3 + (v6 & 0x18)) & negone; - } + *r4 = gUnknown_0842F788; + r4->x = r2; + r2 += 8; } - - cursub++; - v2 = v2 + 1; - v6 = ((v7 >> 16) - v3) & 0xFFFF; } - while (v7 - v3 > 7); + //_0814AA20 + r4++; + r7++; + i = r5; } - *cursub = gUnknown_0842F790; - cursub->x = v6 + v3 - 7; - v8 = v2 + 1; - if (gUnknown_0203A3D0 != 0x40) - SetSubspriteTables(&gSprites[gUnknown_0203A3D0], &gSubspriteTables_842F5C0[v8]); - if (gUnknown_0203A3D1 != 0x40) - SetSubspriteTables(&gSprites[gUnknown_0203A3D1], &gSubspriteTables_842F5C0[v8]); - return; + //_0814AA3A + *r4 = gUnknown_0842F790; + r4->x = r2 - 7 + i; + r7++; + if (gUnknown_0203A3D0 != 64) + SetSubspriteTables(&gSprites[gUnknown_0203A3D0], gSubspriteTables_842F5C0 + r7); + if (gUnknown_0203A3D1 != 64) + SetSubspriteTables(&gSprites[gUnknown_0203A3D1], gSubspriteTables_842F5C0 + r7); } -#elif ENGLISH +#else __attribute__((naked)) void sub_814A958(u8 a1) { @@ -434,6 +428,7 @@ _0814AAB4: .4byte gSubspriteTables_842F5C0\n\ _0814AAB8: .4byte gUnknown_0203A3D1\n\ .syntax divided\n"); } +#endif #elif GERMAN __attribute__((naked)) void sub_814A958(u8 a1) -- cgit v1.2.3