public NatureLock(int lockNum)
{
lockInfo = natureLockListGales(lockNum);
rand = new List <uint>();
if (lockInfo != null)
{
backCount = lockInfo.Length;
frontCount = backCount == 1 ? 0 : backCount - 2;
shadowCount = backCount - 1;
x = 0;
if (backCount == 1)
{
getCurrLock();
}
}
reverse = new XdRngR(0);
forward = new XdRng(0);
}
private void buttonXDSetStats_Click(object sender, EventArgs e)
{
if (dataGridViewXDCalibration.SelectedRows[0] != null)
{
var frame = (IFrameCaptureXD) dataGridViewXDCalibration.SelectedRows[0].DataBoundItem;
gameTick = frame.Seed;
var oneFrameBack = new XdRngR((uint) frame.Seed);
gameTickAlt = oneFrameBack.GetNext32BitNumber();
maskedTextBoxXDHp.Text = frame.DisplayHp;
maskedTextBoxXDAtk.Text = frame.DisplayAtk;
maskedTextBoxXDDef.Text = frame.DisplayDef;
maskedTextBoxXDSpa.Text = frame.DisplaySpa;
maskedTextBoxXDSpd.Text = frame.DisplaySpd;
maskedTextBoxXDSpe.Text = frame.DisplaySpe;
textBoxXDNature.Text = frame.Nature;
}
}
// We need a function to return a list of monster seeds,
// which will be updated to include a method.
public static List <Seed> GetXDSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List <Seed>();
uint ivs1 = hp + (atk << 5) + (def << 10);
uint ivs2 = spe | (spa << 5) | (spd << 10);
uint x_testXD = ivs1 << 16;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0xFFFF; cnt++)
{
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = x_testXD | cnt;
var rngXD = new XdRng(seed);
uint rng1XD = rngXD.GetNext16BitNumber();
//Check if ivs line up
if ((rng1XD & 0x7FFF) == ivs2)
{
var rngXDR = new XdRngR(seed);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
uint rng2XD = rngXD.GetNext16BitNumber();
uint rng3XD = rngXD.GetNext16BitNumber();
uint rng4XD = rngXD.GetNext16BitNumber();
uint pid = (rng3XD << 16) | rng4XD;
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3] [rng4]
if (pid % 25 == nature)
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = pid,
MonsterSeed = XDColoSeed
};
seeds.Add(newSeed);
}
// Check Colosseum\XD XOR
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3] [rng4]
pid ^= 0x80008000;
if (pid % 25 == nature)
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = pid,
MonsterSeed = XDColoSeed ^ 0x80000000
};
seeds.Add(newSeed);
}
}
}
return(seeds);
}
private void buttonGenerateXD_Click(object sender, EventArgs e)
{
if (maskedTextBoxMinHP.Text == "")
{
maskedTextBoxMinHP.Focus();
maskedTextBoxMinHP.SelectAll();
return;
}
if (maskedTextBoxMinAtk.Text == "")
{
maskedTextBoxMinAtk.Focus();
maskedTextBoxMinAtk.SelectAll();
return;
}
if (maskedTextBoxMinDef.Text == "")
{
maskedTextBoxMinDef.Focus();
maskedTextBoxMinDef.SelectAll();
return;
}
if (maskedTextBoxMinSpA.Text == "")
{
maskedTextBoxMinSpA.Focus();
maskedTextBoxMinSpA.SelectAll();
return;
}
if (maskedTextBoxMinSpD.Text == "")
{
maskedTextBoxMinSpD.Focus();
maskedTextBoxMinSpD.SelectAll();
return;
}
if (maskedTextBoxMinSpe.Text == "")
{
maskedTextBoxMinSpe.Focus();
maskedTextBoxMinSpe.SelectAll();
return;
}
if (maskedTextBoxMaxHP.Text == "")
{
maskedTextBoxMaxHP.Focus();
maskedTextBoxMaxHP.SelectAll();
return;
}
if (maskedTextBoxMaxAtk.Text == "")
{
maskedTextBoxMaxAtk.Focus();
maskedTextBoxMaxAtk.SelectAll();
return;
}
if (maskedTextBoxMaxDef.Text == "")
{
maskedTextBoxMaxDef.Focus();
maskedTextBoxMaxDef.SelectAll();
return;
}
if (maskedTextBoxMaxSpA.Text == "")
{
maskedTextBoxMaxSpA.Focus();
maskedTextBoxMaxSpA.SelectAll();
return;
}
if (maskedTextBoxMaxSpD.Text == "")
{
maskedTextBoxMaxSpD.Focus();
maskedTextBoxMaxSpD.SelectAll();
return;
}
if (maskedTextBoxMaxSpe.Text == "")
{
maskedTextBoxMaxSpe.Focus();
maskedTextBoxMaxSpe.SelectAll();
return;
}
uint minhp = uint.Parse(maskedTextBoxMinHP.Text);
uint minatk = uint.Parse(maskedTextBoxMinAtk.Text);
uint mindef = uint.Parse(maskedTextBoxMinDef.Text);
uint minspa = uint.Parse(maskedTextBoxMinSpA.Text);
uint minspd = uint.Parse(maskedTextBoxMinSpD.Text);
uint minspe = uint.Parse(maskedTextBoxMinSpe.Text);
uint maxhp = uint.Parse(maskedTextBoxMaxHP.Text);
uint maxatk = uint.Parse(maskedTextBoxMaxAtk.Text);
uint maxdef = uint.Parse(maskedTextBoxMaxDef.Text);
uint maxspa = uint.Parse(maskedTextBoxMaxSpA.Text);
uint maxspd = uint.Parse(maskedTextBoxMaxSpD.Text);
uint maxspe = uint.Parse(maskedTextBoxMaxSpe.Text);
var nature = (uint) comboBoxNatureXD.SelectedIndex;
var XDGenerator = new FrameGenerator();
List<Frame> frames = XDGenerator.Generate(minhp, maxhp,
minatk, maxatk,
mindef, maxdef,
minspa, maxspa,
minspd, maxspd,
minspe, maxspe,
nature);
var iframes = new List<IFrameCaptureXD>();
foreach (Frame frame in frames)
{
var iframe = new IFrameCaptureXD {Frame = frame};
// We're calibrating only with shadow Pokémon that are generated first in the party.
// There are 375451 frames between the initial seed generation and Pokémon generation,
// so we need to reverse the RNG that many frames
var reverseRNG = new XdRngR(frame.Seed);
for (int i = 0; i < 375450; i++)
{
reverseRNG.GetNext32BitNumber();
}
iframe.Seed = reverseRNG.GetNext32BitNumber();
//iframe.Seed = frame.Seed;
iframes.Add(iframe);
}
dataGridViewXDCalibration.DataSource = iframes;
}
public static List<Seed> GetSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List<Seed>();
uint x4 = 0;
uint x4_2 = 0;
x4 = spe + (spa << 5) + (spd << 10);
x4_2 = x4 ^ 0x8000;
uint x8 = 0;
uint x8_2 = 0;
x8 = hp + (atk << 5) + (def << 10);
x8_2 = x8 ^ 0x8000;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0x1FFFE; cnt++)
{
uint x_test;
uint x_testXD;
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
x_test = (cnt & 1) == 0 ? x4 : x4_2;
x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_test << 16) + (cnt%0xFFFF);
uint seedXD = (x_testXD << 16) + (cnt%0xFFFF);
var rng = new PokeRngR(seed);
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1 = rng.GetNext16BitNumber();
ushort rng2 = rng.GetNext16BitNumber();
ushort rng3 = rng.GetNext16BitNumber();
ushort rng4 = rng.GetNext16BitNumber();
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
uint method1Seed = rng.Seed;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
ushort choppedPID;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng3, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed();
newSeed.Method = "Method 1";
newSeed.Pid = ((uint) rng2 << 16) + rng3;
newSeed.MonsterSeed = method1Seed;
newSeed.Sid = (rng2 ^ (uint) rng3 ^ id) & 0xFFF8;
seeds.Add(newSeed);
}
// Check Method 2
// [PID] [PID] [xxxx] [IVs] [IVs]
// [rng4] [rng3] [xxxx] [rng1] [START]
if (Check(rng1, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 2",
Pid = ((uint) rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint) rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
/*
* Removed because Method 3 doesn't exist in-game
// Check Method 3
// [PID] [xxxx] [PID] [IVs] [IVs]
// [rng4] [xxxx] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
Seed newSeed = new Seed();
newSeed.Method = "Method 3";
newSeed.Pid = ((uint)rng2 << 16) + (uint)rng4;
newSeed.MonsterSeed = method234Seed;
newSeed.Sid = ((uint)rng2 ^ (uint)rng4 ^ id) & 0xFFF8;
seeds.Add(newSeed);
}
*/
// Check Method 4
// [PID] [PID] [IVs] [xxxx] [IVs]
// [rng4] [rng3] [rng2] [xxxx] [START]
if (Check(rng2, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 4",
Pid = ((uint) rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint) rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3]
if (Check(rng1XD, rng3XD, rng4XD, spe, spa, spd, nature))
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = ((uint) rng3XD << 16) + rng4XD,
MonsterSeed = XDColoSeed,
Sid = (rng4XD ^ (uint) rng3XD ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
if (rng3/0x5556 != 0)
{
// Check DPPt Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2/0xA3E);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2/0xA3E + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2/0xA3E + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2/0xA3E + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2/0xA3E + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
if (rng3%3 != 0)
{
// Check HGSS Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2%25);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2%25 + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2%25 + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2%25 + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort) (rng2%25 + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
}
return seeds;
}
public static List <Seed> GetSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List <Seed>();
uint ivs2 = spe | (spa << 5) | (spd << 10);
uint ivs1 = hp | (atk << 5) | (def << 10);
uint x_test = ivs2 << 16;
uint x_testXD = ivs1 << 16;
uint pid, pidXor, sid;
bool pass = false;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0xFFFF; cnt++)
{
//Check to see if the iv calls line up
uint seedXD = x_testXD | cnt;
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint rng1XD = rngXD.GetNext16BitNumber();
if ((rng1XD & 0x7FFF) == ivs2)
{
//Grab rest of RNG calls for XDColo
uint rng2XD = rngXD.GetNext16BitNumber();
uint rng3XD = rngXD.GetNext16BitNumber();
uint rng4XD = rngXD.GetNext16BitNumber();
uint XDColoSeed = rngXDR.GetNext32BitNumber();
uint XDColoSeedXor = XDColoSeed ^ 0x80000000;
sid = (rng4XD ^ rng3XD ^ id) & 0xFFF8;
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3]
pid = (rng3XD << 16) | rng4XD;
if (pid % 25 == nature)
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = pid,
MonsterSeed = XDColoSeed,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Colosseum\XD XOR
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3]
pidXor = pid ^ 0x80008000;
if (pidXor % 25 == nature)
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = pidXor,
MonsterSeed = XDColoSeedXor,
Sid = sid
};
seeds.Add(newSeed);
}
}
// Now test rest of methods
uint seed = x_test | cnt;
var rng = new PokeRngR(seed);
uint rng1 = rng.GetNext16BitNumber();
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
uint rng2 = rng.GetNext16BitNumber();
uint rng3 = rng.GetNext16BitNumber();
uint rng4 = rng.GetNext16BitNumber();
uint method1Seed = rng.Seed;
uint method1SeedXor = method1Seed ^ 0x80000000;
sid = (rng2 ^ rng3 ^ id) & 0xFFF8;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
uint method234SeedXor = method234Seed ^ 0x80000000;
//Checks that ivs line up
if ((rng1 & 0x7FFF) == ivs1)
{
uint choppedPID;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
pid = (rng2 << 16) + rng3;
if (pid % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 1",
Pid = pid,
MonsterSeed = method1Seed,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Method 1 XOR
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
pidXor = pid ^ 0x80008000;
if (pidXor % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 1",
Pid = pidXor,
MonsterSeed = method1SeedXor,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Reverse Method 1
// [PID] [PID] [IVs] [IVs]
// [rng2] [rng3] [rng1] [START]
pid = (rng3 << 16) + rng2;
if (pid % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Reverse Method 1",
Pid = pid,
MonsterSeed = method1Seed,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Reverse Method 1 XOR
// [PID] [PID] [IVs] [IVs]
// [rng2] [rng3] [rng1] [START]
pid = pid ^ 0x80008000;
if (pid % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Reverse Method 1",
Pid = pid,
MonsterSeed = method1SeedXor,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Wishmkr
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (pid % 25 == nature)
{
if (method1Seed < 0x10000)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Pid = pid,
MonsterSeed = method1Seed,
Sid = sid
};
newSeed.Method = Functions.Shiny(newSeed.Pid, 20043, 0) ? "Wishmkr Shiny" : "Wishmkr";
seeds.Add(newSeed);
}
}
// Check Wishmkr XOR
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (pidXor % 25 == nature)
{
if (method1SeedXor < 0x10000)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Pid = pidXor,
MonsterSeed = method1SeedXor,
Sid = sid
};
newSeed.Method = Functions.Shiny(newSeed.Pid, 20043, 0) ? "Wishmkr Shiny" : "Wishmkr";
seeds.Add(newSeed);
}
}
// Check Method 2
// [PID] [PID] [xxxx] [IVs] [IVs]
// [rng4] [rng3] [xxxx] [rng1] [START]
pid = (rng3 << 16) + rng4;
sid = (rng3 ^ rng4 ^ id) & 0xFFF8;
if (pid % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 2",
Pid = pid,
MonsterSeed = method234Seed,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Method 2
// [PID] [PID] [xxxx] [IVs] [IVs]
// [rng4] [rng3] [xxxx] [rng1] [START]
pidXor = pid ^ 0x80008000;
if (pidXor % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 2",
Pid = pidXor,
MonsterSeed = method234SeedXor,
Sid = sid
};
seeds.Add(newSeed);
}
/* Removed because Method 3 doesn't exist in-game
* // Check Method 3
* // [PID] [xxxx] [PID] [IVs] [IVs]
* // [rng4] [xxxx] [rng2] [rng1] [START]
* if (Check(rng1, rng2, rng4, hp, atk, def, nature))
* {
* // Build a seed to add to our collection
* Seed newSeed = new Seed();
* newSeed.Method = "Method 3";
* newSeed.Pid = (rng2 << 16) + rng4;
* newSeed.MonsterSeed = method234Seed;
* newSeed.Sid = (rng2 ^ rng4 ^ id) & 0xFFF8;
*
* seeds.Add(newSeed);
* } */
// DPPt Cute Charm
if (rng3 / 0x5556 != 0)
{
// Check DPPt Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = rng2 / 0xA3E;
pass = choppedPID % 25 == nature;
if (pass)
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x96;
if (pass)
{
choppedPID += 0x96;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0xC8;
if (pass)
{
choppedPID += 0x32;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x4B;
if (pass)
{
choppedPID -= 0x7D;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x32;
if (pass)
{
choppedPID -= 0x19;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
// HGSS Cute Charm
if (rng3 % 3 != 0)
{
// Check HGSS Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = rng2 % 25;
pass = choppedPID == nature;
if (pass)
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x96;
if (pass)
{
choppedPID += 0x96;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0xC8;
if (pass)
{
choppedPID += 0x32;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x4B;
if (pass)
{
choppedPID -= 0x7D;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x32;
if (pass)
{
choppedPID -= 0x19;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
// DPPt Cute Charm XOR
uint rng3Xor = rng3 ^ 0x8000;
uint rng2Xor = rng2 ^ 0x8000;
if (rng3Xor / 0x5556 != 0)
{
// Check DPPt Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = rng2Xor / 0xA3E;
pass = choppedPID % 25 == nature;
if (pass)
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x96;
if (pass)
{
choppedPID += 0x96;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0xC8;
if (pass)
{
choppedPID += 0x32;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x4B;
if (pass)
{
choppedPID -= 0x7D;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 / 0xA3E + 0x32;
if (pass)
{
choppedPID -= 0x19;
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
// HGSS Cute Charm XOR
if (rng3Xor % 3 != 0)
{
// Check HGSS Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = rng2Xor % 25;
pass = choppedPID == nature;
if (pass)
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x96;
if (pass)
{
choppedPID += 0x96;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0xC8;
if (pass)
{
choppedPID += 0x32;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x4B;
if (pass)
{
choppedPID -= 0x7D;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
//choppedPID = rng2 % 25 + 0x32;
if (pass)
{
choppedPID -= 0x19;
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1SeedXor,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
}
if ((rng2 & 0x7FFF) == ivs1)
{
// Check Method 4
// [PID] [PID] [IVs] [xxxx] [IVs]
// [rng4] [rng3] [rng2] [xxxx] [START]
pid = (rng3 << 16) + rng4;
sid = (rng3 ^ rng4 ^ id) & 0xFFF8;
if (pid % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 4",
Pid = pid,
MonsterSeed = method234Seed,
Sid = sid
};
seeds.Add(newSeed);
}
// Check Method 4 XOR
// [PID] [PID] [IVs] [xxxx] [IVs]
// [rng4] [rng3] [rng2] [xxxx] [START]
pidXor = pid ^ 0x80008000;
if (pidXor % 25 == nature)
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 4",
Pid = pidXor,
MonsterSeed = method234SeedXor,
Sid = sid
};
seeds.Add(newSeed);
}
}
}
return(seeds);
}
// We need a function to return a list of monster seeds,
// which will be updated to include a method.
public static List<Seed> GetXDSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List<Seed>();
uint x8 = 0;
uint x8_2 = 0;
x8 = hp + (atk << 5) + (def << 10);
x8_2 = x8 ^ 0x8000;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0x1FFFE; cnt++)
{
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
uint x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_testXD << 16) + (cnt%0xFFFF);
var rngXD = new XdRng(seed);
var rngXDR = new XdRngR(seed);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3] [rng4]
if (Check(rng1XD, rng3XD, rng4XD, spe, spa, spd, nature))
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = ((uint) rng3XD << 16) + rng4XD,
MonsterSeed = XDColoSeed
};
seeds.Add(newSeed);
}
}
return seeds;
}
private void buttonGenerate_Click(object sender, EventArgs e)
{
// Initial seed that we are going to used for our frame generation
ulong seed = 0;
if (textBoxSeed.Text != "")
{
seed = ulong.Parse(textBoxSeed.Text, NumberStyles.HexNumber);
}
uint maxFrames = 1000;
if (maskedTextBoxMaxFrames.Text != "")
{
maxFrames = uint.Parse(maskedTextBoxMaxFrames.Text);
}
// Generic RNG Interface
IRNG rng = null;
IRNG64 rng64 = null;
// Instantiate based on the type that
// the user has selected ------------
if (radioButtonCommon.Checked)
{
switch (comboBoxRNG.SelectedIndex)
{
case 0:
rng = new PokeRng((uint) seed);
break;
case 1:
rng = new PokeRngR((uint) seed);
break;
case 2:
// if the given seed is 64 bit, remove the lower 32 bits.
if (seed >= 0x100000000) seed >>= 32;
rng = new MersenneTwister((uint) seed);
break;
case 3:
rng64 = new BWRng(seed);
break;
case 4:
rng64 = new BWRngR(seed);
break;
case 5:
rng = new XdRng((uint) seed);
break;
case 6:
rng = new XdRngR((uint) seed);
break;
case 7:
rng = new ARng((uint) seed);
break;
case 8:
rng = new ARngR((uint) seed);
break;
case 9:
rng = new GRng((uint) seed);
break;
case 10:
rng = new GRngR((uint) seed);
break;
case 11:
rng = new EncounterRng((uint) seed);
break;
case 12:
rng = new EncounterRngR((uint) seed);
break;
case 13:
rng = new MersenneTwisterUntempered((int) seed);
break;
case 14:
rng = new MersenneTwisterFast((uint) seed, (int) maxFrames);
break;
case 15:
rng = new MersenneTwisterTable((uint) seed);
break;
}
}
if (radioButtonCustom.Checked)
{
// Check to see if we had valid values in the entry fields, and if so
// covert them over to the adding and multiplier so we can instantiate
// a generic LCRNG.
ulong mult = 0;
ulong add = 0;
if (textBoxMult.Text != "")
{
mult = ulong.Parse(textBoxMult.Text, NumberStyles.HexNumber);
}
if (textBoxAdd.Text != "")
{
add = ulong.Parse(textBoxAdd.Text, NumberStyles.HexNumber);
}
if (checkBox64bit.Checked)
{
rng64 = new GenericRng64(seed, mult, add);
}
else
{
rng = new GenericRng((uint) seed, (uint) mult, (uint) add);
}
}
// This is our collection of operators. At some point, if this gets
// fancy, we may want to break it off and have it in it's own class
var calculators = new Dictionary<string, Calculator>();
calculators["%"] = (x, y) => x%y;
calculators["*"] = (x, y) => x*y;
calculators["/"] = (x, y) => y == 0 ? 0 : x/y;
calculators["&"] = (x, y) => x & y;
calculators["^"] = (x, y) => x ^ y;
calculators["|"] = (x, y) => x | y;
calculators["+"] = (x, y) => x + y;
calculators["-"] = (x, y) => x - y;
calculators[">>"] = (x, y) => x >> (int) y;
calculators["<<"] = (x, y) => x << (int) y;
bool calcCustom1 =
textBoxRValue1.Text != "" &&
(string) comboBoxOperator1.SelectedItem != null &&
(string) comboBoxLValue1.SelectedItem != null;
bool calcCustom2 =
(textBoxRValue2.Text != "" || comboBoxRValue2.SelectedIndex != 0) &&
(string) comboBoxOperator2.SelectedItem != null &&
(string) comboBoxLValue2.SelectedItem != null;
bool calcCustom3 =
(textBoxRValue3.Text != "" || comboBoxRValue3.SelectedIndex != 0) &&
(string) comboBoxOperator3.SelectedItem != null &&
(string) comboBoxLValue3.SelectedItem != null;
bool calcCustom4 =
(textBoxRValue4.Text != "" || comboBoxRValue4.SelectedIndex != 0) &&
(string) comboBoxOperator4.SelectedItem != null &&
(string) comboBoxLValue4.SelectedItem != null;
bool calcCustom5 =
(textBoxRValue5.Text != "" || comboBoxRValue5.SelectedIndex != 0) &&
(string) comboBoxOperator5.SelectedItem != null &&
(string) comboBoxLValue5.SelectedItem != null;
bool calcCustom6 =
(textBoxRValue6.Text != "" || comboBoxRValue6.SelectedIndex != 0) &&
(string) comboBoxOperator6.SelectedItem != null &&
(string) comboBoxLValue6.SelectedItem != null;
bool calcCustom7 =
(textBoxRValue7.Text != "" || comboBoxRValue7.SelectedIndex != 0) &&
(string) comboBoxOperator7.SelectedItem != null &&
(string) comboBoxLValue7.SelectedItem != null;
// Build our custom item transform classes so that we can use them in
// the future without having to do a parse of all of the items.
ulong customRValue1;
ulong customRValue2;
ulong customRValue3;
ulong customRValue4;
ulong customRValue5;
ulong customRValue6;
ulong customRValue7;
try
{
customRValue1 = (textBoxRValue1.Text == ""
? 0
: (checkBoxCustom1Hex.Checked
? ulong.Parse(textBoxRValue1.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue1.Text)));
customRValue2 = (textBoxRValue2.Text == ""
? 0
: (checkBoxCustom2Hex.Checked
? ulong.Parse(textBoxRValue2.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue2.Text)));
customRValue3 = (textBoxRValue3.Text == ""
? 0
: (checkBoxCustom3Hex.Checked
? ulong.Parse(textBoxRValue3.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue3.Text)));
customRValue4 = (textBoxRValue4.Text == ""
? 0
: (checkBoxCustom4Hex.Checked
? ulong.Parse(textBoxRValue4.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue4.Text)));
customRValue5 = (textBoxRValue5.Text == ""
? 0
: (checkBoxCustom5Hex.Checked
? ulong.Parse(textBoxRValue5.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue5.Text)));
customRValue6 = (textBoxRValue6.Text == ""
? 0
: (checkBoxCustom6Hex.Checked
? ulong.Parse(textBoxRValue6.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue6.Text)));
customRValue7 = (textBoxRValue7.Text == ""
? 0
: (checkBoxCustom7Hex.Checked
? ulong.Parse(textBoxRValue7.Text, NumberStyles.HexNumber)
: ulong.Parse(textBoxRValue7.Text)));
}
catch (Exception ex)
{
MessageBox.Show("You must check off the Hex box in order to calculate using hex values.", ex.Message);
return;
}
Calculator custom1Calc = ((string) comboBoxOperator1.SelectedItem == null
? null
: calculators[(string) comboBoxOperator1.SelectedItem]);
Calculator custom2Calc = ((string) comboBoxOperator2.SelectedItem == null
? null
: calculators[(string) comboBoxOperator2.SelectedItem]);
Calculator custom3Calc = ((string) comboBoxOperator3.SelectedItem == null
? null
: calculators[(string) comboBoxOperator3.SelectedItem]);
Calculator custom4Calc = ((string) comboBoxOperator4.SelectedItem == null
? null
: calculators[(string) comboBoxOperator4.SelectedItem]);
Calculator custom5Calc = ((string) comboBoxOperator5.SelectedItem == null
? null
: calculators[(string) comboBoxOperator5.SelectedItem]);
Calculator custom6Calc = ((string) comboBoxOperator6.SelectedItem == null
? null
: calculators[(string) comboBoxOperator6.SelectedItem]);
Calculator custom7Calc = ((string) comboBoxOperator7.SelectedItem == null
? null
: calculators[(string) comboBoxOperator7.SelectedItem]);
// Decide on whether we are going to display each of these items as
// decimal or hex. Can be very useful either way, so it is an option.
Custom1.DefaultCellStyle.Format = checkBoxCustom1Hex.Checked ? "X8" : "";
Custom2.DefaultCellStyle.Format = checkBoxCustom2Hex.Checked ? "X8" : "";
Custom3.DefaultCellStyle.Format = checkBoxCustom3Hex.Checked ? "X8" : "";
Custom4.DefaultCellStyle.Format = checkBoxCustom4Hex.Checked ? "X8" : "";
Custom5.DefaultCellStyle.Format = checkBoxCustom5Hex.Checked ? "X8" : "";
Custom6.DefaultCellStyle.Format = checkBoxCustom6Hex.Checked ? "X8" : "";
Custom7.DefaultCellStyle.Format = checkBoxCustom7Hex.Checked ? "X8" : "";
var frames = new List<FrameResearch>();
bool rngIs64Bit = (comboBoxRNG.SelectedIndex == 3 || comboBoxRNG.SelectedIndex == 4 ||
checkBox64bit.Checked && radioButtonCustom.Checked);
// Loop through X times and create our research frames.
for (uint cnt = 0; cnt < maxFrames; cnt++)
{
FrameResearch frame;
if (!rngIs64Bit)
{
Column64Bit.Visible = false;
Column32Bit.Visible = true;
Column32BitHigh.Visible = false;
Column32BitLow.Visible = false;
uint rngResult = rng.Next();
// Start building the research frame that we are going to use
frame = new FrameResearch {RNG64bit = rngIs64Bit, FrameNumber = cnt + 1, Full32 = rngResult};
}
else
{
Column64Bit.Visible = true;
Column32Bit.Visible = false;
Column32BitHigh.Visible = true;
Column32BitLow.Visible = true;
ulong rngResult = rng64.Next();
// Start building the research frame that we are going to use
frame = new FrameResearch {RNG64bit = rngIs64Bit, FrameNumber = cnt + 1, Full64 = rngResult};
}
// Call Custom 1 ////////////////////////////////////////////////////////////////
if (calcCustom1)
{
ulong customLValue1 = CustomCalcs(comboBoxLValue1, frame, frames);
if (!rngIs64Bit)
customLValue1 = (uint) customLValue1;
frame.Custom1 = custom1Calc(customLValue1, customRValue1);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 2 ////////////////////////////////////////////////////////////////
if (calcCustom2)
{
ulong customLValue2 = CustomCalcs(comboBoxLValue2, frame, frames);
if ((string) comboBoxRValue2.SelectedItem != "None")
customRValue2 = CustomCalcs(comboBoxRValue2, frame, frames);
if (!rngIs64Bit)
customLValue2 = (uint) customLValue2;
frame.Custom2 = custom2Calc(customLValue2, customRValue2);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 3 ////////////////////////////////////////////////////////////////
if (calcCustom3)
{
ulong customLValue3 = CustomCalcs(comboBoxLValue3, frame, frames);
if ((string) comboBoxRValue3.SelectedItem != "None")
customRValue3 = CustomCalcs(comboBoxRValue3, frame, frames);
if (!rngIs64Bit)
customLValue3 = (uint) customLValue3;
frame.Custom3 = custom3Calc(customLValue3, customRValue3);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 4 ////////////////////////////////////////////////////////////////
if (calcCustom4)
{
ulong customLValue4 = CustomCalcs(comboBoxLValue4, frame, frames);
if ((string) comboBoxRValue4.SelectedItem != "None")
customRValue4 = CustomCalcs(comboBoxRValue4, frame, frames);
if (!rngIs64Bit)
customLValue4 = (uint) customLValue4;
frame.Custom4 = custom4Calc(customLValue4, customRValue4);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 5 ////////////////////////////////////////////////////////////////
if (calcCustom5)
{
ulong customLValue5 = CustomCalcs(comboBoxLValue5, frame, frames);
if ((string) comboBoxRValue5.SelectedItem != "None")
customRValue5 = CustomCalcs(comboBoxRValue5, frame, frames);
if (!rngIs64Bit)
customLValue5 = (uint) customLValue5;
frame.Custom5 = custom5Calc(customLValue5, customRValue5);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 6 ////////////////////////////////////////////////////////////////
if (calcCustom6)
{
ulong customLValue6 = CustomCalcs(comboBoxLValue6, frame, frames);
if ((string) comboBoxRValue6.SelectedItem != "None")
customRValue6 = CustomCalcs(comboBoxRValue6, frame, frames);
if (!rngIs64Bit)
customLValue6 = (uint) customLValue6;
frame.Custom6 = custom6Calc(customLValue6, customRValue6);
}
//////////////////////////////////////////////////////////////////////////////////
// Call Custom 7 ////////////////////////////////////////////////////////////////
if (calcCustom7)
{
ulong customLValue7 = CustomCalcs(comboBoxLValue7, frame, frames);
if ((string) comboBoxRValue7.SelectedItem != "None")
customRValue7 = CustomCalcs(comboBoxRValue7, frame, frames);
if (!rngIs64Bit)
customLValue7 = (uint) customLValue7;
frame.Custom7 = custom7Calc(customLValue7, customRValue7);
}
//////////////////////////////////////////////////////////////////////////////////
frames.Add(frame);
}
// Bind to the grid
dataGridViewValues.DataSource = frames;
dataGridViewValues.Focus();
}
// Overloaded method for SeedFinder's Open Search
public static List <Seed> GetSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature)
{
var seeds = new List <Seed>();
uint x4 = spe + (spa << 5) + (spd << 10);
uint x4_2 = x4 ^ 0x8000;
uint x8 = hp + (atk << 5) + (def << 10);
uint x8_2 = x8 ^ 0x8000;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0xFFFE; cnt++)
{
uint x_test;
uint x_testXD;
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
x_test = (cnt & 1) == 0 ? x4 : x4_2;
x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_test << 16) + (cnt & 0xFFFF);
uint seedXD = (x_testXD << 16) + (cnt & 0xFFFF);
var rng = new PokeRngR(seed);
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1 = rng.GetNext16BitNumber();
ushort rng2 = rng.GetNext16BitNumber();
ushort rng3 = rng.GetNext16BitNumber();
ushort rng4 = rng.GetNext16BitNumber();
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
uint method1Seed = rng.Seed;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng3, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 1",
Pid = ((uint)rng2 << 16) + rng3,
MonsterSeed = method1Seed
};
seeds.Add(newSeed);
}
}
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0xFFFF; cnt <= 0x1FFFE; cnt++)
{
uint x_test;
uint x_testXD;
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
x_test = (cnt & 1) == 0 ? x4 : x4_2;
x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_test << 16) + ((cnt + 1) & 0xFFFF);
uint seedXD = (x_testXD << 16) + ((cnt + 1) & 0xFFFF);
var rng = new PokeRngR(seed);
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1 = rng.GetNext16BitNumber();
ushort rng2 = rng.GetNext16BitNumber();
ushort rng3 = rng.GetNext16BitNumber();
ushort rng4 = rng.GetNext16BitNumber();
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
uint method1Seed = rng.Seed;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng3, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 1",
Pid = ((uint)rng2 << 16) + rng3,
MonsterSeed = method1Seed
};
seeds.Add(newSeed);
}
}
return(seeds);
}
public static List <Seed> GetSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List <Seed>();
uint x4 = spe + (spa << 5) + (spd << 10);
uint x4_2 = x4 ^ 0x8000;
uint x8 = hp + (atk << 5) + (def << 10);
uint x8_2 = x8 ^ 0x8000;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0xFFFE; cnt++)
{
uint x_test;
uint x_testXD;
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
x_test = (cnt & 1) == 0 ? x4 : x4_2;
x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_test << 16) + cnt;
uint seedXD = (x_testXD << 16) + cnt;
var rng = new PokeRngR(seed);
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1 = rng.GetNext16BitNumber();
ushort rng2 = rng.GetNext16BitNumber();
ushort rng3 = rng.GetNext16BitNumber();
ushort rng4 = rng.GetNext16BitNumber();
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
uint method1Seed = rng.Seed;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
ushort choppedPID;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng3, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed();
newSeed.Method = "Method 1";
newSeed.Pid = ((uint)rng2 << 16) + rng3;
newSeed.MonsterSeed = method1Seed;
newSeed.Sid = (rng2 ^ (uint)rng3 ^ id) & 0xFFF8;
seeds.Add(newSeed);
}
// Check Wishmkr
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng3, rng2, hp, atk, def, nature))
{
if (method1Seed < 0x10000)
{
// Build a seed to add to our collection
var newSeed = new Seed();
newSeed.Pid = ((uint)rng3 << 16) + rng2;
newSeed.MonsterSeed = method1Seed;
newSeed.Sid = (rng2 ^ (uint)rng3 ^ id) & 0xFFF8;
if (Functions.Shiny(newSeed.Pid, 20043, 0))
{
newSeed.Method = "Wishmkr Shiny";
}
else
{
newSeed.Method = "Wishmkr";
}
seeds.Add(newSeed);
}
}
// Check Method 2
// [PID] [PID] [xxxx] [IVs] [IVs]
// [rng4] [rng3] [xxxx] [rng1] [START]
if (Check(rng1, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 2",
Pid = ((uint)rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint)rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
/*
* Removed because Method 3 doesn't exist in-game
* // Check Method 3
* // [PID] [xxxx] [PID] [IVs] [IVs]
* // [rng4] [xxxx] [rng2] [rng1] [START]
* if (Check(rng1, rng2, rng4, hp, atk, def, nature))
* {
* // Build a seed to add to our collection
* Seed newSeed = new Seed();
* newSeed.Method = "Method 3";
* newSeed.Pid = ((uint)rng2 << 16) + (uint)rng4;
* newSeed.MonsterSeed = method234Seed;
* newSeed.Sid = ((uint)rng2 ^ (uint)rng4 ^ id) & 0xFFF8;
*
* seeds.Add(newSeed);
* }
*/
// Check Method 4
// [PID] [PID] [IVs] [xxxx] [IVs]
// [rng4] [rng3] [rng2] [xxxx] [START]
if (Check(rng2, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 4",
Pid = ((uint)rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint)rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3]
if (Check(rng1XD, rng3XD, rng4XD, spe, spa, spd, nature))
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = ((uint)rng3XD << 16) + rng4XD,
MonsterSeed = XDColoSeed,
Sid = (rng4XD ^ (uint)rng3XD ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
if (rng3 / 0x5556 != 0)
{
// Check DPPt Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
if (rng3 % 3 != 0)
{
// Check HGSS Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
}
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0xFFFF; cnt <= 0x1FFFE; cnt++)
{
uint x_test;
uint x_testXD;
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
x_test = (cnt & 1) == 0 ? x4 : x4_2;
x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_test << 16) + ((cnt + 1) & 0xFFFF);
uint seedXD = (x_testXD << 16) + ((cnt + 1) & 0xFFFF);
var rng = new PokeRngR(seed);
var rngXD = new XdRng(seedXD);
var rngXDR = new XdRngR(seedXD);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1 = rng.GetNext16BitNumber();
ushort rng2 = rng.GetNext16BitNumber();
ushort rng3 = rng.GetNext16BitNumber();
ushort rng4 = rng.GetNext16BitNumber();
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
uint method1Seed = rng.Seed;
rng.GetNext16BitNumber();
uint method234Seed = rng.Seed;
ushort choppedPID;
// Check Method 1
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng2, rng3, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed();
newSeed.Method = "Method 1";
newSeed.Pid = ((uint)rng2 << 16) + rng3;
newSeed.MonsterSeed = method1Seed;
newSeed.Sid = (rng2 ^ (uint)rng3 ^ id) & 0xFFF8;
seeds.Add(newSeed);
}
// Check Wishmkr
// [PID] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
if (Check(rng1, rng3, rng2, hp, atk, def, nature))
{
if (method1Seed < 0x10000)
{
// Build a seed to add to our collection
var newSeed = new Seed();
newSeed.Pid = ((uint)rng3 << 16) + rng2;
newSeed.MonsterSeed = method1Seed;
newSeed.Sid = (rng2 ^ (uint)rng3 ^ id) & 0xFFF8;
if (Functions.Shiny(newSeed.Pid, 20043, 0))
{
newSeed.Method = "Wishmkr Shiny";
}
else
{
newSeed.Method = "Wishmkr";
}
seeds.Add(newSeed);
}
}
// Check Method 2
// [PID] [PID] [xxxx] [IVs] [IVs]
// [rng4] [rng3] [xxxx] [rng1] [START]
if (Check(rng1, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 2",
Pid = ((uint)rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint)rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
/*
* Removed because Method 3 doesn't exist in-game
* // Check Method 3
* // [PID] [xxxx] [PID] [IVs] [IVs]
* // [rng4] [xxxx] [rng2] [rng1] [START]
* if (Check(rng1, rng2, rng4, hp, atk, def, nature))
* {
* // Build a seed to add to our collection
* Seed newSeed = new Seed();
* newSeed.Method = "Method 3";
* newSeed.Pid = ((uint)rng2 << 16) + (uint)rng4;
* newSeed.MonsterSeed = method234Seed;
* newSeed.Sid = ((uint)rng2 ^ (uint)rng4 ^ id) & 0xFFF8;
*
* seeds.Add(newSeed);
* }
*/
// Check Method 4
// [PID] [PID] [IVs] [xxxx] [IVs]
// [rng4] [rng3] [rng2] [xxxx] [START]
if (Check(rng2, rng3, rng4, hp, atk, def, nature))
{
// Build a seed to add to our collection
var newSeed = new Seed
{
Method = "Method 4",
Pid = ((uint)rng3 << 16) + rng4,
MonsterSeed = method234Seed,
Sid = (rng3 ^ (uint)rng4 ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3]
if (Check(rng1XD, rng3XD, rng4XD, spe, spa, spd, nature))
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = ((uint)rng3XD << 16) + rng4XD,
MonsterSeed = XDColoSeed,
Sid = (rng4XD ^ (uint)rng3XD ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
if (rng3 / 0x5556 != 0)
{
// Check DPPt Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check DPPt Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 / 0xA3E + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (DPPt)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
if (rng3 % 3 != 0)
{
// Check HGSS Cute Charm
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (50% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x96);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (25% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0xC8);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (75% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x4B);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
// Check HGSS Cute Charm (87.5% male)
// [CC Check] [PID] [IVs] [IVs]
// [rng3] [rng2] [rng1] [START]
choppedPID = (ushort)(rng2 % 25 + 0x32);
if (Check(rng1, 0, choppedPID, hp, atk, def, nature))
{
var newSeed = new Seed
{
Method = "Cute Charm (HGSS)",
Pid = choppedPID,
MonsterSeed = method1Seed,
Sid = (choppedPID ^ id) & 0xFFF8
};
seeds.Add(newSeed);
}
}
}
return(seeds);
}
// We need a function to return a list of monster seeds,
// which will be updated to include a method.
public static List <Seed> GetXDSeeds(
uint hp,
uint atk,
uint def,
uint spa,
uint spd,
uint spe,
uint nature,
uint id)
{
var seeds = new List <Seed>();
uint x8 = 0;
uint x8_2 = 0;
x8 = hp + (atk << 5) + (def << 10);
x8_2 = x8 ^ 0x8000;
// Now we want to start with IV2 and call the RNG for
// values between 0 and FFFF in the low order bits.
for (uint cnt = 0; cnt <= 0x1FFFE; cnt++)
{
// We want to test with the high bit
// both set and not set, so we're going
// to sneakily do them both. god help
// me if i ever have to figure this out
// in the future.
uint x_testXD = (cnt & 1) == 0 ? x8 : x8_2;
// Set our test seed here so we can start
// working backwards to see if the rest
// of the information we were provided
// is a match.
uint seed = (x_testXD << 16) + (cnt % 0xFFFF);
var rngXD = new XdRng(seed);
var rngXDR = new XdRngR(seed);
uint XDColoSeed = rngXDR.GetNext32BitNumber();
// Right now, this simply assumes method
// 1 and gets the value previous to check
// for match. We need a clean way to do
// this for all of our methods.
// We have a max of 5 total RNG calls
// to make a pokemon and we already have
// one so lets go ahead and get 4 more.
ushort rng1XD = rngXD.GetNext16BitNumber();
ushort rng2XD = rngXD.GetNext16BitNumber();
ushort rng3XD = rngXD.GetNext16BitNumber();
ushort rng4XD = rngXD.GetNext16BitNumber();
// Check Colosseum\XD
// [IVs] [IVs] [xxx] [PID] [PID]
// [START] [rng1] [rng3] [rng4]
if (Check(rng1XD, rng3XD, rng4XD, spe, spa, spd, nature))
{
var newSeed = new Seed
{
Method = "Colosseum/XD",
Pid = ((uint)rng3XD << 16) + rng4XD,
MonsterSeed = XDColoSeed
};
seeds.Add(newSeed);
}
}
return(seeds);
}
