internal static void SetBasicData(PKM pkm)
        {
            var newPID  = pkm.PID;
            var ability = pkm.GenNumber < 5 ? (int)(newPID & 1) : (int)(newPID >> 16) & 1;

            pkm.SetGender(PKX.GetGenderFromPID(pkm.Species, newPID));
            if (pkm.GenNumber < 5)
            {
                pkm.SetNature((int)(newPID % 25));
            }
            switch (pkm.GenNumber)
            {
            case 3:
                var pk3 = new PK3 {
                    PID = newPID, Species = pkm.Species
                };
                var pi3 = (PersonalInfoG3)pk3.PersonalInfo;
                if (!pi3.HasSecondAbility)
                {
                    pkm.SetAbility(pi3.Ability1);
                }
                else
                {
                    pkm.SetAbility(pi3.Abilities[ability]);
                }
                break;

            default:
                pkm.RefreshAbility(ability);
                break;
            }
            pkm.PID = newPID;
        }
示例#2
0
        public void PIDIVMatchingTest3Misc()
        {
            // Colosseum / XD
            var pk3 = new PK3 {
                PID = 0x0985A297, IVs = new[] { 06, 01, 00, 07, 17, 07 }
            };
            var ak3 = MethodFinder.Analyze(pk3);

            Assert.AreEqual(PIDType.CXD, MethodFinder.Analyze(pk3)?.Type, "Unable to match PID to CXD spread");

            var gk3 = new PK3();

            PIDGenerator.SetValuesFromSeed(gk3, PIDType.CXD, ak3.OriginSeed);
            Assert.AreEqual(pk3.PID, gk3.PID, "Unable to match generated PID to Channel spread");
            Assert.IsTrue(pk3.IVs.SequenceEqual(gk3.IVs), "Unable to match generated IVs to Channel spread");

            // Channel Jirachi
            var pkC = new PK3 {
                PID = 0x264750D9, IVs = new[] { 06, 31, 14, 27, 05, 27 }, SID = 45819, OT_Gender = 1, Version = (int)GameVersion.R
            };
            var akC = MethodFinder.Analyze(pkC);

            Assert.AreEqual(PIDType.Channel, akC.Type, "Unable to match PID to Channel spread");

            var gkC = new PK3();

            PIDGenerator.SetValuesFromSeed(gkC, PIDType.Channel, akC.OriginSeed);
            Assert.AreEqual(pkC.PID, gkC.PID, "Unable to match generated PID to Channel spread");
            Assert.IsTrue(pkC.IVs.SequenceEqual(gkC.IVs), "Unable to match generated IVs to Channel spread");
        }
示例#3
0
        public void PIDIVMatchingTest3()
        {
            // Method 1/2/4
            var pk1 = new PK3 {
                PID = 0xE97E0000, IVs = new[] { 17, 19, 20, 16, 13, 12 }
            };
            var ga1 = MethodFinder.Analyze(pk1);

            Assert.AreEqual(PIDType.Method_1, ga1.Type, "Unable to match PID to Method 1 spread");
            var pk2 = new PK3 {
                PID = 0x5271E97E, IVs = new[] { 02, 18, 03, 12, 22, 24 }
            };

            Assert.AreEqual(PIDType.Method_2, MethodFinder.Analyze(pk2)?.Type, "Unable to match PID to Method 2 spread");
            var pk4 = new PK3 {
                PID = 0x31B05271, IVs = new[] { 02, 18, 03, 05, 30, 11 }
            };

            Assert.AreEqual(PIDType.Method_4, MethodFinder.Analyze(pk4)?.Type, "Unable to match PID to Method 4 spread");

            var gk1 = new PK3();

            PIDGenerator.SetValuesFromSeed(gk1, ga1.Type, ga1.OriginSeed);
            Assert.AreEqual(pk1.PID, gk1.PID, "Unable to match generated PID to Method 1 PID");
            Assert.IsTrue(gk1.IVs.SequenceEqual(pk1.IVs), "Unable to match generated PID to Method 1 IVs");
        }
