tbld
/
tumbledemerald-legacy
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 5 Wiki Activity
tumbledemerald-legacy/src/save.c

1048 lines
31 KiB
C
Raw Permalink Blame History

#include "global.h"
#include "agb_flash.h"
#include "gba/flash_internal.h"
#include "fieldmap.h"
#include "save.h"
#include "task.h"
#include "decompress.h"
#include "load_save.h"
#include "overworld.h"
#include "pokemon_storage_system.h"
#include "main.h"
#include "trainer_hill.h"
#include "link.h"
#include "constants/game_stat.h"
static u16 CalculateChecksum(void *, u16);
static bool8 ReadFlashSector(u8, struct SaveSector *);
static u8 GetSaveValidStatus(const struct SaveSectorLocation *);
static u8 CopySaveSlotData(u16, struct SaveSectorLocation *);
static u8 TryWriteSector(u8, u8 *);
static u8 HandleWriteSector(u16, const struct SaveSectorLocation *);
static u8 HandleReplaceSector(u16, const struct SaveSectorLocation *);
// Divide save blocks into individual chunks to be written to flash sectors
/*
* Sector Layout:
*
* Sectors 0 - 13: Save Slot 1
* Sectors 14 - 27: Save Slot 2
* Sectors 28 - 29: Hall of Fame
* Sector 30: Trainer Hill
* 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.
*
* See SECTOR_ID_* constants in save.h
*/
#define SAVEBLOCK_CHUNK(structure, chunkNum) \
{ \
chunkNum * SECTOR_DATA_SIZE, \
sizeof(structure) >= chunkNum * SECTOR_DATA_SIZE ? \
min(sizeof(structure) - chunkNum * SECTOR_DATA_SIZE, SECTOR_DATA_SIZE) : 0 \
}
struct
{
u16 offset;
u16 size;
} static const sSaveSlotLayout[NUM_SECTORS_PER_SLOT] =
{
SAVEBLOCK_CHUNK(struct SaveBlock2, 0), // SECTOR_ID_SAVEBLOCK2
SAVEBLOCK_CHUNK(struct SaveBlock1, 0), // SECTOR_ID_SAVEBLOCK1_START
SAVEBLOCK_CHUNK(struct SaveBlock1, 1),
SAVEBLOCK_CHUNK(struct SaveBlock1, 2),
SAVEBLOCK_CHUNK(struct SaveBlock1, 3), // SECTOR_ID_SAVEBLOCK1_END
SAVEBLOCK_CHUNK(struct PokemonStorage, 0), // SECTOR_ID_PKMN_STORAGE_START
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), // SECTOR_ID_PKMN_STORAGE_END
};
u16 gLastWrittenSector;
u32 gLastSaveCounter;
u16 gLastKnownGoodSector;
u32 gDamagedSaveSectors;
u32 gSaveCounter;
struct SaveSector *gReadWriteSector; // Pointer to a buffer for reading/writing a sector
u16 gIncrementalSectorId;
u16 gSaveUnusedVar;
u16 gSaveFileStatus;
void (*gGameContinueCallback)(void);
struct SaveSectorLocation gRamSaveSectorLocations[NUM_SECTORS_PER_SLOT];
u16 gSaveUnusedVar2;
u16 gSaveAttemptStatus;
EWRAM_DATA struct SaveSector gSaveDataBuffer = {0}; // Buffer used for reading/writing sectors
EWRAM_DATA static u8 sUnusedVar = 0;
void ClearSaveData(void)
{
u16 i;
// Clear the full save two sectors at a time
for (i = 0; i < SECTORS_COUNT / 2; i++)
{
EraseFlashSector(i);
EraseFlashSector(i + SECTORS_COUNT / 2);
}
}
void Save_ResetSaveCounters(void)
{
gSaveCounter = 0;
gLastWrittenSector = 0;
gDamagedSaveSectors = 0;
}
static bool32 SetDamagedSectorBits(u8 op, u8 sectorId)
{
bool32 retVal = FALSE;
switch (op)
{
case ENABLE:
gDamagedSaveSectors |= (1 << sectorId);
break;
case DISABLE:
gDamagedSaveSectors &= ~(1 << sectorId);
break;
case CHECK: // unused
if (gDamagedSaveSectors & (1 << sectorId))
retVal = TRUE;
break;
}
return retVal;
}
static u8 WriteSaveSectorOrSlot(u16 sectorId, const struct SaveSectorLocation *locations)
{
u32 status;
u16 i;
gReadWriteSector = &gSaveDataBuffer;
if (sectorId != FULL_SAVE_SLOT)
{
// A sector was specified, just write that sector.
// This is never reached, FULL_SAVE_SLOT is always used instead.
status = HandleWriteSector(sectorId, locations);
}
else
{
// No sector was specified, write full save slot.
gLastKnownGoodSector = gLastWrittenSector; // backup the current written sector before attempting to write.
gLastSaveCounter = gSaveCounter;
gLastWrittenSector++;
gLastWrittenSector = gLastWrittenSector % NUM_SECTORS_PER_SLOT;
gSaveCounter++;
status = SAVE_STATUS_OK;
for (i = 0; i < NUM_SECTORS_PER_SLOT; i++)
HandleWriteSector(i, locations);
if (gDamagedSaveSectors)
{
// At least one sector save failed
status = SAVE_STATUS_ERROR;
gLastWrittenSector = gLastKnownGoodSector;
gSaveCounter = gLastSaveCounter;
}
}
return status;
}
static u8 HandleWriteSector(u16 sectorId, const struct SaveSectorLocation *locations)
{
u16 i;
u16 sector;
u8 *data;
u16 size;
// Adjust sector id for current save slot
sector = sectorId + gLastWrittenSector;
sector %= NUM_SECTORS_PER_SLOT;
sector += NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
// Get current save data
data = locations[sectorId].data;
size = locations[sectorId].size;
// Clear temp save sector
for (i = 0; i < SECTOR_SIZE; i++)
((u8 *)gReadWriteSector)[i] = 0;
// Set footer data
gReadWriteSector->id = sectorId;
gReadWriteSector->security = SECTOR_SECURITY_NUM;
gReadWriteSector->counter = gSaveCounter;
// Copy current data to temp buffer for writing
for (i = 0; i < size; i++)
gReadWriteSector->data[i] = data[i];
gReadWriteSector->checksum = CalculateChecksum(data, size);
return TryWriteSector(sector, gReadWriteSector->data);
}
static u8 HandleWriteSectorNBytes(u8 sectorId, u8 *data, u16 size)
{
u16 i;
struct SaveSector *sector = &gSaveDataBuffer;
// Clear temp save sector
for (i = 0; i < SECTOR_SIZE; i++)
((u8 *)sector)[i] = 0;
sector->security = SECTOR_SECURITY_NUM;
// Copy data to temp buffer for writing
for (i = 0; i < size; i++)
sector->data[i] = data[i];
sector->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(sectorId, sector->data);
}
static u8 TryWriteSector(u8 sector, u8 *data)
{
if (ProgramFlashSectorAndVerify(sector, data)) // is damaged?
{
// Failed
SetDamagedSectorBits(ENABLE, sector);
return SAVE_STATUS_ERROR;
}
else
{
// Succeeded
SetDamagedSectorBits(DISABLE, sector);
return SAVE_STATUS_OK;
}
}
static u32 RestoreSaveBackupVarsAndIncrement(const struct SaveSectorLocation *locations)
{
gReadWriteSector = &gSaveDataBuffer;
gLastKnownGoodSector = gLastWrittenSector;
gLastSaveCounter = gSaveCounter;
gLastWrittenSector++;
gLastWrittenSector %= NUM_SECTORS_PER_SLOT;
gSaveCounter++;
gIncrementalSectorId = 0;
gDamagedSaveSectors = 0;
return 0;
}
static u32 RestoreSaveBackupVars(const struct SaveSectorLocation *locations)
{
gReadWriteSector = &gSaveDataBuffer;
gLastKnownGoodSector = gLastWrittenSector;
gLastSaveCounter = gSaveCounter;
gIncrementalSectorId = 0;
gDamagedSaveSectors = 0;
return 0;
}
static u8 HandleWriteIncrementalSector(u16 numSectors, const struct SaveSectorLocation *locations)
{
u8 status;
if (gIncrementalSectorId < numSectors - 1)
{
status = SAVE_STATUS_OK;
HandleWriteSector(gIncrementalSectorId, locations);
gIncrementalSectorId++;
if (gDamagedSaveSectors)
{
status = SAVE_STATUS_ERROR;
gLastWrittenSector = gLastKnownGoodSector;
gSaveCounter = gLastSaveCounter;
}
}
else
{
// Exceeded max sector, finished
status = SAVE_STATUS_ERROR;
}
return status;
}
static u8 HandleReplaceSectorAndVerify(u16 sectorId, const struct SaveSectorLocation *locations)
{
u8 status = SAVE_STATUS_OK;
HandleReplaceSector(sectorId - 1, locations);
if (gDamagedSaveSectors)
{
status = SAVE_STATUS_ERROR;
gLastWrittenSector = gLastKnownGoodSector;
gSaveCounter = gLastSaveCounter;
}
return status;
}
// Similar to HandleWriteSector, but fully erases the sector first, and skips writing the first security byte
static u8 HandleReplaceSector(u16 sectorId, const struct SaveSectorLocation *locations)
{
u16 i;
u16 sector;
u8 *data;
u16 size;
u8 status;
// Adjust sector id for current save slot
sector = sectorId + gLastWrittenSector;
sector %= NUM_SECTORS_PER_SLOT;
sector += NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
// Get current save data
data = locations[sectorId].data;
size = locations[sectorId].size;
// Clear temp save sector.
for (i = 0; i < SECTOR_SIZE; i++)
((u8 *)gReadWriteSector)[i] = 0;
// Set footer data
gReadWriteSector->id = sectorId;
gReadWriteSector->security = SECTOR_SECURITY_NUM;
gReadWriteSector->counter = gSaveCounter;
// Copy current data to temp buffer for writing
for (i = 0; i < size; i++)
gReadWriteSector->data[i] = data[i];
gReadWriteSector->checksum = CalculateChecksum(data, size);
// Erase old save data
EraseFlashSector(sector);
status = SAVE_STATUS_OK;
// Write new save data up to security field
for (i = 0; i < SECTOR_SECURITY_OFFSET; i++)
{
if (ProgramFlashByte(sector, i, ((u8 *)gReadWriteSector)[i]))
{
status = SAVE_STATUS_ERROR;
break;
}
}
if (status == SAVE_STATUS_ERROR)
{
// Writing save data failed
SetDamagedSectorBits(ENABLE, sector);
return SAVE_STATUS_ERROR;
}
else
{
// Writing save data succeeded, write security and counter
status = SAVE_STATUS_OK;
// Write security (skipping the first byte) and counter fields.
// The byte of security that is skipped is instead written by WriteSectorSecurityByte or WriteSectorSecurityByte_NoOffset
for (i = 0; i < SECTOR_SIZE - (SECTOR_SECURITY_OFFSET + 1); i++)
{
if (ProgramFlashByte(sector, SECTOR_SECURITY_OFFSET + 1 + i, ((u8 *)gReadWriteSector)[SECTOR_SECURITY_OFFSET + 1 + i]))
{
status = SAVE_STATUS_ERROR;
break;
}
}
if (status == SAVE_STATUS_ERROR)
{
// Writing security/counter failed
SetDamagedSectorBits(ENABLE, sector);
return SAVE_STATUS_ERROR;
}
else
{
// Succeeded
SetDamagedSectorBits(DISABLE, sector);
return SAVE_STATUS_OK;
}
}
}
static u8 WriteSectorSecurityByte_NoOffset(u16 sectorId, const struct SaveSectorLocation *locations)
{
// Adjust sector id for current save slot
// This first line lacking -1 is the only difference from WriteSectorSecurityByte
u16 sector = sectorId + gLastWrittenSector;
sector %= NUM_SECTORS_PER_SLOT;
sector += NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
// Write just the first byte of the security field, which was skipped by HandleReplaceSector
if (ProgramFlashByte(sector, SECTOR_SECURITY_OFFSET, SECTOR_SECURITY_NUM & 0xFF))
{
// 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 SAVE_STATUS_ERROR;
}
else
{
// Succeeded
SetDamagedSectorBits(DISABLE, sector);
return SAVE_STATUS_OK;
}
}
static u8 CopySectorSecurityByte(u16 sectorId, const struct SaveSectorLocation *locations)
{
// Adjust sector id for current save slot
u16 sector = sectorId + gLastWrittenSector - 1;
sector %= NUM_SECTORS_PER_SLOT;
sector += NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
// Copy just the first byte of the security field from the read/write buffer
if (ProgramFlashByte(sector, SECTOR_SECURITY_OFFSET, ((u8 *)gReadWriteSector)[SECTOR_SECURITY_OFFSET]))
{
// 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 SAVE_STATUS_ERROR;
}
else
{
// Succeded
SetDamagedSectorBits(DISABLE, sector);
return SAVE_STATUS_OK;
}
}
static u8 WriteSectorSecurityByte(u16 sectorId, const struct SaveSectorLocation *locations)
{
// Adjust sector id for current save slot
u16 sector = sectorId + gLastWrittenSector - 1;
sector %= NUM_SECTORS_PER_SLOT;
sector += NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
// Write just the first byte of the security field, which was skipped by HandleReplaceSector
if (ProgramFlashByte(sector, SECTOR_SECURITY_OFFSET, SECTOR_SECURITY_NUM & 0xFF))
{
// 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 SAVE_STATUS_ERROR;
}
else
{
// Succeeded
SetDamagedSectorBits(DISABLE, sector);
return SAVE_STATUS_OK;
}
}
static u8 TryLoadSaveSlot(u16 sectorId, struct SaveSectorLocation *locations)
{
u8 status;
gReadWriteSector = &gSaveDataBuffer;
if (sectorId != FULL_SAVE_SLOT)
{
// This function may not be used with a specific sector id
status = SAVE_STATUS_ERROR;
}
else
{
status = GetSaveValidStatus(locations);
CopySaveSlotData(FULL_SAVE_SLOT, locations);
}
return status;
}
// sectorId arg is ignored, this always reads the full save slot
static u8 CopySaveSlotData(u16 sectorId, struct SaveSectorLocation *locations)
{
u16 i;
u16 checksum;
u16 slotOffset = NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
u16 id;
for (i = 0; i < NUM_SECTORS_PER_SLOT; i++)
{
ReadFlashSector(i + slotOffset, gReadWriteSector);
id = gReadWriteSector->id;
if (id == 0)
gLastWrittenSector = i;
checksum = CalculateChecksum(gReadWriteSector->data, locations[id].size);
// Only copy data for sectors whose security and checksum fields are correct
if (gReadWriteSector->security == SECTOR_SECURITY_NUM && gReadWriteSector->checksum == checksum)
{
u16 j;
for (j = 0; j < locations[id].size; j++)
((u8 *)locations[id].data)[j] = gReadWriteSector->data[j];
}
}
return SAVE_STATUS_OK;
}
static u8 GetSaveValidStatus(const struct SaveSectorLocation *locations)
{
u16 i;
u16 checksum;
u32 saveSlot1Counter = 0;
u32 saveSlot2Counter = 0;
u32 validSectorFlags = 0;
bool8 securityPassed = FALSE;
u8 saveSlot1Status;
u8 saveSlot2Status;
// Check save slot 1
for (i = 0; i < NUM_SECTORS_PER_SLOT; i++)
{
ReadFlashSector(i, gReadWriteSector);
if (gReadWriteSector->security == SECTOR_SECURITY_NUM)
{
securityPassed = TRUE;
checksum = CalculateChecksum(gReadWriteSector->data, locations[gReadWriteSector->id].size);
if (gReadWriteSector->checksum == checksum)
{
saveSlot1Counter = gReadWriteSector->counter;
validSectorFlags |= 1 << gReadWriteSector->id;
}
}
}
if (securityPassed)
{
if (validSectorFlags == (1 << NUM_SECTORS_PER_SLOT) - 1)
saveSlot1Status = SAVE_STATUS_OK;
else
saveSlot1Status = SAVE_STATUS_ERROR;
}
else
{
// No sectors in slot 1 have the security number, treat it as empty
saveSlot1Status = SAVE_STATUS_EMPTY;
}
validSectorFlags = 0;
securityPassed = FALSE;
// Check save slot 2
for (i = 0; i < NUM_SECTORS_PER_SLOT; i++)
{
ReadFlashSector(i + NUM_SECTORS_PER_SLOT, gReadWriteSector);
if (gReadWriteSector->security == SECTOR_SECURITY_NUM)
{
securityPassed = TRUE;
checksum = CalculateChecksum(gReadWriteSector->data, locations[gReadWriteSector->id].size);
if (gReadWriteSector->checksum == checksum)
{
saveSlot2Counter = gReadWriteSector->counter;
validSectorFlags |= 1 << gReadWriteSector->id;
}
}
}
if (securityPassed)
{
if (validSectorFlags == (1 << NUM_SECTORS_PER_SLOT) - 1)
saveSlot2Status = SAVE_STATUS_OK;
else
saveSlot2Status = SAVE_STATUS_ERROR;
}
else
{
// No sectors in slot 2 have the security number, treat it as empty.
saveSlot2Status = SAVE_STATUS_EMPTY;
}
if (saveSlot1Status == SAVE_STATUS_OK && saveSlot2Status == SAVE_STATUS_OK)
{
if ((saveSlot1Counter == -1 && saveSlot2Counter == 0)
|| (saveSlot1Counter == 0 && saveSlot2Counter == -1))
{
if ((unsigned)(saveSlot1Counter + 1) < (unsigned)(saveSlot2Counter + 1))
gSaveCounter = saveSlot2Counter;
else
gSaveCounter = saveSlot1Counter;
}
else
{
if (saveSlot1Counter < saveSlot2Counter)
gSaveCounter = saveSlot2Counter;
else
gSaveCounter = saveSlot1Counter;
}
return SAVE_STATUS_OK;
}
// One or both save slots are not OK
if (saveSlot1Status == SAVE_STATUS_OK)
{
gSaveCounter = saveSlot1Counter;
if (saveSlot2Status == SAVE_STATUS_ERROR)
return SAVE_STATUS_ERROR; // Slot 2 errored
return SAVE_STATUS_OK; // Slot 1 is OK, slot 2 is empty
}
if (saveSlot2Status == SAVE_STATUS_OK)
{
gSaveCounter = saveSlot2Counter;
if (saveSlot1Status == SAVE_STATUS_ERROR)
return SAVE_STATUS_ERROR; // Slot 1 errored
return SAVE_STATUS_OK; // Slot 2 is OK, slot 1 is empty
}
// Neither slot is OK, check if both are empty
if (saveSlot1Status == SAVE_STATUS_EMPTY
&& saveSlot2Status == SAVE_STATUS_EMPTY)
{
gSaveCounter = 0;
gLastWrittenSector = 0;
return SAVE_STATUS_EMPTY;
}
// Both slots errored
gSaveCounter = 0;
gLastWrittenSector = 0;
return SAVE_STATUS_CORRUPT;
}
static u8 TryLoadSaveSector(u8 sectorId, u8 *data, u16 size)
{
u16 i;
struct SaveSector *sector = &gSaveDataBuffer;
ReadFlashSector(sectorId, sector);
if (sector->security == SECTOR_SECURITY_NUM)
{
u16 checksum = CalculateChecksum(sector->data, size);
if (sector->id == checksum)
{
// Security and checksum are correct, copy data
for (i = 0; i < size; i++)
data[i] = sector->data[i];
return SAVE_STATUS_OK;
}
else
{
// Incorrect checksum
return SAVE_STATUS_CORRUPT;
}
}
else
{
// Incorrect security value
return SAVE_STATUS_EMPTY;
}
}
// Return value always ignored
static bool8 ReadFlashSector(u8 sectorId, struct SaveSector *sector)
{
ReadFlash(sectorId, 0, sector->data, SECTOR_SIZE);
return TRUE;
}
static u16 CalculateChecksum(void *data, u16 size)
{
u16 i;
u32 checksum = 0;
for (i = 0; i < (size / 4); i++)
{
checksum += *((u32 *)data);
data += sizeof(u32);
}
return ((checksum >> 16) + checksum);
}
static void UpdateSaveAddresses(void)
{
int i = SECTOR_ID_SAVEBLOCK2;
gRamSaveSectorLocations[i].data = (void*)(gSaveBlock2Ptr) + sSaveSlotLayout[i].offset;
gRamSaveSectorLocations[i].size = sSaveSlotLayout[i].size;
for (i = SECTOR_ID_SAVEBLOCK1_START; i <= SECTOR_ID_SAVEBLOCK1_END; i++)
{
gRamSaveSectorLocations[i].data = (void*)(gSaveBlock1Ptr) + sSaveSlotLayout[i].offset;
gRamSaveSectorLocations[i].size = sSaveSlotLayout[i].size;
}
for (; i <= SECTOR_ID_PKMN_STORAGE_END; i++) //setting i to SECTOR_ID_PKMN_STORAGE_START does not match
{
gRamSaveSectorLocations[i].data = (void*)(gPokemonStoragePtr) + sSaveSlotLayout[i].offset;
gRamSaveSectorLocations[i].size = sSaveSlotLayout[i].size;
}
}
u8 HandleSavingData(u8 saveType)
{
u8 i;
u32 *backupVar = gTrainerHillVBlankCounter;
u8 *tempAddr;
gTrainerHillVBlankCounter = NULL;
UpdateSaveAddresses();
switch (saveType)
{
case SAVE_HALL_OF_FAME_ERASE_BEFORE:
// Unused. Erases the special save sectors (HOF, Trainer Hill, Recorded Battle)
// before overwriting HOF.
for (i = SECTOR_ID_HOF_1; i < SECTORS_COUNT; i++)
EraseFlashSector(i);
// fallthrough
case SAVE_HALL_OF_FAME:
if (GetGameStat(GAME_STAT_ENTERED_HOF) < 999)
IncrementGameStat(GAME_STAT_ENTERED_HOF);
// Write the full save slot first
CopyPartyAndObjectsToSave();
WriteSaveSectorOrSlot(FULL_SAVE_SLOT, gRamSaveSectorLocations);
// Save the Hall of Fame
tempAddr = gDecompressionBuffer;
HandleWriteSectorNBytes(SECTOR_ID_HOF_1, tempAddr, SECTOR_DATA_SIZE);
HandleWriteSectorNBytes(SECTOR_ID_HOF_2, tempAddr + SECTOR_DATA_SIZE, SECTOR_DATA_SIZE);
break;
case SAVE_NORMAL:
default:
CopyPartyAndObjectsToSave();
WriteSaveSectorOrSlot(FULL_SAVE_SLOT, gRamSaveSectorLocations);
break;
case SAVE_LINK:
case SAVE_LINK2:
// Used by link / Battle Frontier
// Write only SaveBlocks 1 and 2 (skips the PC)
CopyPartyAndObjectsToSave();
for(i = SECTOR_ID_SAVEBLOCK2; i <= SECTOR_ID_SAVEBLOCK1_END; i++)
HandleReplaceSector(i, gRamSaveSectorLocations);
for(i = SECTOR_ID_SAVEBLOCK2; i <= SECTOR_ID_SAVEBLOCK1_END; i++)
WriteSectorSecurityByte_NoOffset(i, gRamSaveSectorLocations);
break;
case SAVE_OVERWRITE_DIFFERENT_FILE:
// Erase Hall of Fame
for (i = SECTOR_ID_HOF_1; i < SECTORS_COUNT; i++)
EraseFlashSector(i);
// Overwrite save slot
CopyPartyAndObjectsToSave();
WriteSaveSectorOrSlot(FULL_SAVE_SLOT, gRamSaveSectorLocations);
break;
}
gTrainerHillVBlankCounter = backupVar;
return 0;
}
u8 TrySavingData(u8 saveType)
{
if (gFlashMemoryPresent != TRUE)
{
gSaveAttemptStatus = SAVE_STATUS_ERROR;
return SAVE_STATUS_ERROR;
}
HandleSavingData(saveType);
if (!gDamagedSaveSectors)
{
gSaveAttemptStatus = SAVE_STATUS_OK;
return SAVE_STATUS_OK;
}
else
{
DoSaveFailedScreen(saveType);
gSaveAttemptStatus = SAVE_STATUS_ERROR;
return SAVE_STATUS_ERROR;
}
}
bool8 LinkFullSave_Init(void)
{
if (gFlashMemoryPresent != TRUE)
return TRUE;
UpdateSaveAddresses();
CopyPartyAndObjectsToSave();
RestoreSaveBackupVarsAndIncrement(gRamSaveSectorLocations);
return FALSE;
}
bool8 LinkFullSave_WriteSector(void)
{
u8 status = HandleWriteIncrementalSector(NUM_SECTORS_PER_SLOT, gRamSaveSectorLocations);
if (gDamagedSaveSectors)
DoSaveFailedScreen(SAVE_NORMAL);
// In this case "error" either means that an actual error was encountered
// or that the given max sector has been reached (meaning it has finished successfully).
// If there was an actual error the save failed screen above will also be shown.
if (status == SAVE_STATUS_ERROR)
return TRUE;
else
return FALSE;
}
bool8 LinkFullSave_ReplaceLastSector(void)
{
HandleReplaceSectorAndVerify(NUM_SECTORS_PER_SLOT, gRamSaveSectorLocations);
if (gDamagedSaveSectors)
DoSaveFailedScreen(SAVE_NORMAL);
return FALSE;
}
bool8 LinkFullSave_SetLastSectorSecurity(void)
{
CopySectorSecurityByte(NUM_SECTORS_PER_SLOT, gRamSaveSectorLocations);
if (gDamagedSaveSectors)
DoSaveFailedScreen(SAVE_NORMAL);
return FALSE;
}
u8 WriteSaveBlock2(void)
{
if (gFlashMemoryPresent != TRUE)
return TRUE;
UpdateSaveAddresses();
CopyPartyAndObjectsToSave();
RestoreSaveBackupVars(gRamSaveSectorLocations);
// Because RestoreSaveBackupVars is called immediately prior, gIncrementalSectorId will always be 0 below,
// so this function only saves the first sector (SECTOR_ID_SAVEBLOCK2)
HandleReplaceSectorAndVerify(gIncrementalSectorId + 1, gRamSaveSectorLocations);
return FALSE;
}
// Used in conjunction with WriteSaveBlock2 to write both for certain link saves.
// This will be called repeatedly in a task, writing each sector of SaveBlock1 incrementally.
// It returns TRUE when finished.
bool8 WriteSaveBlock1Sector(void)
{
u8 finished = FALSE;
u16 sectorId = ++gIncrementalSectorId; // Because WriteSaveBlock2 will have been called prior, this will be SECTOR_ID_SAVEBLOCK1_START
if (sectorId <= SECTOR_ID_SAVEBLOCK1_END)
{
// Write a single sector of SaveBlock1
HandleReplaceSectorAndVerify(gIncrementalSectorId + 1, gRamSaveSectorLocations);
WriteSectorSecurityByte(sectorId, gRamSaveSectorLocations);
}
else
{
// Beyond SaveBlock1, don't write the sector.
// Does write 1 byte of the next sector's security field, but as these
// are the same for all valid sectors it doesn't matter.
WriteSectorSecurityByte(sectorId, gRamSaveSectorLocations);
finished = TRUE;
}
if (gDamagedSaveSectors)
DoSaveFailedScreen(SAVE_LINK);
return finished;
}
u8 LoadGameSave(u8 saveType)
{
u8 status;
if (gFlashMemoryPresent != TRUE)
{
gSaveFileStatus = SAVE_STATUS_NO_FLASH;
return SAVE_STATUS_ERROR;
}
UpdateSaveAddresses();
switch (saveType)
{
case SAVE_NORMAL:
default:
status = TryLoadSaveSlot(FULL_SAVE_SLOT, gRamSaveSectorLocations);
CopyPartyAndObjectsFromSave();
gSaveFileStatus = status;
gGameContinueCallback = 0;
break;
case SAVE_HALL_OF_FAME:
status = TryLoadSaveSector(SECTOR_ID_HOF_1, gDecompressionBuffer, SECTOR_DATA_SIZE);
if (status == SAVE_STATUS_OK)
status = TryLoadSaveSector(SECTOR_ID_HOF_2, &gDecompressionBuffer[SECTOR_DATA_SIZE], SECTOR_DATA_SIZE);
break;
}
return status;
}
u16 GetSaveBlocksPointersBaseOffset(void)
{
u16 i, slotOffset;
struct SaveSector* sector;
sector = gReadWriteSector = &gSaveDataBuffer;
if (gFlashMemoryPresent != TRUE)
return 0;
UpdateSaveAddresses();
GetSaveValidStatus(gRamSaveSectorLocations);
slotOffset = NUM_SECTORS_PER_SLOT * (gSaveCounter % NUM_SAVE_SLOTS);
for (i = 0; i < NUM_SECTORS_PER_SLOT; i++)
{
ReadFlashSector(i + slotOffset, gReadWriteSector);
// Base offset for SaveBlock2 is calculated using the trainer id
if (gReadWriteSector->id == SECTOR_ID_SAVEBLOCK2)
return sector->data[offsetof(struct SaveBlock2, playerTrainerId[0])] +
sector->data[offsetof(struct SaveBlock2, playerTrainerId[1])] +
sector->data[offsetof(struct SaveBlock2, playerTrainerId[2])] +
sector->data[offsetof(struct SaveBlock2, playerTrainerId[3])];
}
return 0;
}
u32 TryReadSpecialSaveSector(u8 sector, u8* dst)
{
s32 i;
s32 size;
u8* savData;
if (sector != SECTOR_ID_TRAINER_HILL && sector != SECTOR_ID_RECORDED_BATTLE)
return SAVE_STATUS_ERROR;
ReadFlash(sector, 0, (u8 *)&gSaveDataBuffer, SECTOR_SIZE);
if (*(u32*)(&gSaveDataBuffer.data[0]) != SPECIAL_SECTOR_SENTINEL)
return SAVE_STATUS_ERROR;
// Copies whole save sector except u32 counter
i = 0;
size = SECTOR_COUNTER_OFFSET - 1;
savData = &gSaveDataBuffer.data[4]; // data[4] to skip past SPECIAL_SECTOR_SENTINEL
for (; i <= size; i++)
dst[i] = savData[i];
return SAVE_STATUS_OK;
}
u32 TryWriteSpecialSaveSector(u8 sector, u8* src)
{
s32 i;
s32 size;
u8* savData;
void* savDataBuffer;
if (sector != SECTOR_ID_TRAINER_HILL && sector != SECTOR_ID_RECORDED_BATTLE)
return SAVE_STATUS_ERROR;
savDataBuffer = &gSaveDataBuffer;
*(u32*)(savDataBuffer) = SPECIAL_SECTOR_SENTINEL;
// Copies whole save sector except u32 counter
i = 0;
size = SECTOR_COUNTER_OFFSET - 1;
savData = &gSaveDataBuffer.data[4]; // data[4] to skip past SPECIAL_SECTOR_SENTINEL
for (; i <= size; i++)
savData[i] = src[i];
if (ProgramFlashSectorAndVerify(sector, savDataBuffer) != 0)
return SAVE_STATUS_ERROR;
return SAVE_STATUS_OK;
}
#define tState data[0]
#define tTimer data[1]
#define tInBattleTower data[2]
// Note that this is very different from TrySavingData(SAVE_LINK).
// Most notably it does save the PC data.
void Task_LinkFullSave(u8 taskId)
{
s16* data = gTasks[taskId].data;
switch (tState)
{
case 0:
gSoftResetDisabled = TRUE;
tState = 1;
break;
case 1:
SetLinkStandbyCallback();
tState = 2;
break;
case 2:
if (IsLinkTaskFinished())
{
if (!tInBattleTower)
SaveMapView();
tState = 3;
}
break;
case 3:
if (!tInBattleTower)
SetContinueGameWarpStatusToDynamicWarp();
LinkFullSave_Init();
tState = 4;
break;
case 4:
if (++tTimer == 5)
{
tTimer = 0;
tState = 5;
}
break;
case 5:
if (LinkFullSave_WriteSector())
tState = 6;
else
tState = 4; // Not finished, delay again
break;
case 6:
LinkFullSave_ReplaceLastSector();
tState = 7;
break;
case 7:
if (!tInBattleTower)
ClearContinueGameWarpStatus2();
SetLinkStandbyCallback();
tState = 8;
break;
case 8:
if (IsLinkTaskFinished())
{
LinkFullSave_SetLastSectorSecurity();
tState = 9;
}
break;
case 9:
SetLinkStandbyCallback();
tState = 10;
break;
case 10:
if (IsLinkTaskFinished())
tState++;
break;
case 11:
if (++tTimer > 5)
{
gSoftResetDisabled = FALSE;
DestroyTask(taskId);
}
break;
}
}
Reference in New Issue View Git Blame Copy Permalink