Add Stadium2 Support

Introducing a new PKM format: SK2
Split ICaughtData2 off of PK2 so it can be shared with SK2 when type-checks occur
Add conversion for PK2<->SK2
Split the split-buffer handling for GBPKM to GBPKML (what a name), so that I can reuse shared accessor logic for SK2.

PKHeX.Core/Legality/Areas/EncounterArea2.cs

@@ -73,7 +73,7 @@ private EncounterSlot2[] ReadSlots(byte[] data, int count, int start)
 
         public override IEnumerable<EncounterSlot> GetMatchingSlots(PKM pkm, IReadOnlyList<EvoCriteria> chain)
         {
-            if (!(pkm is PK2 pk2) || pk2.CaughtData == 0)
+            if (!(pkm is ICaughtData2 pk2) || pk2.CaughtData == 0)
                 return GetSlotsFuzzy(chain);
 
             if (pk2.Met_Location != Location)

PKHeX.Core/Legality/Encounters/EncounterStatic/EncounterStatic2.cs

@@ -56,7 +56,7 @@ protected override void SetMetData(PKM pk, int level, DateTime today)
 
         protected override bool IsMatchLevel(PKM pkm, DexLevel evo)
         {
-            if (pkm is PK2 pk2 && pk2.CaughtData != 0)
+            if (pkm is ICaughtData2 pk2 && pk2.CaughtData != 0)
                 return pkm.Met_Level == (EggEncounter ? 1 : Level);
 
             return Level <= evo.Level;
@@ -68,7 +68,7 @@ protected override bool IsMatchLocation(PKM pkm)
                 return true;
             if (Location == 0)
                 return true;
-            if (pkm is PK2 pk2 && pk2.CaughtData != 0)
+            if (pkm is ICaughtData2 pk2 && pk2.CaughtData != 0)
                 return Location == pkm.Met_Location;
             return true;
         }

PKHeX.Core/Legality/Encounters/Generator/EncounterGenerator12.cs

@@ -81,7 +81,7 @@ private static IEnumerable<IEncounterable> GenerateRawEncounters12(PKM pkm, Game
         private static IEnumerable<IEncounterable> GenerateFilteredEncounters12(PKM pkm)
         {
             // If the current data indicates that it must have originated from Crystal, only yield encounter data from Crystal.
-            bool crystal = (pkm is PK2 pk2 && pk2.CaughtData != 0) || (pkm.Format >= 7 && pkm.OT_Gender == 1);
+            bool crystal = (pkm is ICaughtData2 pk2 && pk2.CaughtData != 0) || (pkm.Format >= 7 && pkm.OT_Gender == 1);
             if (crystal)
                 return GenerateRawEncounters12(pkm, GameVersion.C);
 

PKHeX.Core/Legality/Evolutions/EncounterOrigin.cs

@@ -37,11 +37,11 @@ public static IReadOnlyList<EvoCriteria> GetOriginChain12(PKM pkm, GameVersion g
 
             bool hasOriginMet;
             int maxLevel, minLevel;
-            if (pkm is PK2 pk2)
+            if (pkm is ICaughtData2 pk2)
             {
                 hasOriginMet = pk2.CaughtData != 0;
-                maxLevel = rby && Future_LevelUp2.Contains(pk2.Species) ? pkm.CurrentLevel - 1 : pkm.CurrentLevel;
-                minLevel = !hasOriginMet ? 2 : pkm.IsEgg ? 5 : pkm.Met_Level;
+                maxLevel = rby && Future_LevelUp2.Contains(pkm.Species) ? pkm.CurrentLevel - 1 : pkm.CurrentLevel;
+                minLevel = !hasOriginMet ? 2 : pkm.IsEgg ? 5 : pk2.Met_Level;
             }
             else if (pkm is PK1 pk1)
             {

PKHeX.Core/Legality/Restrictions/GBRestrictions.cs

@@ -379,7 +379,7 @@ private static bool CanInhabitGen1(this PKM pkm)
             // If you put a Pokemon in the N64 box, the met info is retained, even if you switch over to a Gen I game to teach it TMs
             // You can use rare candies from within the lab, so level-up moves from RBY context can be learned this way as well
             // Stadium 2 is GB Cart Era only (not 3DS Virtual Console).
-            if (pkm is PK2 pk2 && pk2.CaughtData != 0 && !ParseSettings.AllowGBCartEra)
+            if (pkm is ICaughtData2 pk2 && pk2.CaughtData != 0 && !ParseSettings.AllowGBCartEra)
                 return false;
 
             // Sanity check species, if it could have existed as a pre-evolution.

PKHeX.Core/PKM/PK1.cs

@@ -4,7 +4,7 @@
 namespace PKHeX.Core
 {
     /// <summary> Generation 1 <see cref="PKM"/> format. </summary>
-    public sealed class PK1 : GBPKM
+    public sealed class PK1 : GBPKML
     {
         public override PersonalInfo PersonalInfo => PersonalTable.Y[Species];
 

PKHeX.Core/PKM/PK2.cs

@@ -3,7 +3,7 @@
 namespace PKHeX.Core
 {
     /// <summary> Generation 2 <see cref="PKM"/> format. </summary>
-    public sealed class PK2 : GBPKM
+    public sealed class PK2 : GBPKML, ICaughtData2
     {
         public override PersonalInfo PersonalInfo => PersonalTable.C[Species];
 
@@ -223,5 +223,43 @@ public PK7 ConvertToPK7()
             pk7.RefreshChecksum();
             return pk7;
         }
+
+        public SK2 ConvertToSK2()
+        {
+            return new SK2(Japanese)
+            {
+                Species = Species,
+                HeldItem = HeldItem,
+                Move1 = Move1,
+                Move2 = Move2,
+                Move3 = Move3,
+                Move4 = Move4,
+                TID = TID,
+                EXP = EXP,
+                EV_HP = EV_HP,
+                EV_ATK = EV_ATK,
+                EV_DEF = EV_DEF,
+                EV_SPE = EV_SPE,
+                EV_SPC = EV_SPC,
+                DV16 = DV16,
+                Move1_PP = Move1_PP,
+                Move2_PP = Move2_PP,
+                Move3_PP = Move3_PP,
+                Move4_PP = Move4_PP,
+                Move1_PPUps = Move1_PPUps,
+                Move2_PPUps = Move2_PPUps,
+                Move3_PPUps = Move3_PPUps,
+                Move4_PPUps = Move4_PPUps,
+                CurrentFriendship = CurrentFriendship,
+                Stat_Level = Stat_Level,
+                PKRS_Days = PKRS_Days,
+                PKRS_Strain = PKRS_Strain,
+                CaughtData = CaughtData,
+
+                // Only copies until first 0x50 terminator, but just copy everything
+                Nickname = Nickname,
+                OT_Name = OT_Name,
+            };
+        }
     }
 }

PKHeX.Core/PKM/SK2.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+
+namespace PKHeX.Core
+{
+    /// <summary> Generation 2 <see cref="PKM"/> format for <see cref="GameVersion.Stadium2"/>. </summary>
+    public sealed class SK2 : GBPKM, ICaughtData2
+    {
+        public override PersonalInfo PersonalInfo => PersonalTable.C[Species];
+
+        public override bool Valid => Species <= 252;
+
+        public override int SIZE_PARTY => PokeCrypto.SIZE_2STADIUM;
+        public override int SIZE_STORED => PokeCrypto.SIZE_2STADIUM;
+        public override bool Japanese { get; }
+        public override bool Korean => false;
+        private const int StringLength = 12;
+
+        public override int Format => 2;
+        public override int OTLength => StringLength;
+        public override int NickLength => StringLength;
+
+        public SK2(bool jp = false) : base(PokeCrypto.SIZE_2STADIUM)
+        {
+            Japanese = jp;
+        }
+
+        public SK2(byte[] data) : this(data, IsJapanese(data)) { }
+        public SK2(byte[] data, bool jp) : base(data) => Japanese = jp;
+
+        public override PKM Clone() => new SK2((byte[])Data.Clone(), Japanese)
+        {
+            Identifier = Identifier,
+            IsEgg = IsEgg,
+        };
+
+        protected override byte[] Encrypt() => Data;
+
+        #region Stored Attributes
+        public override int Species { get => Data[0]; set => Data[0] = (byte)value; }
+        public override int SpriteItem => ItemConverter.GetItemFuture2((byte)HeldItem);
+        public override int HeldItem { get => Data[0x1]; set => Data[0x1] = (byte)value; }
+        public override int Move1 { get => Data[2]; set => Data[2] = (byte)value; }
+        public override int Move2 { get => Data[3]; set => Data[3] = (byte)value; }
+        public override int Move3 { get => Data[4]; set => Data[4] = (byte)value; }
+        public override int Move4 { get => Data[5]; set => Data[5] = (byte)value; }
+        public override int TID { get => BigEndian.ToUInt16(Data, 6); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 6); }
+        public override uint EXP { get => BigEndian.ToUInt32(Data, 8); set => BigEndian.GetBytes(value).CopyTo(Data, 8); } // not 3 bytes like in PK2
+        public override int EV_HP { get => BigEndian.ToUInt16(Data, 0x0C); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x0C); }
+        public override int EV_ATK { get => BigEndian.ToUInt16(Data, 0x0E); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x0E); }
+        public override int EV_DEF { get => BigEndian.ToUInt16(Data, 0x10); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x10); }
+        public override int EV_SPE { get => BigEndian.ToUInt16(Data, 0x12); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x12); }
+        public override int EV_SPC { get => BigEndian.ToUInt16(Data, 0x14); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x14); }
+        public override ushort DV16 { get => BigEndian.ToUInt16(Data, 0x16); set => BigEndian.GetBytes(value).CopyTo(Data, 0x16); }
+        public override int Move1_PP { get => Data[0x18] & 0x3F; set => Data[0x18] = (byte)((Data[0x18] & 0xC0) | Math.Min(63, value)); }
+        public override int Move2_PP { get => Data[0x19] & 0x3F; set => Data[0x19] = (byte)((Data[0x19] & 0xC0) | Math.Min(63, value)); }
+        public override int Move3_PP { get => Data[0x1A] & 0x3F; set => Data[0x1A] = (byte)((Data[0x1A] & 0xC0) | Math.Min(63, value)); }
+        public override int Move4_PP { get => Data[0x1B] & 0x3F; set => Data[0x1B] = (byte)((Data[0x1B] & 0xC0) | Math.Min(63, value)); }
+        public override int Move1_PPUps { get => (Data[0x17] & 0xC0) >> 6; set => Data[0x17] = (byte)((Data[0x17] & 0x3F) | ((value & 0x3) << 6)); }
+        public override int Move2_PPUps { get => (Data[0x18] & 0xC0) >> 6; set => Data[0x18] = (byte)((Data[0x18] & 0x3F) | ((value & 0x3) << 6)); }
+        public override int Move3_PPUps { get => (Data[0x19] & 0xC0) >> 6; set => Data[0x19] = (byte)((Data[0x19] & 0x3F) | ((value & 0x3) << 6)); }
+        public override int Move4_PPUps { get => (Data[0x1A] & 0xC0) >> 6; set => Data[0x1A] = (byte)((Data[0x1A] & 0x3F) | ((value & 0x3) << 6)); }
+        public override int CurrentFriendship { get => Data[0x1C]; set => Data[0x1C] = (byte)value; }
+
+        public override int Stat_Level { get => Data[0x1D]; set => Data[0x1D] = (byte)value; }
+
+        // 0x1E, 0x1F
+
+        private byte PKRS { get => Data[0x20]; set => Data[0x20] = value; }
+        // Crystal only Caught Data
+        public override int PKRS_Days { get => PKRS & 0xF; set => PKRS = (byte)((PKRS & ~0xF) | value); }
+        public override int PKRS_Strain { get => PKRS >> 4; set => PKRS = (byte)((PKRS & 0xF) | value << 4); }
+
+        public int CaughtData { get => BigEndian.ToUInt16(Data, 0x21); set => BigEndian.GetBytes((ushort)value).CopyTo(Data, 0x21); }
+
+        public int Met_TimeOfDay { get => (CaughtData >> 14) & 0x3; set => CaughtData = (CaughtData & 0x3FFF) | ((value & 0x3) << 14); }
+        public override int Met_Level { get => (CaughtData >> 8) & 0x3F; set => CaughtData = (CaughtData & 0xC0FF) | ((value & 0x3F) << 8); }
+        public override int OT_Gender { get => (CaughtData >> 7) & 1; set => CaughtData = (CaughtData & 0xFF7F) | ((value & 1) << 7); }
+        public override int Met_Location { get => CaughtData & 0x7F; set => CaughtData = (CaughtData & 0xFF80) | (value & 0x7F); }
+
+        public override string Nickname { get => GetString(0x24, StringLength); set => StringConverter12.SetString1(value, 12, Japanese).CopyTo(Data, 0x24); }
+        public override string OT_Name { get => GetString(0x30, StringLength); set => SetString(value, StringLength).CopyTo(Data, 0x30); }
+
+        public override byte[] Nickname_Trash { get => GetData(0x24, 12); set { if (value.Length == 12) value.CopyTo(Data, 0x24); } }
+        public override byte[] OT_Trash { get => GetData(0x30, 12); set { if (value.Length == 12) value.CopyTo(Data, 0x30); } }
+        #endregion
+
+        #region Party Attributes
+        public override int Status_Condition { get; set; }
+        public override int Stat_HPCurrent { get; set; }
+        public override int Stat_HPMax { get; set; }
+        public override int Stat_ATK { get; set; }
+        public override int Stat_DEF { get; set; }
+        public override int Stat_SPE { get; set; }
+        public override int Stat_SPA { get; set; }
+        public override int Stat_SPD { get; set; }
+        #endregion
+
+        public override bool IsEgg { get; set; }
+        public override int OT_Friendship { get => CurrentFriendship; set => CurrentFriendship = value; }
+        public override bool HasOriginalMetLocation => CaughtData != 0;
+        public override int Version { get => (int)GameVersion.GSC; set { } }
+
+        private string GetString(int offset, int length) => StringConverter12.GetString1(Data, offset, length - 1, Japanese);
+        private byte[] SetString(string value, int length) => StringConverter12.SetString1(value, length - 1, Japanese);
+
+        protected override IEnumerable<byte> GetNonNickname(int language)
+        {
+            var name = SpeciesName.GetSpeciesNameGeneration(Species, language, Format);
+            return SetString(name, StringLength);
+        }
+
+        public override void SetNotNicknamed(int language)
+        {
+            var name = SpeciesName.GetSpeciesNameGeneration(Species, language, Format);
+            Array.Clear(Data, 0x24, 0xC);
+            Nickname = name;
+        }
+
+        // Maximums
+        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 PK2 ConvertToPK2()
+        {
+            return new PK2(Japanese)
+            {
+                Species = Species,
+                HeldItem = HeldItem,
+                Move1 = Move1,
+                Move2 = Move2,
+                Move3 = Move3,
+                Move4 = Move4,
+                TID = TID,
+                EXP = EXP,
+                EV_HP = EV_HP,
+                EV_ATK  = EV_ATK,
+                EV_DEF  = EV_DEF,
+                EV_SPE  = EV_SPE,
+                EV_SPC = EV_SPC,
+                DV16 = DV16,
+                Move1_PP = Move1_PP,
+                Move2_PP = Move2_PP,
+                Move3_PP = Move3_PP,
+                Move4_PP = Move4_PP,
+                Move1_PPUps = Move1_PPUps,
+                Move2_PPUps = Move2_PPUps,
+                Move3_PPUps = Move3_PPUps,
+                Move4_PPUps = Move4_PPUps,
+                CurrentFriendship = CurrentFriendship,
+                Stat_Level = Stat_Level,
+                PKRS_Days = PKRS_Days,
+                PKRS_Strain = PKRS_Strain,
+                CaughtData = CaughtData,
+
+                // Only copies until first 0x50 terminator, but just copy everything
+                Nickname = Nickname,
+                OT_Name = OT_Name,
+            };
+        }
+
+        private static bool IsJapanese(byte[] data) => StringConverter12.GetIsG1Japanese(data, 0x24, StringLength) && StringConverter12.GetIsG1Japanese(data, 0x30, StringLength);
+    }
+}

