PKHeX/PKHeX.Core/Legality/RNG/PIDGenerator.cs

408 lines
14 KiB
C#
Raw Normal View History

using System;
namespace PKHeX.Core
{
public static class PIDGenerator
{
private static void SetValuesFromSeedLCRNG(PKM pk, PIDType type, uint seed)
{
var rng = RNG.LCRNG;
var A = rng.Next(seed);
var B = rng.Next(A);
var skipBetweenPID = type == PIDType.Method_3 || type == PIDType.Method_3_Unown;
if (skipBetweenPID) // VBlank skip between PID rand() [RARE]
B = rng.Next(B);
var swappedPIDHalves = PIDType.Method_1_Unown <= type && type <= PIDType.Method_4_Unown;
if (swappedPIDHalves) // switched order of PID halves, "BA.."
pk.PID = (A & 0xFFFF0000) | B >> 16;
else
pk.PID = (B & 0xFFFF0000) | A >> 16;
var C = rng.Next(B);
var skipIV1Frame = type == PIDType.Method_2 || type == PIDType.Method_2_Unown;
if (skipIV1Frame) // VBlank skip after PID
C = rng.Next(C);
var D = rng.Next(C);
var skipIV2Frame = type == PIDType.Method_4 || type == PIDType.Method_4_Unown;
if (skipIV2Frame) // VBlank skip between IVs
D = rng.Next(D);
var IVs = MethodFinder.GetIVsInt32(C >> 16, D >> 16);
if (type == PIDType.Method_1_Roamer)
{
// Only store lowest 8 bits of IV data; zero out the other bits.
IVs[1] &= 7;
for (int i = 2; i < 6; i++)
IVs[i] = 0;
}
pk.IVs = IVs;
}
private static void SetValuesFromSeedBACD(PKM pk, PIDType type, uint seed)
{
var rng = RNG.LCRNG;
bool shiny = type == PIDType.BACD_R_S || type == PIDType.BACD_U_S;
uint X = shiny ? rng.Next(seed) : seed;
var A = rng.Next(X);
var B = rng.Next(A);
var C = rng.Next(B);
var D = rng.Next(C);
if (shiny)
{
uint PID = (X & 0xFFFF0000) | ((uint)pk.SID ^ (uint)pk.TID ^ X >> 16);
PID &= 0xFFFFFFF8;
PID |= B >> 16 & 0x7; // lowest 3 bits
pk.PID = PID;
}
else if (type == PIDType.BACD_R_AX || type == PIDType.BACD_U_AX)
{
uint low = B >> 16;
pk.PID = ((A & 0xFFFF0000) ^ (((uint)pk.TID ^ (uint)pk.SID ^ low) << 16)) | low;
}
else
{
pk.PID = (A & 0xFFFF0000) | B >> 16;
}
pk.IVs = MethodFinder.GetIVsInt32(C >> 16, D >> 16);
bool antishiny = type == PIDType.BACD_R_A || type == PIDType.BACD_U_A;
while (antishiny && pk.IsShiny)
pk.PID = unchecked(pk.PID + 1);
}
private static void SetValuesFromSeedXDRNG(PKM pk, uint seed)
{
var rng = RNG.XDRNG;
switch (pk.Species)
{
2019-06-01 17:22:49 +00:00
case (int)Species.Umbreon: // Colo Umbreon
case (int)Species.Eevee: // XD Eevee
pk.TID = (int)((seed = rng.Next(seed)) >> 16);
pk.SID = (int)((seed = rng.Next(seed)) >> 16);
seed = rng.Advance(seed, 2); // PID calls consumed
break;
2019-06-01 17:22:49 +00:00
case (int)Species.Espeon: // Colo Espeon
pk.TID = (int)((seed = rng.Next(seed)) >> 16);
pk.SID = (int)((seed = rng.Next(seed)) >> 16);
seed = rng.Advance(seed, 9); // PID calls consumed, skip over Umbreon
break;
}
var A = rng.Next(seed); // IV1
var B = rng.Next(A); // IV2
var C = rng.Next(B); // Ability?
var D = rng.Next(C); // PID
var E = rng.Next(D); // PID
pk.PID = (D & 0xFFFF0000) | E >> 16;
pk.IVs = MethodFinder.GetIVsInt32(A >> 16, B >> 16);
}
private static void SetValuesFromSeedChannel(PKM pk, uint seed)
{
var rng = RNG.XDRNG;
var O = rng.Next(seed); // SID
var A = rng.Next(O); // PID
var B = rng.Next(A); // PID
var C = rng.Next(B); // Held Item
var D = rng.Next(C); // Version
var E = rng.Next(D); // OT Gender
const int TID = 40122;
var SID = (int)(O >> 16);
var pid1 = A >> 16;
var pid2 = B >> 16;
pk.TID = TID;
pk.SID = SID;
var pid = pid1 << 16 | pid2;
if ((pid2 > 7 ? 0 : 1) != (pid1 ^ SID ^ TID))
pid ^= 0x80000000;
pk.PID = pid;
pk.HeldItem = (int)(C >> 31) + 169; // 0-Ganlon, 1-Salac
pk.Version = (int)(D >> 31) + 1; // 0-Sapphire, 1-Ruby
pk.OT_Gender = (int)(E >> 31);
pk.IVs = rng.GetSequentialIVsInt32(E);
}
public static void SetValuesFromSeed(PKM pk, PIDType type, uint seed)
{
var method = GetGeneratorMethod(type);
method(pk, seed);
}
private static Action<PKM, uint> GetGeneratorMethod(PIDType t)
{
switch (t)
{
case PIDType.Channel:
return SetValuesFromSeedChannel;
case PIDType.CXD:
return SetValuesFromSeedXDRNG;
case PIDType.Method_1:
case PIDType.Method_2:
case PIDType.Method_3:
case PIDType.Method_4:
case PIDType.Method_1_Unown:
case PIDType.Method_2_Unown:
case PIDType.Method_3_Unown:
case PIDType.Method_4_Unown:
case PIDType.Method_1_Roamer:
return (pk, seed) => SetValuesFromSeedLCRNG(pk, t, seed);
case PIDType.BACD_R:
case PIDType.BACD_R_A:
case PIDType.BACD_R_S:
return (pk, seed) => SetValuesFromSeedBACD(pk, t, seed & 0xFFFF);
case PIDType.BACD_U:
case PIDType.BACD_U_A:
case PIDType.BACD_U_S:
return (pk, seed) => SetValuesFromSeedBACD(pk, t, seed);
case PIDType.PokeSpot:
return SetRandomPIDIV;
case PIDType.G5MGShiny:
return SetValuesFromSeedMG5Shiny;
case PIDType.Pokewalker:
return (pk, seed) => pk.PID = GetPokeWalkerPID(pk.TID, pk.SID, seed%24, pk.Gender, pk.PersonalInfo.Gender);
// others: unimplemented
case PIDType.CuteCharm:
break;
case PIDType.ChainShiny:
return SetRandomChainShinyPID;
case PIDType.G4MGAntiShiny:
break;
}
return (_, __) => { };
}
public static void SetRandomChainShinyPID(PKM pk, uint seed)
{
// 13 rand bits
// 1 3-bit for upper
// 1 3-bit for lower
uint Next() => (seed = RNG.LCRNG.Next(seed)) >> 16;
uint lower = Next() & 7;
uint upper = Next() & 7;
for (int i = 0; i < 13; i++)
lower |= (Next() & 1) << (3 + i);
upper = ((uint)(lower ^ pk.TID ^ pk.SID) & 0xFFF8) | (upper & 0x7);
pk.PID = upper << 16 | lower;
pk.IVs = MethodFinder.GetIVsInt32(Next(), Next());
}
public static void SetRandomPokeSpotPID(PKM pk, int nature, int gender, int ability, int slot)
{
while (true)
{
var seed = Util.Rand32();
if (!MethodFinder.IsPokeSpotActivation(slot, seed, out var _))
continue;
var rng = RNG.XDRNG;
var D = rng.Next(seed); // PID
var E = rng.Next(D); // PID
pk.PID = (D & 0xFFFF0000) | E >> 16;
if (!IsValidCriteria4(pk, nature, ability, gender))
continue;
pk.SetRandomIVs();
return;
}
}
public static uint GetMG5ShinyPID(uint gval, uint av, int TID, int SID)
{
uint PID = (uint)((TID ^ SID ^ gval) << 16 | gval);
if ((PID & 0x10000) != av << 16)
PID ^= 0x10000;
return PID;
}
public static uint GetPokeWalkerPID(int TID, int SID, uint nature, int gender, int gr)
{
if (nature >= 24)
nature = 0;
uint pid = (uint)((TID ^ SID) >> 8 ^ 0xFF) << 24; // the most significant byte of the PID is chosen so the Pokémon can never be shiny.
// Ensure nature is set to required nature without affecting shininess
pid += nature - (pid % 25);
if (gr >= 0xFE || gr == 0) // non-dual gender
return pid;
// Ensure Gender is set to required gender without affecting other properties
// If Gender is modified, modify the ability if appropriate
// either m/f
var pidGender = (pid & 0xFF) < gr ? 1 : 0;
if (gender == pidGender)
return pid;
if (gender == 0) // Male
{
pid += (uint)((((gr - (pid & 0xFF)) / 25) + 1) * 25);
if ((nature & 1) != (pid & 1))
pid += 25;
}
else
{
pid -= (uint)(((((pid & 0xFF) - gr) / 25) + 1) * 25);
if ((nature & 1) != (pid & 1))
pid -= 25;
}
return pid;
}
public static void SetValuesFromSeedMG5Shiny(PKM pk, uint seed)
{
var gv = seed >> 24;
var av = seed & 1; // arbitrary choice
pk.PID = GetMG5ShinyPID(gv, av, pk.TID, pk.SID);
SetRandomIVs(pk);
}
public static void SetRandomWildPID(PKM pk, int gen, int nature, int ability, int gender, PIDType specific = PIDType.None)
{
if (specific == PIDType.Pokewalker)
{
pk.Gender = gender;
do
{
pk.PID = GetPokeWalkerPID(pk.TID, pk.SID, (uint) nature, gender, pk.PersonalInfo.Gender);
} while (!pk.IsGenderValid());
pk.RefreshAbility((int)(pk.PID & 1));
SetRandomIVs(pk);
return;
}
switch (gen)
{
case 3:
case 4:
SetRandomWildPID4(pk, nature, ability, gender, specific);
break;
case 5:
SetRandomWildPID5(pk, nature, ability, gender, specific);
break;
default:
SetRandomWildPID(pk, nature, ability, gender);
break;
}
}
/// <summary>
/// Generates a <see cref="PKM.PID"/> and <see cref="PKM.IVs"/> that are unrelated.
/// </summary>
/// <param name="pkm">Pokémon to modify.</param>
/// <param name="seed">Seed which is used for the <see cref="PKM.PID"/>.</param>
private static void SetRandomPIDIV(PKM pkm, uint seed)
{
pkm.PID = seed;
SetRandomIVs(pkm);
}
private static void SetRandomWildPID4(PKM pk, int nature, int ability, int gender, PIDType specific = PIDType.None)
{
pk.RefreshAbility(ability);
pk.Gender = gender;
var type = GetPIDType(pk, specific);
var method = GetGeneratorMethod(type);
while (true)
{
method(pk, Util.Rand32());
if (!IsValidCriteria4(pk, nature, ability, gender))
continue;
return;
}
}
private static bool IsValidCriteria4(PKM pk, int nature, int ability, int gender)
{
if (pk.GetSaneGender() != gender)
return false;
if (pk.Nature != nature)
return false;
if ((pk.PID & 1) != ability)
return false;
return true;
}
private static PIDType GetPIDType(PKM pk, PIDType specific)
{
if (specific != PIDType.None)
return specific;
if (pk.Version == 15)
return PIDType.CXD;
if (pk.Gen3 && pk.Species == (int)Species.Unown)
return PIDType.Method_1_Unown + Util.Rand.Next(3);
return PIDType.Method_1;
}
private static void SetRandomWildPID5(PKM pk, int nature, int ability, int gender, PIDType specific = PIDType.None)
{
var tidbit = (pk.TID ^ pk.SID) & 1;
pk.RefreshAbility(ability);
pk.Gender = gender;
pk.Nature = nature;
if (ability == 2)
ability = 0;
while (true)
{
uint seed = Util.Rand32();
if (specific == PIDType.G5MGShiny)
{
SetValuesFromSeedMG5Shiny(pk, seed);
seed = pk.PID;
}
else
{
var bitxor = (seed >> 31) ^ (seed & 1);
if (bitxor != tidbit)
seed ^= 1;
}
if (((seed >> 16) & 1) != ability)
continue;
pk.PID = seed;
if (pk.GetSaneGender() != gender)
continue;
SetRandomIVs(pk);
return;
}
}
private static void SetRandomWildPID(PKM pk, int nature, int ability, int gender)
{
uint seed = Util.Rand32();
pk.PID = seed;
pk.Nature = nature;
pk.Gender = gender;
pk.RefreshAbility(ability);
SetRandomIVs(pk);
}
private static void SetRandomIVs(PKM pk)
{
Offload EncounterSlot loading logic to reduce complexity (#2980) * Rework gen1 slot loading Slot templates are precomputed from ROM data and just loaded straight in, with tight coupling to the encounter area (grouped by slot types). * Revise fuzzy met check for underleveled wild evos Example: Level 23 poliwhirl in RBY as a level 50 poliwhirl, will assume the chain is 25-50 for poliwhirl (as poliwag evolves at 25). Instead of revising the origin chain, just ignore the evo min level in the comparison. Previous commit fixed it for gen1. * Rework gen2-4 slot loading Gen4 not finished, Type Encounter data and some edge encounters not recognizing yet... * Add feebas slots for old/good encounters * Begin moving properties Great news! Gen5-7 need to be de-dumbed like Gen1-4. Then I can remove the bang (!) on the Area accessor and ensure that it's never null! * Split off XD pokespot slot encounter table type * Set area in constructor * Deduplicate g3 roaming encounters * Deduplicate xd encounter locations (rebattle) Only difference is met location; no need to create 500 extra encounter objects. A simple contains check is ok (rarely in gen3 format). * Make all slots have a readonly reference to their parent area * Minor clean * Remove "Safari" slot type flag Can be determined via other means (generation-location), allows us to reduce the size of SlotType member to a byte Output of slot binaries didn't preserve the Safari flag anyway. * Update SlotType.cs * Handle type encounters correctly * Merge safari area into regular xy area * Merge dexnav accessor logic * fix some logic so that tests pass again rearrange g5 dw init to be done outside of static constructor (initializer instead) PIDGenerator: friend safari slots now generate with required flawless IV count * Add cianwood tentacool gift encounter * Remove unnecessary abstractions Fake area just returned a slot; since Slots have a non-null reference to the area, we can just return the slot and use the API to grab a list of possible slots for the chain. Increase restrictiveness of location/type get-set operations * Minor tweaks, pass parameters DexNav observed state isn't necessary to use, only need to see if it's possible to dexnav. Now that we have metadata for slots, we can. * Remove unused legality tables
2020-08-30 17:23:22 +00:00
pk.IVs = pk.SetRandomIVs();
}
}
}