2
0
Fork 0
mirror of https://github.com/kwsch/PKHeX synced 2024-12-21 01:43:10 +00:00
PKHeX/PKHeX.Core/Saves/SAV2.cs
Kurt a1f2f8708a Refactoring
pass identifier on cloning pkm
remove unnecessary ref for passing Data (not modifying array reference)
const some magic numbers
2017-12-27 16:36:24 -08:00

607 lines
23 KiB
C#

using System;
using System.Linq;
namespace PKHeX.Core
{
/// <summary>
/// Generation 2 <see cref="SaveFile"/> object.
/// </summary>
public sealed class SAV2 : SaveFile
{
public override string BAKName => $"{FileName} [{OT} ({Version}) - {PlayTimeString}].bak";
public override string Filter => "SAV File|*.sav|All Files|*.*";
public override string Extension => ".sav";
public override string[] PKMExtensions => PKM.Extensions.Where(f =>
{
int gen = f.Last() - 0x30;
if (Korean)
return gen == 2;
return 1 <= gen && gen <= 2;
}).ToArray();
public SAV2(byte[] data = null, GameVersion versionOverride = GameVersion.Any)
{
Data = data ?? new byte[SaveUtil.SIZE_G2RAW_U];
BAK = (byte[])Data.Clone();
Exportable = !Data.All(z => z == 0);
if (data == null)
Version = GameVersion.C;
else if (versionOverride != GameVersion.Any)
Version = versionOverride;
else
Version = SaveUtil.GetIsG2SAV(Data);
if (Version == GameVersion.Invalid)
return;
Japanese = SaveUtil.GetIsG2SAVJ(Data) != GameVersion.Invalid;
if (!Japanese)
Korean = SaveUtil.GetIsG2SAVK(Data) != GameVersion.Invalid;
Box = Data.Length;
Array.Resize(ref Data, Data.Length + SIZE_RESERVED);
Party = GetPartyOffset(0);
Personal = Version == GameVersion.GS ? PersonalTable.GS : PersonalTable.C;
Offsets = new SAV2Offsets(this);
LegalItems = Legal.Pouch_Items_GSC;
LegalBalls = Legal.Pouch_Ball_GSC;
LegalKeyItems = Version == GameVersion.C ? Legal.Pouch_Key_C : Legal.Pouch_Key_GS;
LegalTMHMs = Legal.Pouch_TMHM_GSC;
HeldItems = Legal.HeldItems_GSC;
// Stash boxes after the save file's end.
byte[] TempBox = new byte[SIZE_STOREDBOX];
for (int i = 0; i < BoxCount; i++)
{
if (i < (Japanese ? 6 : 7))
Array.Copy(Data, 0x4000 + i * (TempBox.Length + 2), TempBox, 0, TempBox.Length);
else
Array.Copy(Data, 0x6000 + (i - (Japanese ? 6 : 7)) * (TempBox.Length + 2), TempBox, 0, TempBox.Length);
PokemonList2 PL2 = new PokemonList2(TempBox, Japanese ? PokemonList2.CapacityType.StoredJP : PokemonList2.CapacityType.Stored, Japanese);
for (int j = 0; j < PL2.Pokemon.Length; j++)
{
if (j < PL2.Count)
{
byte[] pkDat = new PokemonList2(PL2[j]).GetBytes();
pkDat.CopyTo(Data, Data.Length - SIZE_RESERVED + i * SIZE_BOX + j * SIZE_STORED);
}
else
{
byte[] pkDat = new byte[PokemonList2.GetDataLength(PokemonList2.CapacityType.Single, Japanese)];
pkDat.CopyTo(Data, Data.Length - SIZE_RESERVED + i * SIZE_BOX + j * SIZE_STORED);
}
}
}
Array.Copy(Data, Offsets.CurrentBox, TempBox, 0, TempBox.Length);
PokemonList2 curBoxPL = new PokemonList2(TempBox, Japanese ? PokemonList2.CapacityType.StoredJP : PokemonList2.CapacityType.Stored, Japanese);
for (int i = 0; i < curBoxPL.Pokemon.Length; i++)
{
if (i < curBoxPL.Count)
{
byte[] pkDat = new PokemonList2(curBoxPL[i]).GetBytes();
pkDat.CopyTo(Data, Data.Length - SIZE_RESERVED + CurrentBox * SIZE_BOX + i * SIZE_STORED);
}
else
{
byte[] pkDat = new byte[PokemonList2.GetDataLength(PokemonList2.CapacityType.Single, Japanese)];
pkDat.CopyTo(Data, Data.Length - SIZE_RESERVED + CurrentBox * SIZE_BOX + i * SIZE_STORED);
}
}
byte[] TempParty = new byte[PokemonList2.GetDataLength(PokemonList2.CapacityType.Party, Japanese)];
Array.Copy(Data, Offsets.Party, TempParty, 0, TempParty.Length);
PokemonList2 partyList = new PokemonList2(TempParty, PokemonList2.CapacityType.Party, Japanese);
for (int i = 0; i < partyList.Pokemon.Length; i++)
{
if (i < partyList.Count)
{
byte[] pkDat = new PokemonList2(partyList[i]).GetBytes();
pkDat.CopyTo(Data, GetPartyOffset(i));
}
else
{
byte[] pkDat = new byte[PokemonList2.GetDataLength(PokemonList2.CapacityType.Single, Japanese)];
pkDat.CopyTo(Data, GetPartyOffset(i));
}
}
// Daycare currently undocumented for all Gen II games.
// Enable Pokedex editing
PokeDex = 0;
EventFlag = Offsets.EventFlag;
if (!Exportable)
ClearBoxes();
}
private const int SIZE_RESERVED = 0x8000; // unpacked box data
public bool Korean { get; }
private readonly SAV2Offsets Offsets;
protected override byte[] Write(bool DSV)
{
for (int i = 0; i < BoxCount; i++)
{
PokemonList2 boxPL = new PokemonList2(Japanese ? PokemonList2.CapacityType.StoredJP : PokemonList2.CapacityType.Stored, Japanese);
int slot = 0;
for (int j = 0; j < boxPL.Pokemon.Length; j++)
{
PK2 boxPK = (PK2) GetPKM(GetData(GetBoxOffset(i) + j*SIZE_STORED, SIZE_STORED));
if (boxPK.Species > 0)
boxPL[slot++] = boxPK;
}
if (i < (Japanese ? 6 : 7))
boxPL.GetBytes().CopyTo(Data, 0x4000 + i * (SIZE_STOREDBOX + 2));
else
boxPL.GetBytes().CopyTo(Data, 0x6000 + (i - (Japanese ? 6 : 7)) * (SIZE_STOREDBOX + 2));
if (i == CurrentBox)
boxPL.GetBytes().CopyTo(Data, Offsets.CurrentBox);
}
PokemonList2 partyPL = new PokemonList2(PokemonList2.CapacityType.Party, Japanese);
int pSlot = 0;
for (int i = 0; i < 6; i++)
{
PK2 partyPK = (PK2)GetPKM(GetData(GetPartyOffset(i), SIZE_STORED));
if (partyPK.Species > 0)
partyPL[pSlot++] = partyPK;
}
partyPL.GetBytes().CopyTo(Data, Offsets.Party);
SetChecksums();
if (Japanese)
{
switch (Version)
{
case GameVersion.GS: Array.Copy(Data, Offsets.Trainer1, Data, 0x7209, 0xC83); break;
case GameVersion.C: Array.Copy(Data, Offsets.Trainer1, Data, 0x7209, 0xADA); break;
}
}
else if (Korean)
{
// Calculate oddball checksum
ushort sum = 0;
ushort[][] offsetpairs =
{
new ushort[] {0x106B, 0x1533},
new ushort[] {0x1534, 0x1A12},
new ushort[] {0x1A13, 0x1C38},
new ushort[] {0x3DD8, 0x3F79},
new ushort[] {0x7E39, 0x7E6A},
};
foreach (ushort[] p in offsetpairs)
for (int i = p[0]; i < p[1]; i++)
sum += Data[i];
BitConverter.GetBytes(sum).CopyTo(Data, 0x7E6B);
}
else
{
switch (Version)
{
case GameVersion.GS:
Array.Copy(Data, 0x2009, Data, 0x15C7, 0x222F - 0x2009);
Array.Copy(Data, 0x222F, Data, 0x3D69, 0x23D9 - 0x222F);
Array.Copy(Data, 0x23D9, Data, 0x0C6B, 0x2856 - 0x23D9);
Array.Copy(Data, 0x2856, Data, 0x7E39, 0x288A - 0x2856);
Array.Copy(Data, 0x288A, Data, 0x10E8, 0x2D69 - 0x288A);
break;
case GameVersion.C:
Array.Copy(Data, 0x2009, Data, 0x1209, 0xB7A);
break;
}
}
byte[] outData = new byte[Data.Length - SIZE_RESERVED];
Array.Copy(Data, outData, outData.Length);
return outData;
}
// Configuration
public override SaveFile Clone() { return new SAV2(Write(DSV: false)); }
public override int SIZE_STORED => Japanese ? PKX.SIZE_2JLIST : PKX.SIZE_2ULIST;
protected override int SIZE_PARTY => Japanese ? PKX.SIZE_2JLIST : PKX.SIZE_2ULIST;
public override PKM BlankPKM => new PK2(jp: Japanese);
public override Type PKMType => typeof(PK2);
private int SIZE_BOX => BoxSlotCount*SIZE_STORED;
private int SIZE_STOREDBOX => PokemonList2.GetDataLength(Japanese ? PokemonList2.CapacityType.StoredJP : PokemonList2.CapacityType.Stored, Japanese);
public override int MaxMoveID => Legal.MaxMoveID_2;
public override int MaxSpeciesID => Legal.MaxSpeciesID_2;
public override int MaxAbilityID => Legal.MaxAbilityID_2;
public override int MaxItemID => Legal.MaxItemID_2;
public override int MaxBallID => 0; // unused
public override int MaxGameID => 99; // unused
public override int MaxMoney => 999999;
public override int MaxCoins => 9999;
// not correct, but whole contains. Data[EventFlag+0x22F]=Data[0x1A2F] means repel count.
protected override int EventFlagMax => Version == GameVersion.C ? 0x230 << 3 : base.EventFlagMax;
protected override int EventConstMax => Version == GameVersion.C ? 0 : base.EventConstMax;
public override int BoxCount => Japanese ? 9 : 14;
public override int MaxEV => 65535;
public override int MaxIV => 15;
public override int Generation => 2;
protected override int GiftCountMax => 0;
public override int OTLength => Japanese || Korean ? 5 : 7;
public override int NickLength => Japanese || Korean ? 5 : 10;
public override int BoxSlotCount => Japanese ? 30 : 20;
public override bool HasParty => true;
public override bool HasNamableBoxes => true;
// Checksums
private ushort GetChecksum()
{
return (ushort)Data.Skip(Offsets.Trainer1).Take(Offsets.AccumulatedChecksumEnd - Offsets.Trainer1 + 1).Sum(a => a);
}
protected override void SetChecksums()
{
ushort accum = GetChecksum();
BitConverter.GetBytes(accum).CopyTo(Data, Offsets.OverallChecksumPosition);
BitConverter.GetBytes(accum).CopyTo(Data, Offsets.OverallChecksumPosition2);
}
public override bool ChecksumsValid
{
get
{
ushort accum = GetChecksum();
ushort actual = BitConverter.ToUInt16(Data, Offsets.OverallChecksumPosition);
return accum == actual;
}
}
public override string ChecksumInfo => ChecksumsValid ? "Checksum valid." : "Checksum invalid";
// Trainer Info
public override GameVersion Version { get; protected set; }
public override string OT
{
get => GetString(Offsets.Trainer1 + 2, (Korean ? 2 : 1) * OTLength);
set => SetString(value, (Korean ? 2 : 1) * OTLength).CopyTo(Data, Offsets.Trainer1 + 2);
}
public override int Gender
{
get => Version == GameVersion.C ? Data[Offsets.Gender] : 0;
set
{
if (Version != GameVersion.C)
return;
Data[Offsets.Gender] = (byte) value;
Data[Offsets.Palette] = (byte) value;
}
}
public override ushort TID
{
get => BigEndian.ToUInt16(Data, Offsets.Trainer1); set => BigEndian.GetBytes(value).CopyTo(Data, Offsets.Trainer1);
}
public override ushort SID
{
get => 0;
set { }
}
public override int PlayedHours
{
get => BigEndian.ToUInt16(Data, Offsets.TimePlayed);
set => BigEndian.GetBytes((ushort)value).CopyTo(Data, Offsets.TimePlayed);
}
public override int PlayedMinutes
{
get => Data[Offsets.TimePlayed + 2];
set => Data[Offsets.TimePlayed + 2] = (byte)value;
}
public override int PlayedSeconds
{
get => Data[Offsets.TimePlayed + 3];
set => Data[Offsets.TimePlayed + 3] = (byte)value;
}
public int Badges
{
get => BitConverter.ToUInt16(Data, Offsets.JohtoBadges);
set { if (value < 0) return; BitConverter.GetBytes((ushort)value).CopyTo(Data, Offsets.JohtoBadges); }
}
private byte Options
{
get => Data[Offsets.Options];
set => Data[Offsets.Options] = value;
}
public bool BattleEffects
{
get => (Options & 0x80) == 0;
set => Options = (byte)((Options & 0x7F) | (value ? 0 : 0x80));
}
public bool BattleStyleSwitch
{
get => (Options & 0x40) == 0;
set => Options = (byte)((Options & 0xBF) | (value ? 0 : 0x40));
}
public int Sound
{
get => (Options & 0x30) >> 4;
set
{
var new_sound = value;
if (new_sound > 0)
new_sound = 2; // Stereo
if (new_sound < 0)
new_sound = 0; // Mono
Options = (byte)((Options & 0xCF) | (new_sound << 4));
}
}
public int TextSpeed
{
get => Options & 0x7;
set
{
var new_speed = value;
if (new_speed > 7)
new_speed = 7;
if (new_speed < 0)
new_speed = 0;
Options = (byte)((Options & 0xF8) | new_speed);
}
}
public override uint Money
{
get => BigEndian.ToUInt32(Data, Offsets.Money - 1) & 0xFFFFFF;
set
{
byte[] data = BigEndian.GetBytes((uint) Math.Min(value, MaxMoney));
Array.Copy(data, 1, Data, Offsets.Money, 3);
}
}
public uint Coin
{
get => BigEndian.ToUInt16(Data, Offsets.Money + 7);
set
{
value = (ushort)Math.Min(value, MaxCoins);
BigEndian.GetBytes((ushort)value).CopyTo(Data, Offsets.Money + 7);
}
}
private readonly ushort[] LegalItems, LegalKeyItems, LegalBalls, LegalTMHMs;
public override InventoryPouch[] Inventory
{
get
{
var pouch = new[]
{
new InventoryPouch(InventoryType.TMHMs, LegalTMHMs, 99, Offsets.PouchTMHM, 57),
new InventoryPouch(InventoryType.Items, LegalItems, 99, Offsets.PouchItem, 20),
new InventoryPouch(InventoryType.KeyItems, LegalKeyItems, 99, Offsets.PouchKey, 26),
new InventoryPouch(InventoryType.Balls, LegalBalls, 99, Offsets.PouchBall, 12),
new InventoryPouch(InventoryType.PCItems, LegalItems.Concat(LegalKeyItems).Concat(LegalBalls).Concat(LegalTMHMs).ToArray(), 99, Offsets.PouchPC, 50)
};
foreach (var p in pouch)
{
p.GetPouchG1(Data);
}
return pouch;
}
set
{
foreach (var p in value)
{
int ofs = 0;
for (int i = 0; i < p.Count; i++)
{
while (p.Items[ofs].Count == 0)
ofs++;
p.Items[i] = p.Items[ofs++];
}
while (ofs < p.Items.Length)
p.Items[ofs++] = new InventoryItem();
p.SetPouchG1(Data);
}
}
}
public override int GetDaycareSlotOffset(int loc, int slot)
{
return Daycare;
}
public override uint? GetDaycareEXP(int loc, int slot)
{
return null;
}
public override bool? IsDaycareOccupied(int loc, int slot)
{
return null;
}
public override void SetDaycareEXP(int loc, int slot, uint EXP)
{
}
public override void SetDaycareOccupied(int loc, int slot, bool occupied)
{
}
// Storage
public override int PartyCount
{
get => Data[Offsets.Party]; protected set => Data[Offsets.Party] = (byte)value;
}
public override int GetBoxOffset(int box)
{
return Data.Length - SIZE_RESERVED + box * SIZE_BOX;
}
public override int GetPartyOffset(int slot)
{
return Data.Length - SIZE_RESERVED + BoxCount * SIZE_BOX + slot * SIZE_STORED;
}
public override int CurrentBox
{
get => Data[Offsets.CurrentBoxIndex] & 0x7F; set => Data[Offsets.CurrentBoxIndex] = (byte)((Data[Offsets.OtherCurrentBox] & 0x80) | (value & 0x7F));
}
public override string GetBoxName(int box)
{
int len = Korean ? 17 : 9;
return GetString(Offsets.BoxNames + box * len, len);
}
public override void SetBoxName(int box, string value)
{
int len = Korean ? 17 : 9;
var data = SetString(value, len, len, 0x50);
SetData(data, Offsets.BoxNames + box * len);
}
public override PKM GetPKM(byte[] data)
{
if (data.Length == SIZE_STORED)
return new PokemonList2(data, PokemonList2.CapacityType.Single, Japanese)[0];
return new PK2(data);
}
public override byte[] DecryptPKM(byte[] data)
{
return data;
}
// Pokédex
protected override void SetDex(PKM pkm)
{
int species = pkm.Species;
if (!CanSetDex(species))
return;
SetCaught(pkm.Species, true);
SetSeen(pkm.Species, true);
}
private bool CanSetDex(int species)
{
if (species <= 0)
return false;
if (species > MaxSpeciesID)
return false;
if (Version == GameVersion.Unknown)
return false;
return true;
}
public override void SetSeen(int species, bool seen)
{
int bit = species - 1;
int ofs = bit >> 3;
SetFlag(Offsets.PokedexSeen + ofs, bit & 7, seen);
}
public override void SetCaught(int species, bool caught)
{
int bit = species - 1;
int ofs = bit >> 3;
SetFlag(Offsets.PokedexCaught + ofs, bit & 7, caught);
if (caught && species == 201)
SetUnownFormFlags();
}
private void SetUnownFormFlags()
{
// Give all Unown caught to prevent a crash on pokedex view
for (int i = 1; i <= 26; i++)
Data[Offsets.PokedexSeen + 0x1F + i] = (byte)i;
if (UnownFirstSeen == 0) // Invalid
UnownFirstSeen = 1; // A
}
/// <summary>
/// Toggles the availability of Unown letter groups in the Wild
/// </summary>
/// <remarks>
/// Max value of 0x0F, 4 bitflags
/// 1 lsh 0: A, B, C, D, E, F, G, H, I, J, K
/// 1 lsh 1: L, M, N, O, P, Q, R
/// 1 lsh 2: S, T, U, V, W
/// 1 lsh 3: X, Y, Z
/// </remarks>
public int UnownUnlocked
{
get => Data[Offsets.PokedexSeen + 0x1F + 27];
set => Data[Offsets.PokedexSeen + 0x1F + 27] = (byte)value;
}
/// <summary>
/// Unlocks all Unown letters/forms in the wild.
/// </summary>
public void UnownUnlockAll() => UnownUnlocked = 0x0F; // all 4 bitflags
/// <summary>
/// Flag that determines if Unown Letters are available in the wild: A, B, C, D, E, F, G, H, I, J, K
/// </summary>
public bool UnownUnlocked0
{
get => (UnownUnlocked & 1 << 0) == 1 << 0;
set => UnownUnlocked |= 1 << 0;
}
/// <summary>
/// Flag that determines if Unown Letters are available in the wild: L, M, N, O, P, Q, R
/// </summary>
public bool UnownUnlocked1
{
get => (UnownUnlocked & 1 << 1) == 1 << 1;
set => UnownUnlocked |= 1 << 1;
}
/// <summary>
/// Flag that determines if Unown Letters are available in the wild: S, T, U, V, W
/// </summary>
public bool UnownUnlocked2
{
get => (UnownUnlocked & 1 << 2) == 1 << 2;
set => UnownUnlocked |= 1 << 2;
}
/// <summary>
/// Flag that determines if Unown Letters are available in the wild: X, Y, Z
/// </summary>
public bool UnownUnlocked3
{
get => (UnownUnlocked & 1 << 3) == 1 << 3;
set => UnownUnlocked |= 1 << 3;
}
/// <summary>
/// Chooses which Unown sprite to show in the regular Pokédex View
/// </summary>
public int UnownFirstSeen
{
get => Data[Offsets.PokedexSeen + 0x1F + 28];
set => Data[Offsets.PokedexSeen + 0x1F + 28] = (byte)value;
}
public override bool GetSeen(int species)
{
int bit = species - 1;
int ofs = bit >> 3;
return GetFlag(Offsets.PokedexSeen + ofs, bit & 7);
}
public override bool GetCaught(int species)
{
int bit = species - 1;
int ofs = bit >> 3;
return GetFlag(Offsets.PokedexCaught + ofs, bit & 7);
}
// Misc
public ushort ResetKey => GetResetKey();
private ushort GetResetKey()
{
var val = (TID >> 8) + (TID & 0xFF) + ((Money >> 16) & 0xFF) + ((Money >> 8) & 0xFF) + (Money & 0xFF);
var ot = Data.Skip(Offsets.Trainer1 + 2).TakeWhile((z, i) => i < 5 && z != 0x50);
var tr = ot.Sum(z => z);
return (ushort)(val + tr);
}
public override string GetString(int Offset, int Count)
{
if (Korean)
return StringConverter.GetString2KOR(Data, Offset, Count);
return StringConverter.GetString1(Data, Offset, Count, Japanese);
}
public override byte[] SetString(string value, int maxLength, int PadToSize = 0, ushort PadWith = 0)
{
if (Korean)
return StringConverter.SetString2KOR(value, maxLength);
return StringConverter.SetString1(value, maxLength, Japanese);
}
}
}