PKHeX.Core/PKM/Shared/GBPKM.cs

@@ -6,16 +6,11 @@ namespace PKHeX.Core
 {
     public abstract class GBPKM : PKM
     {
-        internal const int STRLEN_J = 6;
-        internal const int STRLEN_U = 11;
-
         public sealed override int MaxBallID => -1;
         public sealed override int MinGameID => (int)GameVersion.RD;
         public sealed override int MaxGameID => (int)GameVersion.C;
         public sealed override int MaxIV => 15;
         public sealed override int MaxEV => ushort.MaxValue;
-        public sealed override int OTLength => Japanese ? 5 : 7;
-        public sealed override int NickLength => Japanese ? 5 : 10;
 
         public sealed override IReadOnlyList<ushort> ExtraBytes => Array.Empty<ushort>();
 
@@ -29,48 +24,21 @@ public sealed override string FileNameWithoutExtension
             }
         }
 
-        private int StringLength => Japanese ? STRLEN_J : STRLEN_U;
-        public sealed override bool Japanese => otname.Length == STRLEN_J;
-
-        protected GBPKM(int size, bool jp = false) : base(size)
-        {
-            int strLen = jp ? STRLEN_J : STRLEN_U;
-
-            // initialize string buffers
-            otname = new byte[strLen];
-            nick = new byte[strLen];
-            for (int i = 0; i < otname.Length; i++)
-                otname[i] = nick[i] = 0x50;
-        }
-
-        protected GBPKM(byte[] data, bool jp = false) : base(data)
-        {
-            int strLen = jp ? STRLEN_J : STRLEN_U;
-
-            // initialize string buffers
-            otname = new byte[strLen];
-            nick = new byte[strLen];
-            for (int i = 0; i < otname.Length; i++)
-                otname[i] = nick[i] = 0x50;
-        }
-
-        internal readonly byte[] otname;
-        internal readonly byte[] nick;
-
-        // Trash Bytes
-        public sealed override byte[] Nickname_Trash { get => nick; set { if (value.Length == nick.Length) value.CopyTo(nick, 0); } }
-        public sealed override byte[] OT_Trash { get => otname; set { if (value.Length == otname.Length) value.CopyTo(otname, 0); } }
+        protected GBPKM(int size) : base(size) { }
+        protected GBPKM(byte[] data) : base(data) { }
 
         public sealed override byte[] EncryptedPartyData => Encrypt();
         public sealed override byte[] EncryptedBoxData => Encrypt();
         public sealed override byte[] DecryptedBoxData => Encrypt();
         public sealed override byte[] DecryptedPartyData => Encrypt();
 
