PKHeX/PKHeX.Core/Saves/SAV3.cs
Kurt 27cdcb8b0c Simplify SAV3 loading
Remove hardcoded chunk lengths array
Remove cached chunk index array
Handle new-game files correctly (all blocks present check).
Consistently call things sector instead of chunk or block.

Somehow there was a bug with my FRLG save file's box data, which now loads completely?? Neat
2021-03-16 23:32:16 -07:00

586 lines
22 KiB
C#

using System;
using System.Collections.Generic;
namespace PKHeX.Core
{
/// <summary>
/// Generation 3 <see cref="SaveFile"/> object.
/// </summary>
public abstract class SAV3 : SaveFile, ILangDeviantSave
{
protected internal sealed override string ShortSummary => $"{OT} ({Version}) - {PlayTimeString}";
public sealed override string Extension => ".sav";
public int SaveRevision => Japanese ? 0 : 1;
public string SaveRevisionString => Japanese ? "J" : "U";
public bool Japanese { get; }
public bool Korean => false;
// Similar to future games, the Generation 3 Mainline save files are comprised of separate objects:
// Object 1 - Small, containing misc configuration data & the Pokédex.
// Object 2 - Large, containing everything else that isn't PC Storage system data.
// Object 3 - Storage, containing all the data for the PC storage system.
// When the objects are serialized to the savedata, the game fragments each object and saves it to a sector.
// The main save data for a save file occupies 14 sectors; there are a total of two serialized main saves.
// After the serialized main save data, there is "extra data", for stuff like Hall of Fame and battle videos.
// Extra data is always at the same sector, while the main sectors rotate sectors within their region (on each successive save?).
private const int SIZE_SECTOR = 0x1000;
private const int SIZE_SECTOR_USED = 0xF80;
private const int COUNT_MAIN = 14; // sectors worth of data
private const int SIZE_MAIN = COUNT_MAIN * SIZE_SECTOR;
// There's no harm having buffers larger than their actual size (per format).
// A checksum consuming extra zeroes does not change the prior checksum result.
public readonly byte[] Small = new byte[1 * SIZE_SECTOR]; // [0x890 RS, 0xf24 FR/LG, 0xf2c E]
public readonly byte[] Large = new byte[4 * SIZE_SECTOR]; //3+[0xc40 RS, 0xee8 FR/LG, 0xf08 E]
public readonly byte[] Storage = new byte[9 * SIZE_SECTOR]; // [0x83D0]
private readonly int ActiveSlot;
protected SAV3(bool japanese) => Japanese = japanese;
protected SAV3(byte[] data) : base(data)
{
// Copy sector data to the allocated location
ReadSectors(data, ActiveSlot = GetActiveSlot(data));
// OT name is the first 8 bytes of Small. The game fills any unused characters with 0xFF.
// Japanese games are limited to 5 character OT names; INT 7 characters. +1 0xFF terminator.
// Since JPN games don't touch the last 2 bytes (alignment), they end up as zeroes!
Japanese = BitConverter.ToInt16(Small, 0x6) == 0;
}
private void ReadSectors(byte[] data, int group)
{
int start = group * SIZE_MAIN;
int end = start + SIZE_MAIN;
for (int ofs = start; ofs < end; ofs += SIZE_SECTOR)
{
var id = BitConverter.ToInt16(data, ofs + 0xFF4);
switch (id)
{
case >=5: Buffer.BlockCopy(data, ofs, Storage, (id - 5) * SIZE_SECTOR_USED, SIZE_SECTOR_USED); break;
case >=1: Buffer.BlockCopy(data, ofs, Large , (id - 1) * SIZE_SECTOR_USED, SIZE_SECTOR_USED); break;
default: Buffer.BlockCopy(data, ofs, Small , 0 , SIZE_SECTOR_USED); break;
}
}
}
private void WriteSectors(byte[] data, int group)
{
int start = group * SIZE_MAIN;
int end = start + SIZE_MAIN;
for (int ofs = start; ofs < end; ofs += SIZE_SECTOR)
{
var id = BitConverter.ToInt16(data, ofs + 0xFF4);
switch (id)
{
case >=5: Buffer.BlockCopy(Storage, (id - 5) * SIZE_SECTOR_USED, data, ofs, SIZE_SECTOR_USED); break;
case >=1: Buffer.BlockCopy(Large , (id - 1) * SIZE_SECTOR_USED, data, ofs, SIZE_SECTOR_USED); break;
default: Buffer.BlockCopy(Small , 0 , data, ofs, SIZE_SECTOR_USED); break;
}
}
}
/// <summary>
/// Checks the input data to see if all required sectors for the main save data are present for the <see cref="slot"/>.
/// </summary>
/// <param name="data">Data to check</param>
/// <param name="slot">Which main to check (primary or secondary)</param>
/// <param name="sector0">Offset of the sector that has the small object data</param>
public static bool IsAllMainSectorsPresent(byte[] data, int slot, out int sector0)
{
System.Diagnostics.Debug.Assert(slot is 0 or 1);
int start = SIZE_MAIN * slot;
int end = start + SIZE_MAIN;
int bitTrack = 0;
sector0 = 0;
for (int ofs = 0; ofs < end; ofs += SIZE_SECTOR)
{
var id = BitConverter.ToInt16(data, ofs + 0xFF4);
bitTrack |= (1 << id);
if (id == 0)
sector0 = ofs;
}
// all 14 fragments present
return bitTrack == 0b_0011_1111_1111_1111;
}
private static int GetActiveSlot(byte[] data)
{
if (data.Length == SaveUtil.SIZE_G3RAWHALF)
return 0;
var v0 = IsAllMainSectorsPresent(data, 0, out var sectorZero0);
var v1 = IsAllMainSectorsPresent(data, 1, out var sectorZero1);
if (!v0)
return v1 ? 1 : 0;
if (!v1)
return 0;
var count0 = BitConverter.ToUInt32(data, sectorZero0 + 0x0FFC);
var count1 = BitConverter.ToUInt32(data, sectorZero1 + 0x0FFC);
// don't care about 32bit overflow. a 10 second save would take 1,000 years to overflow!
return count1 > count0 ? 1 : 0;
}
protected sealed override byte[] GetFinalData()
{
// Copy Box data back
WriteSectors(Data, ActiveSlot);
return base.GetFinalData();
}
protected sealed override int SIZE_STORED => PokeCrypto.SIZE_3STORED;
protected sealed override int SIZE_PARTY => PokeCrypto.SIZE_3PARTY;
public sealed override PKM BlankPKM => new PK3();
public sealed override Type PKMType => typeof(PK3);
public sealed override int MaxMoveID => Legal.MaxMoveID_3;
public sealed override int MaxSpeciesID => Legal.MaxSpeciesID_3;
public sealed override int MaxAbilityID => Legal.MaxAbilityID_3;
public sealed override int MaxItemID => Legal.MaxItemID_3;
public sealed override int MaxBallID => Legal.MaxBallID_3;
public sealed override int MaxGameID => Legal.MaxGameID_3;
public sealed override IReadOnlyList<ushort> HeldItems => Legal.HeldItems_RS;
public sealed override int BoxCount => 14;
public sealed override int MaxEV => 255;
public sealed override int Generation => 3;
protected sealed override int GiftCountMax => 1;
public sealed override int OTLength => 7;
public sealed override int NickLength => 10;
public sealed override int MaxMoney => 999999;
public sealed override bool HasParty => true;
public sealed override bool IsPKMPresent(byte[] data, int offset) => PKX.IsPKMPresentGBA(data, offset);
protected sealed override PKM GetPKM(byte[] data) => new PK3(data);
protected sealed override byte[] DecryptPKM(byte[] data) => PokeCrypto.DecryptArray3(data);
protected sealed override byte[] BoxBuffer => Storage;
protected sealed override byte[] PartyBuffer => Large;
private const int COUNT_BOX = 14;
private const int COUNT_SLOTSPERBOX = 30;
// Checksums
protected sealed override void SetChecksums()
{
int start = ActiveSlot * SIZE_MAIN;
int end = start + SIZE_MAIN;
for (int ofs = start; ofs < end; ofs += SIZE_SECTOR)
{
ushort chk = Checksums.CheckSum32(Data, ofs, SIZE_SECTOR_USED);
BitConverter.GetBytes(chk).CopyTo(Data, ofs + 0xFF6);
}
if (State.BAK.Length < SaveUtil.SIZE_G3RAW) // don't update HoF for half-sizes
return;
// Hall of Fame Checksums
{
ushort chk = Checksums.CheckSum32(Data, 0x1C000, SIZE_SECTOR_USED);
BitConverter.GetBytes(chk).CopyTo(Data, 0x1CFF4);
}
{
ushort chk = Checksums.CheckSum32(Data, 0x1D000, SIZE_SECTOR_USED);
BitConverter.GetBytes(chk).CopyTo(Data, 0x1DFF4);
}
}
public sealed override bool ChecksumsValid
{
get
{
for (int i = 0; i < COUNT_MAIN; i++)
{
if (!IsSectorValid(i))
return false;
}
if (State.BAK.Length < SaveUtil.SIZE_G3RAW) // don't check HoF for half-sizes
return true;
if (!IsSectorValidExtra(0x1C000))
return false;
if (!IsSectorValidExtra(0x1D000))
return false;
return true;
}
}
private bool IsSectorValidExtra(int ofs)
{
ushort chk = Checksums.CheckSum32(Data, ofs, SIZE_SECTOR_USED);
return chk == BitConverter.ToUInt16(Data, ofs + 0xFF4);
}
private bool IsSectorValid(int sector)
{
int start = ActiveSlot * SIZE_MAIN;
int ofs = start + (sector * SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(Data, ofs, SIZE_SECTOR_USED);
return chk == BitConverter.ToUInt16(Data, ofs + 0xFF6);
}
public sealed override string ChecksumInfo
{
get
{
var list = new List<string>();
for (int i = 0; i < COUNT_MAIN; i++)
{
if (!IsSectorValid(i))
list.Add($"Sector {i} @ {i*SIZE_SECTOR:X5} invalid.");
}
if (State.BAK.Length > SaveUtil.SIZE_G3RAW) // don't check HoF for half-sizes
{
if (!IsSectorValidExtra(0x1C000))
list.Add("HoF first sector invalid.");
if (!IsSectorValidExtra(0x1D000))
list.Add("HoF second sector invalid.");
}
return list.Count != 0 ? string.Join(Environment.NewLine, list) : "Checksums are valid.";
}
}
public abstract uint SecurityKey { get; set; }
public sealed override string OT
{
get => GetString(Small, 0, 0x10);
set
{
int len = Japanese ? 5 : OTLength;
SetString(value, len, PadToSize: len, PadWith: 0xFF).CopyTo(Small, 0);
}
}
public sealed override int Gender
{
get => Small[8];
set => Small[8] = (byte)value;
}
public sealed override int TID
{
get => BitConverter.ToUInt16(Small, 0xA);
set => BitConverter.GetBytes((ushort)value).CopyTo(Small, 0xA);
}
public sealed override int SID
{
get => BitConverter.ToUInt16(Small, 0xC);
set => BitConverter.GetBytes((ushort)value).CopyTo(Small, 0xC);
}
public sealed override int PlayedHours
{
get => BitConverter.ToUInt16(Small, 0xE);
set => BitConverter.GetBytes((ushort)value).CopyTo(Small, 0xE);
}
public sealed override int PlayedMinutes
{
get => Small[0x10];
set => Small[0x10] = (byte)value;
}
public sealed override int PlayedSeconds
{
get => Small[0x11];
set => Small[0x11] = (byte)value;
}
public int PlayedFrames
{
get => Small[0x12];
set => Small[0x12] = (byte)value;
}
public sealed override bool GetEventFlag(int flagNumber)
{
if (flagNumber >= EventFlagMax)
throw new ArgumentException($"Event Flag to get ({flagNumber}) is greater than max ({EventFlagMax}).");
var start = EventFlag;
return GetFlag(start + (flagNumber >> 3), flagNumber & 7);
}
public sealed override void SetEventFlag(int flagNumber, bool value)
{
if (flagNumber >= EventFlagMax)
throw new ArgumentException($"Event Flag to set ({flagNumber}) is greater than max ({EventFlagMax}).");
var start = EventFlag;
SetFlag(start + (flagNumber >> 3), flagNumber & 7, value);
}
public sealed override bool GetFlag(int offset, int bitIndex) => FlagUtil.GetFlag(Large, offset, bitIndex);
public sealed override void SetFlag(int offset, int bitIndex, bool value) => FlagUtil.SetFlag(Large, offset, bitIndex, value);
public ushort GetEventConst(int index) => BitConverter.ToUInt16(Large, EventConst + (index * 2));
public void SetEventConst(int index, ushort value) => BitConverter.GetBytes(value).CopyTo(Large, EventConst + (index * 2));
public sealed override ushort[] GetEventConsts()
{
ushort[] Constants = new ushort[EventConstMax];
for (int i = 0; i < Constants.Length; i++)
Constants[i] = GetEventConst(i);
return Constants;
}
public sealed override void SetEventConsts(ushort[] value)
{
if (value.Length != EventConstMax)
return;
for (int i = 0; i < value.Length; i++)
SetEventConst(i, value[i]);
}
protected abstract int BadgeFlagStart { get; }
public abstract uint Coin { get; set; }
public int Badges
{
get
{
int startFlag = BadgeFlagStart;
int val = 0;
for (int i = 0; i < 8; i++)
{
if (GetEventFlag(startFlag + i))
val |= 1 << i;
}
return val;
}
set
{
int startFlag = BadgeFlagStart;
for (int i = 0; i < 8; i++)
SetEventFlag(startFlag + i, (value & (1 << i)) != 0);
}
}
public sealed override IReadOnlyList<InventoryPouch> Inventory
{
get
{
var pouch = GetItems();
foreach (var p in pouch)
{
if (p.Type != InventoryType.PCItems)
p.SecurityKey = SecurityKey;
}
return pouch.LoadAll(Large);
}
set => value.SaveAll(Large);
}
protected abstract InventoryPouch3[] GetItems();
protected abstract int DaycareSlotSize { get; }
public sealed override uint? GetDaycareEXP(int loc, int slot) => BitConverter.ToUInt32(Large, GetDaycareEXPOffset(slot));
public sealed override void SetDaycareEXP(int loc, int slot, uint EXP) => BitConverter.GetBytes(EXP).CopyTo(Large, GetDaycareEXPOffset(slot));
public sealed override bool? IsDaycareOccupied(int loc, int slot) => IsPKMPresent(Large, GetDaycareSlotOffset(loc, slot));
public sealed override void SetDaycareOccupied(int loc, int slot, bool occupied) { /* todo */ }
public sealed override int GetDaycareSlotOffset(int loc, int slot) => DaycareOffset + (slot * DaycareSlotSize);
protected abstract int EggEventFlag { get; }
public sealed override bool? IsDaycareHasEgg(int loc) => GetEventFlag(EggEventFlag);
public sealed override void SetDaycareHasEgg(int loc, bool hasEgg) => SetEventFlag(EggEventFlag, hasEgg);
protected abstract int GetDaycareEXPOffset(int slot);
#region Storage
public sealed override int GetBoxOffset(int box) => Box + 4 + (SIZE_STORED * box * COUNT_SLOTSPERBOX);
public sealed override int CurrentBox
{
get => Storage[0];
set => Storage[0] = (byte)value;
}
public sealed override int GetBoxWallpaper(int box)
{
if (box > COUNT_BOX)
return box;
int offset = GetBoxWallpaperOffset(box);
return Storage[offset];
}
private const int COUNT_BOXNAME = 8 + 1;
public sealed override void SetBoxWallpaper(int box, int value)
{
if (box > COUNT_BOX)
return;
int offset = GetBoxWallpaperOffset(box);
Storage[offset] = (byte)value;
}
protected sealed override int GetBoxWallpaperOffset(int box)
{
int offset = GetBoxOffset(COUNT_BOX);
offset += (COUNT_BOX * COUNT_BOXNAME) + box;
return offset;
}
public sealed override string GetBoxName(int box)
{
int offset = GetBoxOffset(COUNT_BOX);
return StringConverter3.GetString3(Storage, offset + (box * COUNT_BOXNAME), COUNT_BOXNAME, Japanese);
}
public sealed override void SetBoxName(int box, string value)
{
int offset = GetBoxOffset(COUNT_BOX);
SetString(value, COUNT_BOXNAME - 1).CopyTo(Storage, offset + (box * COUNT_BOXNAME));
}
#endregion
#region Pokédex
protected sealed override void SetDex(PKM pkm)
{
int species = pkm.Species;
if (!CanSetDex(species))
return;
switch (species)
{
case (int)Species.Unown when !GetSeen(species): // Unown
DexPIDUnown = pkm.PID;
break;
case (int)Species.Spinda when !GetSeen(species): // Spinda
DexPIDSpinda = pkm.PID;
break;
}
SetCaught(species, true);
SetSeen(species, true);
}
private bool CanSetDex(int species)
{
if (species <= 0)
return false;
if (species > MaxSpeciesID)
return false;
return true;
}
public uint DexPIDUnown { get => BitConverter.ToUInt32(Small, PokeDex + 0x4); set => BitConverter.GetBytes(value).CopyTo(Small, PokeDex + 0x4); }
public uint DexPIDSpinda { get => BitConverter.ToUInt32(Small, PokeDex + 0x8); set => BitConverter.GetBytes(value).CopyTo(Small, PokeDex + 0x8); }
public int DexUnownForm => PKX.GetUnownForm(DexPIDUnown);
public sealed override bool GetCaught(int species)
{
int bit = species - 1;
int ofs = bit >> 3;
int caughtOffset = PokeDex + 0x10;
return FlagUtil.GetFlag(Small, caughtOffset + ofs, bit & 7);
}
public sealed override void SetCaught(int species, bool caught)
{
int bit = species - 1;
int ofs = bit >> 3;
int caughtOffset = PokeDex + 0x10;
FlagUtil.SetFlag(Small, caughtOffset + ofs, bit & 7, caught);
}
public sealed override bool GetSeen(int species)
{
int bit = species - 1;
int ofs = bit >> 3;
int seenOffset = PokeDex + 0x44;
return FlagUtil.GetFlag(Small, seenOffset + ofs, bit & 7);
}
protected abstract int SeenOffset2 { get; }
protected abstract int SeenOffset3 { get; }
public sealed override void SetSeen(int species, bool seen)
{
int bit = species - 1;
int ofs = bit >> 3;
int seenOffset = PokeDex + 0x44;
FlagUtil.SetFlag(Small, seenOffset + ofs, bit & 7, seen);
FlagUtil.SetFlag(Large, SeenOffset2 + ofs, bit & 7, seen);
FlagUtil.SetFlag(Large, SeenOffset3 + ofs, bit & 7, seen);
}
public byte PokedexSort
{
get => Small[PokeDex + 0x01];
set => Small[PokeDex + 0x01] = value;
}
public byte PokedexMode
{
get => Small[PokeDex + 0x01];
set => Small[PokeDex + 0x01] = value;
}
public byte PokedexNationalMagicRSE
{
get => Small[PokeDex + 0x02];
set => Small[PokeDex + 0x02] = value;
}
public byte PokedexNationalMagicFRLG
{
get => Small[PokeDex + 0x03];
set => Small[PokeDex + 0x03] = value;
}
protected const int PokedexNationalUnlockRSE = 0xDA;
protected const int PokedexNationalUnlockFRLG = 0xDA;
protected const ushort PokedexNationalUnlockWorkRSE = 0x0302;
protected const ushort PokedexNationalUnlockWorkFRLG = 0x6258;
public abstract bool NationalDex { get; set; }
#endregion
public sealed override string GetString(byte[] data, int offset, int length) => StringConverter3.GetString3(data, offset, length, Japanese);
public sealed override byte[] SetString(string value, int maxLength, int PadToSize = 0, ushort PadWith = 0)
{
if (PadToSize == 0)
PadToSize = maxLength + 1;
return StringConverter3.SetString3(value, maxLength, Japanese, PadToSize, PadWith);
}
protected abstract int MailOffset { get; }
public int GetMailOffset(int index) => (index * Mail3.SIZE) + MailOffset;
public abstract string EBerryName { get; }
public abstract bool IsEBerryEngima { get; }
public byte[] GetHallOfFameData()
{
// HoF Data is split across two sectors
byte[] data = new byte[SIZE_SECTOR_USED * 2];
Buffer.BlockCopy(Data, 0x1C000, data, 0 , SIZE_SECTOR_USED);
Buffer.BlockCopy(Data, 0x1D000, data, SIZE_SECTOR_USED, SIZE_SECTOR_USED);
return data;
}
public void SetHallOfFameData(byte[] value)
{
if (value.Length != SIZE_SECTOR_USED * 2)
throw new ArgumentException("Invalid size", nameof(value));
// HoF Data is split across two sav sectors
Buffer.BlockCopy(value, 0 , Data, 0x1C000, SIZE_SECTOR_USED);
Buffer.BlockCopy(value, SIZE_SECTOR_USED, Data, 0x1D000, SIZE_SECTOR_USED);
}
}
}