diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/battle/battle_ai.c | 12 | ||||
| -rw-r--r-- | src/contest.c | 9 | ||||
| -rwxr-xr-x | src/contest_ai.c | 1763 | ||||
| -rw-r--r-- | src/engine/clear_save_data_menu.c | 2 | ||||
| -rw-r--r-- | src/engine/link.c | 2 | ||||
| -rw-r--r-- | src/engine/main_menu.c | 16 | ||||
| -rw-r--r-- | src/engine/mystery_event_menu.c | 2 | ||||
| -rw-r--r-- | src/engine/reset_rtc_screen.c | 2 | ||||
| -rw-r--r-- | src/engine/save.c | 683 | ||||
| -rw-r--r-- | src/engine/save_failed_screen.c | 2 | ||||
| -rw-r--r-- | src/field/battle_tower.c | 2 | ||||
| -rw-r--r-- | src/field/start_menu.c | 8 | ||||
| -rw-r--r-- | src/scene/hall_of_fame.c | 6 | ||||
| -rw-r--r-- | src/scene/intro.c | 4 |
14 files changed, 2185 insertions, 328 deletions
diff --git a/src/battle/battle_ai.c b/src/battle/battle_ai.c index 977e91f5c..80848d2fd 100644 --- a/src/battle/battle_ai.c +++ b/src/battle/battle_ai.c @@ -355,7 +355,7 @@ u8 BattleAI_GetAIActionToUse(void) { if (AI_THINKING_STRUCT->aiFlags & 1) { - AI_THINKING_STRUCT->aiState = AIState_SettingUp; + AI_THINKING_STRUCT->aiState = BATTLEAI_SETTING_UP; BattleAI_DoAIProcessing(); } AI_THINKING_STRUCT->aiFlags >>= 1; @@ -393,13 +393,13 @@ u8 BattleAI_GetAIActionToUse(void) void BattleAI_DoAIProcessing(void) { - while (AI_THINKING_STRUCT->aiState != AIState_FinishedProcessing) + while (AI_THINKING_STRUCT->aiState != BATTLEAI_FINISHED) { switch (AI_THINKING_STRUCT->aiState) { - case AIState_DoNotProcess: //Needed to match. + case BATTLEAI_DO_NOT_PROCESS: //Needed to match. break; - case AIState_SettingUp: + case BATTLEAI_SETTING_UP: gAIScriptPtr = BattleAIs[AI_THINKING_STRUCT->aiLogicId]; // set the AI ptr. if (gBattleMons[gBankAttacker].pp[AI_THINKING_STRUCT->movesetIndex] == 0) { @@ -411,7 +411,7 @@ void BattleAI_DoAIProcessing(void) } AI_THINKING_STRUCT->aiState++; break; - case AIState_Processing: + case BATTLEAI_PROCESSING: if (AI_THINKING_STRUCT->moveConsidered != MOVE_NONE) sBattleAICmdTable[*gAIScriptPtr](); // run AI command. else @@ -423,7 +423,7 @@ void BattleAI_DoAIProcessing(void) { AI_THINKING_STRUCT->movesetIndex++; if (AI_THINKING_STRUCT->movesetIndex < MAX_MON_MOVES && (AI_THINKING_STRUCT->aiAction & AI_ACTION_DO_NOT_ATTACK) == 0) - AI_THINKING_STRUCT->aiState = AIState_SettingUp; // as long as their are more moves to process, keep setting this to setup state. + AI_THINKING_STRUCT->aiState = BATTLEAI_SETTING_UP; // as long as their are more moves to process, keep setting this to setup state. else AI_THINKING_STRUCT->aiState++; // done processing. AI_THINKING_STRUCT->aiAction &= (AI_ACTION_FLEE | AI_ACTION_WATCH | AI_ACTION_DO_NOT_ATTACK | diff --git a/src/contest.c b/src/contest.c index 875fe4502..df4bb361d 100644 --- a/src/contest.c +++ b/src/contest.c @@ -31,13 +31,12 @@ #include "tv.h" #include "scanline_effect.h" #include "util.h" +#include "contest_ai.h" extern u8 AreMovesContestCombo(u16, u16); // I don't think this is a bool extern void sub_80C8A38(u8); extern void sub_80C8AD0(u8); extern void sub_80C8C80(u8); -extern void sub_81288F4(); -extern u8 sub_8128944(void); extern struct MusicPlayerInfo gMPlay_SE1; extern u16 gSpecialVar_ContestCategory; @@ -391,7 +390,7 @@ void ClearContestVars(void) } memset(&shared192D0, 0, sizeof(shared192D0)); - memset(shared192E4, 0, 0x44 * sizeof(*shared192E4)); + memset(eContestAI, 0, sizeof(struct ContestAIInfo)); memset(&shared19328, 0, sizeof(shared19328)); memset(shared19338, 0, 4 * sizeof(*shared19338)); if (!(gIsLinkContest & 1)) @@ -2629,8 +2628,8 @@ u16 GetChosenMove(u8 a) { u8 moveChoice; - sub_81288F4(a); - moveChoice = sub_8128944(); + ContestAI_ResetAI(a); + moveChoice = ContestAI_GetActionToUse(); return gContestMons[a].moves[moveChoice]; } } diff --git a/src/contest_ai.c b/src/contest_ai.c new file mode 100755 index 000000000..66b387270 --- /dev/null +++ b/src/contest_ai.c @@ -0,0 +1,1763 @@ +#include "global.h" +#include "contest.h" +#include "random.h" +#include "contest_ai.h" +#include "ewram.h" + +extern u8 AreMovesContestCombo(u16, u16); +extern bool8 sub_80B214C(u8); +extern bool8 Contest_IsMonsTurnDisabled(u8); + +extern s16 gUnknown_02038670[]; +extern u16 gSpecialVar_ContestCategory; + +extern u8 *gAIScriptPtr; +extern u8 *gContestAIs[]; + +static void ContestAICmd_unk_00(void); +static void ContestAICmd_get_turn(void); +static void ContestAICmd_unk_02(void); +static void ContestAICmd_unk_03(void); +static void ContestAICmd_unk_04(void); +static void ContestAICmd_unk_05(void); +static void ContestAICmd_get_excitement(void); +static void ContestAICmd_unk_07(void); +static void ContestAICmd_unk_08(void); +static void ContestAICmd_unk_09(void); +static void ContestAICmd_unk_0A(void); +static void ContestAICmd_get_user_order(void); +static void ContestAICmd_unk_0C(void); +static void ContestAICmd_unk_0D(void); +static void ContestAICmd_unk_0E(void); +static void ContestAICmd_unk_0F(void); +static void ContestAICmd_get_user_condition_maybe(void); +static void ContestAICmd_unk_11(void); +static void ContestAICmd_unk_12(void); +static void ContestAICmd_unk_13(void); +static void ContestAICmd_unk_14(void); +static void ContestAICmd_unk_15(void); +static void ContestAICmd_unk_16(void); +static void ContestAICmd_unk_17(void); +static void ContestAICmd_unk_18(void); +static void ContestAICmd_unk_19(void); +static void ContestAICmd_unk_1A(void); +static void ContestAICmd_unk_1B(void); +static void ContestAICmd_unk_1C(void); +static void ContestAICmd_unk_1D(void); +static void ContestAICmd_unk_1E(void); +static void ContestAICmd_get_contest_type(void); +static void ContestAICmd_unk_20(void); +static void ContestAICmd_unk_21(void); +static void ContestAICmd_get_move_excitement(void); +static void ContestAICmd_unk_23(void); +static void ContestAICmd_unk_24(void); +static void ContestAICmd_unk_25(void); +static void ContestAICmd_unk_26(void); +static void ContestAICmd_get_move_effect(void); +static void ContestAICmd_unk_28(void); +static void ContestAICmd_unk_29(void); +static void ContestAICmd_get_move_effect_type(void); +static void ContestAICmd_unk_2B(void); +static void ContestAICmd_unk_2C(void); +static void ContestAICmd_check_move_has_highest_appeal(void); +static void ContestAICmd_unk_2E(void); +static void ContestAICmd_unk_2F(void); +static void ContestAICmd_unk_30(void); +static void ContestAICmd_unk_31(void); +static void ContestAICmd_unk_32(void); +static void ContestAICmd_unk_33(void); +static void ContestAICmd_unk_34(void); +static void ContestAICmd_unk_35(void); +static void ContestAICmd_unk_36(void); +static void ContestAICmd_unk_37(void); +static void ContestAICmd_unk_38(void); +static void ContestAICmd_unk_39(void); +static void ContestAICmd_unk_3A(void); +static void ContestAICmd_get_move_used_count(void); +static void ContestAICmd_unk_3C(void); +static void ContestAICmd_unk_3D(void); +static void ContestAICmd_unk_3E(void); +static void ContestAICmd_unk_3F(void); +static void ContestAICmd_check_combo_starter(void); +static void ContestAICmd_unk_41(void); +static void ContestAICmd_unk_42(void); +static void ContestAICmd_check_combo_finisher(void); +static void ContestAICmd_unk_44(void); +static void ContestAICmd_unk_45(void); +static void ContestAICmd_check_would_finish_combo(void); +static void ContestAICmd_unk_47(void); +static void ContestAICmd_unk_48(void); +static void ContestAICmd_get_condition(void); +static void ContestAICmd_unk_4A(void); +static void ContestAICmd_unk_4B(void); +static void ContestAICmd_unk_4C(void); +static void ContestAICmd_unk_4D(void); +static void ContestAICmd_get_used_combo_starter(void); +static void ContestAICmd_unk_4F(void); +static void ContestAICmd_unk_50(void); +static void ContestAICmd_unk_51(void); +static void ContestAICmd_unk_52(void); +static void ContestAICmd_check_can_participate(void); +static void ContestAICmd_unk_54(void); +static void ContestAICmd_unk_55(void); +static void ContestAICmd_get_val_812A188(void); +static void ContestAICmd_unk_57(void); +static void ContestAICmd_unk_58(void); +static void ContestAICmd_unk_59(void); +static void ContestAICmd_unk_5A(void); +static void ContestAICmd_unk_5B(void); +static void ContestAICmd_unk_5C(void); +static void ContestAICmd_unk_5D(void); +static void ContestAICmd_unk_5E(void); +static void ContestAICmd_unk_5F(void); +static void ContestAICmd_unk_60(void); +static void ContestAICmd_unk_61(void); +static void ContestAICmd_unk_62(void); +static void ContestAICmd_unk_63(void); +static void ContestAICmd_unk_64(void); +static void ContestAICmd_unk_65(void); +static void ContestAICmd_unk_66(void); +static void ContestAICmd_unk_67(void); +static void ContestAICmd_unk_68(void); +static void ContestAICmd_unk_69(void); +static void ContestAICmd_unk_6A(void); +static void ContestAICmd_unk_6B(void); +static void ContestAICmd_unk_6C(void); +static void ContestAICmd_unk_6D(void); +static void ContestAICmd_unk_6E(void); +static void ContestAICmd_unk_6F(void); +static void ContestAICmd_unk_70(void); +static void ContestAICmd_unk_71(void); +static void ContestAICmd_unk_72(void); +static void ContestAICmd_unk_73(void); +static void ContestAICmd_unk_74(void); +static void ContestAICmd_unk_75(void); +static void ContestAICmd_unk_76(void); +static void ContestAICmd_unk_77(void); +static void ContestAICmd_unk_78(void); +static void ContestAICmd_unk_79(void); +static void ContestAICmd_unk_7A(void); +static void ContestAICmd_unk_7B(void); +static void ContestAICmd_unk_7C(void); +static void ContestAICmd_unk_7D(void); +static void ContestAICmd_unk_7E(void); +static void ContestAICmd_unk_7F(void); +static void ContestAICmd_unk_80(void); +static void ContestAICmd_unk_81(void); +static void ContestAICmd_check_for_exciting_move(void); +static void ContestAICmd_unk_83(void); +static void ContestAICmd_unk_84(void); +static void ContestAICmd_unk_85(void); +static void ContestAICmd_unk_86(void); +static void ContestAICmd_unk_87(void); + +typedef void (* ContestAICmdFunc)(void); + +static const ContestAICmdFunc sContestAICmdTable[] = +{ + ContestAICmd_unk_00, // 0x00 + ContestAICmd_get_turn, // 0x01 + ContestAICmd_unk_02, // 0x02 + ContestAICmd_unk_03, // 0x03 + ContestAICmd_unk_04, // 0x04 + ContestAICmd_unk_05, // 0x05 + ContestAICmd_get_excitement, // 0x06 + ContestAICmd_unk_07, // 0x07 + ContestAICmd_unk_08, // 0x08 + ContestAICmd_unk_09, // 0x09 + ContestAICmd_unk_0A, // 0x0A + ContestAICmd_get_user_order, // 0x0B + ContestAICmd_unk_0C, // 0x0C + ContestAICmd_unk_0D, // 0x0D + ContestAICmd_unk_0E, // 0x0E + ContestAICmd_unk_0F, // 0x0F + ContestAICmd_get_user_condition_maybe, // 0x10 + ContestAICmd_unk_11, // 0x11 + ContestAICmd_unk_12, // 0x12 + ContestAICmd_unk_13, // 0x13 + ContestAICmd_unk_14, // 0x14 + ContestAICmd_unk_15, // 0x15 + ContestAICmd_unk_16, // 0x16 + ContestAICmd_unk_17, // 0x17 + ContestAICmd_unk_18, // 0x18 + ContestAICmd_unk_19, // 0x19 + ContestAICmd_unk_1A, // 0x1A + ContestAICmd_unk_1B, // 0x1B + ContestAICmd_unk_1C, // 0x1C + ContestAICmd_unk_1D, // 0x1D + ContestAICmd_unk_1E, // 0x1E + ContestAICmd_get_contest_type, // 0x1F + ContestAICmd_unk_20, // 0x20 + ContestAICmd_unk_21, // 0x21 + ContestAICmd_get_move_excitement, // 0x22 + ContestAICmd_unk_23, // 0x23 + ContestAICmd_unk_24, // 0x24 + ContestAICmd_unk_25, // 0x25 + ContestAICmd_unk_26, // 0x26 + ContestAICmd_get_move_effect, // 0x27 + ContestAICmd_unk_28, // 0x28 + ContestAICmd_unk_29, // 0x29 + ContestAICmd_get_move_effect_type, // 0x2A + ContestAICmd_unk_2B, // 0x2B + ContestAICmd_unk_2C, // 0x2C + ContestAICmd_check_move_has_highest_appeal, // 0x2D + ContestAICmd_unk_2E, // 0x2E + ContestAICmd_unk_2F, // 0x2F + ContestAICmd_unk_30, // 0x30 + ContestAICmd_unk_31, // 0x31 + ContestAICmd_unk_32, // 0x32 + ContestAICmd_unk_33, // 0x33 + ContestAICmd_unk_34, // 0x34 + ContestAICmd_unk_35, // 0x35 + ContestAICmd_unk_36, // 0x36 + ContestAICmd_unk_37, // 0x37 + ContestAICmd_unk_38, // 0x38 + ContestAICmd_unk_39, // 0x39 + ContestAICmd_unk_3A, // 0x3A + ContestAICmd_get_move_used_count, // 0x3B + ContestAICmd_unk_3C, // 0x3C + ContestAICmd_unk_3D, // 0x3D + ContestAICmd_unk_3E, // 0x3E + ContestAICmd_unk_3F, // 0x3F + ContestAICmd_check_combo_starter, // 0x40 + ContestAICmd_unk_41, // 0x41 + ContestAICmd_unk_42, // 0x42 + ContestAICmd_check_combo_finisher, // 0x43 + ContestAICmd_unk_44, // 0x44 + ContestAICmd_unk_45, // 0x45 + ContestAICmd_check_would_finish_combo, // 0x46 + ContestAICmd_unk_47, // 0x47 + ContestAICmd_unk_48, // 0x48 + ContestAICmd_get_condition, // 0x49 + ContestAICmd_unk_4A, // 0x4A + ContestAICmd_unk_4B, // 0x4B + ContestAICmd_unk_4C, // 0x4C + ContestAICmd_unk_4D, // 0x4D + ContestAICmd_get_used_combo_starter, // 0x4E + ContestAICmd_unk_4F, // 0x4F + ContestAICmd_unk_50, // 0x50 + ContestAICmd_unk_51, // 0x51 + ContestAICmd_unk_52, // 0x52 + ContestAICmd_check_can_participate, // 0x53 + ContestAICmd_unk_54, // 0x54 + ContestAICmd_unk_55, // 0x55 + ContestAICmd_get_val_812A188, // 0x56 + ContestAICmd_unk_57, // 0x57 + ContestAICmd_unk_58, // 0x58 + ContestAICmd_unk_59, // 0x59 + ContestAICmd_unk_5A, // 0x5A + ContestAICmd_unk_5B, // 0x5B + ContestAICmd_unk_5C, // 0x5C + ContestAICmd_unk_5D, // 0x5D + ContestAICmd_unk_5E, // 0x5E + ContestAICmd_unk_5F, // 0x5F + ContestAICmd_unk_60, // 0x60 + ContestAICmd_unk_61, // 0x61 + ContestAICmd_unk_62, // 0x62 + ContestAICmd_unk_63, // 0x63 + ContestAICmd_unk_64, // 0x64 + ContestAICmd_unk_65, // 0x65 + ContestAICmd_unk_66, // 0x66 + ContestAICmd_unk_67, // 0x67 + ContestAICmd_unk_68, // 0x68 + ContestAICmd_unk_69, // 0x69 + ContestAICmd_unk_6A, // 0x6A + ContestAICmd_unk_6B, // 0x6B + ContestAICmd_unk_6C, // 0x6C + ContestAICmd_unk_6D, // 0x6D + ContestAICmd_unk_6E, // 0x6E + ContestAICmd_unk_6F, // 0x6F + ContestAICmd_unk_70, // 0x70 + ContestAICmd_unk_71, // 0x71 + ContestAICmd_unk_72, // 0x72 + ContestAICmd_unk_73, // 0x73 + ContestAICmd_unk_74, // 0x74 + ContestAICmd_unk_75, // 0x75 + ContestAICmd_unk_76, // 0x76 + ContestAICmd_unk_77, // 0x77 + ContestAICmd_unk_78, // 0x78 + ContestAICmd_unk_79, // 0x79 + ContestAICmd_unk_7A, // 0x7A + ContestAICmd_unk_7B, // 0x7B + ContestAICmd_unk_7C, // 0x7C + ContestAICmd_unk_7D, // 0x7D + ContestAICmd_unk_7E, // 0x7E + ContestAICmd_unk_7F, // 0x7F + ContestAICmd_unk_80, // 0x80 + ContestAICmd_unk_81, // 0x81 + ContestAICmd_check_for_exciting_move, // 0x82 + ContestAICmd_unk_83, // 0x83 + ContestAICmd_unk_84, // 0x84 + ContestAICmd_unk_85, // 0x85 + ContestAICmd_unk_86, // 0x86 + ContestAICmd_unk_87, // 0x87 +}; + +static void ContestAI_DoAIProcessing(void); +static bool8 sub_8128A7C(u8); +static void sub_812ACA4(u8 *); +static u8 sub_812ACC8(void); + +void ContestAI_ResetAI(u8 var) +{ + int i; + memset(eContestAI, 0, sizeof(struct ContestAIInfo)); + + for(i = 0; i < 4; i++) + eContestAI->unk5[i] = 100; + + eContestAI->unk41 = var; + eContestAI->unk40 = 0; + eContestAI->flags = gContestMons[eContestAI->unk41].flags; +} + +u8 ContestAI_GetActionToUse(void) +{ + while(eContestAI->flags != 0) + { + if(eContestAI->flags & 1) + { + eContestAI->aiState = 0; + ContestAI_DoAIProcessing(); + } + eContestAI->flags >>= 1; + eContestAI->unk10++; + eContestAI->unk4 = 0; + } + + while (1) + { + u8 rval = Random() & 3; + u8 r2 = eContestAI->unk5[rval]; + int i; + for (i = 0; i < 4; i++) + { + if (r2 < eContestAI->unk5[i]) + break; + } + if (i == 4) + return rval; + } +} + +static void ContestAI_DoAIProcessing(void) +{ + while(eContestAI->aiState != CONTESTAI_FINISHED) + { + switch(eContestAI->aiState) + { + case CONTESTAI_DO_NOT_PROCESS: + break; + case CONTESTAI_SETTING_UP: + gAIScriptPtr = gContestAIs[eContestAI->unk10]; + + if(gContestMons[eContestAI->unk41].moves[eContestAI->unk4] == 0) + eContestAI->unk2 = 0; // don't process a move that doesn't exist. + else + eContestAI->unk2 = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + eContestAI->aiState++; + break; + case CONTESTAI_PROCESSING: + if(eContestAI->unk2 != 0) + sContestAICmdTable[*gAIScriptPtr](); // run the command. + else + { + eContestAI->unk5[eContestAI->unk4] = 0; // don't consider a move that doesn't exist. + eContestAI->aiAction |= 1; + } + if(eContestAI->aiAction & 1) + { + eContestAI->unk4++; + if(eContestAI->unk4 < 4) + eContestAI->aiState = 0; + else + eContestAI->aiState++; + eContestAI->aiAction &= 0xFE; // TODO: Define action flags + } + break; + } + } +} + +static u8 sub_8128A7C(u8 var) +{ + int i; + + for(i = 0; i < 4; i++) + if(shared192D0.unk0[i] == var) + break; + + return i; +} + +static void ContestAICmd_unk_00(void) +{ + s16 score = eContestAI->unk5[eContestAI->unk4] + (s8)gAIScriptPtr[1]; + + if (score > 255) + score = 255; + else if (score < 0) + score = 0; + + eContestAI->unk5[eContestAI->unk4] = score; + + gAIScriptPtr += 2; +} + +static void ContestAICmd_get_turn(void) +{ + eContestAI->scriptResult = sContest.turnNumber; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_02(void) +{ + ContestAICmd_get_turn(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_03(void) +{ + ContestAICmd_get_turn(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_04(void) +{ + ContestAICmd_get_turn(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_05(void) +{ + ContestAICmd_get_turn(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_excitement(void) +{ + eContestAI->scriptResult = sContest.applauseLevel; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_07(void) +{ + ContestAICmd_get_excitement(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_08(void) +{ + ContestAICmd_get_excitement(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_09(void) +{ + ContestAICmd_get_excitement(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_0A(void) +{ + ContestAICmd_get_excitement(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_user_order(void) +{ + eContestAI->scriptResult = shared192D0.unk0[eContestAI->unk41]; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_0C(void) +{ + ContestAICmd_get_user_order(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_0D(void) +{ + ContestAICmd_get_user_order(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_0E(void) +{ + ContestAICmd_get_user_order(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_0F(void) +{ + ContestAICmd_get_user_order(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_user_condition_maybe(void) +{ + eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unkD / 10; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_11(void) +{ + ContestAICmd_get_user_condition_maybe(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_12(void) +{ + ContestAICmd_get_user_condition_maybe(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_13(void) +{ + ContestAICmd_get_user_condition_maybe(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_14(void) +{ + ContestAICmd_get_user_condition_maybe(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_15(void) +{ + eContestAI->scriptResult = sContestantStatus[eContestAI->unk41].unk4; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_16(void) +{ + ContestAICmd_unk_15(); + + if(eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_17(void) +{ + ContestAICmd_unk_15(); + + if(eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_18(void) +{ + ContestAICmd_unk_15(); + + if(eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_19(void) +{ + ContestAICmd_unk_15(); + + if(eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_1A(void) +{ + eContestAI->scriptResult = gUnknown_02038670[eContestAI->unk41]; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_1B(void) +{ + ContestAICmd_unk_1A(); + + if(eContestAI->scriptResult < (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_1C(void) +{ + ContestAICmd_unk_1A(); + + if(eContestAI->scriptResult > (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_1D(void) +{ + ContestAICmd_unk_1A(); + + if(eContestAI->scriptResult == (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_1E(void) +{ + ContestAICmd_unk_1A(); + + if(eContestAI->scriptResult != (s16)T1_READ_16(gAIScriptPtr + 0)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_get_contest_type(void) +{ + eContestAI->scriptResult = gSpecialVar_ContestCategory; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_20(void) +{ + ContestAICmd_get_contest_type(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_21(void) +{ + ContestAICmd_get_contest_type(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_move_excitement(void) +{ + eContestAI->scriptResult = Contest_GetMoveExcitement(gContestMons[eContestAI->unk41].moves[eContestAI->unk4]); + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_23(void) +{ + ContestAICmd_get_move_excitement(); + + if(eContestAI->scriptResult < (s8)gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_24(void) +{ + ContestAICmd_get_move_excitement(); + + if(eContestAI->scriptResult > (s8)gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_25(void) +{ + ContestAICmd_get_move_excitement(); + + if(eContestAI->scriptResult == (s8)gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_26(void) +{ + ContestAICmd_get_move_excitement(); + + if(eContestAI->scriptResult != (s8)gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_move_effect(void) +{ + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + eContestAI->scriptResult = gContestMoves[move].effect; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_28(void) +{ + ContestAICmd_get_move_effect(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_29(void) +{ + ContestAICmd_get_move_effect(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_move_effect_type(void) +{ + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].effectType; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_2B(void) +{ + ContestAICmd_get_move_effect_type(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_2C(void) +{ + ContestAICmd_get_move_effect_type(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_check_move_has_highest_appeal(void) +{ + int i; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + u8 appeal = gContestEffects[gContestMoves[move].effect].appeal; + + for(i = 0; i < 4; i++) + { + u16 newMove = gContestMons[eContestAI->unk41].moves[i]; + if(newMove != 0 && appeal < gContestEffects[gContestMoves[newMove].effect].appeal) + break; + } + + if(i == 4) + eContestAI->scriptResult = TRUE; + else + eContestAI->scriptResult = FALSE; + + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_2E(void) +{ + ContestAICmd_check_move_has_highest_appeal(); + + if(eContestAI->scriptResult != FALSE) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_2F(void) +{ + int i; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + u8 jam = gContestEffects[gContestMoves[move].effect].jam; + + for(i = 0; i < 4; i++) + { + u16 newMove = gContestMons[eContestAI->unk41].moves[i]; + if(newMove != 0 && jam < gContestEffects[gContestMoves[newMove].effect].jam) + break; + } + + if(i == 4) + eContestAI->scriptResult = TRUE; + else + eContestAI->scriptResult = FALSE; + + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_30(void) +{ + ContestAICmd_unk_2F(); + + if(eContestAI->scriptResult != FALSE) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_31(void) +{ + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].appeal / 10; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_32(void) +{ + ContestAICmd_unk_31(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_33(void) +{ + ContestAICmd_unk_31(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_34(void) +{ + ContestAICmd_unk_31(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_35(void) +{ + ContestAICmd_unk_31(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_36(void) +{ + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].jam / 10; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_37(void) +{ + ContestAICmd_unk_36(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_38(void) +{ + ContestAICmd_unk_36(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_39(void) +{ + ContestAICmd_unk_36(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_3A(void) +{ + ContestAICmd_unk_36(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_move_used_count(void) +{ + s16 result; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + if(move != sContestantStatus[eContestAI->unk41].prevMove) + result = 0; // move is unique and not reused. + else + result = sContestantStatus[eContestAI->unk41].moveRepeatCount + 1; + + eContestAI->scriptResult = result; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_3C(void) +{ + ContestAICmd_get_move_used_count(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_3D(void) +{ + ContestAICmd_get_move_used_count(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_3E(void) +{ + ContestAICmd_get_move_used_count(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_3F(void) +{ + ContestAICmd_get_move_used_count(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_check_combo_starter(void) +{ + u8 result = 0; + int i; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + for(i = 0; i < 4; i++) + { + if (gContestMons[eContestAI->unk41].moves[i]) + { + result = AreMovesContestCombo(move, gContestMons[eContestAI->unk41].moves[i]); + if (result) + { + result = 1; + break; + } + } + } + + if (result) + result = 1; + + eContestAI->scriptResult = result; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_41(void) +{ + ContestAICmd_check_combo_starter(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_42(void) +{ + ContestAICmd_check_combo_starter(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_check_combo_finisher(void) +{ + u8 result = 0; + int i; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + for(i = 0; i < 4; i++) + { + if (gContestMons[eContestAI->unk41].moves[i]) + { + result = AreMovesContestCombo(gContestMons[eContestAI->unk41].moves[i], move); + if (result) + { + result = 1; + break; + } + } + } + + if (result) + result = 1; + + eContestAI->scriptResult = result; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_44(void) +{ + ContestAICmd_check_combo_finisher(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_45(void) +{ + ContestAICmd_check_combo_finisher(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_check_would_finish_combo(void) +{ + u8 result = 0; + u16 move = gContestMons[eContestAI->unk41].moves[eContestAI->unk4]; + + if(sContestantStatus[eContestAI->unk41].prevMove) + result = AreMovesContestCombo(sContestantStatus[eContestAI->unk41].prevMove, move); + + if(result) + result = 1; + + eContestAI->scriptResult = result; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_47(void) +{ + ContestAICmd_check_would_finish_combo(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_48(void) +{ + ContestAICmd_check_would_finish_combo(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_get_condition(void) +{ + int var = sub_8128A7C(gAIScriptPtr[1]); + + eContestAI->scriptResult = sContestantStatus[var].unkD / 10; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_4A(void) +{ + ContestAICmd_get_condition(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_4B(void) +{ + ContestAICmd_get_condition(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_4C(void) +{ + ContestAICmd_get_condition(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_4D(void) +{ + ContestAICmd_get_condition(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_get_used_combo_starter(void) +{ + u16 result = 0; + u8 var = sub_8128A7C(gAIScriptPtr[1]); + + if(sub_80B214C(var)) + result = gContestMoves[sContestantStatus[var].prevMove].comboStarterId ? 1 : 0; + + eContestAI->scriptResult = result; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_4F(void) +{ + ContestAICmd_get_used_combo_starter(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_50(void) +{ + ContestAICmd_get_used_combo_starter(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_51(void) +{ + ContestAICmd_get_used_combo_starter(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_52(void) +{ + ContestAICmd_get_used_combo_starter(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_check_can_participate(void) +{ + if(Contest_IsMonsTurnDisabled(sub_8128A7C(gAIScriptPtr[1]))) + eContestAI->scriptResult = FALSE; + else + eContestAI->scriptResult = TRUE; + + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_54(void) +{ + ContestAICmd_check_can_participate(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_55(void) +{ + ContestAICmd_check_can_participate(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_get_val_812A188(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + + eContestAI->scriptResult = sContestantStatus[var].unk15_3; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_57(void) +{ + ContestAICmd_get_val_812A188(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_58(void) +{ + ContestAICmd_get_val_812A188(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_59(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + + eContestAI->scriptResult = sContestantStatus[var].unk4 - sContestantStatus[eContestAI->unk41].unk4; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_5A(void) +{ + ContestAICmd_unk_59(); + + if(eContestAI->scriptResult < 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_5B(void) +{ + ContestAICmd_unk_59(); + + if(eContestAI->scriptResult > 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_5C(void) +{ + ContestAICmd_unk_59(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_5D(void) +{ + ContestAICmd_unk_59(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_5E(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + + eContestAI->scriptResult = gUnknown_02038670[var] - gUnknown_02038670[eContestAI->unk41]; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_5F(void) +{ + ContestAICmd_unk_5E(); + + if(eContestAI->scriptResult < 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_60(void) +{ + ContestAICmd_unk_5E(); + + if(eContestAI->scriptResult > 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_61(void) +{ + ContestAICmd_unk_5E(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_62(void) +{ + ContestAICmd_unk_5E(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_63(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + u8 var2 = gAIScriptPtr[2]; + u16 move = sContest.unk19220[var2][var]; + + eContestAI->scriptResult = gContestMoves[move].effect; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_64(void) +{ + ContestAICmd_unk_63(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_65(void) +{ + ContestAICmd_unk_63(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_66(void) +{ + ContestAICmd_unk_63(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_67(void) +{ + ContestAICmd_unk_63(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_68(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + u8 var2 = gAIScriptPtr[2]; + s8 result = sContest.unk19248[var2][var]; + + eContestAI->scriptResult = result; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_69(void) +{ + ContestAICmd_unk_68(); + + if(eContestAI->scriptResult < gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_6A(void) +{ + ContestAICmd_unk_68(); + + if(eContestAI->scriptResult > gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_6B(void) +{ + ContestAICmd_unk_68(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_6C(void) +{ + ContestAICmd_unk_68(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_6D(void) +{ + u8 var = sub_8128A7C(gAIScriptPtr[1]); + u8 var2 = gAIScriptPtr[2]; + u16 move = sContest.unk19220[var2][var]; + + eContestAI->scriptResult = gContestEffects[gContestMoves[move].effect].effectType; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_6E(void) +{ + ContestAICmd_unk_6D(); + + if(eContestAI->scriptResult == gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_6F(void) +{ + ContestAICmd_unk_6D(); + + if(eContestAI->scriptResult != gAIScriptPtr[0]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); + else + gAIScriptPtr += 5; +} + +static void ContestAICmd_unk_70(void) +{ + eContestAI->scriptArr[gAIScriptPtr[1]] = eContestAI->scriptResult; + gAIScriptPtr += 2; +} + +static void ContestAICmd_unk_71(void) +{ + eContestAI->scriptArr[gAIScriptPtr[1]] = T1_READ_16(gAIScriptPtr + 2); + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_72(void) +{ + // wtf? shouldn't T1_READ_16 work here? why the signed 8 load by gAIScriptPtr[2]? + eContestAI->scriptArr[gAIScriptPtr[1]] += ((s8)gAIScriptPtr[2] | gAIScriptPtr[3] << 8); + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_73(void) +{ + eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]]; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_74(void) +{ + eContestAI->scriptArr[gAIScriptPtr[1]] += eContestAI->scriptArr[gAIScriptPtr[2]]; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_75(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] < T1_READ_16(gAIScriptPtr + 2)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4); + else + gAIScriptPtr += 8; +} + +static void ContestAICmd_unk_76(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] > T1_READ_16(gAIScriptPtr + 2)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4); + else + gAIScriptPtr += 8; +} + +static void ContestAICmd_unk_77(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] == T1_READ_16(gAIScriptPtr + 2)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4); + else + gAIScriptPtr += 8; +} + +static void ContestAICmd_unk_78(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] != T1_READ_16(gAIScriptPtr + 2)) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 4); + else + gAIScriptPtr += 8; +} + +static void ContestAICmd_unk_79(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] < (eContestAI->scriptArr[gAIScriptPtr[2]])) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3); + else + gAIScriptPtr += 7; +} + +static void ContestAICmd_unk_7A(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] > (eContestAI->scriptArr[gAIScriptPtr[2]])) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3); + else + gAIScriptPtr += 7; +} + +static void ContestAICmd_unk_7B(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] == (eContestAI->scriptArr[gAIScriptPtr[2]])) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3); + else + gAIScriptPtr += 7; +} + +static void ContestAICmd_unk_7C(void) +{ + if(eContestAI->scriptArr[gAIScriptPtr[1]] != (eContestAI->scriptArr[gAIScriptPtr[2]])) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 3); + else + gAIScriptPtr += 7; +} + +static void ContestAICmd_unk_7D(void) +{ + if((Random() & 0xFF) < eContestAI->scriptArr[gAIScriptPtr[1]]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +static void ContestAICmd_unk_7E(void) +{ + if((Random() & 0xFF) > eContestAI->scriptArr[gAIScriptPtr[1]]) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 2); + else + gAIScriptPtr += 6; +} + +// jump +static void ContestAICmd_unk_7F(void) +{ + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); +} + +static void ContestAICmd_unk_80(void) +{ + sub_812ACA4(gAIScriptPtr + 5); + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 1); +} + +static void ContestAICmd_unk_81(void) +{ + if(!sub_812ACC8()) + eContestAI->aiAction |= 1; +} + +// push stack? +static void sub_812ACA4(u8 *ptr) +{ + u8 unk40 = eContestAI->unk40++; + eContestAI->stack[unk40] = (u32)ptr; +} + +// pop stack? +static bool8 sub_812ACC8(void) +{ + if(eContestAI->unk40 != 0) + { + --eContestAI->unk40; + gAIScriptPtr = (u8 *)eContestAI->stack[eContestAI->unk40]; + return TRUE; + } + else + return FALSE; +} + +static void ContestAICmd_check_for_exciting_move(void) +{ + int result = 0; + int i; + + for(i = 0; i < 4; i++) + { + if(gContestMons[eContestAI->unk41].moves[i]) + { + // why is it using gSharedMem + 0x19325? that does not exist... + if(Contest_GetMoveExcitement(gContestMons[eContestAI->unk41].moves[i]) == 1) + { + result = 1; + break; + } + } + } + + eContestAI->scriptResult = result; + gAIScriptPtr += 1; +} + +static void ContestAICmd_unk_83(void) +{ + ContestAICmd_check_for_exciting_move(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_84(void) +{ + ContestAICmd_check_for_exciting_move(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_85(void) +{ + int result = 0; + int i; + u16 arg = T1_READ_16(gAIScriptPtr + 1); + + for(i = 0; i < 4; i++) + { + u16 move = gContestMons[eContestAI->unk41].moves[i]; + if(move == arg) + { + result = 1; + break; + } + } + + eContestAI->scriptResult = result; + gAIScriptPtr += 3; +} + +static void ContestAICmd_unk_86(void) +{ + ContestAICmd_unk_85(); + + if(eContestAI->scriptResult != 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} + +static void ContestAICmd_unk_87(void) +{ + ContestAICmd_unk_85(); + + if(eContestAI->scriptResult == 0) + gAIScriptPtr = T1_READ_PTR(gAIScriptPtr + 0); + else + gAIScriptPtr += 4; +} diff --git a/src/engine/clear_save_data_menu.c b/src/engine/clear_save_data_menu.c index 08fd5cd18..b6053715a 100644 --- a/src/engine/clear_save_data_menu.c +++ b/src/engine/clear_save_data_menu.c @@ -73,7 +73,7 @@ static void Task_ProcessMenuInput(u8 taskId) static void Task_ClearSaveData(u8 taskId) { - ClearSaveData(); + Save_EraseAllData(); DestroyTask(taskId); SetMainCallback2(CB2_SoftReset); } diff --git a/src/engine/link.c b/src/engine/link.c index 34016d607..ec94295d7 100644 --- a/src/engine/link.c +++ b/src/engine/link.c @@ -409,7 +409,7 @@ static void LinkTestProcessKeyInput(void) if (gMain.newKeys & START_BUTTON) SetSuppressLinkErrorMessage(TRUE); if (gMain.newKeys & R_BUTTON) - TrySavingData(LINK_SAVE); + Save_WriteData(SAVE_LINK); if (gMain.newKeys & SELECT_BUTTON) sub_800832C(); if (gLinkTestDebugValuesEnabled) diff --git a/src/engine/main_menu.c b/src/engine/main_menu.c index a0b8b7020..5a3f55b29 100644 --- a/src/engine/main_menu.c +++ b/src/engine/main_menu.c @@ -1,4 +1,6 @@ #include "global.h" +#include "constants/songs.h" +#include "constants/species.h" #include "main_menu.h" #include "data2.h" #include "decompress.h" @@ -13,9 +15,8 @@ #include "overworld.h" #include "rtc.h" #include "save_menu_util.h" -#include "constants/songs.h" +#include "save.h" #include "sound.h" -#include "constants/species.h" #include "string_util.h" #include "strings.h" #include "task.h" @@ -28,8 +29,6 @@ extern struct PaletteFadeControl gPaletteFade; -extern u16 gSaveFileStatus; - extern const u8 gBirchSpeech_Welcome[]; extern const u8 gBirchSpeech_ThisIsPokemon[]; extern const u8 gBirchSpeech_WorldInhabitedByPokemon[]; @@ -284,12 +283,11 @@ void Task_MainMenuCheckSave(u8 taskId) switch (gSaveFileStatus) { - case 1: + case SAVE_STATUS_OK: if (IsMysteryGiftEnabled() == TRUE) gTasks[taskId].tMenuLayout = HAS_MYSTERY_GIFT; else gTasks[taskId].tMenuLayout = HAS_SAVED_GAME; - gTasks[taskId].func = Task_MainMenuCheckRtc; break; case 2: @@ -300,7 +298,7 @@ void Task_MainMenuCheckSave(u8 taskId) gTasks[taskId].tMenuLayout = HAS_NO_SAVED_GAME; gTasks[taskId].func = Task_MainMenuWaitForSaveErrorAck; break; - case 255: + case SAVE_STATUS_ERROR: Menu_DrawStdWindowFrame(2, 14, 27, 19); MenuPrintMessage(gSaveFileCorruptMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); @@ -313,12 +311,12 @@ void Task_MainMenuCheckSave(u8 taskId) else gTasks[taskId].tMenuLayout = HAS_SAVED_GAME; break; - case 0: + case SAVE_STATUS_EMPTY: default: gTasks[taskId].tMenuLayout = HAS_NO_SAVED_GAME; gTasks[taskId].func = Task_MainMenuCheckRtc; break; - case 4: + case SAVE_STATUS_NO_FLASH: Menu_DrawStdWindowFrame(2, 14, 27, 19); MenuPrintMessage(gBoardNotInstalledMessage, 3, 15); REG_WIN0H = WIN_RANGE(17, 223); diff --git a/src/engine/mystery_event_menu.c b/src/engine/mystery_event_menu.c index b7b7c047e..8fad563e6 100644 --- a/src/engine/mystery_event_menu.c +++ b/src/engine/mystery_event_menu.c @@ -289,7 +289,7 @@ static void CB2_MysteryEventMenu(void) unkVal = RunMysteryEventScript(gSharedMem); CpuFill32(0, gSharedMem, 0x7D4); if (!GetEventLoadMessage(gStringVar4, unkVal)) - TrySavingData(NORMAL_SAVE); + Save_WriteData(SAVE_NORMAL); gMain.state++; break; case 12: diff --git a/src/engine/reset_rtc_screen.c b/src/engine/reset_rtc_screen.c index a8b49a8eb..c7d45e929 100644 --- a/src/engine/reset_rtc_screen.c +++ b/src/engine/reset_rtc_screen.c @@ -576,7 +576,7 @@ void Task_ResetRtcScreen(u8 taskId) } break; case 4: - if (TrySavingData(0) == TRUE) + if (Save_WriteData(0) == SAVE_STATUS_OK) { ResetRtcScreen_ShowMessage(gSystemText_SaveCompleted); PlaySE(SE_PINPON); diff --git a/src/engine/save.c b/src/engine/save.c index d5de2e408..be907edcc 100644 --- a/src/engine/save.c +++ b/src/engine/save.c @@ -4,55 +4,132 @@ #include "save.h" #include "load_save.h" #include "overworld.h" +#include "pokemon.h" #include "save_failed_screen.h" #include "ewram.h" -#define GETVALIDSTATUSBITFIELD ((1 << ARRAY_COUNT(gSaveSectionLocations)) - 1) -#define GETCHUNKSIZE(chunk, n) ((sizeof(chunk) - (0xF80 * (n - 1))) >= 0xF80 ? 0xF80 : (sizeof(chunk) - (0xF80 * (n - 1)))) -#define GETBLOCKOFFSET(n) (0xF80 * (n - 1)) -#define TOTALNUMSECTORS ((ARRAY_COUNT(gSaveSectionLocations) * 2) + (ARRAY_COUNT(gHallOfFameSaveSectionLocations) * 2)) // there are 2 slots, so double each array count and get the sum. +#define FILE_SIGNATURE 0x08012025 // signature value to determine if a sector is in use -u16 gLastWrittenSector; -u32 gLastSaveCounter; +//#define TOTAL_FLASH_SECTORS ((ARRAY_COUNT(sSaveBlockChunks) * 2) + (ARRAY_COUNT(sHallOfFameChunks) * 2)) // there are 2 slots, so double each array count and get the sum. +#define TOTAL_FLASH_SECTORS 32 + +struct SaveBlockChunk +{ + u8 *data; + u16 size; +}; + +struct SaveSector +{ + u8 data[0xFF4]; + u16 id; + u16 checksum; + u32 signature; + u32 counter; +}; // size is 0x1000 + +// headless save section? +struct UnkSaveSection +{ + u8 data[0xFF4]; + u32 signature; +}; // size is 0xFF8 + +static u8 WriteSingleChunk(u16, const struct SaveBlockChunk *); +static u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size); +static u8 TryWriteSector(u8, u8 *); +static u32 RestoreSaveBackupVarsAndIncrement(const struct SaveBlockChunk *location); +static u32 RestoreSaveBackupVars(const struct SaveBlockChunk *location); +static u8 sub_812550C(u16 a1, const struct SaveBlockChunk *location); +static u8 sub_812556C(u16 a1, const struct SaveBlockChunk *location); +static u8 sub_81255B8(u16, const struct SaveBlockChunk *location); +static u8 WriteSomeFlashByteToPrevSector(u16 a1, const struct SaveBlockChunk *location); +static u8 WriteSomeFlashByte0x25ToPrevSector(u16 a1, const struct SaveBlockChunk *location); +static u8 sub_812587C(u16 a1, const struct SaveBlockChunk *location); +static u8 sub_81258BC(u16, const struct SaveBlockChunk *location); +static u8 GetSaveValidStatus(const struct SaveBlockChunk *location); +static u8 ReadSomeUnknownSectorAndVerify(u8 a1, u8 *data, u16 size); +static u8 DoReadFlashWholeSection(u8, struct SaveSector *); +static u16 CalculateChecksum(void *, u16); +bool8 unref_sub_8125F4C(struct UnkSaveSection *a1); +u8 unref_sub_8125FA0(void); +u8 unref_sub_8125FF0(u8 *data, u16 size); +u8 unref_sub_8126068(u8 sector, u8 *data, u32 size); +u8 unref_sub_8126080(u8 sector, u8 *data); + +// Sector num to begin writing save data. Sectors are rotated each time the game is saved. (possibly to avoid wear on flash memory?) +u16 gFirstSaveSector; +u32 gPrevSaveCounter; u16 gLastKnownGoodSector; u32 gDamagedSaveSectors; u32 gSaveCounter; -struct SaveSection *gFastSaveSection; // the pointer is in fast IWRAM but may sometimes point to the slower EWRAM. +struct SaveSector *gFastSaveSection; // the pointer is in fast IWRAM but may sometimes point to the slower EWRAM. u16 gUnknown_03005EB4; u16 gSaveFileStatus; u32 gGameContinueCallback; -extern struct PokemonStorage gPokemonStorage; - static EWRAM_DATA u32 gLastSaveSectorStatus = 0; // used but in an unferenced function, so unused -const struct SaveSectionLocation gSaveSectionLocations[] = -{ - {((u8 *) &gSaveBlock2) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gSaveBlock2, 1)}, - {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gSaveBlock1, 1)}, - {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(2), GETCHUNKSIZE(gSaveBlock1, 2)}, - {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(3), GETCHUNKSIZE(gSaveBlock1, 3)}, - {((u8 *) &gSaveBlock1) + GETBLOCKOFFSET(4), GETCHUNKSIZE(gSaveBlock1, 4)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(1), GETCHUNKSIZE(gPokemonStorage, 1)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(2), GETCHUNKSIZE(gPokemonStorage, 2)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(3), GETCHUNKSIZE(gPokemonStorage, 3)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(4), GETCHUNKSIZE(gPokemonStorage, 4)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(5), GETCHUNKSIZE(gPokemonStorage, 5)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(6), GETCHUNKSIZE(gPokemonStorage, 6)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(7), GETCHUNKSIZE(gPokemonStorage, 7)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(8), GETCHUNKSIZE(gPokemonStorage, 8)}, - {((u8 *) &gPokemonStorage) + GETBLOCKOFFSET(9), GETCHUNKSIZE(gPokemonStorage, 9)} +// Each 4 KiB flash sector contains 3968 bytes of actual data followed by a 128 byte footer +#define SECTOR_DATA_SIZE 3968 +#define SECTOR_FOOTER_SIZE 128 + +/* + * Sector Layout: + * + * Sectors 0 - 13: Save Slot 1 + * Sectors 14 - 27: Save Slot 2 + * Sectors 28 - 29: Hall of Fame + * Sectors 30 - 31: e-Reader battle tower data, maybe? + * + * There are two save slots for saving the player's game data. We alternate between + * them each time the game is saved, so that if the current save slot is corrupt, + * we can load the previous one. We also rotate the sectors in each save slot + * so that the same data is not always being written to the same sector. This + * might be done to reduce wear on the flash memory, but I'm not sure, since all + * 14 sectors get written anyway. + */ + +#define HALL_OF_FAME_SECTOR 28 + +#define NUM_SECTORS_PER_SAVE_SLOT 14 // Number of sectors occupied by a save slot +#define NUM_HALL_OF_FAME_SECTORS 2 + +// Divide save blocks into individual chunks to be written to flash sectors + +#define SAVEBLOCK_CHUNK(structure, chunkNum) \ +{ \ + (u8 *)&structure + chunkNum * SECTOR_DATA_SIZE, \ + min(sizeof(structure) - chunkNum * SECTOR_DATA_SIZE, SECTOR_DATA_SIZE) \ +} \ + +static const struct SaveBlockChunk sSaveBlockChunks[] = +{ + SAVEBLOCK_CHUNK(gSaveBlock2, 0), + + SAVEBLOCK_CHUNK(gSaveBlock1, 0), + SAVEBLOCK_CHUNK(gSaveBlock1, 1), + SAVEBLOCK_CHUNK(gSaveBlock1, 2), + SAVEBLOCK_CHUNK(gSaveBlock1, 3), + + SAVEBLOCK_CHUNK(gPokemonStorage, 0), + SAVEBLOCK_CHUNK(gPokemonStorage, 1), + SAVEBLOCK_CHUNK(gPokemonStorage, 2), + SAVEBLOCK_CHUNK(gPokemonStorage, 3), + SAVEBLOCK_CHUNK(gPokemonStorage, 4), + SAVEBLOCK_CHUNK(gPokemonStorage, 5), + SAVEBLOCK_CHUNK(gPokemonStorage, 6), + SAVEBLOCK_CHUNK(gPokemonStorage, 7), + SAVEBLOCK_CHUNK(gPokemonStorage, 8), }; -const struct SaveSectionLocation gHallOfFameSaveSectionLocations[] = +static const struct SaveBlockChunk sHallOfFameChunks[] = { - {((u8 *) eHallOfFame) + GETBLOCKOFFSET(1), GETCHUNKSIZE(struct HallOfFame, 1)}, // eHallOfFame is not a proper sym, so the struct must be used. - {((u8 *) eHallOfFame) + GETBLOCKOFFSET(2), GETCHUNKSIZE(struct HallOfFame, 2)} + SAVEBLOCK_CHUNK(*eHallOfFame, 0), + SAVEBLOCK_CHUNK(*eHallOfFame, 1), }; -const u8 gFlashSectors[] = { 0x1E, 0x1F }; - -void ClearSaveData(void) +void Save_EraseAllData(void) { u16 i; @@ -60,27 +137,34 @@ void ClearSaveData(void) EraseFlashSector(i); } -void ResetSaveCounters(void) +void Save_ResetSaveCounters(void) { gSaveCounter = 0; - gLastWrittenSector = 0; + gFirstSaveSector = 0; gDamagedSaveSectors = 0; } -bool32 SetDamagedSectorBits(u8 op, u8 bit) +enum +{ + SECTOR_DAMAGED, + SECTOR_OK, + SECTOR_CHECK, // unused +}; + +static bool32 SetSectorDamagedStatus(u8 op, u8 sectorNum) { bool32 retVal = FALSE; switch (op) { - case ENABLE: - gDamagedSaveSectors |= (1 << bit); + case SECTOR_DAMAGED: + gDamagedSaveSectors |= (1 << sectorNum); break; - case DISABLE: - gDamagedSaveSectors &= ~(1 << bit); + case SECTOR_OK: + gDamagedSaveSectors &= ~(1 << sectorNum); break; - case CHECK: // unused - if (gDamagedSaveSectors & (1 << bit)) + case SECTOR_CHECK: // unused + if (gDamagedSaveSectors & (1 << sectorNum)) retVal = TRUE; break; } @@ -88,163 +172,166 @@ bool32 SetDamagedSectorBits(u8 op, u8 bit) return retVal; } -u8 save_write_to_flash(u16 a1, const struct SaveSectionLocation *location) +// If chunkId is 0xFFFF, this function will write all of the chunks pointed to by 'chunks'. +// Otherwise, it will write a single chunk with the given 'chunkId'. +static u8 WriteSaveBlockChunks(u16 chunkId, const struct SaveBlockChunk *chunks) { u32 retVal; u16 i; gFastSaveSection = eSaveSection; - if (a1 != 0xFFFF) // for link + if (chunkId != 0xFFFF) // write single chunk { - retVal = HandleWriteSector(a1, location); + retVal = WriteSingleChunk(chunkId, chunks); } - else + else // write all chunks { - gLastKnownGoodSector = gLastWrittenSector; // backup the current written sector before attempting to write. - gLastSaveCounter = gSaveCounter; - gLastWrittenSector++; - gLastWrittenSector = gLastWrittenSector % ARRAY_COUNT(gSaveSectionLocations); + gLastKnownGoodSector = gFirstSaveSector; + gPrevSaveCounter = gSaveCounter; + gFirstSaveSector++; + gFirstSaveSector %= NUM_SECTORS_PER_SAVE_SLOT; gSaveCounter++; - retVal = 1; + retVal = SAVE_STATUS_OK; - for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++) - HandleWriteSector(i, location); + for (i = 0; i < NUM_SECTORS_PER_SAVE_SLOT; i++) + WriteSingleChunk(i, chunks); + // Check for any bad sectors if (gDamagedSaveSectors != 0) // skip the damaged sector. { - retVal = 0xFF; - gLastWrittenSector = gLastKnownGoodSector; - gSaveCounter = gLastSaveCounter; + retVal = SAVE_STATUS_ERROR; + gFirstSaveSector = gLastKnownGoodSector; + gSaveCounter = gPrevSaveCounter; } } return retVal; } -u8 HandleWriteSector(u16 a1, const struct SaveSectionLocation *location) +static u8 WriteSingleChunk(u16 chunkId, const struct SaveBlockChunk *chunks) { u16 i; - u16 sector; - u8 *data; - u16 size; + u16 sectorNum; + u8 *chunkData; + u16 chunkSize; - sector = a1 + gLastWrittenSector; - sector %= ARRAY_COUNT(gSaveSectionLocations); - sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2); + // select sector number + sectorNum = chunkId + gFirstSaveSector; + sectorNum %= NUM_SECTORS_PER_SAVE_SLOT; + // select save slot + sectorNum += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2); - data = location[a1].data; - size = location[a1].size; + chunkData = chunks[chunkId].data; + chunkSize = chunks[chunkId].size; // clear save section. - for (i = 0; i < sizeof(struct SaveSection); i++) - ((char *)gFastSaveSection)[i] = 0; + for (i = 0; i < sizeof(struct SaveSector); i++) + ((u8 *)gFastSaveSection)[i] = 0; - gFastSaveSection->id = a1; - gFastSaveSection->security = UNKNOWN_CHECK_VALUE; + gFastSaveSection->id = chunkId; + gFastSaveSection->signature = FILE_SIGNATURE; gFastSaveSection->counter = gSaveCounter; + for (i = 0; i < chunkSize; i++) + gFastSaveSection->data[i] = chunkData[i]; + gFastSaveSection->checksum = CalculateChecksum(chunkData, chunkSize); - for (i = 0; i < size; i++) - gFastSaveSection->data[i] = data[i]; - - gFastSaveSection->checksum = CalculateChecksum(data, size); - return TryWriteSector(sector, gFastSaveSection->data); + return TryWriteSector(sectorNum, gFastSaveSection->data); } -u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size) +static u8 HandleWriteSectorNBytes(u8 sectorNum, u8 *data, u16 size) { u16 i; - struct SaveSection *section = eSaveSection; + struct SaveSector *section = eSaveSection; - for (i = 0; i < sizeof(struct SaveSection); i++) + for (i = 0; i < sizeof(struct SaveSector); i++) ((char *)section)[i] = 0; - section->security = UNKNOWN_CHECK_VALUE; - + section->signature = FILE_SIGNATURE; for (i = 0; i < size; i++) section->data[i] = data[i]; - section->id = CalculateChecksum(data, size); // though this appears to be incorrect, it might be some sector checksum instead of a whole save checksum and only appears to be relevent to HOF data, if used. - return TryWriteSector(sector, section->data); + + return TryWriteSector(sectorNum, section->data); } -u8 TryWriteSector(u8 sector, u8 *data) +static u8 TryWriteSector(u8 sectorNum, u8 *data) { - if (ProgramFlashSectorAndVerify(sector, data) != 0) // is damaged? + if (ProgramFlashSectorAndVerify(sectorNum, data) != 0) // is damaged? { - SetDamagedSectorBits(ENABLE, sector); // set damaged sector bits. - return 0xFF; + SetSectorDamagedStatus(SECTOR_DAMAGED, sectorNum); // set damaged sector bits. + return SAVE_STATUS_ERROR; } else { - SetDamagedSectorBits(DISABLE, sector); // unset damaged sector bits. it's safe now. - return 1; + SetSectorDamagedStatus(SECTOR_OK, sectorNum); // unset damaged sector bits. it's safe now. + return SAVE_STATUS_OK; } } -u32 RestoreSaveBackupVarsAndIncrement(const struct SaveSectionLocation *location) // location is unused +static u32 RestoreSaveBackupVarsAndIncrement(const struct SaveBlockChunk *chunk) // chunk is unused { gFastSaveSection = eSaveSection; - gLastKnownGoodSector = gLastWrittenSector; - gLastSaveCounter = gSaveCounter; - gLastWrittenSector++; - gLastWrittenSector = gLastWrittenSector % ARRAY_COUNT(gSaveSectionLocations); + gLastKnownGoodSector = gFirstSaveSector; + gPrevSaveCounter = gSaveCounter; + gFirstSaveSector++; + gFirstSaveSector %= NUM_SECTORS_PER_SAVE_SLOT; gSaveCounter++; gUnknown_03005EB4 = 0; gDamagedSaveSectors = 0; return 0; } -u32 RestoreSaveBackupVars(const struct SaveSectionLocation *location) // only ever called once, and gSaveBlock2 is passed to this function. location is unused +static u32 RestoreSaveBackupVars(const struct SaveBlockChunk *chunk) // chunk is unused { gFastSaveSection = eSaveSection; - gLastKnownGoodSector = gLastWrittenSector; - gLastSaveCounter = gSaveCounter; + gLastKnownGoodSector = gFirstSaveSector; + gPrevSaveCounter = gSaveCounter; gUnknown_03005EB4 = 0; gDamagedSaveSectors = 0; return 0; } -u8 sub_812550C(u16 a1, const struct SaveSectionLocation *location) +static u8 sub_812550C(u16 a1, const struct SaveBlockChunk *chunk) { u8 retVal; if (gUnknown_03005EB4 < a1 - 1) { - retVal = 1; - HandleWriteSector(gUnknown_03005EB4, location); + retVal = SAVE_STATUS_OK; + WriteSingleChunk(gUnknown_03005EB4, chunk); gUnknown_03005EB4++; if (gDamagedSaveSectors) { - retVal = 0xFF; - gLastWrittenSector = gLastKnownGoodSector; - gSaveCounter = gLastSaveCounter; + retVal = SAVE_STATUS_ERROR; + gFirstSaveSector = gLastKnownGoodSector; + gSaveCounter = gPrevSaveCounter; } } else { - retVal = 0xFF; + retVal = SAVE_STATUS_ERROR; } return retVal; } -u8 sub_812556C(u16 a1, const struct SaveSectionLocation *location) +static u8 sub_812556C(u16 a1, const struct SaveBlockChunk *chunk) { - u8 retVal = 1; + u8 retVal = SAVE_STATUS_OK; - sub_81255B8(a1 - 1, location); + sub_81255B8(a1 - 1, chunk); if (gDamagedSaveSectors) { - retVal = 0xFF; - gLastWrittenSector = gLastKnownGoodSector; - gSaveCounter = gLastSaveCounter; + retVal = SAVE_STATUS_ERROR; + gFirstSaveSector = gLastKnownGoodSector; + gSaveCounter = gPrevSaveCounter; } return retVal; } -u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location) +static u8 sub_81255B8(u16 chunkId, const struct SaveBlockChunk *chunks) { u16 i; u16 sector; @@ -252,19 +339,21 @@ u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location) u16 size; u8 status; - sector = a1 + gLastWrittenSector; - sector %= ARRAY_COUNT(gSaveSectionLocations); - sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2); + // select sector number + sector = chunkId + gFirstSaveSector; + sector %= NUM_SECTORS_PER_SAVE_SLOT; + // select save slot + sector += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2); - data = location[a1].data; - size = location[a1].size; + data = chunks[chunkId].data; + size = chunks[chunkId].size; // clear temp save section. - for (i = 0; i < sizeof(struct SaveSection); i++) + for (i = 0; i < sizeof(struct SaveSector); i++) ((char *)gFastSaveSection)[i] = 0; - gFastSaveSection->id = a1; - gFastSaveSection->security = UNKNOWN_CHECK_VALUE; + gFastSaveSection->id = chunkId; + gFastSaveSection->signature = FILE_SIGNATURE; gFastSaveSection->counter = gSaveCounter; // set temp section's data. @@ -276,275 +365,275 @@ u8 sub_81255B8(u16 a1, const struct SaveSectionLocation *location) EraseFlashSector(sector); - status = 1; + status = SAVE_STATUS_OK; for (i = 0; i < sizeof(struct UnkSaveSection); i++) { if (ProgramFlashByte(sector, i, gFastSaveSection->data[i])) { - status = 0xFF; + status = SAVE_STATUS_ERROR; break; } } - if (status == 0xFF) + if (status == SAVE_STATUS_ERROR) { - SetDamagedSectorBits(ENABLE, sector); - return 0xFF; + SetSectorDamagedStatus(SECTOR_DAMAGED, sector); + return SAVE_STATUS_ERROR; } else { - status = 1; + status = SAVE_STATUS_OK; for (i = 0; i < 7; i++) { if (ProgramFlashByte(sector, 0xFF9 + i, ((u8 *)gFastSaveSection)[0xFF9 + i])) { - status = 0xFF; + status = SAVE_STATUS_ERROR; break; } } - if (status == 0xFF) + if (status == SAVE_STATUS_ERROR) { - SetDamagedSectorBits(ENABLE, sector); - return 0xFF; + SetSectorDamagedStatus(SECTOR_DAMAGED, sector); + return SAVE_STATUS_ERROR; } else { - SetDamagedSectorBits(DISABLE, sector); - return 1; + SetSectorDamagedStatus(SECTOR_OK, sector); + return SAVE_STATUS_OK; } } } -u8 sub_8125758(u16 a1, const struct SaveSectionLocation *location) +static u8 WriteSomeFlashByteToPrevSector(u16 a1, const struct SaveBlockChunk *chunk) { u16 sector; - sector = a1 + gLastWrittenSector - 1; - sector %= ARRAY_COUNT(gSaveSectionLocations); - sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2); + // select sector number + sector = a1 + gFirstSaveSector - 1; + sector %= NUM_SECTORS_PER_SAVE_SLOT; + // select save slot + sector += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2); if (ProgramFlashByte(sector, sizeof(struct UnkSaveSection), ((u8 *)gFastSaveSection)[sizeof(struct UnkSaveSection)])) { // sector is damaged, so enable the bit in gDamagedSaveSectors and restore the last written sector and save counter. - SetDamagedSectorBits(ENABLE, sector); - gLastWrittenSector = gLastKnownGoodSector; - gSaveCounter = gLastSaveCounter; - return 0xFF; + SetSectorDamagedStatus(SECTOR_DAMAGED, sector); + gFirstSaveSector = gLastKnownGoodSector; + gSaveCounter = gPrevSaveCounter; + return SAVE_STATUS_ERROR; } else { - SetDamagedSectorBits(DISABLE, sector); - return 1; + SetSectorDamagedStatus(SECTOR_OK, sector); + return SAVE_STATUS_OK; } } -u8 sub_81257F0(u16 a1, const struct SaveSectionLocation *location) +static u8 WriteSomeFlashByte0x25ToPrevSector(u16 a1, const struct SaveBlockChunk *chunk) { u16 sector; - sector = a1 + gLastWrittenSector - 1; - sector %= ARRAY_COUNT(gSaveSectionLocations); - sector += ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2); + sector = a1 + gFirstSaveSector - 1; + sector %= NUM_SECTORS_PER_SAVE_SLOT; + sector += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2); if (ProgramFlashByte(sector, sizeof(struct UnkSaveSection), 0x25)) { // sector is damaged, so enable the bit in gDamagedSaveSectors and restore the last written sector and save counter. - SetDamagedSectorBits(ENABLE, sector); - gLastWrittenSector = gLastKnownGoodSector; - gSaveCounter = gLastSaveCounter; - return 0xFF; + SetSectorDamagedStatus(SECTOR_DAMAGED, sector); + gFirstSaveSector = gLastKnownGoodSector; + gSaveCounter = gPrevSaveCounter; + return SAVE_STATUS_ERROR; } else { - SetDamagedSectorBits(DISABLE, sector); - return 1; + SetSectorDamagedStatus(SECTOR_OK, sector); + return SAVE_STATUS_OK; } } -u8 sub_812587C(u16 a1, const struct SaveSectionLocation *location) +static u8 sub_812587C(u16 a1, const struct SaveBlockChunk *chunk) { u8 retVal; gFastSaveSection = eSaveSection; if (a1 != 0xFFFF) { - retVal = 0xFF; + retVal = SAVE_STATUS_ERROR; } else { - retVal = GetSaveValidStatus(location); - sub_81258BC(0xFFFF, location); + retVal = GetSaveValidStatus(chunk); + sub_81258BC(0xFFFF, chunk); } return retVal; } -u8 sub_81258BC(u16 a1, const struct SaveSectionLocation *location) +static u8 sub_81258BC(u16 a1, const struct SaveBlockChunk *chunks) { u16 i; u16 checksum; - u16 v3 = ARRAY_COUNT(gSaveSectionLocations) * (gSaveCounter % 2); + u16 sector = NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2); u16 id; - for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++) + for (i = 0; i < NUM_SECTORS_PER_SAVE_SLOT; i++) { - DoReadFlashWholeSection(i + v3, gFastSaveSection); + DoReadFlashWholeSection(i + sector, gFastSaveSection); id = gFastSaveSection->id; if (id == 0) - gLastWrittenSector = i; - checksum = CalculateChecksum(gFastSaveSection->data, location[id].size); - if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE + gFirstSaveSector = i; + checksum = CalculateChecksum(gFastSaveSection->data, chunks[id].size); + if (gFastSaveSection->signature == FILE_SIGNATURE && gFastSaveSection->checksum == checksum) { u16 j; - for (j = 0; j < location[id].size; j++) - location[id].data[j] = gFastSaveSection->data[j]; + for (j = 0; j < chunks[id].size; j++) + chunks[id].data[j] = gFastSaveSection->data[j]; } } return 1; } -u8 GetSaveValidStatus(const struct SaveSectionLocation *location) +static u8 GetSaveValidStatus(const struct SaveBlockChunk *chunks) { - u16 i; + u16 sector; + bool8 signatureValid; u16 checksum; - u32 saveSlot1Counter = 0; - u32 saveSlot2Counter = 0; - u32 slotCheckField = 0; - bool8 securityPassed = FALSE; - u8 saveSlot1Status; - u8 saveSlot2Status; + u32 slot1saveCounter = 0; + u32 slot2saveCounter = 0; + u8 slot1Status; + u8 slot2Status; + u32 validSectors; + const u32 ALL_SECTORS = (1 << NUM_SECTORS_PER_SAVE_SLOT) - 1; // bitmask of all saveblock sectors // check save slot 1. - for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++) + validSectors = 0; + signatureValid = FALSE; + for (sector = 0; sector < NUM_SECTORS_PER_SAVE_SLOT; sector++) { - DoReadFlashWholeSection(i, gFastSaveSection); - if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE) + DoReadFlashWholeSection(sector, gFastSaveSection); + if (gFastSaveSection->signature == FILE_SIGNATURE) { - securityPassed = TRUE; - checksum = CalculateChecksum(gFastSaveSection->data, location[gFastSaveSection->id].size); + signatureValid = TRUE; + checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size); if (gFastSaveSection->checksum == checksum) { - saveSlot1Counter = gFastSaveSection->counter; - slotCheckField |= 1 << gFastSaveSection->id; + slot1saveCounter = gFastSaveSection->counter; + validSectors |= 1 << gFastSaveSection->id; } } } - if (securityPassed) + if (signatureValid) { - if (slotCheckField == GETVALIDSTATUSBITFIELD) - saveSlot1Status = 1; + if (validSectors == ALL_SECTORS) + slot1Status = SAVE_STATUS_OK; else - saveSlot1Status = 255; + slot1Status = SAVE_STATUS_ERROR; } else { - saveSlot1Status = 0; + slot1Status = SAVE_STATUS_EMPTY; } - slotCheckField = 0; - securityPassed = FALSE; - // check save slot 2. - for (i = 0; i < ARRAY_COUNT(gSaveSectionLocations); i++) + validSectors = 0; + signatureValid = FALSE; + for (sector = 0; sector < NUM_SECTORS_PER_SAVE_SLOT; sector++) { - DoReadFlashWholeSection(i + ARRAY_COUNT(gSaveSectionLocations), gFastSaveSection); - if (gFastSaveSection->security == UNKNOWN_CHECK_VALUE) + DoReadFlashWholeSection(NUM_SECTORS_PER_SAVE_SLOT + sector, gFastSaveSection); + if (gFastSaveSection->signature == FILE_SIGNATURE) { - securityPassed = TRUE; - checksum = CalculateChecksum(gFastSaveSection->data, location[gFastSaveSection->id].size); + signatureValid = TRUE; + checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size); if (gFastSaveSection->checksum == checksum) { - saveSlot2Counter = gFastSaveSection->counter; - slotCheckField |= 1 << gFastSaveSection->id; + slot2saveCounter = gFastSaveSection->counter; + validSectors |= 1 << gFastSaveSection->id; } } } - if (securityPassed) + if (signatureValid) { - if (slotCheckField == GETVALIDSTATUSBITFIELD) - saveSlot2Status = 1; + if (validSectors == ALL_SECTORS) + slot2Status = SAVE_STATUS_OK; else - saveSlot2Status = 255; + slot2Status = SAVE_STATUS_ERROR; } else { - saveSlot2Status = 0; + slot2Status = SAVE_STATUS_EMPTY; } - if (saveSlot1Status == 1 && saveSlot2Status == 1) + if (slot1Status == SAVE_STATUS_OK && slot2Status == SAVE_STATUS_OK) { - if ((saveSlot1Counter == -1 && saveSlot2Counter == 0) || (saveSlot1Counter == 0 && saveSlot2Counter == -1)) + // Choose counter of the most recent save file + if ((slot1saveCounter == -1 && slot2saveCounter == 0) || (slot1saveCounter == 0 && slot2saveCounter == -1)) { - if ((unsigned)(saveSlot1Counter + 1) < (unsigned)(saveSlot2Counter + 1)) - { - gSaveCounter = saveSlot2Counter; - } + if ((unsigned)(slot1saveCounter + 1) < (unsigned)(slot2saveCounter + 1)) + gSaveCounter = slot2saveCounter; else - { - gSaveCounter = saveSlot1Counter; - } + gSaveCounter = slot1saveCounter; } else { - if (saveSlot1Counter < saveSlot2Counter) - { - gSaveCounter = saveSlot2Counter; - } + if (slot1saveCounter < slot2saveCounter) + gSaveCounter = slot2saveCounter; else - { - gSaveCounter = saveSlot1Counter; - } + gSaveCounter = slot1saveCounter; } - return 1; + return SAVE_STATUS_OK; } - if (saveSlot1Status == 1) + if (slot1Status == SAVE_STATUS_OK) { - gSaveCounter = saveSlot1Counter; - if (saveSlot2Status == 255) - return 255; - return 1; + gSaveCounter = slot1saveCounter; + if (slot2Status == SAVE_STATUS_ERROR) + return SAVE_STATUS_ERROR; + else + return SAVE_STATUS_OK; } - if (saveSlot2Status == 1) + if (slot2Status == SAVE_STATUS_OK) { - gSaveCounter = saveSlot2Counter; - if (saveSlot1Status == 255) - return 255; - return 1; + gSaveCounter = slot2saveCounter; + if (slot1Status == SAVE_STATUS_ERROR) + return SAVE_STATUS_ERROR; + else + return SAVE_STATUS_OK; } - if (saveSlot1Status == 0 && saveSlot2Status == 0) + if (slot1Status == SAVE_STATUS_EMPTY && slot2Status == SAVE_STATUS_EMPTY) { gSaveCounter = 0; - gLastWrittenSector = 0; - return 0; + gFirstSaveSector = 0; + return SAVE_STATUS_EMPTY; } gSaveCounter = 0; - gLastWrittenSector = 0; + gFirstSaveSector = 0; return 2; } -u8 sub_8125B88(u8 a1, u8 *data, u16 size) +static u8 ReadSomeUnknownSectorAndVerify(u8 sector, u8 *data, u16 size) { u16 i; - struct SaveSection *section = eSaveSection; - DoReadFlashWholeSection(a1, section); - if (section->security == UNKNOWN_CHECK_VALUE) + struct SaveSector *section = eSaveSection; + + DoReadFlashWholeSection(sector, section); + if (section->signature == FILE_SIGNATURE) { u16 checksum = CalculateChecksum(section->data, size); if (section->id == checksum) { for (i = 0; i < size; i++) data[i] = section->data[i]; - return 1; + return SAVE_STATUS_OK; } else { @@ -553,17 +642,17 @@ u8 sub_8125B88(u8 a1, u8 *data, u16 size) } else { - return 0; + return SAVE_STATUS_EMPTY; } } -u8 DoReadFlashWholeSection(u8 sector, struct SaveSection *section) +static u8 DoReadFlashWholeSection(u8 sector, struct SaveSector *section) { - ReadFlash(sector, 0, section->data, sizeof(struct SaveSection)); + ReadFlash(sector, 0, section->data, sizeof(struct SaveSector)); return 1; } -u16 CalculateChecksum(void *data, u16 size) +static u16 CalculateChecksum(void *data, u16 size) { u16 i; u32 checksum = 0; @@ -574,55 +663,60 @@ u16 CalculateChecksum(void *data, u16 size) return ((checksum >> 16) + checksum); } -u8 HandleSavingData(u8 saveType) +u8 Save_WriteDataInternal(u8 saveType) { u8 i; + switch (saveType) { - case HOF_DELETE_SAVE: // deletes HOF before overwriting HOF completely. unused - for (i = (ARRAY_COUNT(gSaveSectionLocations) * 2 + 0); i < TOTALNUMSECTORS; i++) + case SAVE_HALL_OF_FAME_ERASE_BEFORE: // wipes all hall of fame data, then saves hall of fame. unused + for (i = HALL_OF_FAME_SECTOR; i < TOTAL_FLASH_SECTORS; i++) EraseFlashSector(i); - case HOF_SAVE: // hall of fame. + // fall through + case SAVE_HALL_OF_FAME: // hall of fame. if (GetGameStat(10) < 999) IncrementGameStat(10); - for (i = 0; i < ARRAY_COUNT(gHallOfFameSaveSectionLocations); i++) - HandleWriteSectorNBytes((ARRAY_COUNT(gSaveSectionLocations) * 2 + 0) + i, gHallOfFameSaveSectionLocations[i].data, gHallOfFameSaveSectionLocations[i].size); + for (i = 0; i < NUM_HALL_OF_FAME_SECTORS; i++) + HandleWriteSectorNBytes(HALL_OF_FAME_SECTOR + i, sHallOfFameChunks[i].data, sHallOfFameChunks[i].size); SaveSerializedGame(); - save_write_to_flash(0xFFFF, gSaveSectionLocations); + WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks); break; - case NORMAL_SAVE: // normal save. also called by overwriting your own save. + case SAVE_NORMAL: // normal save. also called by overwriting your own save. default: SaveSerializedGame(); - save_write_to_flash(0xFFFF, gSaveSectionLocations); + WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks); break; - case LINK_SAVE: // link save. updates only gSaveBlock1 and gSaveBlock2. + case SAVE_LINK: // link save. updates only gSaveBlock1 and gSaveBlock2. SaveSerializedGame(); for (i = 0; i < 5; i++) - save_write_to_flash(i, gSaveSectionLocations); + WriteSaveBlockChunks(i, sSaveBlockChunks); break; - case EREADER_SAVE: // used in mossdeep "game corner" before/after battling old man e-reader trainer + case SAVE_EREADER: // used in mossdeep "game corner" before/after battling old man e-reader trainer SaveSerializedGame(); - save_write_to_flash(0, gSaveSectionLocations); + WriteSaveBlockChunks(0, sSaveBlockChunks); break; - case DIFFERENT_FILE_SAVE: // there is a different file, so erase the file and overwrite it completely. - for (i = (ARRAY_COUNT(gSaveSectionLocations) * 2 + 0); i < TOTALNUMSECTORS; i++) - EraseFlashSector(i); // erase HOF. + case SAVE_OVERWRITE_DIFFERENT_FILE: // there is a different file, so overwrite it completely. + // Erase Hall of Fame. + for (i = HALL_OF_FAME_SECTOR; i < TOTAL_FLASH_SECTORS; i++) + EraseFlashSector(i); SaveSerializedGame(); - save_write_to_flash(0xFFFF, gSaveSectionLocations); + WriteSaveBlockChunks(0xFFFF, sSaveBlockChunks); break; } return 0; } -u8 TrySavingData(u8 saveType) // TrySave +u8 Save_WriteData(u8 saveType) // TrySave { if (gFlashMemoryPresent != TRUE) - return 0xFF; - HandleSavingData(saveType); + return SAVE_STATUS_ERROR; + + Save_WriteDataInternal(saveType); if (!gDamagedSaveSectors) - return 1; + return SAVE_STATUS_OK; + DoSaveFailedScreen(saveType); - return 0xFF; + return SAVE_STATUS_ERROR; } u8 sub_8125D80(void) // trade.s save @@ -630,16 +724,16 @@ u8 sub_8125D80(void) // trade.s save if (gFlashMemoryPresent != TRUE) return 1; SaveSerializedGame(); - RestoreSaveBackupVarsAndIncrement(gSaveSectionLocations); + RestoreSaveBackupVarsAndIncrement(sSaveBlockChunks); return 0; } bool8 sub_8125DA8(void) // trade.s save { - u8 retVal = sub_812550C(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations); + u8 retVal = sub_812550C(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks); if (gDamagedSaveSectors) DoSaveFailedScreen(0); - if (retVal == 0xFF) + if (retVal == SAVE_STATUS_ERROR) return 1; else return 0; @@ -647,7 +741,7 @@ bool8 sub_8125DA8(void) // trade.s save u8 sub_8125DDC(void) // trade.s save { - sub_812556C(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations); + sub_812556C(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks); if (gDamagedSaveSectors) DoSaveFailedScreen(0); return 0; @@ -655,7 +749,7 @@ u8 sub_8125DDC(void) // trade.s save u8 sub_8125E04(void) // trade.s save { - sub_8125758(ARRAY_COUNT(gSaveSectionLocations), gSaveSectionLocations); + WriteSomeFlashByteToPrevSector(ARRAY_COUNT(sSaveBlockChunks), sSaveBlockChunks); if (gDamagedSaveSectors) DoSaveFailedScreen(0); return 0; @@ -667,23 +761,24 @@ u8 sub_8125E2C(void) return 1; SaveSerializedGame(); - RestoreSaveBackupVars(gSaveSectionLocations); - sub_812556C(gUnknown_03005EB4 + 1, gSaveSectionLocations); + RestoreSaveBackupVars(sSaveBlockChunks); + sub_812556C(gUnknown_03005EB4 + 1, sSaveBlockChunks); return 0; } +// something to do with multiplayer. Possibly record mizing? bool8 sub_8125E6C(void) { u8 retVal = FALSE; u16 val = ++gUnknown_03005EB4; if (val <= 4) { - sub_812556C(gUnknown_03005EB4 + 1, gSaveSectionLocations); - sub_81257F0(val, gSaveSectionLocations); + sub_812556C(gUnknown_03005EB4 + 1, sSaveBlockChunks); + WriteSomeFlashByte0x25ToPrevSector(val, sSaveBlockChunks); } else { - sub_81257F0(val, gSaveSectionLocations); + WriteSomeFlashByte0x25ToPrevSector(val, sSaveBlockChunks); retVal = TRUE; } if (gDamagedSaveSectors) @@ -691,46 +786,48 @@ bool8 sub_8125E6C(void) return retVal; } -u8 sub_8125EC8(u8 a1) +u8 Save_LoadGameData(u8 saveType) { u8 result; if (gFlashMemoryPresent != TRUE) { - gSaveFileStatus = 4; - return 0xFF; + gSaveFileStatus = SAVE_STATUS_NO_FLASH; + return SAVE_STATUS_ERROR; } - switch (a1) + switch (saveType) { - case 0: + case SAVE_NORMAL: default: - result = sub_812587C(0xFFFF, gSaveSectionLocations); + result = sub_812587C(0xFFFF, sSaveBlockChunks); LoadSerializedGame(); gSaveFileStatus = result; gGameContinueCallback = 0; break; - case 3: - result = sub_8125B88((ARRAY_COUNT(gSaveSectionLocations) * 2 + 0), gHallOfFameSaveSectionLocations[0].data, gHallOfFameSaveSectionLocations[0].size); - if (result == 1) - result = sub_8125B88((ARRAY_COUNT(gSaveSectionLocations) * 2 + 1), gHallOfFameSaveSectionLocations[1].data, gHallOfFameSaveSectionLocations[1].size); + case SAVE_HALL_OF_FAME: + result = ReadSomeUnknownSectorAndVerify(HALL_OF_FAME_SECTOR, sHallOfFameChunks[0].data, sHallOfFameChunks[0].size); + if (result == SAVE_STATUS_OK) + result = ReadSomeUnknownSectorAndVerify(HALL_OF_FAME_SECTOR + 1, sHallOfFameChunks[1].data, sHallOfFameChunks[1].size); break; } return result; } +static const u8 sUnusedFlashSectors[] = { 30, 31 }; + bool8 unref_sub_8125F4C(struct UnkSaveSection *a1) { u16 i; char *raw = (char *)a1; - for (i = 0; i < sizeof(struct SaveSection); i++) + for (i = 0; i < sizeof(struct SaveSector); i++) raw[i] = 0; - ReadFlash(gFlashSectors[0], 0, a1->data, 4096); + ReadFlash(sUnusedFlashSectors[0], 0, a1->data, 4096); - if (a1->security != UNKNOWN_CHECK_VALUE) + if (a1->signature != FILE_SIGNATURE) return FALSE; return TRUE; @@ -739,22 +836,22 @@ bool8 unref_sub_8125F4C(struct UnkSaveSection *a1) u8 unref_sub_8125FA0(void) { u16 i; - u8 v0 = TrySavingData(0); + u8 status = Save_WriteData(SAVE_NORMAL); for (i = 0; i < 2; i++) - EraseFlashSector(gFlashSectors[i]); + EraseFlashSector(sUnusedFlashSectors[i]); - if (v0 == 255) + if (status == SAVE_STATUS_ERROR) { return 3; } - else if (v0 == 3) + else if (status == 3) { return 2; } else { - sub_8125EC8(0); + Save_LoadGameData(SAVE_NORMAL); return 1; } } @@ -764,32 +861,32 @@ u8 unref_sub_8125FF0(u8 *data, u16 size) u16 i; struct UnkSaveSection *section = (struct UnkSaveSection *)eSaveSection; - for (i = 0; i < sizeof(struct SaveSection); i++) + for (i = 0; i < sizeof(struct SaveSector); i++) ((char *)section)[i] = 0; - section->security = UNKNOWN_CHECK_VALUE; + section->signature = FILE_SIGNATURE; for (i = 0; i < size; i++) section->data[i] = data[i]; - gLastSaveSectorStatus = ProgramFlashSectorAndVerifyNBytes(gFlashSectors[0], section, sizeof(struct SaveSection)); + gLastSaveSectorStatus = ProgramFlashSectorAndVerifyNBytes(sUnusedFlashSectors[0], section, sizeof(struct SaveSector)); if (gLastSaveSectorStatus) - return 0xFF; + return SAVE_STATUS_ERROR; else - return 1; + return SAVE_STATUS_OK; } u8 unref_sub_8126068(u8 sector, u8 *data, u32 size) { if (ProgramFlashSectorAndVerify(sector, data)) - return 255; + return SAVE_STATUS_ERROR; else - return 1; + return SAVE_STATUS_OK; } u8 unref_sub_8126080(u8 sector, u8 *data) { - ReadFlash(sector, 0, data, sizeof(struct SaveSection)); + ReadFlash(sector, 0, data, sizeof(struct SaveSector)); return 1; } diff --git a/src/engine/save_failed_screen.c b/src/engine/save_failed_screen.c index 64b84a2f7..74a1e9612 100644 --- a/src/engine/save_failed_screen.c +++ b/src/engine/save_failed_screen.c @@ -166,7 +166,7 @@ static void CB2_WipeSave(void) Menu_DrawStdWindowFrame(1, MSG_WIN_TOP, 28, 19); Menu_PrintText(gSystemText_CheckCompleteSaveAttempt, 2, MSG_WIN_TOP + 1); - HandleSavingData(gSaveFailedType); + Save_WriteDataInternal(gSaveFailedType); if (gDamagedSaveSectors != 0) { diff --git a/src/field/battle_tower.c b/src/field/battle_tower.c index 11c05e478..ab2a818a7 100644 --- a/src/field/battle_tower.c +++ b/src/field/battle_tower.c @@ -1895,7 +1895,7 @@ void SaveBattleTowerProgress(void) VarSet(VAR_TEMP_0, 0); gSaveBlock2.battleTower.unk_554 = 1; - TrySavingData(EREADER_SAVE); + Save_WriteData(SAVE_EREADER); } void BattleTower_SoftReset(void) diff --git a/src/field/start_menu.c b/src/field/start_menu.c index 2f6f1e7dd..87597eb6a 100644 --- a/src/field/start_menu.c +++ b/src/field/start_menu.c @@ -664,20 +664,20 @@ static u8 SaveDialogCB_DisplaySavingMessage(void) static u8 SaveDialogCB_DoSave(void) { - bool8 saveSucceeded; + u8 saveStatus; IncrementGameStat(0); if (gDifferentSaveFile == TRUE) { - saveSucceeded = TrySavingData(DIFFERENT_FILE_SAVE); + saveStatus = Save_WriteData(SAVE_OVERWRITE_DIFFERENT_FILE); gDifferentSaveFile = FALSE; } else { - saveSucceeded = TrySavingData(NORMAL_SAVE); + saveStatus = Save_WriteData(SAVE_NORMAL); } - if (saveSucceeded == TRUE) + if (saveStatus == SAVE_STATUS_OK) { //"(Player) saved the game." DisplaySaveMessageWithCallback(gSaveText_PlayerSavedTheGame, SaveDialogCB_SaveSuccess); diff --git a/src/scene/hall_of_fame.c b/src/scene/hall_of_fame.c index 303dcf3e0..a9532fd09 100644 --- a/src/scene/hall_of_fame.c +++ b/src/scene/hall_of_fame.c @@ -539,7 +539,7 @@ static void sub_814217C(u8 taskID) ewram1E000(i) = 0; } else - sub_8125EC8(3); + Save_LoadGameData(SAVE_HALL_OF_FAME); for (i = 0; i < HALL_OF_FAME_MAX_TEAMS; i++, lastSavedTeam++) { @@ -566,7 +566,7 @@ static void sub_814217C(u8 taskID) static void sub_8142274(u8 taskID) { gGameContinueCallback = sub_8141FC4; - TrySavingData(3); + Save_WriteData(3); PlaySE(SE_SAVE); gTasks[taskID].func = sub_81422B8; gTasks[taskID].tFrameCount = 32; @@ -840,7 +840,7 @@ void sub_81428CC(void) static void sub_8142A28(u8 taskID) { - if (sub_8125EC8(3) != 1) + if (Save_LoadGameData(SAVE_HALL_OF_FAME) != SAVE_STATUS_OK) gTasks[taskID].func = sub_8142FEC; else { diff --git a/src/scene/intro.c b/src/scene/intro.c index d7d772a40..f7e196133 100644 --- a/src/scene/intro.c +++ b/src/scene/intro.c @@ -930,8 +930,8 @@ void CB2_InitCopyrightScreenAfterBootup(void) if (!SetUpCopyrightScreen()) { sub_8052E4C(); - ResetSaveCounters(); - sub_8125EC8(0); + Save_ResetSaveCounters(); + Save_LoadGameData(SAVE_NORMAL); if (gSaveFileStatus == 0 || gSaveFileStatus == 2) ClearSav2(); SetPokemonCryStereo(gSaveBlock2.optionsSound); |