PKHeX/PKHeX.Core/Saves/SAV3.cs

697 lines
27 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using static System.Buffers.Binary.BinaryPrimitives;
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;
2018-09-15 05:37:47 +00:00
// 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_USED]; // [0x890 RS, 0xf24 FR/LG, 0xf2c E]
public readonly byte[] Large = new byte[4 * SIZE_SECTOR_USED]; //3+[0xc40 RS, 0xee8 FR/LG, 0xf08 E]
public readonly byte[] Storage = new byte[9 * SIZE_SECTOR_USED]; // [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 = ReadInt16LittleEndian(Small.AsSpan(0x6)) == 0;
}
private void ReadSectors(ReadOnlySpan<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 = ReadInt16LittleEndian(data[(ofs + 0xFF4)..]);
switch (id)
{
case >=5: data.Slice(ofs, SIZE_SECTOR_USED).CopyTo(Storage.AsSpan((id - 5) * SIZE_SECTOR_USED)); break;
case >=1: data.Slice(ofs, SIZE_SECTOR_USED).CopyTo(Large .AsSpan((id - 1) * SIZE_SECTOR_USED)); break;
default: data.Slice(ofs, SIZE_SECTOR_USED).CopyTo(Small .AsSpan(0 )); break;
}
}
}
private void WriteSectors(Span<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 = ReadInt16LittleEndian(data[(ofs + 0xFF4)..]);
switch (id)
{
case >=5: Storage.AsSpan((id - 5) * SIZE_SECTOR_USED, SIZE_SECTOR_USED).CopyTo(data[ofs..]); break;
case >=1: Large .AsSpan((id - 1) * SIZE_SECTOR_USED, SIZE_SECTOR_USED).CopyTo(data[ofs..]); break;
default: Small .AsSpan(0 , SIZE_SECTOR_USED).CopyTo(data[ofs..]); 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(ReadOnlySpan<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 = start; ofs < end; ofs += SIZE_SECTOR)
{
var span = data[ofs..];
var id = ReadInt16LittleEndian(span[0xFF4..]);
bitTrack |= (1 << id);
if (id == 0)
sector0 = ofs;
}
// all 14 fragments present
return bitTrack == 0b_0011_1111_1111_1111;
}
2016-07-04 05:21:45 +00:00
private static int GetActiveSlot(ReadOnlySpan<byte> data)
2018-09-15 05:37:47 +00:00
{
if (data.Length == SaveUtil.SIZE_G3RAWHALF)
return 0;
2018-09-15 05:37:47 +00:00
var v0 = IsAllMainSectorsPresent(data, 0, out var sectorZero0);
var v1 = IsAllMainSectorsPresent(data, 1, out var sectorZero1);
if (!v0)
return v1 ? 1 : 0;
if (!v1)
2018-09-15 05:37:47 +00:00
return 0;
var count0 = ReadUInt32LittleEndian(data[(sectorZero0 + 0x0FFC)..]);
var count1 = ReadUInt32LittleEndian(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;
2018-09-15 05:37:47 +00:00
}
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(ReadOnlySpan<byte> data) => PKX.IsPKMPresentGBA(data);
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)
{
var sector = Data.AsSpan(ofs, SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(sector[..SIZE_SECTOR_USED]);
WriteUInt16LittleEndian(sector[0xFF6..], chk);
}
if (State.BAK.Length < SaveUtil.SIZE_G3RAW) // don't update HoF for half-sizes
return;
// Hall of Fame Checksums
{
var sector2 = Data.AsSpan(0x1C000, SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(sector2[..SIZE_SECTOR_USED]);
WriteUInt16LittleEndian(sector2[0xFF4..], chk);
}
{
var sector2 = Data.AsSpan(0x1D000, SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(sector2[..SIZE_SECTOR_USED]);
WriteUInt16LittleEndian(sector2[0xFF4..], chk);
}
}
2018-09-15 05:37:47 +00:00
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;
}
}
2018-09-15 05:37:47 +00:00
private bool IsSectorValidExtra(int ofs)
{
var sector = Data.AsSpan(ofs, SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(sector[..SIZE_SECTOR_USED]);
return chk == ReadUInt16LittleEndian(sector[0xFF4..]);
}
private bool IsSectorValid(int sectorIndex)
{
int start = ActiveSlot * SIZE_MAIN;
int ofs = start + (sectorIndex * SIZE_SECTOR);
var sector = Data.AsSpan(ofs, SIZE_SECTOR);
ushort chk = Checksums.CheckSum32(sector[..SIZE_SECTOR_USED]);
return chk == ReadUInt16LittleEndian(sector[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.AsSpan(0, 8));
set
{
int len = Japanese ? 5 : OTLength;
SetString(Small.AsSpan(0, len), value.AsSpan(), len, StringConverterOption.ClearFF);
}
}
2018-09-15 05:37:47 +00:00
public sealed override int Gender
{
get => Small[8];
set => Small[8] = (byte)value;
}
2018-09-15 05:37:47 +00:00
public sealed override int TID
{
get => ReadUInt16LittleEndian(Small.AsSpan(0xA));
set => WriteUInt16LittleEndian(Small.AsSpan(0xA), (ushort)value);
}
2018-09-15 05:37:47 +00:00
public sealed override int SID
{
get => ReadUInt16LittleEndian(Small.AsSpan(0xC));
set => WriteUInt16LittleEndian(Small.AsSpan(0xC), (ushort)value);
}
2018-09-15 05:37:47 +00:00
public sealed override int PlayedHours
{
get => ReadUInt16LittleEndian(Small.AsSpan(0xE));
set => WriteUInt16LittleEndian(Small.AsSpan(0xE), (ushort)value);
}
2018-09-15 05:37:47 +00:00
public sealed override int PlayedMinutes
{
get => Small[0x10];
set => Small[0x10] = (byte)value;
}
2018-09-15 05:37:47 +00:00
public sealed override int PlayedSeconds
{
get => Small[0x11];
set => Small[0x11] = (byte)value;
}
2018-09-15 05:37:47 +00:00
public int PlayedFrames
{
get => Small[0x12];
set => Small[0x12] = (byte)value;
}
2018-09-15 05:37:47 +00:00
public sealed override bool GetEventFlag(int flagNumber)
{
2018-09-28 03:01:34 +00:00
if (flagNumber >= EventFlagMax)
throw new ArgumentOutOfRangeException(nameof(flagNumber), $"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)
{
2018-09-28 03:01:34 +00:00
if (flagNumber >= EventFlagMax)
throw new ArgumentOutOfRangeException(nameof(flagNumber), $"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) => ReadUInt16LittleEndian(Large.AsSpan(EventConst + (index * 2)));
public void SetEventConst(int index, ushort value) => WriteUInt16LittleEndian(Large.AsSpan(EventConst + (index * 2)), value);
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(ReadOnlySpan<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; }
2017-04-16 06:14:07 +00:00
public int Badges
{
get
{
2018-07-08 00:01:47 +00:00
int startFlag = BadgeFlagStart;
int val = 0;
for (int i = 0; i < 8; i++)
2018-09-15 05:37:47 +00:00
{
2018-07-08 00:01:47 +00:00
if (GetEventFlag(startFlag + i))
val |= 1 << i;
2018-09-15 05:37:47 +00:00
}
2018-07-08 00:01:47 +00:00
return val;
2017-04-16 06:14:07 +00:00
}
set
{
2018-07-08 00:01:47 +00:00
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();
2018-09-15 05:37:47 +00:00
protected abstract int DaycareSlotSize { get; }
public sealed override uint? GetDaycareEXP(int loc, int slot) => ReadUInt32LittleEndian(Large.AsSpan(GetDaycareEXPOffset(slot)));
public sealed override void SetDaycareEXP(int loc, int slot, uint EXP) => WriteUInt32LittleEndian(Large.AsSpan(GetDaycareEXPOffset(slot)), EXP);
public sealed override bool? IsDaycareOccupied(int loc, int slot) => IsPKMPresent(Large.AsSpan(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);
2018-09-15 05:37:47 +00:00
protected abstract int GetDaycareEXPOffset(int slot);
2018-09-15 05:37:47 +00:00
#region Storage
public sealed override int GetBoxOffset(int box) => Box + 4 + (SIZE_STORED * box * COUNT_SLOTSPERBOX);
2018-09-15 05:37:47 +00:00
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;
}
2018-09-15 05:37:47 +00:00
protected sealed override int GetBoxWallpaperOffset(int box)
{
int offset = GetBoxOffset(COUNT_BOX);
offset += (COUNT_BOX * COUNT_BOXNAME) + box;
return offset;
}
2018-09-15 05:37:47 +00:00
public sealed override string GetBoxName(int box)
{
int offset = GetBoxOffset(COUNT_BOX);
return StringConverter3.GetString(Storage.AsSpan(offset + (box * COUNT_BOXNAME), COUNT_BOXNAME), Japanese);
}
2018-09-15 05:37:47 +00:00
public sealed override void SetBoxName(int box, string value)
{
int offset = GetBoxOffset(COUNT_BOX);
var dest = Storage.AsSpan(offset + (box * COUNT_BOXNAME), COUNT_BOXNAME);
SetString(dest, value.AsSpan(), COUNT_BOXNAME - 1, StringConverterOption.ClearZero);
}
#endregion
2018-09-15 05:37:47 +00:00
#region Pokédex
protected sealed override void SetDex(PKM pkm)
2016-07-04 05:21:45 +00:00
{
int species = pkm.Species;
2021-06-05 00:29:55 +00:00
if (species is 0 or > Legal.MaxSpeciesID_3)
return;
if (pkm.IsEgg)
2016-07-04 05:21:45 +00:00
return;
2018-05-12 15:13:39 +00:00
2018-07-13 05:07:44 +00:00
switch (species)
{
2019-06-01 17:22:49 +00:00
case (int)Species.Unown when !GetSeen(species): // Unown
2018-07-13 05:07:44 +00:00
DexPIDUnown = pkm.PID;
break;
2019-06-01 17:22:49 +00:00
case (int)Species.Spinda when !GetSeen(species): // Spinda
2018-07-13 05:07:44 +00:00
DexPIDSpinda = pkm.PID;
break;
}
SetCaught(species, true);
SetSeen(species, true);
}
2018-09-15 05:37:47 +00:00
public uint DexPIDUnown { get => ReadUInt32LittleEndian(Small.AsSpan(PokeDex + 0x4)); set => WriteUInt32LittleEndian(Small.AsSpan(PokeDex + 0x4), value); }
public uint DexPIDSpinda { get => ReadUInt32LittleEndian(Small.AsSpan(PokeDex + 0x8)); set => WriteUInt32LittleEndian(Small.AsSpan(PokeDex + 0x8), value); }
2018-07-13 05:07:44 +00:00
public int DexUnownForm => PKX.GetUnownForm(DexPIDUnown);
public sealed override bool GetCaught(int species)
{
int bit = species - 1;
int ofs = bit >> 3;
2018-07-13 05:07:44 +00:00
int caughtOffset = PokeDex + 0x10;
return FlagUtil.GetFlag(Small, caughtOffset + ofs, bit & 7);
}
2018-09-15 05:37:47 +00:00
public sealed override void SetCaught(int species, bool caught)
{
int bit = species - 1;
int ofs = bit >> 3;
2018-07-13 05:07:44 +00:00
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;
2018-07-13 05:07:44 +00:00
int seenOffset = PokeDex + 0x44;
return FlagUtil.GetFlag(Small, seenOffset + ofs, bit & 7);
}
2018-09-15 05:37:47 +00:00
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);
2016-07-04 05:21:45 +00:00
}
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 byte PokedexNationalUnlockRSE = 0xDA;
protected const byte PokedexNationalUnlockFRLG = 0xDA;
protected const ushort PokedexNationalUnlockWorkRSE = 0x0302;
protected const ushort PokedexNationalUnlockWorkFRLG = 0x6258;
public abstract bool NationalDex { get; set; }
#endregion
2018-09-15 05:37:47 +00:00
public sealed override string GetString(ReadOnlySpan<byte> data) => StringConverter3.GetString(data, Japanese);
2018-09-15 05:37:47 +00:00
public sealed override int SetString(Span<byte> destBuffer, ReadOnlySpan<char> value, int maxLength, StringConverterOption option)
{
return StringConverter3.SetString(destBuffer, value, maxLength, Japanese, option);
}
protected abstract int MailOffset { get; }
public int GetMailOffset(int index) => (index * Mail3.SIZE) + MailOffset;
public Mail GetMail(int mailIndex)
2021-05-22 16:28:04 +00:00
{
var ofs = GetMailOffset(mailIndex);
2021-05-22 16:28:04 +00:00
var data = Large.Slice(ofs, Mail3.SIZE);
return new Mail3(data, ofs, Japanese);
}
public abstract string EBerryName { get; }
public abstract bool IsEBerryEngima { get; }
public abstract MysteryEvent3 MysteryEvent { get; set; }
public byte[] GetHallOfFameData()
{
// HoF Data is split across two sectors
byte[] data = new byte[SIZE_SECTOR_USED * 2];
Data.AsSpan(0x1C000, SIZE_SECTOR_USED).CopyTo(data.AsSpan(0 , SIZE_SECTOR_USED));
Data.AsSpan(0x1D000, SIZE_SECTOR_USED).CopyTo(data.AsSpan(SIZE_SECTOR_USED, SIZE_SECTOR_USED));
return data;
}
public void SetHallOfFameData(ReadOnlySpan<byte> value)
{
if (value.Length != SIZE_SECTOR_USED * 2)
throw new ArgumentException("Invalid size", nameof(value));
// HoF Data is split across two sav sectors
Span<byte> savedata = Data;
value[..SIZE_SECTOR_USED].CopyTo(savedata[0x1C000..]);
value.Slice(SIZE_SECTOR_USED, SIZE_SECTOR_USED).CopyTo(savedata[0x1D000..]);
}
public bool IsCorruptPokedexFF() => MemoryMarshal.Read<ulong>(Small.AsSpan(0xAC)) == ulong.MaxValue;
2021-04-01 20:43:06 +00:00
public override void CopyChangesFrom(SaveFile sav)
{
SetData(sav.Data, 0);
var s3 = (SAV3)sav;
SetData(Small, s3.Small, 0);
SetData(Large, s3.Large, 0);
SetData(Storage, s3.Storage, 0);
}
#region External Connections
protected abstract int ExternalEventData { get; }
protected int ExternalEventFlags => ExternalEventData + 0x14;
public uint ColosseumRaw1
{
get => ReadUInt32LittleEndian(Large.AsSpan(ExternalEventData + 7));
set => WriteUInt32LittleEndian(Large.AsSpan(ExternalEventData + 7), value);
}
public uint ColosseumRaw2
{
get => ReadUInt32LittleEndian(Large.AsSpan(ExternalEventData + 11));
set => WriteUInt32LittleEndian(Large.AsSpan(ExternalEventData + 11), value);
}
/// <summary>
/// PokéCoupons stored by Pokémon Colosseum and XD from Mt. Battle runs. Earned PokéCoupons are also added to <see cref="ColosseumCouponsTotal"/>.
/// </summary>
/// <remarks>Colosseum/XD caps this at 9,999,999, but will read up to 16,777,215.</remarks>
public uint ColosseumCoupons
{
get => ColosseumRaw1 >> 8;
set => ColosseumRaw1 = (value << 8) | (ColosseumRaw1 & 0xFF);
}
/// <summary> Master Ball from JP Colosseum Bonus Disc; for reaching 30,000 <see cref="ColosseumCouponsTotal"/> </summary>
public bool ColosseumPokeCouponTitleGold
{
get => (ColosseumRaw2 & (1 << 0)) != 0;
set => ColosseumRaw2 = (ColosseumRaw2 & (1 << 0)) | ((value ? 1u : 0) << 0);
}
/// <summary> Light Ball Pikachu from JP Colosseum Bonus Disc; for reaching 5000 <see cref="ColosseumCouponsTotal"/> </summary>
public bool ColosseumPokeCouponTitleSilver
{
get => (ColosseumRaw2 & (1 << 1)) != 0;
set => ColosseumRaw2 = (ColosseumRaw2 & (1 << 1)) | ((value ? 1u : 0) << 1);
}
/// <summary> PP Max from JP Colosseum Bonus Disc; for reaching 2500 <see cref="ColosseumCouponsTotal"/> </summary>
public bool ColosseumPokeCouponTitleBronze
{
get => (ColosseumRaw2 & (1 << 2)) != 0;
set => ColosseumRaw2 = (ColosseumRaw2 & (1 << 2)) | ((value ? 1u : 0) << 2);
}
/// <summary> Received Celebi Gift from JP Colosseum Bonus Disc </summary>
public bool ColosseumReceivedAgeto
{
get => (ColosseumRaw2 & (1 << 3)) != 0;
set => ColosseumRaw2 = (ColosseumRaw2 & (1 << 3)) | ((value ? 1u : 0) << 3);
}
/// <summary>
/// Used by the JP Colosseum bonus disc. Determines PokéCoupon rank to distribute rewards. Unread in International games.
/// </summary>
/// <remarks>
/// Colosseum/XD caps this at 9,999,999.
/// </remarks>
public uint ColosseumCouponsTotal
{
get => ColosseumRaw2 >> 8;
set => ColosseumRaw2 = (value << 8) | (ColosseumRaw2 & 0xFF);
}
/// <summary> Indicates if this save has connected to RSBOX and triggered the free False Swipe Swablu Egg giveaway. </summary>
public bool HasUsedRSBOX
{
get => GetFlag(ExternalEventFlags + 0, 0);
set => SetFlag(ExternalEventFlags + 0, 0, value);
}
/// <summary>
/// 1 for ExtremeSpeed Zigzagoon (at 100 deposited), 2 for Pay Day Skitty (at 500 deposited), 3 for Surf Pichu (at 1499 deposited)
/// </summary>
public int RSBoxDepositEggsUnlocked
{
get => (Large[ExternalEventFlags] >> 1) & 3;
set => Large[ExternalEventFlags] = (byte)((Large[ExternalEventFlags] & ~(3 << 1)) | ((value & 3) << 1));
}
/// <summary> Received Jirachi Gift from Colosseum Bonus Disc </summary>
public bool HasReceivedWishmkrJirachi
{
get => GetFlag(ExternalEventFlags + 2, 0);
set => SetFlag(ExternalEventFlags + 2, 0, value);
}
#endregion
}
}