PKHeX/PKHeX.Core/Saves/SAV6.cs
Kurt 7d39b70d91 Fix wc7 deletion
shift down logic does not apply for array writes; the setter sets empty
slots to fill all required slots
Closes #1142
2017-05-16 21:29:34 -07:00

1022 lines
41 KiB
C#

using System;
using System.Linq;
using System.Text;
namespace PKHeX.Core
{
public sealed class SAV6 : SaveFile
{
// Save Data Attributes
public override string BAKName => $"{FileName} [{OT} ({Version}) - {LastSavedTime}].bak";
public override string Filter => "Main SAV|*.*";
public override string Extension => "";
public SAV6(byte[] data = null)
{
Data = data == null ? new byte[SaveUtil.SIZE_G6ORAS] : (byte[])data.Clone();
BAK = (byte[])Data.Clone();
Exportable = !Data.SequenceEqual(new byte[Data.Length]);
// Load Info
getBlockInfo();
getSAVOffsets();
HeldItems = ORAS ? Legal.HeldItem_AO : Legal.HeldItem_XY;
Personal = ORAS ? PersonalTable.AO : PersonalTable.XY;
if (!Exportable)
resetBoxes();
}
// Configuration
public override SaveFile Clone() { return new SAV6(Data); }
public override int SIZE_STORED => PKX.SIZE_6STORED;
public override int SIZE_PARTY => PKX.SIZE_6PARTY;
public override PKM BlankPKM => new PK6();
public override Type PKMType => typeof(PK6);
public override int BoxCount => 31;
public override int MaxEV => 252;
public override int Generation => 6;
protected override int GiftCountMax => 24;
protected override int GiftFlagMax => 0x100 * 8;
protected override int EventFlagMax => 8 * 0x180;
protected override int EventConstMax => (EventFlag - EventConst) / 2;
public override int OTLength => 12;
public override int NickLength => 12;
public override int MaxMoveID => XY ? Legal.MaxMoveID_6_XY : Legal.MaxMoveID_6_AO;
public override int MaxSpeciesID => Legal.MaxSpeciesID_6;
public override int MaxItemID => XY ? Legal.MaxItemID_6_XY : Legal.MaxItemID_6_AO;
public override int MaxAbilityID => XY ? Legal.MaxAbilityID_6_XY : Legal.MaxAbilityID_6_AO;
public override int MaxBallID => Legal.MaxBallID_6;
public override int MaxGameID => Legal.MaxGameID_6; // OR
// Feature Overrides
public override bool HasGeolocation => true;
// Blocks & Offsets
private int BlockInfoOffset;
private BlockInfo[] Blocks;
private void getBlockInfo()
{
BlockInfoOffset = Data.Length - 0x200 + 0x10;
if (BitConverter.ToUInt32(Data, BlockInfoOffset) != SaveUtil.BEEF)
BlockInfoOffset -= 0x200; // No savegames have more than 0x3D blocks, maybe in the future?
int count = (Data.Length - BlockInfoOffset - 0x8) / 8;
BlockInfoOffset += 4;
Blocks = new BlockInfo[count];
int CurrentPosition = 0;
for (int i = 0; i < Blocks.Length; i++)
{
Blocks[i] = new BlockInfo
{
Offset = CurrentPosition,
Length = BitConverter.ToInt32(Data, BlockInfoOffset + 0 + 8 * i),
ID = BitConverter.ToUInt16(Data, BlockInfoOffset + 4 + 8 * i),
Checksum = BitConverter.ToUInt16(Data, BlockInfoOffset + 6 + 8 * i)
};
// Expand out to nearest 0x200
CurrentPosition += Blocks[i].Length % 0x200 == 0 ? Blocks[i].Length : 0x200 - Blocks[i].Length % 0x200 + Blocks[i].Length;
if ((Blocks[i].ID != 0) || i == 0) continue;
count = i;
break;
}
// Fix Final Array Lengths
Array.Resize(ref Blocks, count);
}
protected override void setChecksums()
{
// Check for invalid block lengths
if (Blocks.Length < 3) // arbitrary...
{
Console.WriteLine("Not enough blocks ({0}), aborting setChecksums", Blocks.Length);
return;
}
// Apply checksums
for (int i = 0; i < Blocks.Length; i++)
{
if (Blocks[i].Length + Blocks[i].Offset > Data.Length)
{ Console.WriteLine("Block {0} has invalid offset/length value.", i); return; }
byte[] array = new byte[Blocks[i].Length];
Array.Copy(Data, Blocks[i].Offset, array, 0, array.Length);
BitConverter.GetBytes(SaveUtil.ccitt16(array)).CopyTo(Data, BlockInfoOffset + 6 + i * 8);
}
}
public override bool ChecksumsValid
{
get
{
for (int i = 0; i < Blocks.Length; i++)
{
if (Blocks[i].Length + Blocks[i].Offset > Data.Length)
return false;
byte[] array = new byte[Blocks[i].Length];
Array.Copy(Data, Blocks[i].Offset, array, 0, array.Length);
if (SaveUtil.ccitt16(array) != BitConverter.ToUInt16(Data, BlockInfoOffset + 6 + i * 8))
return false;
}
return true;
}
}
public override string ChecksumInfo
{
get
{
int invalid = 0;
string rv = "";
for (int i = 0; i < Blocks.Length; i++)
{
if (Blocks[i].Length + Blocks[i].Offset > Data.Length)
return $"Block {i} Invalid Offset/Length.";
byte[] array = new byte[Blocks[i].Length];
Array.Copy(Data, Blocks[i].Offset, array, 0, array.Length);
if (SaveUtil.ccitt16(array) == BitConverter.ToUInt16(Data, BlockInfoOffset + 6 + i * 8))
continue;
invalid++;
rv += $"Invalid: {i:X2} @ Region {Blocks[i].Offset:X5}" + Environment.NewLine;
}
// Return Outputs
rv += $"SAV: {Blocks.Length - invalid}/{Blocks.Length + Environment.NewLine}";
return rv;
}
}
public override ulong? Secure1
{
get => BitConverter.ToUInt64(Data, BlockInfoOffset - 0x14);
set => BitConverter.GetBytes(value ?? 0).CopyTo(Data, BlockInfoOffset - 0x14);
}
public override ulong? Secure2
{
get => BitConverter.ToUInt64(Data, BlockInfoOffset - 0xC);
set => BitConverter.GetBytes(value ?? 0).CopyTo(Data, BlockInfoOffset - 0xC);
}
private void getSAVOffsets()
{
if (ORASDEMO)
{
/* 00: */ Item = 0x00000;
/* 01: */ ItemInfo = 0x00C00; // Select Bound Items
/* 02: */ AdventureInfo = 0x00E00;
/* 03: */ Trainer1 = 0x01000;
/* 04: */ // = 0x01200; [00004] // ???
/* 05: */ PlayTime = 0x01400;
/* 06: */ // = 0x01600; [00024] // FFFFFFFF
/* 07: */ // = 0x01800; [02100] // Overworld Data
/* 08: */ Trainer2 = 0x03A00;
/* 09: */ TrainerCard = 0x03C00;
/* 10: */ Party = 0x03E00;
/* 11: */ EventConst = 0x04600; EventFlag = EventConst + 0x2FC;
/* 12: */ // = 0x04C00; [00004] // 87B1A23F const
/* 13: */ // = 0x04E00; [00048] // Repel Info, (Swarm?) and other overworld info
/* 14: */ SUBE = 0x05000;
/* 15: */ PSSStats = 0x05400;
OFS_PouchHeldItem = Item + 0;
OFS_PouchKeyItem = Item + 0x640;
OFS_PouchTMHM = Item + 0x7C0;
OFS_PouchMedicine = Item + 0x970;
OFS_PouchBerry = Item + 0xA70;
}
else if (XY)
{
Puff = 0x00000;
Item = 0x00400;
ItemInfo = 0x1000;
AdventureInfo = 0x01200;
Trainer1 = 0x1400;
PlayTime = 0x1800;
Accessories = 0x1A00;
Trainer2 = 0x4200;
PCLayout = 0x4400;
BattleBox = 0x04A00;
PSS = 0x05000;
TrainerCard = 0x14000;
Party = 0x14200;
EventConst = 0x14A00;
PSSStats = 0x1E400;
PokeDex = 0x15000;
Fused = 0x16000;
OPower = 0x16A00;
GTS = 0x17800;
HoF = 0x19400;
MaisonStats = 0x1B1C0;
Daycare = 0x1B200;
BerryField = 0x1B800;
WondercardFlags = 0x1BC00;
SUBE = 0x1D890;
SuperTrain = 0x1F200;
LinkInfo = 0x1FE00;
Box = 0x22600;
JPEG = 0x57200;
PCBackgrounds = PCLayout + 0x41E;
PCFlags = PCLayout + 0x43D;
LastViewedBox = PCLayout + 0x43F;
EventFlag = EventConst + 0x2FC;
PokeDexLanguageFlags = PokeDex + 0x3C8;
Spinda = PokeDex + 0x648;
WondercardData = WondercardFlags + 0x100;
OFS_PouchHeldItem = Item + 0;
OFS_PouchKeyItem = Item + 0x640;
OFS_PouchTMHM = Item + 0x7C0;
OFS_PouchMedicine = Item + 0x968;
OFS_PouchBerry = Item + 0xA68;
}
else if (ORAS)
{
Puff = 0x00000;
Item = 0x00400;
ItemInfo = 0x1000;
AdventureInfo = 0x01200;
Trainer1 = 0x01400;
PlayTime = 0x1800;
Accessories = 0x1A00;
Trainer2 = 0x04200;
PCLayout = 0x04400;
BattleBox = 0x04A00;
PSS = 0x05000;
TrainerCard = 0x14000;
Party = 0x14200;
EventConst = 0x14A00;
PokeDex = 0x15000;
Fused = 0x16A00;
OPower = 0x17400;
GTS = 0x18200;
HoF = 0x19E00;
MaisonStats = 0x1BBC0;
Daycare = 0x1BC00;
BerryField = 0x1C400;
WondercardFlags = 0x1CC00;
SUBE = 0x1D890;
PSSStats = 0x1F400;
SuperTrain = 0x20200;
LinkInfo = 0x20E00;
Contest = 0x23600;
SecretBase = 0x23A00;
EonTicket = 0x319B8;
Box = 0x33000;
JPEG = 0x67C00;
PCBackgrounds = PCLayout + 0x41E;
PCFlags = PCLayout + 0x43D;
LastViewedBox = PCLayout + 0x43F;
EventFlag = EventConst + 0x2FC;
PokeDexLanguageFlags = PokeDex + 0x400;
Spinda = PokeDex + 0x680;
EncounterCount = PokeDex + 0x686;
WondercardData = WondercardFlags + 0x100;
Daycare2 = Daycare + 0x1F0;
OFS_PouchHeldItem = Item + 0;
OFS_PouchKeyItem = Item + 0x640;
OFS_PouchTMHM = Item + 0x7C0;
OFS_PouchMedicine = Item + 0x970;
OFS_PouchBerry = Item + 0xA70;
}
else // Empty input
{
Party = 0x0;
Box = Party + SIZE_PARTY * 6 + 0x1000;
}
}
// Private Only
private int Item { get; set; } = int.MinValue;
private int AdventureInfo { get; set; } = int.MinValue;
private int Trainer2 { get; set; } = int.MinValue;
private int LastViewedBox { get; set; } = int.MinValue;
private int WondercardFlags { get; set; } = int.MinValue;
private int PlayTime { get; set; } = int.MinValue;
private int JPEG { get; set; } = int.MinValue;
private int ItemInfo { get; set; } = int.MinValue;
private int Daycare2 { get; set; } = int.MinValue;
private int LinkInfo { get; set; } = int.MinValue;
// Accessible as SAV6
public int TrainerCard { get; private set; } = 0x14000;
public int PCFlags { get; private set; } = int.MinValue;
public int PSSStats { get; private set; } = int.MinValue;
public int MaisonStats { get; private set; } = int.MinValue;
public int EonTicket { get; private set; } = int.MinValue;
public int PCBackgrounds { get; private set; } = int.MinValue;
public int Contest { get; private set; } = int.MinValue;
public int Accessories { get; private set; } = int.MinValue;
public int PokeDexLanguageFlags { get; private set; } = int.MinValue;
public int Spinda { get; private set; } = int.MinValue;
public int EncounterCount { get; private set; } = int.MinValue;
public override GameVersion Version
{
get
{
switch (Game)
{
case 24: return GameVersion.X;
case 25: return GameVersion.Y;
case 26: return GameVersion.AS;
case 27: return GameVersion.OR;
}
return GameVersion.Unknown;
}
}
// Player Information
public override ushort TID
{
get => BitConverter.ToUInt16(Data, TrainerCard + 0);
set => BitConverter.GetBytes(value).CopyTo(Data, TrainerCard + 0);
}
public override ushort SID
{
get => BitConverter.ToUInt16(Data, TrainerCard + 2);
set => BitConverter.GetBytes(value).CopyTo(Data, TrainerCard + 2);
}
public override int Game
{
get => Data[TrainerCard + 4];
set => Data[TrainerCard + 4] = (byte)value;
}
public override int Gender
{
get => Data[TrainerCard + 5];
set => Data[TrainerCard + 5] = (byte)value;
}
public override int MultiplayerSpriteID
{
get => Data[TrainerCard + 7];
set => Data[TrainerCard + 7] = (byte)value;
}
public override int GameSyncIDSize => 16; // 64 bits
public override string GameSyncID
{
get
{
var data = Data.Skip(TrainerCard + 8).Take(GameSyncIDSize / 2).Reverse().ToArray();
return BitConverter.ToString(data).Replace("-", "");
}
set
{
if (value == null)
return;
if (value.Length > GameSyncIDSize)
return;
Enumerable.Range(0, value.Length)
.Where(x => x % 2 == 0)
.Reverse()
.Select(x => Convert.ToByte(value.Substring(x, 2), 16))
.ToArray().CopyTo(Data, TrainerCard + 8);
}
}
public override int SubRegion
{
get => Data[TrainerCard + 0x26];
set => Data[TrainerCard + 0x26] = (byte)value;
}
public override int Country
{
get => Data[TrainerCard + 0x27];
set => Data[TrainerCard + 0x27] = (byte)value;
}
public override int ConsoleRegion
{
get => Data[TrainerCard + 0x2C];
set => Data[TrainerCard + 0x2C] = (byte)value;
}
public override int Language
{
get => Data[TrainerCard + 0x2D];
set => Data[TrainerCard + 0x2D] = (byte)value;
}
public override string OT
{
get => getString(TrainerCard + 0x48, 0x1A);
set => setString(value, OTLength).CopyTo(Data, TrainerCard + 0x48);
}
public string OT_Nick
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x62, 0x1A));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x62);
}
public string Saying1
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x7C + 0x22 * 0, 0x22));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x7C + 0x22 * 0);
}
public string Saying2
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x7C + 0x22 * 1, 0x22));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x7C + 0x22 * 1);
}
public string Saying3
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x7C + 0x22 * 2, 0x22));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x7C + 0x22 * 2);
}
public string Saying4
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x7C + 0x22 * 3, 0x22));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x7C + 0x22 * 3);
}
public string Saying5
{
get => Util.TrimFromZero(Encoding.Unicode.GetString(Data, TrainerCard + 0x7C + 0x22 * 4, 0x22));
set => Encoding.Unicode.GetBytes(value.PadRight(value.Length + 1, '\0')).CopyTo(Data, TrainerCard + 0x7C + 0x22 * 4);
}
public int M
{
get => BitConverter.ToUInt16(Data, Trainer1 + 0x02);
set => BitConverter.GetBytes((ushort)value).CopyTo(Data, Trainer1 + 0x02);
}
public float X
{
get => BitConverter.ToSingle(Data, Trainer1 + 0x10) / 18;
set => BitConverter.GetBytes(value * 18).CopyTo(Data, Trainer1 + 0x10);
}
public float Z
{
get => BitConverter.ToSingle(Data, Trainer1 + 0x14);
set => BitConverter.GetBytes(value).CopyTo(Data, Trainer1 + 0x14);
}
public float Y
{
get => BitConverter.ToSingle(Data, Trainer1 + 0x18) / 18;
set => BitConverter.GetBytes(value * 18).CopyTo(Data, Trainer1 + 0x18);
}
public int Style
{
get => Data[Trainer1 + 0x14D];
set => Data[Trainer1 + 0x14D] = (byte)value;
}
public override uint Money
{
get => BitConverter.ToUInt32(Data, Trainer2 + 0x8);
set => BitConverter.GetBytes(value).CopyTo(Data, Trainer2 + 0x8);
}
public int Badges
{
get => Data[Trainer2 + 0xC];
set => Data[Trainer2 + 0xC] = (byte)value;
}
public int BP
{
get
{
int offset = Trainer2 + 0x3C;
if (ORAS) offset -= 0xC; // 0x30
return BitConverter.ToUInt16(Data, offset);
}
set
{
int offset = Trainer2 + 0x3C;
if (ORAS) offset -= 0xC; // 0x30
BitConverter.GetBytes((ushort)value).CopyTo(Data, offset);
}
}
public int Vivillon
{
get
{
int offset = Trainer2 + 0x50;
if (ORAS) offset -= 0xC; // 0x44
return Data[offset];
}
set
{
int offset = Trainer2 + 0x50;
if (ORAS) offset -= 0xC; // 0x44
Data[offset] = (byte)value;
}
}
public override int PlayedHours
{
get => BitConverter.ToUInt16(Data, PlayTime);
set => BitConverter.GetBytes((ushort)value).CopyTo(Data, PlayTime);
}
public override int PlayedMinutes
{
get => Data[PlayTime + 2];
set => Data[PlayTime + 2] = (byte)value;
}
public override int PlayedSeconds
{
get => Data[PlayTime + 3];
set => Data[PlayTime + 3] = (byte)value;
}
private uint LastSaved { get => BitConverter.ToUInt32(Data, PlayTime + 0x4); set => BitConverter.GetBytes(value).CopyTo(Data, PlayTime + 0x4); }
private int LastSavedYear { get => (int)(LastSaved & 0xFFF); set => LastSaved = LastSaved & 0xFFFFF000 | (uint)value; }
private int LastSavedMonth { get => (int)(LastSaved >> 12 & 0xF); set => LastSaved = LastSaved & 0xFFFF0FFF | ((uint)value & 0xF) << 12; }
private int LastSavedDay { get => (int)(LastSaved >> 16 & 0x1F); set => LastSaved = LastSaved & 0xFFE0FFFF | ((uint)value & 0x1F) << 16; }
private int LastSavedHour { get => (int)(LastSaved >> 21 & 0x1F); set => LastSaved = LastSaved & 0xFC1FFFFF | ((uint)value & 0x1F) << 21; }
private int LastSavedMinute { get => (int)(LastSaved >> 26 & 0x3F); set => LastSaved = LastSaved & 0x03FFFFFF | ((uint)value & 0x3F) << 26; }
private string LastSavedTime => $"{LastSavedYear:0000}{LastSavedMonth:00}{LastSavedDay:00}{LastSavedHour:00}{LastSavedMinute:00}";
public DateTime? LastSavedDate
{
get => !Util.IsDateValid(LastSavedYear, LastSavedMonth, LastSavedDay)
? (DateTime?)null
: new DateTime(LastSavedYear, LastSavedMonth, LastSavedDay, LastSavedHour, LastSavedMinute, 0);
set
{
// Only update the properties if a value is provided.
if (value.HasValue)
{
var dt = value.Value;
LastSavedYear = dt.Year;
LastSavedMonth = dt.Month;
LastSavedDay = dt.Day;
LastSavedHour = dt.Hour;
LastSavedMinute = dt.Minute;
}
else // Clear the date.
{
// If code tries to access MetDate again, null will be returned.
LastSavedYear = 0;
LastSavedMonth = 0;
LastSavedDay = 0;
LastSavedHour = 0;
LastSavedMinute = 0;
}
}
}
public int ResumeYear { get => BitConverter.ToInt32(Data, AdventureInfo + 0x4); set => BitConverter.GetBytes(value).CopyTo(Data, AdventureInfo + 0x4); }
public int ResumeMonth { get => Data[AdventureInfo + 0x8]; set => Data[AdventureInfo + 0x8] = (byte)value; }
public int ResumeDay { get => Data[AdventureInfo + 0x9]; set => Data[AdventureInfo + 0x9] = (byte)value; }
public int ResumeHour { get => Data[AdventureInfo + 0xB]; set => Data[AdventureInfo + 0xB] = (byte)value; }
public int ResumeMinute { get => Data[AdventureInfo + 0xC]; set => Data[AdventureInfo + 0xC] = (byte)value; }
public int ResumeSeconds { get => Data[AdventureInfo + 0xD]; set => Data[AdventureInfo + 0xD] = (byte)value; }
public override int SecondsToStart { get => BitConverter.ToInt32(Data, AdventureInfo + 0x18); set => BitConverter.GetBytes(value).CopyTo(Data, AdventureInfo + 0x18); }
public override int SecondsToFame { get => BitConverter.ToInt32(Data, AdventureInfo + 0x20); set => BitConverter.GetBytes(value).CopyTo(Data, AdventureInfo + 0x20); }
public uint getPSSStat(int index) { return BitConverter.ToUInt32(Data, PSSStats + 4*index); }
public void setPSSStat(int index, uint value) { BitConverter.GetBytes(value).CopyTo(Data, PSSStats + 4*index); }
public ushort getMaisonStat(int index) { return BitConverter.ToUInt16(Data, MaisonStats + 2 * index); }
public void setMaisonStat(int index, ushort value) { BitConverter.GetBytes(value).CopyTo(Data, MaisonStats + 2*index); }
public uint getEncounterCount(int index) { return BitConverter.ToUInt16(Data, EncounterCount + 2*index); }
public void setEncounterCount(int index, ushort value) { BitConverter.GetBytes(value).CopyTo(Data, EncounterCount + 2*index); }
// Daycare
public override int DaycareSeedSize => 16;
public override bool HasTwoDaycares => ORAS;
public override int getDaycareSlotOffset(int loc, int slot)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs < 0)
return -1;
return ofs + 8 + slot*(SIZE_STORED + 8);
}
public override uint? getDaycareEXP(int loc, int slot)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
return BitConverter.ToUInt32(Data, ofs + (SIZE_STORED + 8)*slot + 4);
return null;
}
public override bool? getDaycareOccupied(int loc, int slot)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
return Data[ofs + (SIZE_STORED + 8) * slot] == 1;
return null;
}
public override string getDaycareRNGSeed(int loc)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs <= 0)
return null;
var data = Data.Skip(Daycare + 0x1E8).Take(DaycareSeedSize/2).Reverse().ToArray();
return BitConverter.ToString(data).Replace("-", "");
}
public override bool? getDaycareHasEgg(int loc)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
return Data[ofs + 0x1E0] == 1;
return null;
}
public override void setDaycareEXP(int loc, int slot, uint EXP)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
BitConverter.GetBytes(EXP).CopyTo(Data, ofs + (SIZE_STORED + 8)*slot + 4);
}
public override void setDaycareOccupied(int loc, int slot, bool occupied)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
Data[ofs + (SIZE_STORED + 8)*slot] = (byte) (occupied ? 1 : 0);
}
public override void setDaycareRNGSeed(int loc, string seed)
{
if (loc != 0)
return;
if (Daycare < 0)
return;
if (seed == null)
return;
if (seed.Length > DaycareSeedSize)
return;
Enumerable.Range(0, seed.Length)
.Where(x => x % 2 == 0)
.Select(x => Convert.ToByte(seed.Substring(x, 2), 16))
.Reverse().ToArray().CopyTo(Data, Daycare + 0x1E8);
}
public override void setDaycareHasEgg(int loc, bool hasEgg)
{
int ofs = loc == 0 ? Daycare : Daycare2;
if (ofs > -1)
Data[ofs + 0x1E0] = (byte)(hasEgg ? 1 : 0);
}
public byte[] Puffs { get => getData(Puff, 100); set => value.CopyTo(Data, Puff); }
public int PuffCount { get => BitConverter.ToInt32(Data, Puff + 100); set => BitConverter.GetBytes(value).CopyTo(Data, Puff + 100); }
public int[] SelectItems
{
// UP,RIGHT,DOWN,LEFT
get
{
int[] list = new int[4];
for (int i = 0; i < list.Length; i++)
list[i] = BitConverter.ToUInt16(Data, ItemInfo + 10 + 2 * i);
return list;
}
set
{
if (value == null || value.Length > 4)
return;
for (int i = 0; i < value.Length; i++)
BitConverter.GetBytes((ushort)value[i]).CopyTo(Data, ItemInfo + 10 + 2 * i);
}
}
public int[] RecentItems
{
// Items recently interacted with (Give, Use)
get
{
int[] list = new int[12];
for (int i = 0; i < list.Length; i++)
list[i] = BitConverter.ToUInt16(Data, ItemInfo + 20 + 2 * i);
return list;
}
set
{
if (value == null || value.Length > 12)
return;
for (int i = 0; i < value.Length; i++)
BitConverter.GetBytes((ushort)value[i]).CopyTo(Data, ItemInfo + 20 + 2 * i);
}
}
public override string JPEGTitle => JPEG < 0 ? null : Util.TrimFromZero(Encoding.Unicode.GetString(Data, JPEG, 0x1A));
public override byte[] JPEGData => JPEG < 0 || Data[JPEG + 0x54] != 0xFF ? null : getData(JPEG + 0x54, 0xE004);
// Inventory
public override InventoryPouch[] Inventory
{
get
{
ushort[] legalItems = ORAS ? Legal.Pouch_Items_AO : Legal.Pouch_Items_XY;
ushort[] legalKey = ORAS ? Legal.Pouch_Key_AO : Legal.Pouch_Key_XY;
ushort[] legalTMHM = ORAS ? Legal.Pouch_TMHM_AO : Legal.Pouch_TMHM_XY;
ushort[] legalMedicine = ORAS ? Legal.Pouch_Medicine_AO : Legal.Pouch_Medicine_XY;
InventoryPouch[] pouch =
{
new InventoryPouch(InventoryType.Items, legalItems, 995, OFS_PouchHeldItem),
new InventoryPouch(InventoryType.KeyItems, legalKey, 1, OFS_PouchKeyItem),
new InventoryPouch(InventoryType.TMHMs, legalTMHM, 1, OFS_PouchTMHM),
new InventoryPouch(InventoryType.Medicine, legalMedicine, 995, OFS_PouchMedicine),
new InventoryPouch(InventoryType.Berries, Legal.Pouch_Berry_XY, 995, OFS_PouchBerry),
};
foreach (var p in pouch)
p.getPouch(ref Data);
return pouch;
}
set
{
foreach (var p in value)
p.setPouch(ref Data);
}
}
// Storage
public override int CurrentBox { get => Data[LastViewedBox]; set => Data[LastViewedBox] = (byte)value; }
public override int getPartyOffset(int slot)
{
return Party + SIZE_PARTY * slot;
}
public override int getBoxOffset(int box)
{
return Box + SIZE_STORED*box*30;
}
protected override int getBoxWallpaperOffset(int box)
{
int ofs = PCBackgrounds > 0 && PCBackgrounds < Data.Length ? PCBackgrounds : -1;
if (ofs > -1)
return ofs + box;
return ofs;
}
public override string getBoxName(int box)
{
if (PCLayout < 0)
return "B" + (box + 1);
return Util.TrimFromZero(Encoding.Unicode.GetString(Data, PCLayout + 0x22*box, 0x22));
}
public override void setBoxName(int box, string val)
{
Encoding.Unicode.GetBytes(val.PadRight(0x11, '\0')).CopyTo(Data, PCLayout + 0x22*box);
Edited = true;
}
public override PKM getPKM(byte[] data)
{
return new PK6(data);
}
protected override void setPKM(PKM pkm)
{
PK6 pk6 = pkm as PK6;
// Apply to this Save File
int CT = pk6.CurrentHandler;
DateTime Date = DateTime.Now;
pk6.Trade(OT, TID, SID, Country, SubRegion, Gender, false, Date.Day, Date.Month, Date.Year);
if (CT != pk6.CurrentHandler) // Logic updated Friendship
{
// Copy over the Friendship Value only under certain circumstances
if (pk6.Moves.Contains(216)) // Return
pk6.CurrentFriendship = pk6.OppositeFriendship;
else if (pk6.Moves.Contains(218)) // Frustration
pkm.CurrentFriendship = pk6.OppositeFriendship;
}
pkm.RefreshChecksum();
}
protected override void setDex(PKM pkm)
{
if (PokeDex < 0)
return;
if (pkm.Species == 0)
return;
if (pkm.Species > MaxSpeciesID)
return;
if (Version == GameVersion.Unknown)
return;
const int brSize = 0x60;
int bit = pkm.Species - 1;
int lang = pkm.Language - 1; if (lang > 5) lang--; // 0-6 language vals
int origin = pkm.Version;
int gender = pkm.Gender % 2; // genderless -> male
int shiny = pkm.IsShiny ? 1 : 0;
int shiftoff = brSize*(1 + gender + 2*shiny); // after the Owned region
int bd = bit >> 3; // div8
int bm = bit & 7; // mod8
byte mask = (byte)(1 << bm);
int ofs = PokeDex + 0x8 + bd;
// Owned quality flag
if (origin < 0x18 && bit < 649 && !ORAS) // Species: 1-649 for X/Y, and not for ORAS; Set the Foreign Owned Flag
Data[ofs + 0x644] |= mask;
else if (origin >= 0x18 || ORAS) // Set Native Owned Flag (should always happen)
Data[ofs + brSize * 0] |= mask;
// Set the [Species/Gender/Shiny] Seen Flag
Data[ofs + shiftoff] |= mask;
// Set the Display flag if none are set
bool Displayed = false;
Displayed |= (Data[ofs + brSize * 5] & mask) != 0;
Displayed |= (Data[ofs + brSize * 6] & mask) != 0;
Displayed |= (Data[ofs + brSize * 7] & mask) != 0;
Displayed |= (Data[ofs + brSize * 8] & mask) != 0;
if (!Displayed) // offset is already biased by brSize, reuse shiftoff but for the display flags.
Data[ofs + brSize * 4 + shiftoff] |= mask;
// Set the Language
if (lang < 0) lang = 1;
Data[PokeDexLanguageFlags + (bit * 7 + lang) / 8] |= (byte)(1 << ((bit * 7 + lang) % 8));
// Set DexNav count (only if not encountered previously)
if (ORAS && getEncounterCount(pkm.Species - 1) == 0)
setEncounterCount(pkm.Species - 1, 1);
// Set Form flags
int fc = Personal[pkm.Species].FormeCount;
int f = ORAS ? SaveUtil.getDexFormIndexORAS(pkm.Species, fc) : SaveUtil.getDexFormIndexXY(pkm.Species, fc);
if (f < 0) return;
int FormLen = ORAS ? 0x26 : 0x18;
int FormDex = PokeDex + 0x8 + brSize*9;
bit = f + pkm.AltForm;
// Set Form Seen Flag
Data[FormDex + FormLen*shiny + bit/8] |= (byte)(1 << (bit%8));
// Set Displayed Flag if necessary, check all flags
for (int i = 0; i < fc; i++)
{
bit = f + i;
if ((Data[FormDex + FormLen*2 + bit/8] & (byte) (1 << (bit%8))) != 0) // Nonshiny
return; // already set
if ((Data[FormDex + FormLen*3 + bit/8] & (byte) (1 << (bit%8))) != 0) // Shiny
return; // already set
}
bit = f + pkm.AltForm;
Data[FormDex + FormLen * (2 + shiny) + bit / 8] |= (byte)(1 << (bit % 8));
}
public override bool getCaught(int species)
{
int bit = species - 1;
int bd = bit >> 3; // div8
int bm = bit & 7; // mod8
int ofs = PokeDex // Raw Offset
+ 0x08; // Magic + Flags
if ((1 << bm & Data[ofs + bd]) != 0)
return true; // Owned Native
if (ORAS || bit >= 649) // no Foreign flag
return false;
return (1 << bm & Data[ofs + bd + 0x644]) != 0;
}
public override bool getSeen(int species)
{
const int brSize = 0x60;
int bit = species - 1;
int bd = bit >> 3; // div8
int bm = bit & 7; // mod8
byte mask = (byte)(1 << bm);
int ofs = PokeDex // Raw Offset
+ 0x08; // Magic + Flags
for (int i = 1; i <= 4; i++) // check all 4 seen flags (gender/shiny)
if ((Data[ofs + bd + i * brSize] & mask) != 0)
return true;
return false;
}
public override byte[] decryptPKM(byte[] data)
{
return PKX.decryptArray(data);
}
public override int PartyCount
{
get => Data[Party + 6 * SIZE_PARTY];
protected set => Data[Party + 6 * SIZE_PARTY] = (byte)value;
}
public override bool BattleBoxLocked
{
get => Data[BattleBox + 6 * SIZE_STORED] != 0;
set => Data[BattleBox + 6 * SIZE_STORED] = (byte)(value ? 1 : 0);
}
public override int BoxesUnlocked { get => Data[PCFlags + 1] - 1; set => Data[PCFlags + 1] = (byte)(value + 1); }
public override byte[] BoxFlags
{
get => new[] { Data[PCFlags], Data[PCFlags + 2] };
set
{
if (value.Length != 2) return;
Data[PCFlags] = value[0];
Data[PCFlags + 2] = value[1];
}
}
// Mystery Gift
protected override bool[] MysteryGiftReceivedFlags
{
get
{
if (WondercardData < 0 || WondercardFlags < 0)
return null;
bool[] r = new bool[(WondercardData-WondercardFlags)*8];
for (int i = 0; i < r.Length; i++)
r[i] = (Data[WondercardFlags + (i>>3)] >> (i&7) & 0x1) == 1;
return r;
}
set
{
if (WondercardData < 0 || WondercardFlags < 0)
return;
if ((WondercardData - WondercardFlags)*8 != value?.Length)
return;
byte[] data = new byte[value.Length/8];
for (int i = 0; i < value.Length; i++)
if (value[i])
data[i>>3] |= (byte)(1 << (i&7));
data.CopyTo(Data, WondercardFlags);
Edited = true;
}
}
protected override MysteryGift[] MysteryGiftCards
{
get
{
if (WondercardData < 0)
return null;
MysteryGift[] cards = new MysteryGift[GiftCountMax];
for (int i = 0; i < cards.Length; i++)
cards[i] = getWC6(i);
return cards;
}
set
{
if (value == null)
return;
if (value.Length > GiftCountMax)
Array.Resize(ref value, GiftCountMax);
for (int i = 0; i < value.Length; i++)
setWC6(value[i], i);
for (int i = value.Length; i < GiftCountMax; i++)
setWC6(new WC6(), i);
}
}
public byte[] LinkBlock
{
get
{
if (LinkInfo < 0)
return null;
return getData(LinkInfo, 0xC48);
}
set
{
if (LinkInfo < 0)
return;
if (value.Length != 0xC48)
return;
value.CopyTo(Data, LinkInfo);
}
}
private MysteryGift getWC6(int index)
{
if (WondercardData < 0)
return null;
if (index < 0 || index > GiftCountMax)
return null;
return new WC6(getData(WondercardData + index * WC6.Size, WC6.Size));
}
private void setWC6(MysteryGift wc6, int index)
{
if (WondercardData < 0)
return;
if (index < 0 || index > GiftCountMax)
return;
wc6.Data.CopyTo(Data, WondercardData + index * WC6.Size);
Edited = true;
}
// Writeback Validity
public override string MiscSaveChecks()
{
string r = "";
byte[] FFFF = Enumerable.Repeat((byte)0xFF, 0x200).ToArray();
for (int i = 0; i < Data.Length / 0x200; i++)
{
if (!FFFF.SequenceEqual(Data.Skip(i * 0x200).Take(0x200))) continue;
r = $"0x200 chunk @ 0x{i*0x200:X5} is FF'd."
+ Environment.NewLine + "Cyber will screw up (as of August 31st 2014)." + Environment.NewLine + Environment.NewLine;
// Check to see if it is in the Pokedex
if (i * 0x200 > PokeDex && i * 0x200 < PokeDex + 0x900)
{
r += "Problem lies in the Pokedex. ";
if (i * 0x200 == PokeDex + 0x400)
r += "Remove a language flag for a species < 585, ie Petilil";
}
break;
}
return r;
}
public override string MiscSaveInfo()
{
return Blocks.Aggregate("", (current, b) => current +
$"{b.ID:00}: {b.Offset:X5}-{b.Offset + b.Length:X5}, {b.Length:X5}{Environment.NewLine}");
}
public override string getString(int Offset, int Count) => PKX.getString6(Data, Offset, Count);
public override byte[] setString(string value, int maxLength, int PadToSize = 0, ushort PadWith = 0)
{
if (PadToSize == 0)
PadToSize = maxLength + 1;
return PKX.setString6(value, maxLength, PadToSize, PadWith);
}
}
}