Merge branch 'master' into vs_seeker
This commit is contained in:
PikalaxALT
@@ -256,7 +256,6 @@ extern const u32 gBitTable[]; // util.h
|
||||
extern u32 gStatuses3[]; // battle_2.h
|
||||
extern u16 gSideAffecting[2];
|
||||
extern const struct BattleMove gBattleMoves[];
|
||||
extern u16 gBattlerPartyIndexes[];
|
||||
extern u16 gDynamicBasePower;
|
||||
extern u8 gMoveResultFlags;
|
||||
extern u8 gCritMultiplier;
|
||||
@@ -485,14 +484,14 @@ void sub_80C71A8(u8 a)
|
||||
|
||||
void sub_80C71D0(u8 a, u8 b)
|
||||
{
|
||||
if (GetBankSide(a) == 0)
|
||||
BATTLE_HISTORY->abilities[GetBankIdentity(a) & 1] = b;
|
||||
if (GetBattlerSide(a) == 0)
|
||||
BATTLE_HISTORY->abilities[GetBattlerPosition(a) & 1] = b;
|
||||
}
|
||||
|
||||
void sub_80C7208(u8 a, u8 b)
|
||||
{
|
||||
if (GetBankSide(a) == 0)
|
||||
BATTLE_HISTORY->itemEffects[GetBankIdentity(a) & 1] = b;
|
||||
if (GetBattlerSide(a) == 0)
|
||||
BATTLE_HISTORY->itemEffects[GetBattlerPosition(a) & 1] = b;
|
||||
}
|
||||
|
||||
static void BattleAICmd_if_random_less_than(void)
|
||||
@@ -720,7 +719,7 @@ static void BattleAICmd_if_status4(void)
|
||||
else
|
||||
index = gBattlerTarget;
|
||||
|
||||
arg1 = GetBankIdentity(index) & 1;
|
||||
arg1 = GetBattlerPosition(index) & 1;
|
||||
arg2 = T1_READ_32(gAIScriptPtr + 2);
|
||||
|
||||
if ((gSideAffecting[arg1] & arg2) != 0)
|
||||
@@ -739,7 +738,7 @@ static void BattleAICmd_if_not_status4(void)
|
||||
else
|
||||
index = gBattlerTarget;
|
||||
|
||||
arg1 = GetBankIdentity(index) & 1;
|
||||
arg1 = GetBattlerPosition(index) & 1;
|
||||
arg2 = T1_READ_32(gAIScriptPtr + 2);
|
||||
|
||||
if ((gSideAffecting[arg1] & arg2) == 0)
|
||||
@@ -1361,7 +1360,7 @@ static void BattleAICmd_count_alive_pokemon(void)
|
||||
else
|
||||
index = gBattlerTarget;
|
||||
|
||||
if (GetBankSide(index) == 0)
|
||||
if (GetBattlerSide(index) == 0)
|
||||
party = gPlayerParty;
|
||||
else
|
||||
party = gEnemyParty;
|
||||
@@ -1370,8 +1369,8 @@ static void BattleAICmd_count_alive_pokemon(void)
|
||||
{
|
||||
u32 status;
|
||||
var = gBattlerPartyIndexes[index];
|
||||
status = GetBankIdentity(index) ^ 2;
|
||||
var2 = gBattlerPartyIndexes[GetBankByIdentity(status)];
|
||||
status = GetBattlerPosition(index) ^ 2;
|
||||
var2 = gBattlerPartyIndexes[GetBattlerAtPosition(status)];
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1414,9 +1413,9 @@ static void BattleAICmd_get_ability(void)
|
||||
else
|
||||
index = gBattlerTarget;
|
||||
|
||||
if (GetBankSide(index) == TARGET)
|
||||
if (GetBattlerSide(index) == TARGET)
|
||||
{
|
||||
u16 side = GetBankIdentity(index) & 1;
|
||||
u16 side = GetBattlerPosition(index) & 1;
|
||||
|
||||
if (BATTLE_HISTORY->abilities[side] != 0)
|
||||
{
|
||||
@@ -2008,9 +2007,9 @@ static void BattleAICmd_get_hold_effect(void)
|
||||
else
|
||||
index = gBattlerTarget;
|
||||
|
||||
if (GetBankSide(index) == 0)
|
||||
if (GetBattlerSide(index) == 0)
|
||||
{
|
||||
side = (GetBankIdentity(index) & 1);
|
||||
side = (GetBattlerPosition(index) & 1);
|
||||
AI_THINKING_STRUCT->funcResult = BATTLE_HISTORY->itemEffects[side];
|
||||
}
|
||||
else
|
||||
|
||||
+297
@@ -0,0 +1,297 @@
|
||||
#include "global.h"
|
||||
#include "gba/flash_internal.h"
|
||||
#include "load_save.h"
|
||||
#include "main.h"
|
||||
#include "pokemon.h"
|
||||
#include "random.h"
|
||||
#include "malloc.h"
|
||||
#include "item.h"
|
||||
|
||||
extern void sub_8099E44(void);
|
||||
extern void sub_8110840(void *oldSave);
|
||||
extern void sub_8055778(int);
|
||||
extern void sub_8054F38(u32 newKey);
|
||||
extern void ApplyNewEncryptionKeyToBagItems_(u32 newKey);
|
||||
extern void sub_815EE6C(u32 newKey);
|
||||
|
||||
#define SAVEBLOCK_MOVE_RANGE 128
|
||||
|
||||
struct LoadedSaveData
|
||||
{
|
||||
/*0x0000*/ struct ItemSlot items[BAG_ITEMS_COUNT];
|
||||
/*0x0078*/ struct ItemSlot keyItems[BAG_KEYITEMS_COUNT];
|
||||
/*0x00F0*/ struct ItemSlot pokeBalls[BAG_POKEBALLS_COUNT];
|
||||
/*0x0130*/ struct ItemSlot TMsHMs[BAG_TMHM_COUNT];
|
||||
/*0x0230*/ struct ItemSlot berries[BAG_BERRIES_COUNT];
|
||||
/*0x02E8*/ struct MailStruct mail[MAIL_COUNT];
|
||||
};
|
||||
|
||||
// EWRAM DATA
|
||||
EWRAM_DATA struct SaveBlock2 gSaveBlock2 = {0};
|
||||
EWRAM_DATA u8 gSaveBlock2_DMA[SAVEBLOCK_MOVE_RANGE] = {0};
|
||||
|
||||
EWRAM_DATA struct SaveBlock1 gSaveBlock1 = {0};
|
||||
EWRAM_DATA u8 gSaveBlock1_DMA[SAVEBLOCK_MOVE_RANGE] = {0};
|
||||
|
||||
EWRAM_DATA struct PokemonStorage gPokemonStorage = {0};
|
||||
EWRAM_DATA u8 gSaveBlock3_DMA[SAVEBLOCK_MOVE_RANGE] = {0};
|
||||
|
||||
EWRAM_DATA struct LoadedSaveData gLoadedSaveData = {0};
|
||||
EWRAM_DATA u32 gLastEncryptionKey = 0;
|
||||
|
||||
// IWRAM common
|
||||
IWRAM_DATA bool32 gFlashMemoryPresent;
|
||||
IWRAM_DATA struct SaveBlock1 *gSaveBlock1Ptr;
|
||||
IWRAM_DATA struct SaveBlock2 *gSaveBlock2Ptr;
|
||||
IWRAM_DATA struct PokemonStorage *gPokemonStoragePtr;
|
||||
|
||||
void CheckForFlashMemory(void)
|
||||
{
|
||||
if (!IdentifyFlash())
|
||||
{
|
||||
gFlashMemoryPresent = TRUE;
|
||||
InitFlashTimer();
|
||||
}
|
||||
else
|
||||
{
|
||||
gFlashMemoryPresent = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
void ClearSav2(void)
|
||||
{
|
||||
CpuFill16(0, &gSaveBlock2, sizeof(struct SaveBlock2) + sizeof(gSaveBlock2_DMA));
|
||||
}
|
||||
|
||||
void ClearSav1(void)
|
||||
{
|
||||
CpuFill16(0, &gSaveBlock1, sizeof(struct SaveBlock1) + sizeof(gSaveBlock1_DMA));
|
||||
}
|
||||
|
||||
void SetSaveBlocksPointers(void)
|
||||
{
|
||||
u32 offset;
|
||||
struct SaveBlock1** sav1_LocalVar = &gSaveBlock1Ptr;
|
||||
void *oldSave = (void *)gSaveBlock1Ptr;
|
||||
|
||||
offset = (Random()) & (SAVEBLOCK_MOVE_RANGE - 4);
|
||||
|
||||
gSaveBlock2Ptr = (void*)(&gSaveBlock2) + offset;
|
||||
*sav1_LocalVar = (void*)(&gSaveBlock1) + offset;
|
||||
gPokemonStoragePtr = (void*)(&gPokemonStorage) + offset;
|
||||
|
||||
sub_8099E44();
|
||||
sub_8110840(oldSave);
|
||||
}
|
||||
|
||||
void MoveSaveBlocks_ResetHeap(void)
|
||||
{
|
||||
void *vblankCB, *hblankCB;
|
||||
u32 encryptionKey;
|
||||
struct SaveBlock2 *saveBlock2Copy;
|
||||
struct SaveBlock1 *saveBlock1Copy;
|
||||
struct PokemonStorage *pokemonStorageCopy;
|
||||
|
||||
// save interrupt functions and turn them off
|
||||
vblankCB = gMain.vblankCallback;
|
||||
hblankCB = gMain.hblankCallback;
|
||||
gMain.vblankCallback = NULL;
|
||||
gMain.hblankCallback = NULL;
|
||||
gMain.vblankCounter1 = NULL;
|
||||
|
||||
saveBlock2Copy = (struct SaveBlock2 *)(gHeap);
|
||||
saveBlock1Copy = (struct SaveBlock1 *)(gHeap + sizeof(struct SaveBlock2));
|
||||
pokemonStorageCopy = (struct PokemonStorage *)(gHeap + sizeof(struct SaveBlock2) + sizeof(struct SaveBlock1));
|
||||
|
||||
// backup the saves.
|
||||
*saveBlock2Copy = *gSaveBlock2Ptr;
|
||||
*saveBlock1Copy = *gSaveBlock1Ptr;
|
||||
*pokemonStorageCopy = *gPokemonStoragePtr;
|
||||
|
||||
// change saveblocks' pointers
|
||||
SetSaveBlocksPointers(); // unlike Emerald, this does not use
|
||||
// the trainer ID sum for an offset.
|
||||
|
||||
// restore saveblock data since the pointers changed
|
||||
*gSaveBlock2Ptr = *saveBlock2Copy;
|
||||
*gSaveBlock1Ptr = *saveBlock1Copy;
|
||||
*gPokemonStoragePtr = *pokemonStorageCopy;
|
||||
|
||||
// heap was destroyed in the copying process, so reset it
|
||||
InitHeap(gHeap, HEAP_SIZE);
|
||||
|
||||
// restore interrupt functions
|
||||
gMain.hblankCallback = hblankCB;
|
||||
gMain.vblankCallback = vblankCB;
|
||||
|
||||
// create a new encryption key
|
||||
encryptionKey = (Random() << 0x10) + (Random());
|
||||
ApplyNewEncryptionKeyToAllEncryptedData(encryptionKey);
|
||||
gSaveBlock2Ptr->encryptionKey = encryptionKey;
|
||||
}
|
||||
|
||||
u32 sav2_x1_query_bit1(void)
|
||||
{
|
||||
return gSaveBlock2Ptr->specialSaveWarp & 1;
|
||||
}
|
||||
|
||||
void sav2_x9_clear_bit1(void)
|
||||
{
|
||||
gSaveBlock2Ptr->specialSaveWarp &= ~1;
|
||||
}
|
||||
|
||||
void sub_804C1AC(void)
|
||||
{
|
||||
gSaveBlock2Ptr->specialSaveWarp |= 1;
|
||||
}
|
||||
|
||||
void sub_804C1C0(void)
|
||||
{
|
||||
sub_8055778(0);
|
||||
gSaveBlock2Ptr->specialSaveWarp |= 1;
|
||||
}
|
||||
|
||||
void sav2_gender2_inplace_and_xFE(void)
|
||||
{
|
||||
gSaveBlock2Ptr->specialSaveWarp &= ~1;
|
||||
}
|
||||
|
||||
void SavePlayerParty(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
gSaveBlock1Ptr->playerPartyCount = gPlayerPartyCount;
|
||||
|
||||
for (i = 0; i < PARTY_SIZE; i++)
|
||||
gSaveBlock1Ptr->playerParty[i] = gPlayerParty[i];
|
||||
}
|
||||
|
||||
void LoadPlayerParty(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
gPlayerPartyCount = gSaveBlock1Ptr->playerPartyCount;
|
||||
|
||||
for (i = 0; i < PARTY_SIZE; i++)
|
||||
gPlayerParty[i] = gSaveBlock1Ptr->playerParty[i];
|
||||
}
|
||||
|
||||
void SaveMapObjects(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NUM_FIELD_OBJECTS; i++)
|
||||
gSaveBlock1Ptr->mapObjects[i] = gMapObjects[i];
|
||||
}
|
||||
|
||||
void LoadMapObjects(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NUM_FIELD_OBJECTS; i++)
|
||||
gMapObjects[i] = gSaveBlock1Ptr->mapObjects[i];
|
||||
}
|
||||
|
||||
void SaveSerializedGame(void)
|
||||
{
|
||||
SavePlayerParty();
|
||||
SaveMapObjects();
|
||||
}
|
||||
|
||||
void LoadSerializedGame(void)
|
||||
{
|
||||
LoadPlayerParty();
|
||||
LoadMapObjects();
|
||||
}
|
||||
|
||||
void LoadPlayerBag(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// load player items.
|
||||
for (i = 0; i < BAG_ITEMS_COUNT; i++)
|
||||
gLoadedSaveData.items[i] = gSaveBlock1Ptr->bagPocket_Items[i];
|
||||
|
||||
// load player key items.
|
||||
for (i = 0; i < BAG_KEYITEMS_COUNT; i++)
|
||||
gLoadedSaveData.keyItems[i] = gSaveBlock1Ptr->bagPocket_KeyItems[i];
|
||||
|
||||
// load player pokeballs.
|
||||
for (i = 0; i < BAG_POKEBALLS_COUNT; i++)
|
||||
gLoadedSaveData.pokeBalls[i] = gSaveBlock1Ptr->bagPocket_PokeBalls[i];
|
||||
|
||||
// load player TMs and HMs.
|
||||
for (i = 0; i < BAG_TMHM_COUNT; i++)
|
||||
gLoadedSaveData.TMsHMs[i] = gSaveBlock1Ptr->bagPocket_TMHM[i];
|
||||
|
||||
// load player berries.
|
||||
for (i = 0; i < BAG_BERRIES_COUNT; i++)
|
||||
gLoadedSaveData.berries[i] = gSaveBlock1Ptr->bagPocket_Berries[i];
|
||||
|
||||
// load mail.
|
||||
for (i = 0; i < MAIL_COUNT; i++)
|
||||
gLoadedSaveData.mail[i] = gSaveBlock1Ptr->mail[i];
|
||||
|
||||
gLastEncryptionKey = gSaveBlock2Ptr->encryptionKey;
|
||||
}
|
||||
|
||||
void SavePlayerBag(void)
|
||||
{
|
||||
int i;
|
||||
u32 encryptionKeyBackup;
|
||||
|
||||
// save player items.
|
||||
for (i = 0; i < BAG_ITEMS_COUNT; i++)
|
||||
gSaveBlock1Ptr->bagPocket_Items[i] = gLoadedSaveData.items[i];
|
||||
|
||||
// save player key items.
|
||||
for (i = 0; i < BAG_KEYITEMS_COUNT; i++)
|
||||
gSaveBlock1Ptr->bagPocket_KeyItems[i] = gLoadedSaveData.keyItems[i];
|
||||
|
||||
// save player pokeballs.
|
||||
for (i = 0; i < BAG_POKEBALLS_COUNT; i++)
|
||||
gSaveBlock1Ptr->bagPocket_PokeBalls[i] = gLoadedSaveData.pokeBalls[i];
|
||||
|
||||
// save player TMs and HMs.
|
||||
for (i = 0; i < BAG_TMHM_COUNT; i++)
|
||||
gSaveBlock1Ptr->bagPocket_TMHM[i] = gLoadedSaveData.TMsHMs[i];
|
||||
|
||||
// save player berries.
|
||||
for (i = 0; i < BAG_BERRIES_COUNT; i++)
|
||||
gSaveBlock1Ptr->bagPocket_Berries[i] = gLoadedSaveData.berries[i];
|
||||
|
||||
// save mail.
|
||||
for (i = 0; i < MAIL_COUNT; i++)
|
||||
gSaveBlock1Ptr->mail[i] = gLoadedSaveData.mail[i];
|
||||
|
||||
encryptionKeyBackup = gSaveBlock2Ptr->encryptionKey;
|
||||
gSaveBlock2Ptr->encryptionKey = gLastEncryptionKey;
|
||||
ApplyNewEncryptionKeyToBagItems(encryptionKeyBackup);
|
||||
gSaveBlock2Ptr->encryptionKey = encryptionKeyBackup;
|
||||
}
|
||||
|
||||
void ApplyNewEncryptionKeyToHword(u16 *hWord, u32 newKey)
|
||||
{
|
||||
*hWord ^= gSaveBlock2Ptr->encryptionKey;
|
||||
*hWord ^= newKey;
|
||||
}
|
||||
|
||||
void ApplyNewEncryptionKeyToWord(u32 *word, u32 newKey)
|
||||
{
|
||||
*word ^= gSaveBlock2Ptr->encryptionKey;
|
||||
*word ^= newKey;
|
||||
}
|
||||
|
||||
void ApplyNewEncryptionKeyToAllEncryptedData(u32 encryptionKey)
|
||||
{
|
||||
int i;
|
||||
|
||||
for(i = 0; i < 4; i++)
|
||||
ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->unkArray[i][1], encryptionKey);
|
||||
|
||||
sub_8054F38(encryptionKey);
|
||||
ApplyNewEncryptionKeyToBagItems_(encryptionKey);
|
||||
sub_815EE6C(encryptionKey);
|
||||
ApplyNewEncryptionKeyToWord(&gSaveBlock1Ptr->money, encryptionKey);
|
||||
ApplyNewEncryptionKeyToHword(&gSaveBlock1Ptr->coins, encryptionKey);
|
||||
}
|
||||
+5609
File diff suppressed because it is too large
Load Diff
+919
@@ -0,0 +1,919 @@
|
||||
#include "global.h"
|
||||
#include "save.h"
|
||||
#include "decompress.h"
|
||||
#include "main.h"
|
||||
#include "overworld.h"
|
||||
#include "load_save.h"
|
||||
#include "task.h"
|
||||
#include "link.h"
|
||||
#include "gba/flash_internal.h"
|
||||
|
||||
#define FILE_SIGNATURE 0x08012025 // signature value to determine if a sector is in use
|
||||
|
||||
#define TOTAL_FLASH_SECTORS 32
|
||||
|
||||
// Divide save blocks into individual chunks to be written to flash sectors
|
||||
|
||||
// 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
|
||||
* Sector 30: e-Reader/Mystery Gift Stuff (note: e-Reader is deprecated in Emerald US)
|
||||
* Sector 31: Recorded Battle
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// (u8 *)structure was removed from the first statement of the macro in Emerald
|
||||
// and Fire Red/Leaf Green. This is because malloc is used to allocate addresses
|
||||
// so storing the raw addresses should not be done in the offsets information.
|
||||
#define SAVEBLOCK_CHUNK(structure, chunkNum) \
|
||||
{ \
|
||||
chunkNum * SECTOR_DATA_SIZE, \
|
||||
min(sizeof(structure) - chunkNum * SECTOR_DATA_SIZE, SECTOR_DATA_SIZE) \
|
||||
} \
|
||||
|
||||
// TODO: use gSaveblock2, gSaveblock1, gPokemonStorage instead of structs
|
||||
// Will be done when load_save is decompiled.
|
||||
const struct SaveSectionOffsets gSaveSectionOffsets[] =
|
||||
{
|
||||
SAVEBLOCK_CHUNK(struct SaveBlock2, 0),
|
||||
|
||||
SAVEBLOCK_CHUNK(struct SaveBlock1, 0),
|
||||
SAVEBLOCK_CHUNK(struct SaveBlock1, 1),
|
||||
SAVEBLOCK_CHUNK(struct SaveBlock1, 2),
|
||||
SAVEBLOCK_CHUNK(struct SaveBlock1, 3),
|
||||
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 0),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 1),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 2),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 3),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 4),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 5),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 6),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 7),
|
||||
SAVEBLOCK_CHUNK(struct PokemonStorage, 8)
|
||||
};
|
||||
|
||||
extern void DoSaveFailedScreen(u8 saveType); // save_failed_screen
|
||||
extern void sub_800AB9C(void); // link
|
||||
extern bool8 sub_800A4BC(void); // link
|
||||
extern void sub_80590D8(void); // fieldmap
|
||||
extern void sub_804C1C0(void); // load_save
|
||||
extern void sav2_gender2_inplace_and_xFE(void); // load_save
|
||||
|
||||
// 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.
|
||||
u16 gUnknown_3005398;
|
||||
u16 gSaveUnusedVar;
|
||||
u16 gSaveFileStatus;
|
||||
void (*gGameContinueCallback)(void);
|
||||
struct SaveBlockChunk gRamSaveSectionLocations[0xE];
|
||||
u16 gUnknown_3005420;
|
||||
|
||||
EWRAM_DATA struct SaveSection gSaveDataBuffer = {0};
|
||||
EWRAM_DATA u32 gSaveUnusedVar2 = 0;
|
||||
|
||||
void ClearSaveData(void)
|
||||
{
|
||||
u16 i;
|
||||
|
||||
for (i = 0; i < NUM_SECTORS; i++)
|
||||
EraseFlashSector(i);
|
||||
}
|
||||
|
||||
void Save_ResetSaveCounters(void)
|
||||
{
|
||||
gSaveCounter = 0;
|
||||
gFirstSaveSector = 0;
|
||||
gDamagedSaveSectors = 0;
|
||||
}
|
||||
|
||||
bool32 SetSectorDamagedStatus(u8 op, u8 sectorNum)
|
||||
{
|
||||
bool32 retVal = FALSE;
|
||||
|
||||
switch (op)
|
||||
{
|
||||
case ENABLE:
|
||||
gDamagedSaveSectors |= (1 << sectorNum);
|
||||
break;
|
||||
case DISABLE:
|
||||
gDamagedSaveSectors &= ~(1 << sectorNum);
|
||||
break;
|
||||
case CHECK: // unused
|
||||
if (gDamagedSaveSectors & (1 << sectorNum))
|
||||
retVal = TRUE;
|
||||
break;
|
||||
}
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
// 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'.
|
||||
u8 save_write_to_flash(u16 chunkId, const struct SaveBlockChunk *chunks)
|
||||
{
|
||||
u32 retVal;
|
||||
u16 i;
|
||||
|
||||
gFastSaveSection = &gSaveDataBuffer;
|
||||
|
||||
if (chunkId != 0xFFFF) // write single chunk
|
||||
{
|
||||
retVal = HandleWriteSector(chunkId, chunks);
|
||||
}
|
||||
else // write all chunks
|
||||
{
|
||||
gLastKnownGoodSector = gFirstSaveSector; // backup the current written sector before attempting to write.
|
||||
gPrevSaveCounter = gSaveCounter;
|
||||
gFirstSaveSector++;
|
||||
gFirstSaveSector %= NUM_SECTORS_PER_SAVE_SLOT; // array count save sector locations
|
||||
gSaveCounter++;
|
||||
retVal = SAVE_STATUS_OK;
|
||||
|
||||
for (i = 0; i < NUM_SECTORS_PER_SAVE_SLOT; i++)
|
||||
HandleWriteSector(i, chunks);
|
||||
|
||||
// Check for any bad sectors
|
||||
if (gDamagedSaveSectors != 0) // skip the damaged sector.
|
||||
{
|
||||
retVal = SAVE_STATUS_ERROR;
|
||||
gFirstSaveSector = gLastKnownGoodSector;
|
||||
gSaveCounter = gPrevSaveCounter;
|
||||
}
|
||||
}
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
u8 HandleWriteSector(u16 chunkId, const struct SaveBlockChunk *chunks)
|
||||
{
|
||||
u16 i;
|
||||
u16 sectorNum;
|
||||
u8 *chunkData;
|
||||
u16 chunkSize;
|
||||
|
||||
// select sector number
|
||||
sectorNum = chunkId + gFirstSaveSector;
|
||||
sectorNum %= NUM_SECTORS_PER_SAVE_SLOT;
|
||||
// select save slot
|
||||
sectorNum += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2);
|
||||
|
||||
chunkData = chunks[chunkId].data;
|
||||
chunkSize = chunks[chunkId].size;
|
||||
|
||||
// clear save section.
|
||||
for (i = 0; i < sizeof(struct SaveSection); i++)
|
||||
((char *)gFastSaveSection)[i] = 0;
|
||||
|
||||
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);
|
||||
return TryWriteSector(sectorNum, gFastSaveSection->data);
|
||||
}
|
||||
|
||||
u8 HandleWriteSectorNBytes(u8 sector, u8 *data, u16 size)
|
||||
{
|
||||
u16 i;
|
||||
struct SaveSection *section = &gSaveDataBuffer;
|
||||
|
||||
for (i = 0; i < sizeof(struct SaveSection); i++)
|
||||
((char *)section)[i] = 0;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
u8 TryWriteSector(u8 sectorNum, u8 *data)
|
||||
{
|
||||
if (ProgramFlashSectorAndVerify(sectorNum, data) != 0) // is damaged?
|
||||
{
|
||||
SetSectorDamagedStatus(ENABLE, sectorNum); // set damaged sector bits.
|
||||
return SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetSectorDamagedStatus(DISABLE, sectorNum); // unset damaged sector bits. it's safe now.
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
}
|
||||
|
||||
u32 RestoreSaveBackupVarsAndIncrement(const struct SaveBlockChunk *chunk) // chunk is unused
|
||||
{
|
||||
gFastSaveSection = &gSaveDataBuffer;
|
||||
gLastKnownGoodSector = gFirstSaveSector;
|
||||
gPrevSaveCounter = gSaveCounter;
|
||||
gFirstSaveSector++;
|
||||
gFirstSaveSector %= NUM_SECTORS_PER_SAVE_SLOT;
|
||||
gSaveCounter++;
|
||||
gUnknown_3005398 = 0;
|
||||
gDamagedSaveSectors = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
u32 RestoreSaveBackupVars(const struct SaveBlockChunk *chunk) // chunk is unused
|
||||
{
|
||||
gFastSaveSection = &gSaveDataBuffer;
|
||||
gLastKnownGoodSector = gFirstSaveSector;
|
||||
gPrevSaveCounter = gSaveCounter;
|
||||
gUnknown_3005398 = 0;
|
||||
gDamagedSaveSectors = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8 sub_80D9AA4(u16 a1, const struct SaveBlockChunk *chunk)
|
||||
{
|
||||
u8 retVal;
|
||||
|
||||
if (gUnknown_3005398 < a1 - 1)
|
||||
{
|
||||
retVal = SAVE_STATUS_OK;
|
||||
HandleWriteSector(gUnknown_3005398, chunk);
|
||||
gUnknown_3005398++;
|
||||
if (gDamagedSaveSectors)
|
||||
{
|
||||
retVal = SAVE_STATUS_ERROR;
|
||||
gFirstSaveSector = gLastKnownGoodSector;
|
||||
gSaveCounter = gPrevSaveCounter;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
retVal = SAVE_STATUS_ERROR;
|
||||
}
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
u8 sub_80D9B04(u16 a1, const struct SaveBlockChunk *chunk)
|
||||
{
|
||||
u8 retVal = SAVE_STATUS_OK;
|
||||
|
||||
ClearSaveData_2(a1 - 1, chunk);
|
||||
|
||||
if (gDamagedSaveSectors)
|
||||
{
|
||||
retVal = SAVE_STATUS_ERROR;
|
||||
gFirstSaveSector = gLastKnownGoodSector;
|
||||
gSaveCounter = gPrevSaveCounter;
|
||||
}
|
||||
return retVal;
|
||||
}
|
||||
|
||||
u8 ClearSaveData_2(u16 chunkId, const struct SaveBlockChunk *chunks)
|
||||
{
|
||||
u16 i;
|
||||
u16 sector;
|
||||
u8 *data;
|
||||
u16 size;
|
||||
u8 status;
|
||||
|
||||
// select sector number
|
||||
sector = chunkId + gFirstSaveSector;
|
||||
sector %= NUM_SECTORS_PER_SAVE_SLOT;
|
||||
// select save slot
|
||||
sector += NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2);
|
||||
|
||||
data = chunks[chunkId].data;
|
||||
size = chunks[chunkId].size;
|
||||
|
||||
// clear temp save section.
|
||||
for (i = 0; i < sizeof(struct SaveSection); i++)
|
||||
((char *)gFastSaveSection)[i] = 0;
|
||||
|
||||
gFastSaveSection->id = chunkId;
|
||||
gFastSaveSection->signature = FILE_SIGNATURE;
|
||||
gFastSaveSection->counter = gSaveCounter;
|
||||
|
||||
// set temp section's data.
|
||||
for (i = 0; i < size; i++)
|
||||
gFastSaveSection->data[i] = data[i];
|
||||
|
||||
// calculate checksum.
|
||||
gFastSaveSection->checksum = CalculateChecksum(data, size);
|
||||
|
||||
EraseFlashSector(sector);
|
||||
|
||||
status = SAVE_STATUS_OK;
|
||||
|
||||
for (i = 0; i < sizeof(struct UnkSaveSection); i++)
|
||||
{
|
||||
if (ProgramFlashByte(sector, i, gFastSaveSection->data[i]))
|
||||
{
|
||||
status = SAVE_STATUS_ERROR;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (status == SAVE_STATUS_ERROR)
|
||||
{
|
||||
SetSectorDamagedStatus(ENABLE, sector);
|
||||
return SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
status = SAVE_STATUS_OK;
|
||||
|
||||
for (i = 0; i < 7; i++)
|
||||
{
|
||||
if (ProgramFlashByte(sector, 0xFF9 + i, ((u8 *)gFastSaveSection)[0xFF9 + i]))
|
||||
{
|
||||
status = SAVE_STATUS_ERROR;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (status == SAVE_STATUS_ERROR)
|
||||
{
|
||||
SetSectorDamagedStatus(ENABLE, sector);
|
||||
return SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetSectorDamagedStatus(DISABLE, sector);
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
u8 sav12_xor_get(u16 a1, const struct SaveBlockChunk *chunk)
|
||||
{
|
||||
u16 sector;
|
||||
|
||||
// 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.
|
||||
SetSectorDamagedStatus(ENABLE, sector);
|
||||
gFirstSaveSector = gLastKnownGoodSector;
|
||||
gSaveCounter = gPrevSaveCounter;
|
||||
return SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetSectorDamagedStatus(DISABLE, sector);
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
}
|
||||
|
||||
u8 sub_80D9D88(u16 a1, const struct SaveBlockChunk *chunk)
|
||||
{
|
||||
u16 sector;
|
||||
|
||||
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.
|
||||
SetSectorDamagedStatus(ENABLE, sector);
|
||||
gFirstSaveSector = gLastKnownGoodSector;
|
||||
gSaveCounter = gPrevSaveCounter;
|
||||
return SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
SetSectorDamagedStatus(DISABLE, sector);
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
}
|
||||
|
||||
u8 sub_80D9E14(u16 a1, const struct SaveBlockChunk *chunk)
|
||||
{
|
||||
u8 retVal;
|
||||
gFastSaveSection = &gSaveDataBuffer;
|
||||
if (a1 != 0xFFFF)
|
||||
{
|
||||
retVal = SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
retVal = GetSaveValidStatus(chunk);
|
||||
sub_80D9E54(0xFFFF, chunk);
|
||||
}
|
||||
|
||||
return retVal;
|
||||
}
|
||||
|
||||
u8 sub_80D9E54(u16 a1, const struct SaveBlockChunk *chunks)
|
||||
{
|
||||
u16 i;
|
||||
u16 checksum;
|
||||
u16 sector = NUM_SECTORS_PER_SAVE_SLOT * (gSaveCounter % 2);
|
||||
u16 id;
|
||||
|
||||
for (i = 0; i < NUM_SECTORS_PER_SAVE_SLOT; i++)
|
||||
{
|
||||
DoReadFlashWholeSection(i + sector, gFastSaveSection);
|
||||
id = gFastSaveSection->id;
|
||||
if (id == 0)
|
||||
gFirstSaveSector = i;
|
||||
checksum = CalculateChecksum(gFastSaveSection->data, chunks[id].size);
|
||||
if (gFastSaveSection->signature == FILE_SIGNATURE
|
||||
&& gFastSaveSection->checksum == checksum)
|
||||
{
|
||||
u16 j;
|
||||
for (j = 0; j < chunks[id].size; j++)
|
||||
chunks[id].data[j] = gFastSaveSection->data[j];
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
u8 GetSaveValidStatus(const struct SaveBlockChunk *chunks)
|
||||
{
|
||||
u16 sector;
|
||||
bool8 signatureValid;
|
||||
u16 checksum;
|
||||
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.
|
||||
validSectors = 0;
|
||||
signatureValid = FALSE;
|
||||
for (sector = 0; sector < NUM_SECTORS_PER_SAVE_SLOT; sector++)
|
||||
{
|
||||
DoReadFlashWholeSection(sector, gFastSaveSection);
|
||||
if (gFastSaveSection->signature == FILE_SIGNATURE)
|
||||
{
|
||||
signatureValid = TRUE;
|
||||
checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size);
|
||||
if (gFastSaveSection->checksum == checksum)
|
||||
{
|
||||
slot1saveCounter = gFastSaveSection->counter;
|
||||
validSectors |= 1 << gFastSaveSection->id;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (signatureValid)
|
||||
{
|
||||
if (validSectors == ALL_SECTORS)
|
||||
slot1Status = SAVE_STATUS_OK;
|
||||
else
|
||||
slot1Status = SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
slot1Status = SAVE_STATUS_EMPTY;
|
||||
}
|
||||
|
||||
// check save slot 2.
|
||||
validSectors = 0;
|
||||
signatureValid = FALSE;
|
||||
for (sector = 0; sector < NUM_SECTORS_PER_SAVE_SLOT; sector++)
|
||||
{
|
||||
DoReadFlashWholeSection(NUM_SECTORS_PER_SAVE_SLOT + sector, gFastSaveSection);
|
||||
if (gFastSaveSection->signature == FILE_SIGNATURE)
|
||||
{
|
||||
signatureValid = TRUE;
|
||||
checksum = CalculateChecksum(gFastSaveSection->data, chunks[gFastSaveSection->id].size);
|
||||
if (gFastSaveSection->checksum == checksum)
|
||||
{
|
||||
slot2saveCounter = gFastSaveSection->counter;
|
||||
validSectors |= 1 << gFastSaveSection->id;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (signatureValid)
|
||||
{
|
||||
if (validSectors == ALL_SECTORS)
|
||||
slot2Status = SAVE_STATUS_OK;
|
||||
else
|
||||
slot2Status = SAVE_STATUS_ERROR;
|
||||
}
|
||||
else
|
||||
{
|
||||
slot2Status = SAVE_STATUS_EMPTY;
|
||||
}
|
||||
|
||||
if (slot1Status == SAVE_STATUS_OK && slot2Status == SAVE_STATUS_OK)
|
||||
{
|
||||
// Choose counter of the most recent save file
|
||||
if ((slot1saveCounter == -1 && slot2saveCounter == 0) || (slot1saveCounter == 0 && slot2saveCounter == -1))
|
||||
{
|
||||
if ((unsigned)(slot1saveCounter + 1) < (unsigned)(slot2saveCounter + 1))
|
||||
gSaveCounter = slot2saveCounter;
|
||||
else
|
||||
gSaveCounter = slot1saveCounter;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (slot1saveCounter < slot2saveCounter)
|
||||
gSaveCounter = slot2saveCounter;
|
||||
else
|
||||
gSaveCounter = slot1saveCounter;
|
||||
}
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
|
||||
if (slot1Status == SAVE_STATUS_OK)
|
||||
{
|
||||
gSaveCounter = slot1saveCounter;
|
||||
if (slot2Status == SAVE_STATUS_ERROR)
|
||||
return SAVE_STATUS_ERROR;
|
||||
else
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
|
||||
if (slot2Status == SAVE_STATUS_OK)
|
||||
{
|
||||
gSaveCounter = slot2saveCounter;
|
||||
if (slot1Status == SAVE_STATUS_ERROR)
|
||||
return SAVE_STATUS_ERROR;
|
||||
else
|
||||
return SAVE_STATUS_OK;
|
||||
}
|
||||
|
||||
if (slot1Status == SAVE_STATUS_EMPTY && slot2Status == SAVE_STATUS_EMPTY)
|
||||
{
|
||||
gSaveCounter = 0;
|
||||
gFirstSaveSector = 0;
|
||||
return SAVE_STATUS_EMPTY;
|
||||
}
|
||||
|
||||
gSaveCounter = 0;
|
||||
gFirstSaveSector = 0;
|
||||
return 2;
|
||||
}
|
||||
|
||||
u8 sub_80DA120(u8 sector, u8 *data, u16 size)
|
||||
{
|
||||
u16 i;
|
||||
struct SaveSection *section = &gSaveDataBuffer;
|
||||
|
||||
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 SAVE_STATUS_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
return SAVE_STATUS_INVALID;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return SAVE_STATUS_EMPTY;
|
||||
}
|
||||
}
|
||||
|
||||
u8 DoReadFlashWholeSection(u8 sector, struct SaveSection *section)
|
||||
{
|
||||
ReadFlash(sector, 0, section->data, sizeof(struct SaveSection));
|
||||
return 1;
|
||||
}
|
||||
|
||||
u16 CalculateChecksum(void *data, u16 size)
|
||||
{
|
||||
u16 i;
|
||||
u32 checksum = 0;
|
||||
|
||||
for (i = 0; i < (size / 4); i++)
|
||||
checksum += *((u32 *)data)++;
|
||||
|
||||
return ((checksum >> 16) + checksum);
|
||||
}
|
||||
|
||||
void UpdateSaveAddresses(void)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
gRamSaveSectionLocations[i].data = (void*)(gSaveBlock2Ptr) + gSaveSectionOffsets[i].toAdd;
|
||||
gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
|
||||
|
||||
for (i = 1; i < 5; i++)
|
||||
{
|
||||
gRamSaveSectionLocations[i].data = (void*)(gSaveBlock1Ptr) + gSaveSectionOffsets[i].toAdd;
|
||||
gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
|
||||
}
|
||||
|
||||
for (i = 5; i < 14; i++)
|
||||
{
|
||||
gRamSaveSectionLocations[i].data = (void*)(gPokemonStoragePtr) + gSaveSectionOffsets[i].toAdd;
|
||||
gRamSaveSectionLocations[i].size = gSaveSectionOffsets[i].size;
|
||||
|
||||
i++;i--; // needed to match
|
||||
}
|
||||
}
|
||||
|
||||
u8 HandleSavingData(u8 saveType)
|
||||
{
|
||||
u8 i;
|
||||
u32 *backupPtr = gMain.vblankCounter1;
|
||||
u8 *tempAddr;
|
||||
|
||||
gMain.vblankCounter1 = NULL;
|
||||
UpdateSaveAddresses();
|
||||
switch (saveType)
|
||||
{
|
||||
case SAVE_HALL_OF_FAME_ERASE_BEFORE: // deletes HOF before overwriting HOF completely. unused
|
||||
for (i = 0xE * 2 + 0; i < 32; i++)
|
||||
EraseFlashSector(i);
|
||||
// fallthrough
|
||||
case SAVE_HALL_OF_FAME: // hall of fame.
|
||||
if (GetGameStat(GAME_STAT_ENTERED_HOF) < 999)
|
||||
IncrementGameStat(GAME_STAT_ENTERED_HOF);
|
||||
tempAddr = gDecompressionBuffer;
|
||||
HandleWriteSectorNBytes(0x1C, tempAddr, 0xF80);
|
||||
HandleWriteSectorNBytes(0x1D, tempAddr + 0xF80, 0xF80);
|
||||
// fallthrough
|
||||
case SAVE_NORMAL: // normal save. also called by overwriting your own save.
|
||||
default:
|
||||
SaveSerializedGame();
|
||||
save_write_to_flash(0xFFFF, gRamSaveSectionLocations);
|
||||
break;
|
||||
case SAVE_LINK: // _081532C4
|
||||
SaveSerializedGame();
|
||||
for(i = 0; i < 5; i++)
|
||||
save_write_to_flash(i, gRamSaveSectionLocations);
|
||||
break;
|
||||
case EREADER_SAVE:
|
||||
SaveSerializedGame();
|
||||
save_write_to_flash(0, gRamSaveSectionLocations);
|
||||
break;
|
||||
case SAVE_OVERWRITE_DIFFERENT_FILE:
|
||||
for (i = (0xE * 2 + 0); i < 32; i++)
|
||||
EraseFlashSector(i); // erase HOF.
|
||||
SaveSerializedGame();
|
||||
save_write_to_flash(0xFFFF, gRamSaveSectionLocations);
|
||||
break;
|
||||
}
|
||||
gMain.vblankCounter1 = backupPtr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8 TrySavingData(u8 saveType)
|
||||
{
|
||||
if(gFlashMemoryPresent == TRUE)
|
||||
{
|
||||
HandleSavingData(saveType);
|
||||
if(gDamagedSaveSectors)
|
||||
DoSaveFailedScreen(saveType);
|
||||
else
|
||||
goto OK; // really?
|
||||
}
|
||||
gUnknown_3005420 = 0xFF;
|
||||
return 0xFF;
|
||||
|
||||
OK:
|
||||
gUnknown_3005420 = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
u8 sub_80DA3AC(void)
|
||||
{
|
||||
if (gFlashMemoryPresent != TRUE)
|
||||
return 1;
|
||||
UpdateSaveAddresses();
|
||||
SaveSerializedGame();
|
||||
RestoreSaveBackupVarsAndIncrement(gRamSaveSectionLocations);
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool8 sub_80DA3D8(void)
|
||||
{
|
||||
u8 retVal = sub_80D9AA4(0xE, gRamSaveSectionLocations);
|
||||
if (gDamagedSaveSectors)
|
||||
DoSaveFailedScreen(0);
|
||||
if (retVal == 0xFF)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8 sub_80DA40C(void)
|
||||
{
|
||||
sub_80D9B04(0xE, gRamSaveSectionLocations);
|
||||
if (gDamagedSaveSectors)
|
||||
DoSaveFailedScreen(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8 sub_80DA434(void)
|
||||
{
|
||||
sav12_xor_get(0xE, gRamSaveSectionLocations);
|
||||
if (gDamagedSaveSectors)
|
||||
DoSaveFailedScreen(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8 sub_80DA45C(void)
|
||||
{
|
||||
if (gFlashMemoryPresent != TRUE)
|
||||
return 1;
|
||||
|
||||
UpdateSaveAddresses();
|
||||
SaveSerializedGame();
|
||||
RestoreSaveBackupVars(gRamSaveSectionLocations);
|
||||
sub_80D9B04(gUnknown_3005398 + 1, gRamSaveSectionLocations);
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool8 sub_80DA4A0(void)
|
||||
{
|
||||
u8 retVal = FALSE;
|
||||
u16 val = ++gUnknown_3005398;
|
||||
if (val <= 4)
|
||||
{
|
||||
sub_80D9B04(gUnknown_3005398 + 1, gRamSaveSectionLocations);
|
||||
sub_80D9D88(val, gRamSaveSectionLocations);
|
||||
}
|
||||
else
|
||||
{
|
||||
sub_80D9D88(val, gRamSaveSectionLocations);
|
||||
retVal = TRUE;
|
||||
}
|
||||
if (gDamagedSaveSectors)
|
||||
DoSaveFailedScreen(1);
|
||||
return retVal;
|
||||
}
|
||||
|
||||
u8 Save_LoadGameData(u8 a1)
|
||||
{
|
||||
u8 result;
|
||||
|
||||
if (gFlashMemoryPresent != TRUE)
|
||||
{
|
||||
gSaveFileStatus = 4;
|
||||
return 0xFF;
|
||||
}
|
||||
|
||||
UpdateSaveAddresses();
|
||||
switch (a1)
|
||||
{
|
||||
case 0:
|
||||
default:
|
||||
result = sub_80D9E14(0xFFFF, gRamSaveSectionLocations);
|
||||
LoadSerializedGame();
|
||||
gSaveFileStatus = result;
|
||||
gGameContinueCallback = 0;
|
||||
break;
|
||||
case 3:
|
||||
result = sub_80DA120(0x1C, gDecompressionBuffer, 0xF80);
|
||||
if(result == 1)
|
||||
result = sub_80DA120(0x1D, gDecompressionBuffer + 0xF80, 0xF80);
|
||||
break;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
u32 TryCopySpecialSaveSection(u8 sector, u8* dst)
|
||||
{
|
||||
s32 i;
|
||||
s32 size;
|
||||
u8* savData;
|
||||
|
||||
if (sector != 30 && sector != 31)
|
||||
return 0xFF;
|
||||
ReadFlash(sector, 0, (u8 *)&gSaveDataBuffer, sizeof(struct SaveSection));
|
||||
if (*(u32*)(&gSaveDataBuffer.data[0]) != 0xB39D)
|
||||
return 0xFF;
|
||||
// copies whole save section except u32 counter
|
||||
i = 0;
|
||||
size = 0xFFB;
|
||||
savData = &gSaveDataBuffer.data[4];
|
||||
for (; i <= size; i++)
|
||||
dst[i] = savData[i];
|
||||
return 1;
|
||||
}
|
||||
|
||||
u32 sub_80DA5E0(u8 sector, u8* src)
|
||||
{
|
||||
s32 i;
|
||||
s32 size;
|
||||
u8* savData;
|
||||
void* savDataBuffer;
|
||||
|
||||
if (sector != 30 && sector != 31)
|
||||
return 0xFF;
|
||||
|
||||
savDataBuffer = &gSaveDataBuffer;
|
||||
*(u32*)(savDataBuffer) = 0xB39D;
|
||||
|
||||
// copies whole save section except u32 counter
|
||||
i = 0;
|
||||
size = 0xFFB;
|
||||
savData = &gSaveDataBuffer.data[4];
|
||||
for (; i <= size; i++)
|
||||
savData[i] = src[i];
|
||||
if (ProgramFlashSectorAndVerify(sector, savDataBuffer) != 0)
|
||||
return 0xFF;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void sub_80DA634(u8 taskId)
|
||||
{
|
||||
switch (gTasks[taskId].data[0])
|
||||
{
|
||||
case 0:
|
||||
gSoftResetDisabled = TRUE;
|
||||
gTasks[taskId].data[0] = 1;
|
||||
break;
|
||||
case 1:
|
||||
sub_800AB9C();
|
||||
gTasks[taskId].data[0] = 2;
|
||||
break;
|
||||
case 2:
|
||||
if (sub_800A4BC())
|
||||
{
|
||||
sub_80590D8();
|
||||
gTasks[taskId].data[0] = 3;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
sub_804C1C0();
|
||||
sub_80DA3AC();
|
||||
gTasks[taskId].data[0] = 4;
|
||||
break;
|
||||
case 4:
|
||||
if (++gTasks[taskId].data[1] == 5)
|
||||
{
|
||||
gTasks[taskId].data[1] = 0;
|
||||
gTasks[taskId].data[0] = 5;
|
||||
}
|
||||
break;
|
||||
case 5:
|
||||
if (sub_80DA3D8())
|
||||
gTasks[taskId].data[0] = 6;
|
||||
else
|
||||
gTasks[taskId].data[0] = 4;
|
||||
break;
|
||||
case 6:
|
||||
sub_80DA40C();
|
||||
gTasks[taskId].data[0] = 7;
|
||||
break;
|
||||
case 7:
|
||||
sav2_gender2_inplace_and_xFE();
|
||||
sub_800AB9C();
|
||||
gTasks[taskId].data[0] = 8;
|
||||
break;
|
||||
case 8:
|
||||
if (sub_800A4BC())
|
||||
{
|
||||
sub_80DA434();
|
||||
gTasks[taskId].data[0] = 9;
|
||||
}
|
||||
break;
|
||||
case 9:
|
||||
sub_800AB9C();
|
||||
gTasks[taskId].data[0] = 10;
|
||||
break;
|
||||
case 10:
|
||||
if (sub_800A4BC())
|
||||
gTasks[taskId].data[0]++;
|
||||
break;
|
||||
case 11:
|
||||
if (++gTasks[taskId].data[1] > 5)
|
||||
{
|
||||
gSoftResetDisabled = FALSE;
|
||||
DestroyTask(taskId);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
+10
-10
@@ -64,7 +64,7 @@ struct VsSeekerStruct
|
||||
};
|
||||
|
||||
extern u16 gUnknown_20370D2;
|
||||
extern struct MapObject gUnknown_2036E38[MAP_OBJECTS_COUNT];
|
||||
extern struct MapObject gMapObjects[MAP_OBJECTS_COUNT];
|
||||
extern u8 gUnknown_3005074;
|
||||
|
||||
// static declarations
|
||||
@@ -642,8 +642,8 @@ static void GatherNearbyTrainerInfo(void)
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].localId = templates[mapObjectIdx].localId;
|
||||
TryGetFieldObjectIdByLocalIdAndMap(templates[mapObjectIdx].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &fieldObjectId);
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].fieldObjectId = fieldObjectId;
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].xCoord = gUnknown_2036E38[fieldObjectId].coords2.x - 7;
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].yCoord = gUnknown_2036E38[fieldObjectId].coords2.y - 7;
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].xCoord = gMapObjects[fieldObjectId].coords2.x - 7;
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].yCoord = gMapObjects[fieldObjectId].coords2.y - 7;
|
||||
sVsSeeker->trainerInfo[vsSeekerObjectIdx].graphicsId = templates[mapObjectIdx].graphicsId;
|
||||
vsSeekerObjectIdx++;
|
||||
}
|
||||
@@ -731,7 +731,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
|
||||
else
|
||||
{
|
||||
gSaveBlock1Ptr->trainerRematches[sVsSeeker->trainerInfo[vsSeekerIdx].localId] = r7;
|
||||
npc_coords_shift_still(&gUnknown_2036E38[sVsSeeker->trainerInfo[vsSeekerIdx].fieldObjectId]);
|
||||
npc_coords_shift_still(&gMapObjects[sVsSeeker->trainerInfo[vsSeekerIdx].fieldObjectId]);
|
||||
StartTrainerObjectMovementScript(&sVsSeeker->trainerInfo[vsSeekerIdx], gUnknown_8453F64);
|
||||
sVsSeeker->trainerIdxArray[sVsSeeker->numRematchableTrainers] = r8;
|
||||
sVsSeeker->runningBehaviourEtcArray[sVsSeeker->numRematchableTrainers] = GetRunningBehaviorFromGraphicsId(sVsSeeker->trainerInfo[vsSeekerIdx].graphicsId);
|
||||
@@ -891,7 +891,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
|
||||
"\tlsls r0, r1, 3\n"
|
||||
"\tadds r0, r1\n"
|
||||
"\tlsls r0, 2\n"
|
||||
"\tldr r1, _0810CB5C @ =gUnknown_2036E38\n"
|
||||
"\tldr r1, _0810CB5C @ =gMapObjects\n"
|
||||
"\tadds r0, r1\n"
|
||||
"\tbl npc_coords_shift_still\n"
|
||||
"\tldr r0, [r6]\n"
|
||||
@@ -965,7 +965,7 @@ static u8 GetVsSeekerResponseInArea(const VsSeekerData * a0)
|
||||
"\t.align 2, 0\n"
|
||||
"_0810CB54: .4byte gSaveBlock1Ptr\n"
|
||||
"_0810CB58: .4byte 0x0000063a\n"
|
||||
"_0810CB5C: .4byte gUnknown_2036E38\n"
|
||||
"_0810CB5C: .4byte gMapObjects\n"
|
||||
"_0810CB60: .4byte gUnknown_8453F64\n"
|
||||
"_0810CB64: .4byte 0x00000431\n"
|
||||
"_0810CB68: .4byte sVsSeeker\n"
|
||||
@@ -1008,7 +1008,7 @@ void sub_810CB90(void)
|
||||
struct MapObject *r4_2;
|
||||
|
||||
TryGetFieldObjectIdByLocalIdAndMap(r4[r8].localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, &sp0);
|
||||
r4_2 = &gUnknown_2036E38[sp0];
|
||||
r4_2 = &gMapObjects[sp0];
|
||||
sub_810CF54(&r4[r8]); // You are using this function incorrectly. Please consult the manual.
|
||||
sub_805FE7C(r4_2, gUnknown_8453F67[r4_2->mapobj_unk_18]);
|
||||
gSaveBlock1Ptr->trainerRematches[r4[r8].localId] = 0;
|
||||
@@ -1155,7 +1155,7 @@ static bool8 sub_810CED0(const VsSeekerData * a0, u16 a1)
|
||||
|
||||
bool8 sub_810CF04(u8 a0)
|
||||
{
|
||||
struct MapObject *r1 = &gUnknown_2036E38[a0];
|
||||
struct MapObject *r1 = &gMapObjects[a0];
|
||||
|
||||
if (r1->active && gMapHeader.events->mapObjectCount >= r1->localId && gSprites[r1->spriteId].data[0] == a0)
|
||||
return TRUE;
|
||||
@@ -1331,7 +1331,7 @@ static u8 GetRematchableTrainerLocalId(void)
|
||||
|
||||
static void StartTrainerObjectMovementScript(struct VsSeekerTrainerInfo * trainerInfo, const u8 * script)
|
||||
{
|
||||
npc_sync_anim_pause_bits(&gUnknown_2036E38[trainerInfo->fieldObjectId]);
|
||||
npc_sync_anim_pause_bits(&gMapObjects[trainerInfo->fieldObjectId]);
|
||||
ScriptMovement_StartObjectMovementScript(trainerInfo->localId, gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup, script);
|
||||
}
|
||||
|
||||
@@ -1367,7 +1367,7 @@ static void StartAllRespondantIdleMovements(void)
|
||||
{
|
||||
if (sVsSeeker->trainerInfo[j].trainerIdx == sVsSeeker->trainerIdxArray[i])
|
||||
{
|
||||
struct MapObject *r4 = &gUnknown_2036E38[sVsSeeker->trainerInfo[j].fieldObjectId];
|
||||
struct MapObject *r4 = &gMapObjects[sVsSeeker->trainerInfo[j].fieldObjectId];
|
||||
|
||||
if (sub_810CF04(sVsSeeker->trainerInfo[j].fieldObjectId) == 1)
|
||||
npc_set_running_behaviour_etc(r4, sVsSeeker->runningBehaviourEtcArray[i]);
|
||||
|
||||
Reference in New Issue
Block a user