示例#4
0
        public static void VerifyResults(IReadOnlyList <uint[]> results, TeamLock[] team)
        {
            var pkm = new PK3();

            for (int i = 0; i < results.Count; i++)
            {
                var  result = results[i];
                var  seeds  = getSeeds(result[^ 1]);
示例#5
0
    public override PKM Clone()
    {
        // Don't use the byte[] constructor, the DecryptIfEncrypted call is based on checksum.
        // An invalid checksum will shuffle the data; we already know it's un-shuffled. Set up manually.
        var pk = new PK3();

        Data.CopyTo(pk.Data, 0);
        return(pk);
    }
示例#6
0
        public static void CheckGen3PID()
        {
            var pk3 = new PK3(File.ReadAllBytes(PKMFolder + @"\003 - VENUSAUR - 156F1CC41245.pk3"));

            Assert.NotNull(pk3);
            PIDEdits.Gen345UnShiny(pk3);

            Assert.True(new LegalityAnalysis(pk3).Valid, "Set Gen3 Pokemon UnShiny Successfully");
        }
示例#7
0
        public void PIDIVMatchingTest3Event()
        {
            // Restricted: TID/SID are zero.
            var pkR = new PK3 {
                PID = 0x0000E97E, IVs = new[] { 17, 19, 20, 16, 13, 12 }
            };

            Assert.AreEqual(PIDType.BACD_R, MethodFinder.Analyze(pkR)?.Type, "Unable to match PID to BACD-R spread");

            // Restricted Antishiny: PID is incremented 2 times to lose shininess.
            var pkRA = new PK3 {
                PID = 0x0000E980, IVs = new[] { 17, 19, 20, 16, 13, 12 }, TID = 01337, SID = 60486
            };

            Assert.AreEqual(PIDType.BACD_R_A, MethodFinder.Analyze(pkRA)?.Type, "Unable to match PID to BACD-R antishiny spread");

            // Unrestricted: TID/SID are zero.
            var pkU = new PK3 {
                PID = 0x67DBFC33, IVs = new[] { 12, 25, 27, 30, 02, 31 }
            };

            Assert.AreEqual(PIDType.BACD_U, MethodFinder.Analyze(pkU)?.Type, "Unable to match PID to BACD-U spread");

            // Unrestricted Antishiny: PID is incremented 5 times to lose shininess.
            var pkUA = new PK3 {
                PID = 0x67DBFC38, IVs = new[] { 12, 25, 27, 30, 02, 31 }, TID = 01337, SID = 40657
            };

            Assert.AreEqual(PIDType.BACD_U_A, MethodFinder.Analyze(pkUA)?.Type, "Unable to match PID to BACD-U antishiny spread");

            // berry fix zigzagoon: seed 0x0020
            var pkRS = new PK3 {
                PID = 0x38CA4EA0, IVs = new[] { 00, 20, 28, 11, 19, 00 }, TID = 30317, SID = 00000
            };
            var a_pkRS = MethodFinder.Analyze(pkRS);

            Assert.AreEqual(PIDType.BACD_R_S, a_pkRS?.Type, "Unable to match PID to BACD-R shiny spread");
            Assert.IsTrue(0x0020 == a_pkRS?.OriginSeed, "Unable to match PID to BACD-R shiny spread origin seed");

            var gkRS = new PK3 {
                TID = 30317, SID = 00000
            };

            PIDGenerator.SetValuesFromSeed(gkRS, PIDType.BACD_R_S, a_pkRS.OriginSeed);
            Assert.AreEqual(pkRS.PID, gkRS.PID, "Unable to match generated PID to BACD-R shiny spread");
            Assert.IsTrue(pkRS.IVs.SequenceEqual(gkRS.IVs), "Unable to match generated IVs to BACD-R shiny spread");

            // Unrestricted Antishiny nyx
            var nyxUA = new PK3 {
                PID = 0xBD3DF676, IVs = new[] { 00, 15, 05, 04, 21, 05 }, TID = 80, SID = 0
            };
            var nyx_pkUA = MethodFinder.Analyze(nyxUA);

            Assert.AreEqual(PIDType.BACD_U_AX, nyx_pkUA?.Type, "Unable to match PID to BACD-U antishiny nyx spread");
        }
示例#8
0
        /// <summary>
        /// Reads an archive from the path provided.
        /// </summary>
        /// <param name="path">The path to read from.</param>
        /// <returns>The archive, if it can be read.</returns>
        public static Optional <IArchive> ReadFile(string path)
        {
            if (path.EndsWith(".wad", StringComparison.OrdinalIgnoreCase))
            {
                return(Wad.FromArchive(path));
            }

            // Note that by not searching for PK3 only, we indirectly support
            // reading anything that is a zip archive.
            return(PK3.FromArchive(path));
        }
示例#9
0
        private static void Verify(TeamLock[] teams, uint pid, int[] ivs, bool xd = true)
        {
            var pk3 = new PK3 {
                PID = pid, IVs = ivs
            };
            var info = MethodFinder.Analyze(pk3);

            Assert.AreEqual(PIDType.CXD, info.Type, "Unable to match PID to CXD spread!");
            bool match = GetCanOriginateFrom(teams, info, xd, out var _);

            Assert.IsTrue(match, "Unable to verify lock conditions: " + teams[0].Species);
        }
示例#10
0
        private static void VerifySingle(TeamLock[] teams, uint pid, int[] ivs, bool xd = true)
        {
            var pk3 = new PK3 {
                PID = pid, IVs = ivs
            };
            var info = MethodFinder.Analyze(pk3);

            Assert.AreEqual(PIDType.CXD, info.Type, "Unable to match PID to CXD spread!");
            bool match = LockFinder.IsFirstShadowLockValid(info, teams, xd);

            Assert.IsTrue(match, "Unable to verify lock conditions: " + teams[0].Species);
        }
示例#11
0
        public static void Verify(TeamLock[] teams, uint pid, int[] ivs)
        {
            var pk3 = new PK3 {
                PID = pid, IVs = ivs
            };
            var info = MethodFinder.Analyze(pk3);

            info.Type.Should().Be(PIDType.CXD, "because the PID should match the CXD spread");
            bool match = LockFinder.IsAllShadowLockValid(info, teams);

            match.Should().BeTrue($"because the lock conditions for {teams[0].Species} should have been verified");
        }
示例#12
0
        public void PIDIVMatchingTest3()
        {
            // Method 1/2/4
            var pk1 = new PK3 {
                PID = 0xE97E0000, IVs = new[] { 17, 19, 20, 16, 13, 12 }
            };

            Assert.AreEqual(PIDType.Method_1, MethodFinder.Analyze(pk1)?.Type, "Unable to match PID to Method 1 spread");
            var pk2 = new PK3 {
                PID = 0x5271E97E, IVs = new[] { 02, 18, 03, 12, 22, 24 }
            };

            Assert.AreEqual(PIDType.Method_2, MethodFinder.Analyze(pk2)?.Type, "Unable to match PID to Method 2 spread");
            var pk4 = new PK3 {
                PID = 0x31B05271, IVs = new[] { 02, 18, 03, 05, 30, 11 }
            };

            Assert.AreEqual(PIDType.Method_4, MethodFinder.Analyze(pk4)?.Type, "Unable to match PID to Method 4 spread");

            // Method 1/2/4, reversed for Unown.
            var pk1U = new PK3 {
                PID = 0x815549A2, IVs = new[] { 02, 26, 30, 30, 11, 26 }, Species = 201
            };                                                                                          // Unown-C

            Assert.AreEqual(PIDType.Method_1_Unown, MethodFinder.Analyze(pk1U)?.Type, "Unable to match PID to Method 1 Unown spread");
            var pk2U = new PK3 {
                PID = 0x8A7B5190, IVs = new[] { 14, 02, 21, 30, 29, 15 }, Species = 201
            };                                                                                          // Unown-M

            Assert.AreEqual(PIDType.Method_2_Unown, MethodFinder.Analyze(pk2U)?.Type, "Unable to match PID to Method 2 Unown spread");
            var pk4U = new PK3 {
                PID = 0x5FA80D70, IVs = new[] { 02, 06, 03, 26, 04, 19 }, Species = 201
            };                                                                                          // Unown-A

            Assert.AreEqual(PIDType.Method_4_Unown, MethodFinder.Analyze(pk4U)?.Type, "Unable to match PID to Method 4 Unown spread");

            // Colosseum / XD
            var pk3 = new PK3 {
                PID = 0x0985A297, IVs = new[] { 06, 01, 00, 07, 17, 07 }
            };

            Assert.AreEqual(PIDType.CXD, MethodFinder.Analyze(pk3)?.Type, "Unable to match PID to CXD spread");

            // Channel Jirachi
            var pkC = new PK3 {
                PID = 0x9E27D2F6, IVs = new[] { 04, 15, 21, 14, 18, 29 }
            };

            Assert.AreEqual(PIDType.Channel, MethodFinder.Analyze(pkC)?.Type, "Unable to match PID to Channel spread");
        }
示例#13
0
        public void PIDIVMatchingTest3Method3()
        {
            // Method 3, reversed for Unown.
            var m3R = new PK3 {
                PID = 0x3DD1BB49, IVs = new[] { 23, 12, 31, 09, 03, 03 }, Species = 001
            };                                                                                             // Regular
            var m3t = MethodFinder.Analyze(m3R)?.Type;

            Assert.Equal(PIDType.Method_3, m3t);
            var m3u = new PK3 {
                PID = 0xBB493DD1, IVs = new[] { 23, 12, 31, 09, 03, 03 }, Species = 201
            };                                                                                             // Unown
            var u3t = MethodFinder.Analyze(m3u)?.Type;

            Assert.Equal(PIDType.Method_3_Unown, u3t);
        }
示例#14
0
        public void PIDIVMatchingTest3MiscCXD()
        {
            // Colosseum / XD
            var pk3 = new PK3 {
                PID = 0x0985A297, IVs = new[] { 06, 01, 00, 07, 17, 07 }
            };

            var(type, seed) = MethodFinder.Analyze(pk3);
            Assert.Equal(PIDType.CXD, type);

            var gk3 = new PK3();

            PIDGenerator.SetValuesFromSeed(gk3, PIDType.CXD, seed);
            Assert.Equal(pk3.PID, gk3.PID);
            Assert.True(pk3.IVs.SequenceEqual(gk3.IVs), "Unable to match generated IVs to CXD spread");
        }
示例#15
0
        public void PIDIVMatchingTest3MiscChannel()
        {
            // Channel Jirachi
            var pkC = new PK3 {
                PID = 0x264750D9, IVs = new[] { 06, 31, 14, 27, 05, 27 }, SID = 45819, OT_Gender = 1, Version = (int)GameVersion.R
            };

            var(type, seed) = MethodFinder.Analyze(pkC);
            Assert.Equal(PIDType.Channel, type);

            var gkC = new PK3();

            PIDGenerator.SetValuesFromSeed(gkC, PIDType.Channel, seed);
            Assert.Equal(pkC.PID, gkC.PID);
            Assert.True(pkC.IVs.SequenceEqual(gkC.IVs), "Unable to match generated IVs to Channel spread");
        }
示例#16
0
        public void PIDIVPokeSpotTest()
        {
            // XD PokeSpots: Check all 3 Encounter Slots (examples are one for each location).
            var pkPS0 = new PK3 {
                PID = 0x7B2D9DA7
            };                                        // Zubat (Cave)

            Assert.IsTrue(MethodFinder.GetPokeSpotSeeds(pkPS0, 0).Any(), "PokeSpot encounter info mismatch (Common)");
            var pkPS1 = new PK3 {
                PID = 0x3EE9AF66
            };                                        // Gligar (Rock)

            Assert.IsTrue(MethodFinder.GetPokeSpotSeeds(pkPS1, 1).Any(), "PokeSpot encounter info mismatch (Uncommon)");
            var pkPS2 = new PK3 {
                PID = 0x9B667F3C
            };                                        // Surskit (Oasis)

            Assert.IsTrue(MethodFinder.GetPokeSpotSeeds(pkPS2, 2).Any(), "PokeSpot encounter info mismatch (Rare)");
        }
示例#17
0
        public void PIDIVMatchingTest3Unown()
        {
            // Method 1/2/4, reversed for Unown.
            var pk1U = new PK3 {
                PID = 0x815549A2, IVs = new[] { 02, 26, 30, 30, 11, 26 }, Species = 201
            };                                                                                          // Unown-C

            Assert.AreEqual(PIDType.Method_1_Unown, MethodFinder.Analyze(pk1U)?.Type, "Unable to match PID to Method 1 Unown spread");
            var pk2U = new PK3 {
                PID = 0x8A7B5190, IVs = new[] { 14, 02, 21, 30, 29, 15 }, Species = 201
            };                                                                                          // Unown-M

            Assert.AreEqual(PIDType.Method_2_Unown, MethodFinder.Analyze(pk2U)?.Type, "Unable to match PID to Method 2 Unown spread");
            var pk4U = new PK3 {
                PID = 0x5FA80D70, IVs = new[] { 02, 06, 03, 26, 04, 19 }, Species = 201
            };                                                                                          // Unown-A

            Assert.AreEqual(PIDType.Method_4_Unown, MethodFinder.Analyze(pk4U)?.Type, "Unable to match PID to Method 4 Unown spread");
        }
示例#18
0
        public void PIDIVMethod4IVs()
        {
            var pk4 = new PK3 {
                PID = 0xFEE73213, IVs = new[] { 03, 29, 23, 30, 28, 24 }
            };

            Assert.AreEqual(PIDType.Method_4, MethodFinder.Analyze(pk4)?.Type, "Unable to match PID to Method 4 spread");

            // See if any origin seed for the IVs matches what we expect
            // Load the IVs
            uint rand1 = 0; // HP/ATK/DEF
            uint rand3 = 0; // SPE/SPA/SPD
            var  IVs   = pk4.IVs;

            for (int i = 0; i < 3; i++)
            {
                rand1 |= (uint)IVs[i] << (5 * i);
                rand3 |= (uint)IVs[i + 3] << (5 * i);
            }
            Assert.IsTrue(MethodFinder.GetSeedsFromIVsSkip(RNG.LCRNG, rand1, rand3).Any(z => z == 0xFEE7047C));
        }
示例#19
0
        public void PIDIVEncounterSlotTest()
        {
            // Modest Method 1
            var pk = new PK3 {
                PID = 0x6937DA48, IVs = new[] { 31, 31, 31, 31, 31, 31 }
            };
            var pidiv = MethodFinder.Analyze(pk);

            Assert.AreEqual(PIDType.Method_1, pidiv?.Type, "Unable to match PID to Method 1 spread");

            // Test for Method J
            {
                // Pearl
                pk.Version = (int)GameVersion.P;
                var       results       = FrameFinder.GetFrames(pidiv, pk);
                const int failSyncCount = 1;
                const int noSyncCount   = 2;
                const int SyncCount     = 37;
                var       r2            = results.ToArray();
                var       failSync      = r2.Where(z => z.Lead == LeadRequired.SynchronizeFail);
                var       noSync        = r2.Where(z => z.Lead == LeadRequired.None);
                var       sync          = r2.Where(z => z.Lead == LeadRequired.Synchronize);

                Assert.AreEqual(failSync.Count(), failSyncCount, "Failed Sync count mismatch.");
                Assert.AreEqual(sync.Count(), SyncCount, "Sync count mismatch.");
                Assert.AreEqual(noSync.Count(), noSyncCount, "Non-Sync count mismatch.");

                var type  = SlotType.Grass;
                var slots = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 9 };
                Assert.IsTrue(slots.All(s => r2.Any(z => z.GetSlot(type) == s)), "Required slots not present.");
                var slotsForType = r2.Where(z => !z.LevelSlotModified).Select(z => z.GetSlot(type)).Distinct().OrderBy(z => z);
                Assert.IsTrue(slotsForType.SequenceEqual(slots), "Unexpected slots present.");
            }
            // Test for Method H and K
            {
                // Sapphire
                // pk.Version = (int)GameVersion.S;
                // var results = FrameFinder.GetFrames(pidiv, pk);
            }
        }
示例#20
0
        public void PIDIVMatchingTest3Event()
        {
            // Restricted: TID/SID are zero.
            var pkR = new PK3 {
                PID = 0x0000E97E, IVs = new[] { 17, 19, 20, 16, 13, 12 }
            };

            Assert.AreEqual(PIDType.BACD_R, MethodFinder.Analyze(pkR)?.Type, "Unable to match PID to BACD-R spread");

            // Restricted Antishiny: PID is incremented 2 times to lose shininess.
            var pkRA = new PK3 {
                PID = 0x0000E980, IVs = new[] { 17, 19, 20, 16, 13, 12 }, TID = 01337, SID = 60486
            };

            Assert.AreEqual(PIDType.BACD_R_A, MethodFinder.Analyze(pkRA)?.Type, "Unable to match PID to BACD-R antishiny spread");

            // Unrestricted: TID/SID are zero.
            var pkU = new PK3 {
                PID = 0x67DBFC33, IVs = new[] { 12, 25, 27, 30, 02, 31 }
            };

            Assert.AreEqual(PIDType.BACD_U, MethodFinder.Analyze(pkU)?.Type, "Unable to match PID to BACD-U spread");

            // Unrestricted Antishiny: PID is incremented 5 times to lose shininess.
            var pkUA = new PK3 {
                PID = 0x67DBFC38, IVs = new[] { 12, 25, 27, 30, 02, 31 }, TID = 01337, SID = 40657
            };

            Assert.AreEqual(PIDType.BACD_U_A, MethodFinder.Analyze(pkUA)?.Type, "Unable to match PID to BACD-U antishiny spread");

            // berry fix zigzagoon: seed 0x0020
            var pkRS = new PK3 {
                PID = 0x38CA4EA0, IVs = new[] { 00, 20, 28, 11, 19, 00 }, TID = 30317, SID = 00000
            };
            var a_pkRS = MethodFinder.Analyze(pkRS);

            Assert.AreEqual(PIDType.BACD_R_S, a_pkRS?.Type, "Unable to match PID to BACD-R shiny spread");
            Assert.IsTrue(0x0020 == a_pkRS?.OriginSeed, "Unable to match PID to BACD-R shiny spread origin seed");
        }
示例#21
0
        public void PIDIVMethod4IVs()
        {
            var pk4 = new PK3 {
                PID = 0xFEE73213, IVs = new[] { 03, 29, 23, 30, 28, 24 }
            };
            var analysis = MethodFinder.Analyze(pk4);

            analysis.Type.Should().Be(PIDType.Method_4);

            // See if any origin seed for the IVs matches what we expect
            // Load the IVs
            uint rand1 = 0; // HP/ATK/DEF
            uint rand3 = 0; // SPE/SPA/SPD
            var  IVs   = pk4.IVs;

            for (int i = 0; i < 3; i++)
            {
                rand1 |= (uint)IVs[i] << (5 * i);
                rand3 |= (uint)IVs[i + 3] << (5 * i);
            }
            Assert.Contains(MethodFinder.GetSeedsFromIVsSkip(RNG.LCRNG, rand1, rand3), z => z == 0xFEE7047C);
        }
示例#22
0
        public void SimulatorGetWC3()
        {
            var set = new ShowdownSet(SetROCKSMetang);
            var pk3 = new PK3 {
                Species = set.Species, AltForm = set.FormIndex, Moves = set.Moves
            };
            var encs = EncounterMovesetGenerator.GenerateEncounters(pk3, set.Moves, GameVersion.R);

            Assert.IsTrue(encs.Any());
            encs = EncounterMovesetGenerator.GenerateEncounters(pk3, set.Moves, GameVersion.R);
            var first = encs.FirstOrDefault();

            Assert.IsTrue(first != null);

            var wc3  = (WC3)first;
            var info = new SimpleTrainerInfo();
            var pk   = wc3.ConvertToPKM(info);

            var la = new LegalityAnalysis(pk);

            Assert.IsTrue(la.Valid);
        }
示例#23
0
            public static void VerifyResults(IReadOnlyList <uint[]> results, TeamLock[] team)
            {
                var pkm = new PK3();

                for (int i = 0; i < results.Count; i++)
                {
                    var  result = results[i];
                    var  seeds  = getSeeds(result[result.Length - 1]);
                    bool match  = false;
                    foreach (var seed in seeds)
                    {
                        PIDGenerator.SetValuesFromSeed(pkm, PIDType.CXD, seed);
                        var info = MethodFinder.Analyze(pkm);
                        info.OriginSeed.Should().Be(seed);
                        info.Type.Should().Be(PIDType.CXD, "because the PID should have matched the CXD spread");
                        if (!GetCanOriginateFrom(team, info))
                        {
                            continue;
                        }
                        match = true;
                        break;
                    }
                    match.Should().BeTrue($"because the lock conditions for result {i} and species {team[0].Species} should have been verified");
                }

                IEnumerable <uint> getSeeds(uint PID)
                {
                    var top = PID >> 16;
                    var bot = PID & 0xFFFF;

                    var seeds = MethodFinder.GetSeedsFromPIDEuclid(RNG.XDRNG, top, bot);

                    foreach (var s in seeds)
                    {
                        yield return(RNG.XDRNG.Reverse(s, 3));
                    }
                }
            }
示例#24
0
        public void PIDIVEncounterSlotTest()
        {
            // Modest Method 1
            var pk = new PK3 {
                PID = 0x6937DA48, IVs = new[] { 31, 31, 31, 31, 31, 31 }
            };
            var pidiv = MethodFinder.Analyze(pk);

            Assert.Equal(PIDType.Method_1, pidiv?.Type);

            // Test for Method J
            {
                // Pearl
                pk.Version = (int)GameVersion.P;
                var results = FrameFinder.GetFrames(pidiv, pk).ToArray();

                var failSync = results.Where(z => z.Lead == LeadRequired.SynchronizeFail);
                var noSync   = results.Where(z => z.Lead == LeadRequired.None);
                var sync     = results.Where(z => z.Lead == LeadRequired.Synchronize);

                failSync.Should().HaveCount(1);
                sync.Should().HaveCount(37);
                noSync.Should().HaveCount(2);

                const SlotType type  = SlotType.Grass;
                var            slots = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 9 };
                Assert.True(slots.All(s => results.Any(z => z.GetSlot(type) == s)), "Required slots not present.");
                var slotsForType = results.Where(z => !z.LevelSlotModified).Select(z => z.GetSlot(type)).Distinct().OrderBy(z => z);
                Assert.True(slotsForType.SequenceEqual(slots), "Unexpected slots present.");
            }
            // Test for Method H and K
            {
                // Sapphire
                // pk.Version = (int)GameVersion.S;
                // var results = FrameFinder.GetFrames(pidiv, pk);
            }
        }