+        protected abstract IEnumerable<byte> GetNonNickname(int language);
+
         private bool? _isnicknamed;
 
         public sealed override bool IsNicknamed
         {
-            get => _isnicknamed ??= !nick.SequenceEqual(GetNonNickname(GuessedLanguage()));
+            get => _isnicknamed ??= !Nickname_Trash.SequenceEqual(GetNonNickname(GuessedLanguage()));
             set
             {
                 _isnicknamed = value;
@@ -96,7 +64,7 @@ public sealed override int Language
                     return (int)LanguageID.Japanese;
                 if (Korean)
                     return (int)LanguageID.Korean;
-                if (StringConverter12.IsG12German(otname))
+                if (StringConverter12.IsG12German(OT_Trash))
                     return (int)LanguageID.German; // german
                 int lang = SpeciesName.GetSpeciesNameLanguage(Species, Nickname, Format);
                 if (lang > 0)
@@ -116,34 +84,6 @@ public sealed override int Language
             }
         }
 
-        public sealed override string Nickname
-        {
-            get
-            {
-                if (Korean)
-                    return StringConverter2KOR.GetString2KOR(nick, 0, nick.Length);
-                return StringConverter12.GetString1(nick, 0, nick.Length, Japanese);
-            }
-            set
-            {
-                if (!IsNicknamed && Nickname == value)
-                    return;
-
-                GetStringSpecial(value, StringLength).CopyTo(nick, 0);
-            }
-        }
-
-        public sealed override string OT_Name
-        {
-            get
-            {
-                if (Korean)
-                    return StringConverter2KOR.GetString2KOR(otname, 0, otname.Length);
-                return StringConverter12.GetString1(otname, 0, otname.Length, Japanese);
-            }
-            set => GetStringSpecial(value, StringLength).CopyTo(otname, 0);
-        }
-
         public sealed override int Gender
         {
             get
@@ -223,18 +163,8 @@ public sealed override int AltForm
         public sealed override int IV_SPA { get => IV_SPC; set => IV_SPC = value; }
         public sealed override int IV_SPD { get => IV_SPC; set { } }
 
-        public void SetNotNicknamed() => GetNonNickname(GuessedLanguage()).CopyTo(nick);
-        public void SetNotNicknamed(int language) => GetNonNickname(language).CopyTo(nick);
-
-        private IEnumerable<byte> GetNonNickname(int language)
-        {
-            var name = SpeciesName.GetSpeciesNameGeneration(Species, language, Format);
-            var bytes = SetString(name, StringLength);
-            var data = bytes.Concat(Enumerable.Repeat((byte)0x50, nick.Length - bytes.Length));
-            if (!Korean)
-                data = data.Select(b => (byte)(b == 0xF2 ? 0xE8 : b)); // Decimal point<->period fix
-            return data;
-        }
+        public void SetNotNicknamed() => SetNotNicknamed(GuessedLanguage());
+        public abstract void SetNotNicknamed(int language);
 
         public int GuessedLanguage(int fallback = (int)LanguageID.English)
         {
@@ -298,35 +228,5 @@ public sealed override void SetShiny()
             IV_SPE = 10;
             IV_SPA = 10;
         }
-
-        protected string GetString(int Offset, int Count)
-        {
-            if (Korean)
-                return StringConverter2KOR.GetString2KOR(Data, Offset, Count);
-            return StringConverter12.GetString1(Data, Offset, Count, Japanese);
-        }
-
-        private byte[] SetString(string value, int maxLength)
-        {
-            if (Korean)
-                return StringConverter2KOR.SetString2KOR(value, maxLength - 1);
-            return StringConverter12.SetString1(value, maxLength - 1, Japanese);
-        }
-
-        private byte[] GetStringSpecial(string value, int length)
-        {
-            byte[] strdata = SetString(value, length);
-            if (nick.All(b => b != 0) || nick[length - 1] != 0x50 || Array.FindIndex(nick, b => b == 0) != strdata.Length - 1)
-                return strdata;
-
-            int firstInd = Array.FindIndex(nick, b => b == 0);
-            for (int i = firstInd; i < length - 1; i++)
-            {
-                if (nick[i] != 0)
-                    break;
-            }
-
-            return strdata.Take(strdata.Length - 1).ToArray();
-        }
     }
 }

PKHeX.Core/PKM/Shared/GBPKML.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PKHeX.Core
+{
+    public abstract class GBPKML : GBPKM
+    {
+        internal const int STRLEN_J = 6;
+        internal const int STRLEN_U = 11;
+        public sealed override int OTLength => Japanese ? 5 : 7;
+        public sealed override int NickLength => Japanese ? 5 : 10;
+
+        public sealed override bool Japanese => otname.Length == STRLEN_J;
+
+        internal readonly byte[] otname;
+        internal readonly byte[] nick;
+
+        // Trash Bytes
+        public sealed override byte[] Nickname_Trash { get => nick; set { if (value.Length == nick.Length) value.CopyTo(nick, 0); } }
+        public sealed override byte[] OT_Trash { get => otname; set { if (value.Length == otname.Length) value.CopyTo(otname, 0); } }
+
+        protected GBPKML(int size, bool jp = false) : base(size)
+        {
+            int strLen = jp ? STRLEN_J : STRLEN_U;
+
+            // initialize string buffers
+            otname = new byte[strLen];
+            nick = new byte[strLen];
+            for (int i = 0; i < otname.Length; i++)
+                otname[i] = nick[i] = 0x50;
+        }
+
+        protected GBPKML(byte[] data, bool jp = false) : base(data)
+        {
+            int strLen = jp ? STRLEN_J : STRLEN_U;
+
+            // initialize string buffers
+            otname = new byte[strLen];
+            nick = new byte[strLen];
+            for (int i = 0; i < otname.Length; i++)
+                otname[i] = nick[i] = 0x50;
+        }
+
+        public override void SetNotNicknamed(int language) => GetNonNickname(language).CopyTo(nick);
+
+        protected override IEnumerable<byte> GetNonNickname(int language)
+        {
+            var name = SpeciesName.GetSpeciesNameGeneration(Species, language, Format);
+            var len = Nickname_Trash.Length;
+            var bytes = SetString(name, len);
+            var data = bytes.Concat(Enumerable.Repeat((byte)0x50, len - bytes.Length));
+            if (!Korean)
+                data = data.Select(b => (byte)(b == 0xF2 ? 0xE8 : b)); // Decimal point<->period fix
+            return data;
+        }
+
+        private byte[] SetString(string value, int maxLength)
+        {
+            if (Korean)
+                return StringConverter2KOR.SetString2KOR(value, maxLength - 1);
+            return StringConverter12.SetString1(value, maxLength - 1, Japanese);
+        }
+
+        public sealed override string Nickname
+        {
+            get
+            {
+                if (Korean)
+                    return StringConverter2KOR.GetString2KOR(nick, 0, nick.Length);
+                return StringConverter12.GetString1(nick, 0, nick.Length, Japanese);
+            }
+            set
+            {
+                if (!IsNicknamed && Nickname == value)
+                    return;
+
+                Nickname_Trash = GetStringSpecial(value, Nickname_Trash.Length);
+            }
+        }
+
+        public sealed override string OT_Name
+        {
+            get
+            {
+                if (Korean)
+                    return StringConverter2KOR.GetString2KOR(otname, 0, otname.Length);
+                return StringConverter12.GetString1(otname, 0, otname.Length, Japanese);
+            }
+            set => OT_Trash = GetStringSpecial(value, OT_Trash.Length);
+        }
+
+        private byte[] GetStringSpecial(string value, int length)
+        {
+            byte[] strdata = SetString(value, length);
+            if (nick.All(b => b != 0) || nick[length - 1] != 0x50 || Array.FindIndex(nick, b => b == 0) != strdata.Length - 1)
+                return strdata;
+
+            int firstInd = Array.FindIndex(nick, b => b == 0);
+            for (int i = firstInd; i < length - 1; i++)
+            {
+                if (nick[i] != 0)
+                    break;
+            }
+
+            return strdata.Take(strdata.Length - 1).ToArray();
+        }
+    }
+}