示例#25
0
        public static void VerifyResults(IReadOnlyList <uint[]> results, TeamLock[] team)
        {
            var pkm = new PK3();

            for (int i = 0; i < results.Count; i++)
            {
                var  result = results[i];
                var  seeds  = getSeeds(result[result.Length - 1]);
                bool match  = false;
                foreach (var seed in seeds)
                {
                    PIDGenerator.SetValuesFromSeed(pkm, PIDType.CXD, seed);
                    var info = MethodFinder.Analyze(pkm);
                    info.OriginSeed.Should().Be(seed);
                    info.Type.Should().Be(PIDType.CXD, "because the PID should have matched the CXD spread");
                    if (!LockFinder.IsAllShadowLockValid(info, team))
                    {
                        continue;
                    }
                    match = true;
                    break;
                }
                match.Should().BeTrue($"because the lock conditions for result {i} and species {team[0].Species} should have been verified");
            }
示例#26
0
        public void AddToBoxesButtonClick(Object sender, EventArgs events)
        {
            var        sav          = SaveFileEditor.SAV;                                        // current save
            int        generation   = sav.Generation;                                            // the generation of the current save -- used to determine the PK save format
            List <PKM> pokemonList  = new List <PKM>();                                          // list of all Pokemon that will be added to the sav
            string     showdownData = this.input.Text;                                           // user's input

            var pokemonArray = JsonConvert.DeserializeObject <List <RawPokemon> >(showdownData); //jsonify the data

            foreach (RawPokemon rawPokemon in pokemonArray)
            {
                PKM pokemon = new PK2();

                //Determine save format
                switch (generation)
                {
                case 1:
                    pokemon = new PK1();
                    break;

                case 2:
                    pokemon = new PK2();
                    break;

                case 3:
                    pokemon = new PK3();
                    break;

                case 4:
                    pokemon = new PK4();
                    break;

                case 5:
                    pokemon = new PK5();
                    break;

                case 6:
                    pokemon = new PK6();
                    break;

                case 7:
                    pokemon = new PK7();
                    break;

                case 8:
                    pokemon = new PK8();
                    break;
                }

                // Set the species according to the Species enum
                int speciesAsNumber = 0;

                //Check if the Pokemon is Alolan or not; if it is, do some extra logic to set the proper form
                if (rawPokemon.Species.Contains("Alolan"))
                {
                    string[] pokemon_name = rawPokemon.Species.Split('_');
                    speciesAsNumber = (int)(Species)Enum.Parse(typeof(Species), pokemon_name[1]);
                    pokemon.SetForm(810);
                    pokemon.Species = speciesAsNumber;
                }
                else
                {
                    speciesAsNumber = (int)(Species)Enum.Parse(typeof(Species), rawPokemon.Species);
                    pokemon.Species = speciesAsNumber;
                }

                // Check to see if the Pokemon has forms (i.e. Flabebe, Shellos, etc.), and if it does, randomly generate one
                if (rawPokemon.Species.Contains("Burmy"))
                {
                    int form = random.Next(0, burmyForms.Length - 1);
                    pokemon.SetForm(form);
                }
                else if (rawPokemon.Species.Contains("Shellos"))
                {
                    int form = random.Next(0, shellosForms.Length - 1);
                    pokemon.SetForm(form);
                }
                else if (rawPokemon.Species.Contains("Scatterbug"))
                {
                    int form = random.Next(0, scatterbugForms.Length - 1);
                    pokemon.SetForm(form);
                }
                else if (rawPokemon.Species.Contains("Flabébé"))
                {
                    int form = random.Next(0, flabebeForms.Length - 1);
                    pokemon.SetForm(form);
                }
                else if (rawPokemon.Species.Contains("Oricorio"))
                {
                    int form = random.Next(0, oricorioForms.Length - 1);
                    pokemon.SetForm(form);
                }
                else if (rawPokemon.Species.Contains("Minior"))
                {
                    int form = random.Next(0, miniorForms.Length - 1);
                    pokemon.SetForm(form);
                }

                GameVersion  game         = (GameVersion)sav.Game;
                EncounterEgg encounterEgg = new EncounterEgg(speciesAsNumber, pokemon.Form, 1, sav.Generation, game);
                PKM          pokemonAsEgg = encounterEgg.ConvertToPKM(sav);
                pokemonAsEgg.IsEgg  = true;
                pokemon.IsNicknamed = true;
                pokemon.Nickname    = "Egg";

                // Set the ability
                string ability         = rawPokemon.Ability.Replace(" ", "");
                int    abilityAsNumber = (int)(Ability)Enum.Parse(typeof(Ability), ability);
                pokemonAsEgg.SetAbility(abilityAsNumber);

                //Set gender
                switch (rawPokemon.Gender)
                {
                case "M":
                    pokemonAsEgg.SetGender(0);
                    break;

                case "F":
                    pokemonAsEgg.SetGender(1);
                    break;

                case "N":
                    pokemonAsEgg.SetGender(2);
                    break;
                }

                // Set Nature via the Nature enum
                int natureAsNumber = (int)(Nature)Enum.Parse(typeof(Nature), rawPokemon.Nature);
                pokemonAsEgg.Nature = natureAsNumber;

                // Set the IVs
                pokemonAsEgg.IV_HP  = rawPokemon.HP;
                pokemonAsEgg.IV_ATK = rawPokemon.Atk;
                pokemonAsEgg.IV_DEF = rawPokemon.Def;
                pokemonAsEgg.IV_SPA = rawPokemon.SpA;
                pokemonAsEgg.IV_SPD = rawPokemon.SpD;
                pokemonAsEgg.IV_SPE = rawPokemon.Spe;

                // Set moves and make sure they have the proper PP
                string move = "";
                if (string.IsNullOrEmpty(rawPokemon.MoveOne) == false)
                {
                    move = rawPokemon.MoveOne.Replace("-", "");
                    move = move.Replace(" ", "");
                    pokemonAsEgg.Move1        = (int)(Move)Enum.Parse(typeof(Move), move);
                    pokemonAsEgg.RelearnMove1 = pokemonAsEgg.Move1;
                }
                if (string.IsNullOrEmpty(rawPokemon.MoveTwo) == false)
                {
                    move = rawPokemon.MoveTwo.Replace("-", "");
                    move = move.Replace(" ", "");
                    pokemonAsEgg.Move2        = (int)(Move)Enum.Parse(typeof(Move), move);
                    pokemonAsEgg.RelearnMove2 = pokemonAsEgg.Move2;
                }
                if (string.IsNullOrEmpty(rawPokemon.MoveThree) == false)
                {
                    move = rawPokemon.MoveThree.Replace("-", "");
                    move = move.Replace(" ", "");
                    pokemonAsEgg.Move3        = (int)(Move)Enum.Parse(typeof(Move), move);
                    pokemonAsEgg.RelearnMove3 = pokemonAsEgg.Move3;
                }
                if (string.IsNullOrEmpty(rawPokemon.MoveFour) == false)
                {
                    move = rawPokemon.MoveFour.Replace("-", "");
                    move = move.Replace(" ", "");
                    pokemonAsEgg.Move4        = (int)(Move)Enum.Parse(typeof(Move), move);
                    pokemonAsEgg.RelearnMove4 = pokemonAsEgg.Move4;
                }

                pokemonAsEgg.SetMaximumPPCurrent();

                //Finally, if the Pokemon is supposed to be shiny, make it so
                if (rawPokemon.IsShiny == "true")
                {
                    CommonEdits.SetShiny(pokemonAsEgg);
                }
                else
                {
                    CommonEdits.SetUnshiny(pokemonAsEgg);
                }

                pokemonAsEgg.Met_Location = 0;

                if (generation == 7 || generation == 6 || generation == 5)
                {
                    pokemonAsEgg.Egg_Location = Locations.Daycare5;
                }
                else
                {
                    pokemonAsEgg.Egg_Location = Locations.Daycare4;
                }

                pokemonAsEgg.IsNicknamed = true;
                pokemonAsEgg.Nickname    = SpeciesName.GetSpeciesNameGeneration(0, sav.Language, generation);

                //Hatch counter is for some reason called "CurrentFriendship".  Don't ask me why, I don't know.
                pokemonAsEgg.CurrentFriendship = 1;

                pokemonList.Add(pokemonAsEgg);
            }

            // Import Pokemon, reload the boxes so they can be seen, show a message and close the window
            sav.ImportPKMs(pokemonList);
            SaveFileEditor.ReloadSlots();
            MessageBox.Show("Done!");
            this.input.Clear();
            this.form.Close();
        }
示例#27
0
        private PKM preparePK3()
        {
            PK3 pk3 = pkm as PK3;

            if (pk3 == null)
            {
                return(null);
            }

            pk3.Species       = WinFormsUtil.getIndex(CB_Species);
            pk3.HeldItem      = WinFormsUtil.getIndex(CB_HeldItem);
            pk3.TID           = Util.ToInt32(TB_TID.Text);
            pk3.SID           = Util.ToInt32(TB_SID.Text);
            pk3.EXP           = Util.ToUInt32(TB_EXP.Text);
            pk3.PID           = Util.getHEXval(TB_PID.Text);
            pk3.AbilityNumber = 1 << CB_Ability.SelectedIndex; // to match gen6+

            pk3.FatefulEncounter = CHK_Fateful.Checked;
            pk3.Gender           = PKX.getGender(Label_Gender.Text);
            pk3.EV_HP            = Util.ToInt32(TB_HPEV.Text);
            pk3.EV_ATK           = Util.ToInt32(TB_ATKEV.Text);
            pk3.EV_DEF           = Util.ToInt32(TB_DEFEV.Text);
            pk3.EV_SPE           = Util.ToInt32(TB_SPEEV.Text);
            pk3.EV_SPA           = Util.ToInt32(TB_SPAEV.Text);
            pk3.EV_SPD           = Util.ToInt32(TB_SPDEV.Text);

            pk3.CNT_Cool   = Util.ToInt32(TB_Cool.Text);
            pk3.CNT_Beauty = Util.ToInt32(TB_Beauty.Text);
            pk3.CNT_Cute   = Util.ToInt32(TB_Cute.Text);
            pk3.CNT_Smart  = Util.ToInt32(TB_Smart.Text);
            pk3.CNT_Tough  = Util.ToInt32(TB_Tough.Text);
            pk3.CNT_Sheen  = Util.ToInt32(TB_Sheen.Text);

            pk3.PKRS_Days   = CB_PKRSDays.SelectedIndex;
            pk3.PKRS_Strain = CB_PKRSStrain.SelectedIndex;
            pk3.Nickname    = TB_Nickname.Text;
            pk3.Move1       = WinFormsUtil.getIndex(CB_Move1);
            pk3.Move2       = WinFormsUtil.getIndex(CB_Move2);
            pk3.Move3       = WinFormsUtil.getIndex(CB_Move3);
            pk3.Move4       = WinFormsUtil.getIndex(CB_Move4);
            pk3.Move1_PP    = WinFormsUtil.getIndex(CB_Move1) > 0 ? Util.ToInt32(TB_PP1.Text) : 0;
            pk3.Move2_PP    = WinFormsUtil.getIndex(CB_Move2) > 0 ? Util.ToInt32(TB_PP2.Text) : 0;
            pk3.Move3_PP    = WinFormsUtil.getIndex(CB_Move3) > 0 ? Util.ToInt32(TB_PP3.Text) : 0;
            pk3.Move4_PP    = WinFormsUtil.getIndex(CB_Move4) > 0 ? Util.ToInt32(TB_PP4.Text) : 0;
            pk3.Move1_PPUps = WinFormsUtil.getIndex(CB_Move1) > 0 ? CB_PPu1.SelectedIndex : 0;
            pk3.Move2_PPUps = WinFormsUtil.getIndex(CB_Move2) > 0 ? CB_PPu2.SelectedIndex : 0;
            pk3.Move3_PPUps = WinFormsUtil.getIndex(CB_Move3) > 0 ? CB_PPu3.SelectedIndex : 0;
            pk3.Move4_PPUps = WinFormsUtil.getIndex(CB_Move4) > 0 ? CB_PPu4.SelectedIndex : 0;

            pk3.IV_HP       = Util.ToInt32(TB_HPIV.Text);
            pk3.IV_ATK      = Util.ToInt32(TB_ATKIV.Text);
            pk3.IV_DEF      = Util.ToInt32(TB_DEFIV.Text);
            pk3.IV_SPE      = Util.ToInt32(TB_SPEIV.Text);
            pk3.IV_SPA      = Util.ToInt32(TB_SPAIV.Text);
            pk3.IV_SPD      = Util.ToInt32(TB_SPDIV.Text);
            pk3.IsEgg       = CHK_IsEgg.Checked;
            pk3.IsNicknamed = CHK_Nicknamed.Checked;

            pk3.OT_Name           = TB_OT.Text;
            pk3.CurrentFriendship = Util.ToInt32(TB_Friendship.Text);

            pk3.Ball      = WinFormsUtil.getIndex(CB_Ball);
            pk3.Met_Level = Util.ToInt32(TB_MetLevel.Text);
            pk3.OT_Gender = PKX.getGender(Label_OTGender.Text);
            pk3.Version   = WinFormsUtil.getIndex(CB_GameOrigin);
            pk3.Language  = WinFormsUtil.getIndex(CB_Language);

            pk3.Met_Location = WinFormsUtil.getIndex(CB_MetLocation);

            // Toss in Party Stats
            Array.Resize(ref pk3.Data, pk3.SIZE_PARTY);
            pk3.Stat_Level     = Util.ToInt32(TB_Level.Text);
            pk3.Stat_HPCurrent = Util.ToInt32(Stat_HP.Text);
            pk3.Stat_HPMax     = Util.ToInt32(Stat_HP.Text);
            pk3.Stat_ATK       = Util.ToInt32(Stat_ATK.Text);
            pk3.Stat_DEF       = Util.ToInt32(Stat_DEF.Text);
            pk3.Stat_SPE       = Util.ToInt32(Stat_SPE.Text);
            pk3.Stat_SPA       = Util.ToInt32(Stat_SPA.Text);
            pk3.Stat_SPD       = Util.ToInt32(Stat_SPD.Text);

            if (HaX)
            {
                pk3.Stat_Level = (byte)Math.Min(Convert.ToInt32(MT_Level.Text), byte.MaxValue);
            }

            // Fix Moves if a slot is empty
            pk3.FixMoves();

            pk3.RefreshChecksum();
            return(pk3);
        }
示例#28
0
文件: PKM.cs 项目: kwsch/PKHeX
 public PKM convertToPK3()
 {
     if (Format != 3)
         return null;
     if (GetType() == typeof(PK3))
         return this;
     var pk = new PK3();
     TransferPropertiesWithReflection(this, pk);
     pk.RefreshChecksum();
     return pk;
 }
示例#29
0
        private void populateFieldsPK3()
        {
            PK3 pk3 = pkm as PK3;

            if (pk3 == null)
            {
                return;
            }

            // Do first
            pk3.Stat_Level = PKX.getLevel(pk3.Species, pk3.EXP);
            if (pk3.Stat_Level == 100 && !HaX)
            {
                pk3.EXP = PKX.getEXP(pk3.Stat_Level, pk3.Species);
            }

            CB_Species.SelectedValue = pk3.Species;
            TB_Level.Text            = pk3.Stat_Level.ToString();
            TB_EXP.Text = pk3.EXP.ToString();

            // Load rest
            CHK_Fateful.Checked      = pk3.FatefulEncounter;
            CHK_IsEgg.Checked        = pk3.IsEgg;
            CHK_Nicknamed.Checked    = pk3.IsNicknamed;
            Label_OTGender.Text      = gendersymbols[pk3.OT_Gender];
            Label_OTGender.ForeColor = getGenderColor(pk3.OT_Gender);
            TB_PID.Text = pk3.PID.ToString("X8");
            CB_HeldItem.SelectedValue = pk3.HeldItem;
            CB_Ability.SelectedIndex  = pk3.AbilityBit && CB_Ability.Items.Count > 1 ? 1 : 0;
            CB_Nature.SelectedValue   = pk3.Nature;
            TB_TID.Text                    = pk3.TID.ToString("00000");
            TB_SID.Text                    = pk3.SID.ToString("00000");
            TB_Nickname.Text               = pk3.Nickname;
            TB_OT.Text                     = pk3.OT_Name;
            TB_Friendship.Text             = pk3.CurrentFriendship.ToString();
            GB_OT.BackgroundImage          = null;
            CB_Language.SelectedValue      = pk3.Language;
            CB_GameOrigin.SelectedValue    = pk3.Version;
            CB_EncounterType.SelectedValue = pk3.Gen4 ? pk3.EncounterType : 0;
            CB_Ball.SelectedValue          = pk3.Ball;

            CB_MetLocation.SelectedValue = pk3.Met_Location;

            TB_MetLevel.Text = pk3.Met_Level.ToString();

            // Reset Label and ComboBox visibility, as well as non-data checked status.
            Label_PKRS.Visible     = CB_PKRSStrain.Visible = CHK_Infected.Checked = pk3.PKRS_Strain != 0;
            Label_PKRSdays.Visible = CB_PKRSDays.Visible = pk3.PKRS_Days != 0;

            // Set SelectedIndexes for PKRS
            CB_PKRSStrain.SelectedIndex = pk3.PKRS_Strain;
            CHK_Cured.Checked           = pk3.PKRS_Strain > 0 && pk3.PKRS_Days == 0;
            CB_PKRSDays.SelectedIndex   = Math.Min(CB_PKRSDays.Items.Count - 1, pk3.PKRS_Days); // to strip out bad hacked 'rus

            TB_Cool.Text   = pk3.CNT_Cool.ToString();
            TB_Beauty.Text = pk3.CNT_Beauty.ToString();
            TB_Cute.Text   = pk3.CNT_Cute.ToString();
            TB_Smart.Text  = pk3.CNT_Smart.ToString();
            TB_Tough.Text  = pk3.CNT_Tough.ToString();
            TB_Sheen.Text  = pk3.CNT_Sheen.ToString();

            TB_HPIV.Text            = pk3.IV_HP.ToString();
            TB_ATKIV.Text           = pk3.IV_ATK.ToString();
            TB_DEFIV.Text           = pk3.IV_DEF.ToString();
            TB_SPEIV.Text           = pk3.IV_SPE.ToString();
            TB_SPAIV.Text           = pk3.IV_SPA.ToString();
            TB_SPDIV.Text           = pk3.IV_SPD.ToString();
            CB_HPType.SelectedValue = pk3.HPType;

            TB_HPEV.Text  = pk3.EV_HP.ToString();
            TB_ATKEV.Text = pk3.EV_ATK.ToString();
            TB_DEFEV.Text = pk3.EV_DEF.ToString();
            TB_SPEEV.Text = pk3.EV_SPE.ToString();
            TB_SPAEV.Text = pk3.EV_SPA.ToString();
            TB_SPDEV.Text = pk3.EV_SPD.ToString();

            CB_Move1.SelectedValue = pk3.Move1;
            CB_Move2.SelectedValue = pk3.Move2;
            CB_Move3.SelectedValue = pk3.Move3;
            CB_Move4.SelectedValue = pk3.Move4;
            CB_PPu1.SelectedIndex  = pk3.Move1_PPUps;
            CB_PPu2.SelectedIndex  = pk3.Move2_PPUps;
            CB_PPu3.SelectedIndex  = pk3.Move3_PPUps;
            CB_PPu4.SelectedIndex  = pk3.Move4_PPUps;
            TB_PP1.Text            = pk3.Move1_PP.ToString();
            TB_PP2.Text            = pk3.Move2_PP.ToString();
            TB_PP3.Text            = pk3.Move3_PP.ToString();
            TB_PP4.Text            = pk3.Move4_PP.ToString();

            // Set Form if count is enough, else cap.
            CB_Form.SelectedIndex = CB_Form.Items.Count > pk3.AltForm ? pk3.AltForm : CB_Form.Items.Count - 1;

            // Load Extrabyte Value
            TB_ExtraByte.Text = pk3.Data[Convert.ToInt32(CB_ExtraBytes.Text, 16)].ToString();

            updateStats();

            TB_EXP.Text            = pk3.EXP.ToString();
            Label_Gender.Text      = gendersymbols[pk3.Gender];
            Label_Gender.ForeColor = getGenderColor(pk3.Gender);
        }