PKHeX.Core/PKM/Shared/ICaughtData2.cs

@@ -0,0 +1,11 @@
+namespace PKHeX.Core
+{
+    public interface ICaughtData2
+    {
+        int CaughtData { get; set; }
+        int Met_TimeOfDay { get; set; }
+        int Met_Level { get; set; }
+        int OT_Gender { get; set; }
+        int Met_Location { get; set; }
+    }
+}

PKHeX.Core/PKM/Shared/PokeListGB.cs

@@ -78,7 +78,7 @@ private byte[] GetEmptyList(PokeListType c, bool jp = false)
         private int GetOffsetPKMOT(int base_ofs, int i) => GetOffsetPKMData(base_ofs, Capacity) + (StringLength * i);
         private int GetOffsetPKMNickname(int base_ofs, int i) => GetOffsetPKMOT(base_ofs, Capacity) + (StringLength * i);
 
-        private static int GetStringLength(bool jp) => jp ? GBPKM.STRLEN_J : GBPKM.STRLEN_U;
+        private static int GetStringLength(bool jp) => jp ? GBPKML.STRLEN_J : GBPKML.STRLEN_U;
         protected bool IsFormatParty => IsCapacityPartyFormat((PokeListType)Capacity);
         protected static bool IsCapacityPartyFormat(PokeListType Capacity) => Capacity == PokeListType.Single || Capacity == PokeListType.Party;
 

PKHeX.Core/PKM/Strings/StringConverter12.cs

@@ -9,8 +9,28 @@ namespace PKHeX.Core
     /// </summary>
     public static class StringConverter12
     {
-        public static bool GetIsG1Japanese(string str) => str.All(z => U2RBY_J.ContainsKey(z));
-        public static bool GetIsG1English(string str) => str.All(z => U2RBY_U.ContainsKey(z));
+        public static bool GetIsG1Japanese(string str) => AllCharsInDictionary(str, U2RBY_J);
+        public static bool GetIsG1English(string str) => AllCharsInDictionary(str, U2RBY_U);
+        private static bool AllCharsInDictionary(IEnumerable<char> c, IReadOnlyDictionary<char, byte> d) => c.All(d.ContainsKey);
+
+        public static bool GetIsG1Japanese(byte[] data, int start, int length)
+        {
+            var d = RBY2U_J;
+            return AllCharsInDictionary(data, start, length, d);
+        }
+
+        private static bool AllCharsInDictionary(IReadOnlyList<byte> data, int start, int length, IReadOnlyDictionary<byte, char> d)
+        {
+            for (int i = start; i < start + length; i++)
+            {
+                var c = data[i];
+                if (c == 0)
+                    break;
+                if (!d.ContainsKey(c))
+                    return false;
+            }
+            return true;
+        }
 
         public const byte G1TerminatorCode = 0x50;
         public const char G1Terminator = '\0';

PKHeX.Core/PKM/Util/PKMConverter.cs

@@ -60,6 +60,7 @@ public static int GetPKMDataFormat(byte[] data)
                     return 1;
                 case PokeCrypto.SIZE_2ULIST:
                 case PokeCrypto.SIZE_2JLIST:
+                case PokeCrypto.SIZE_2STADIUM:
                     return 2;
                 case PokeCrypto.SIZE_3PARTY:
                 case PokeCrypto.SIZE_3STORED:
@@ -114,6 +115,9 @@ public static int GetPKMDataFormat(byte[] data)
                     var list1 = new PokeList1(data);
                     return list1[0];
                 case 2:
+                    if (data.Length == PokeCrypto.SIZE_2STADIUM)
+                        return new SK2(data);
+
                     var list2 = new PokeList2(data);
                     return list2[0];
                 case 3:
@@ -288,6 +292,7 @@ public static bool IsConvertibleToFormat(PKM pk, int format)
                 // Non-sequential
                 case PK1 pk1 when destGeneration > 2: return pk1.ConvertToPK7();
                 case PK2 pk2 when destGeneration > 2: return pk2.ConvertToPK7();
+                case PK2 pk2 when destType == typeof(SK2): return pk2.ConvertToSK2();
                 case PK3 pk3 when destType == typeof(CK3): return pk3.ConvertToCK3();
                 case PK3 pk3 when destType == typeof(XK3): return pk3.ConvertToXK3();
                 case PK4 pk4 when destType == typeof(BK4): return pk4.ConvertToBK4();
@@ -302,6 +307,7 @@ public static bool IsConvertibleToFormat(PKM pk, int format)
                 // Sequential
                 case PK1 pk1: return pk1.ConvertToPK2();
                 case PK2 pk2: return pk2.ConvertToPK1();
+                case SK2 sk2: return sk2.ConvertToPK2();
                 case CK3 ck3: return ck3.ConvertToPK3();
                 case XK3 xk3: return xk3.ConvertToPK3();
                 case PK3 pk3: return pk3.ConvertToPK4();

PKHeX.Core/PKM/Util/PKX.cs

@@ -14,7 +14,7 @@ public static class PKX
         private static readonly HashSet<int> Sizes = new HashSet<int>
         {
             PokeCrypto.SIZE_1JLIST,   PokeCrypto.SIZE_1ULIST,
-            PokeCrypto.SIZE_2ULIST,   PokeCrypto.SIZE_2JLIST,
+            PokeCrypto.SIZE_2ULIST,   PokeCrypto.SIZE_2JLIST,   PokeCrypto.SIZE_2STADIUM,
             PokeCrypto.SIZE_3STORED,  PokeCrypto.SIZE_3PARTY,
             PokeCrypto.SIZE_3CSTORED, PokeCrypto.SIZE_3XSTORED,
             PokeCrypto.SIZE_4STORED,  PokeCrypto.SIZE_4PARTY,

PKHeX.Core/PKM/Util/PokeCrypto.cs

@@ -18,6 +18,7 @@ public static class PokeCrypto
         internal const int SIZE_2JLIST = 63;
         internal const int SIZE_2PARTY = 48;
         internal const int SIZE_2STORED = 32;
+        internal const int SIZE_2STADIUM = 60;
 
         internal const int SIZE_3CSTORED = 312;
         internal const int SIZE_3XSTORED = 196;

PKHeX.Core/Saves/SAV1.cs

@@ -214,7 +214,7 @@ private int GetBoxRawDataOffset(int i)
         public override int BoxSlotCount => Japanese ? 30 : 20;
 
         public override bool HasParty => true;
-        private int StringLength => Japanese ? GBPKM.STRLEN_J : GBPKM.STRLEN_U;
+        private int StringLength => Japanese ? GBPKML.STRLEN_J : GBPKML.STRLEN_U;
 
         public override bool IsPKMPresent(byte[] data, int offset) => PKX.IsPKMPresentGB(data, offset);
 

PKHeX.Core/Saves/SAV2.cs

@@ -283,7 +283,7 @@ protected override byte[] GetFinalData()
 
         public override bool HasParty => true;
         public override bool HasNamableBoxes => true;
-        private int StringLength => Japanese ? GBPKM.STRLEN_J : GBPKM.STRLEN_U;
+        private int StringLength => Japanese ? GBPKML.STRLEN_J : GBPKML.STRLEN_U;
 
         // Checksums
         private ushort GetChecksum()

PKHeX.Core/Saves/SAV2Stadium.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections.Generic;
+
+namespace PKHeX.Core
+{
+    public sealed class SAV2Stadium : SaveFile, ILangDeviantSave
+    {
+        protected override string BAKText => $"{OT} ({Version})";
+        public override string Filter => "SAV File|*.sav|All Files|*.*";
+        public override string Extension => ".sav";
+
+        public int SaveRevision => Japanese ? 0 : 1;
+        public string SaveRevisionString => Japanese ? "J" : "U";
+        public bool Japanese { get; }
+        public bool Korean => false;
+
+        public override PersonalTable Personal => PersonalTable.C;
+        public override int MaxEV => ushort.MaxValue;
+        public override IReadOnlyList<ushort> HeldItems => Legal.HeldItems_GSC;
+        public override GameVersion Version { get; protected set; } = GameVersion.Stadium2;
+
+        public override SaveFile Clone() => new SAV1Stadium((byte[])Data.Clone(), Japanese);
+
+        public override string ChecksumInfo => ChecksumsValid ? "Checksum valid." : "Checksum invalid";
+        public override int Generation => 2;
+
+        public override string GetString(byte[] data, int offset, int length) => StringConverter12.GetString1(data, offset, length, Japanese);
+
+        public override byte[] SetString(string value, int maxLength, int PadToSize = 0, ushort PadWith = 0)
+        {
+            if (PadToSize == 0)
+                PadToSize = maxLength + 1;
+            return StringConverter12.SetString1(value, maxLength, Japanese, PadToSize, PadWith);
+        }
+
+        private const int StringLength = 12;
+        public override int OTLength => StringLength;
+        public override int NickLength => StringLength;
+        public override int BoxCount => Japanese ? 9 : 14;
+        public override int BoxSlotCount => Japanese ? 30 : 20;
+
+        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;
+
+        public override int GetPartyOffset(int slot) => -1;
+
+        private readonly bool IsPairSwapped;
+
+        protected override byte[] GetFinalData()
+        {
+            var result = base.GetFinalData();
+            if (IsPairSwapped)
+                BigEndian.SwapBytes32(result = (byte[])result.Clone());
+            return result;
+        }
+
+        public override bool ChecksumsValid => GetBoxChecksumsValid();
+        protected override void SetChecksums() => SetBoxChecksums();
+
+        private bool GetBoxChecksumsValid()
+        {
+            for (int i = 0; i < BoxCount; i++)
+            {
+                var boxOfs = GetBoxOffset(i) - ListHeaderSizeBox;
+                var size = BoxSize - 2;
+                var chk = Checksums.CheckSum16(Data, boxOfs, size);
+                var actual = BigEndian.ToUInt16(Data, boxOfs + size);
+                if (chk != actual)
+                    return false;
+            }
+            return true;
+        }
+
+        private void SetBoxChecksums()
+        {
+            for (int i = 0; i < BoxCount; i++)
+            {
+                var boxOfs = GetBoxOffset(i) - ListHeaderSizeBox;
+                var size = BoxSize - 2;
+                var chk = Checksums.CheckSum16(Data, boxOfs, size);
+                BigEndian.GetBytes(chk).CopyTo(Data, boxOfs + size);
+            }
+        }
+
+        public override Type PKMType => typeof(SK2);
+        protected override PKM GetPKM(byte[] data) => new SK2(data, Japanese);
+        protected override byte[] DecryptPKM(byte[] data) => data;
+
+        public override PKM BlankPKM => new SK2(Japanese);
+        private const int SIZE_SK2 = PokeCrypto.SIZE_2STADIUM; // 60
+        protected override int SIZE_STORED => SIZE_SK2;
+        protected override int SIZE_PARTY => SIZE_SK2;
+
+        public SAV2Stadium(byte[] data) : this(data, IsJapanese(data)) { }
+
+        public SAV2Stadium(byte[] data, bool japanese) : base(data)
+        {
+            var swap = StadiumUtil.IsMagicPresentSwap(data, TeamSize, MAGIC_POKE);
+            if (swap)
+            {
+                BigEndian.SwapBytes32(Data);
+                IsPairSwapped = true;
+            }
+            Japanese = japanese;
+            Box = BoxStart;
+        }
+
+        public SAV2Stadium(bool japanese = false) : base(SaveUtil.SIZE_G1STAD)
+        {
+            Japanese = japanese;
+            Box = BoxStart;
+            ClearBoxes();
+        }
+
+        private const int ListHeaderSizeTeam = 0x10;
+        private const int ListHeaderSizeBox = 0x20;
+        private const int ListFooterSize = 6; // POKE + 2byte checksum
+
+        private const int TeamCount = 40;
+        private const int TeamSize = ListHeaderSizeTeam + (SIZE_SK2 * 6) + 2 + ListFooterSize; // 0x180
+        public static int GetTeamOffset(int team) => 0 + ListHeaderSizeTeam + (team * TeamSize);
+        public static string GetTeamName(int team) => $"Team {team + 1}";
+
+        public BattleTeam<SK2> GetTeam(int team)
+        {
+            if ((uint)team >= TeamCount)
+                throw new ArgumentOutOfRangeException(nameof(team));
+
+            var name = GetTeamName(team);
+            var members = new SK2[6];
+            var ofs = GetTeamOffset(team);
+            for (int i = 0; i < 6; i++)
+            {
+                var rel = ofs + (i * SIZE_STORED);
+                members[i] = (SK2)GetStoredSlot(Data, rel);
+            }
+            return new BattleTeam<SK2>(name, members);
+        }
+
+        private int BoxSize => Japanese ? BoxSizeJ : BoxSizeU;
+        private const int BoxSizeJ = ListHeaderSizeBox + (SIZE_SK2 * 30) + 2 + ListFooterSize; // 0x730
+        private const int BoxSizeU = ListHeaderSizeBox + (SIZE_SK2 * 20) + 2 + ListFooterSize; // 0x4D8
+
+        // Box 1 is stored separately from the remainder of the boxes.
+        private const int BoxStart = 0x5E00; // Box 1
+        private const int BoxContinue = 0x8000; // Box 2+
+
+        public override int GetBoxOffset(int box)
+        {
+            if (box == 0)
+                return BoxStart + ListHeaderSizeBox;
+            return BoxContinue + ListHeaderSizeBox + ((box - 1) * BoxSize);
+        }
+
+        public override string GetBoxName(int box) => $"Box {box + 1}";
+        public override void SetBoxName(int box, string value) { }
+
+        private const uint MAGIC_POKE = 0x30763350; // P3v0
+
+        public static bool IsStadium(byte[] data)
+        {
+            if (data.Length != SaveUtil.SIZE_G1STAD)
+                return false;
+            return StadiumUtil.IsMagicPresentEither(data, TeamSize, MAGIC_POKE);
+        }
+
+        // Check Box 1's footer magic.
+        private static bool IsJapanese(byte[] data) => StadiumUtil.IsMagicPresentAbsolute(data, BoxStart + BoxSizeJ - ListFooterSize, MAGIC_POKE);
+    }
+}

PKHeX.Core/Saves/Util/SaveUtil.cs

@@ -39,6 +39,7 @@ public static class SaveUtil
         public const int SIZE_G3XDGCI = SIZE_G3XD + 0x40; // GCI data
         public const int SIZE_G3RAW = 0x20000;
         public const int SIZE_G3RAWHALF = 0x10000;
+        public const int SIZE_G2STAD = 0x20000; // same as G3RAW_U
         public const int SIZE_G2RAW_U = 0x8000;
         public const int SIZE_G2VC_U = 0x8010;
         public const int SIZE_G2BAT_U = 0x802C;
@@ -122,6 +123,8 @@ private static GameVersion GetSAVType(byte[] data)
                 return Gen3;
             if (GetIsRanch4(data)) // ranch
                 return DPPt;
+            if (SAV2Stadium.IsStadium(data))
+                return Stadium2;
             if (SAV1Stadium.IsStadiumU(data) || SAV1Stadium.IsStadiumJ(data))
                 return Stadium;
             if (SAV1StadiumJ.IsStadiumJ(data))
@@ -524,14 +527,15 @@ private static GameVersion GetIsG8SAV(byte[] data)
                 case XD:     return new SAV3XD(data);
                 case RSBOX:  return new SAV3RSBox(data);
                 case BATREV: return new SAV4BR(data);
+                case Stadium2: return new SAV2Stadium(data);
+                case Stadium:  return new SAV1Stadium(data);
+                case StadiumJ: return new SAV1StadiumJ(data);
 
                 // Bulk Storage
                 case Gen3: return new Bank3(data);
                 case DPPt: return new SAV4Ranch(data);
                 case Gen4: return new Bank4(data);
                 case Gen7: return Bank7.GetBank7(data);
-                case Stadium: return new SAV1Stadium(data);
-                case StadiumJ: return new SAV1StadiumJ(data);
 
                 // No pattern matched
                 default: return null;

PKHeX.Core/Saves/Util/StadiumUtil.cs

@@ -44,5 +44,24 @@ public static bool IsMagicPresentSwap(byte[] data, int size, uint magic)
             }
             return true;
         }
+
+        public static bool IsMagicPresentAbsolute(byte[] data, int offset, uint magic)
+        {
+            var actual = BitConverter.ToUInt32(data, offset);
+            if (actual == magic) // POKE
+                return true;
+
+            var left = (ushort)magic;
+            var right = (ushort)(magic >> 16);
+            left = (ushort)((left >> 8) | (left << 8));
+            right = (ushort)((right >> 8) | (right << 8));
+
+            if (BitConverter.ToUInt16(data, offset - 2) != left) // OP
+                return false;
+            if (BitConverter.ToUInt16(data, offset + 4) != right) // EK
+                return false;
+
+            return true;
+        }
     }
-}
+}

PKHeX.WinForms/Controls/PKM Editor/EditPK2.cs

@@ -7,16 +7,16 @@ public partial class PKMEditor
     {
         private void PopulateFieldsPK2()
         {
-            if (!(Entity is PK2 pk2))
+            if (!(Entity is GBPKM pk2) || !(Entity is ICaughtData2 c2))
                 throw new FormatException(nameof(Entity));
 
             LoadMisc1(pk2);
             LoadMisc2(pk2);
 
             TID_Trainer.LoadIDValues(pk2);
-            TB_MetLevel.Text = pk2.Met_Level.ToString();
-            CB_MetLocation.SelectedValue = pk2.Met_Location;
-            CB_MetTimeOfDay.SelectedIndex = pk2.Met_TimeOfDay;
+            TB_MetLevel.Text = c2.Met_Level.ToString();
+            CB_MetLocation.SelectedValue = c2.Met_Location;
+            CB_MetTimeOfDay.SelectedIndex = c2.Met_TimeOfDay;
 
             // Attempt to detect language
             CB_Language.SelectedValue = pk2.GuessedLanguage();
@@ -25,17 +25,17 @@ private void PopulateFieldsPK2()
             UpdateStats();
         }
 
-        private PK2 PreparePK2()
+        private GBPKM PreparePK2()
         {
-            if (!(Entity is PK2 pk2))
+            if (!(Entity is GBPKM pk2) || !(Entity is ICaughtData2 c2))
                 throw new FormatException(nameof(Entity));
 
             SaveMisc1(pk2);
             SaveMisc2(pk2);
 
-            pk2.Met_Level = Util.ToInt32(TB_MetLevel.Text);
-            pk2.Met_Location = WinFormsUtil.GetIndex(CB_MetLocation);
-            pk2.Met_TimeOfDay = CB_MetTimeOfDay.SelectedIndex;
+            c2.Met_Level = Util.ToInt32(TB_MetLevel.Text);
+            c2.Met_Location = WinFormsUtil.GetIndex(CB_MetLocation);
+            c2.Met_TimeOfDay = CB_MetTimeOfDay.SelectedIndex;
 
             SavePartyStats(pk2);
             pk2.FixMoves();