private void GenerateSearchJob(DateTime testTime, int[] minIVs, int[] maxIVs,
uint VCountMin, uint VCountMax, uint Timer0Min, uint Timer0Max,
uint GxStatMin, uint GxStatMax, uint VFrameMin, uint VFrameMax,
int secondsMin, int secondsMax, Version version, Language language, DSType dstype,
int[] button,
bool softReset, bool roamer, bool minMaxGxStat)
{
// offset the start by 2 for BW2
int offset = version == Version.Black2 || version == Version.White2 ? 2 : 0;
uint buttonMashed = Functions.buttonMashed(button);
var array = new uint[80];
uint[] h = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0};
array[6] = (uint) (MAC_address & 0xFFFF);
if (softReset)
{
array[6] = array[6] ^ 0x01000000;
}
var upperMAC = (uint) (MAC_address >> 16);
// Get the version-unique part of the message
Array.Copy(Nazos.Nazo(version, language, dstype), array, 5);
array[10] = 0x00000000;
array[11] = 0x00000000;
array[12] = buttonMashed;
array[13] = 0x80000000;
array[14] = 0x00000000;
array[15] = 0x000001A0;
array[8] = Functions.seedDate(testTime);
var GxStatList = new List<uint> {GxStatMin};
// build the GxStat ranges
if (GxStatMin != GxStatMax)
if (!minMaxGxStat)
GxStatList.Add(GxStatMax);
else
for (uint i = GxStatMin + 1; i <= GxStatMax; ++i)
GxStatList.Add(i);
for (int cntSeconds = secondsMin; cntSeconds <= secondsMax; cntSeconds++)
{
array[9] = Functions.seedTime(testTime, dstype);
for (uint cntVCount = VCountMin; cntVCount <= VCountMax; cntVCount++)
{
for (uint cntTimer0 = Timer0Min; cntTimer0 <= Timer0Max; cntTimer0++)
{
array[5] = cntVCount*0x10000 + cntTimer0;
array[5] = Functions.Reorder(array[5]);
foreach (uint GxStat in GxStatList)
{
for (uint cntVFrame = VFrameMin; cntVFrame <= VFrameMax; cntVFrame++)
{
uint a = h[0];
uint b = h[1];
uint c = h[2];
uint d = h[3];
uint e = h[4];
uint f = 0;
uint k = 0;
array[7] = (upperMAC ^ (cntVFrame*0x1000000) ^ GxStat);
for (int i = 0; i < 80; i++)
{
if (i < 20)
{
f = (b & c) | ((~b) & d);
k = 0x5A827999;
}
if (i < 40 && i >= 20)
{
f = b ^ c ^ d;
k = 0x6ED9EBA1;
}
if (i < 60 && i >= 40)
{
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDC;
}
if (i >= 60)
{
f = b ^ c ^ d;
k = 0xCA62C1D6;
}
if (i > 15)
{
array[i] =
Functions.RotateLeft(
array[i - 3] ^ array[i - 8] ^ array[i - 14] ^ array[i - 16], 1);
}
uint temp = Functions.RotateLeft(a, 5) + f + e + k + array[i];
e = d;
d = c;
c = Functions.RotateRight(b, 2);
b = a;
a = temp;
}
uint part1 = Functions.Reorder(h[0] + a);
uint part2 = Functions.Reorder(h[1] + b);
ulong seed2 = (ulong) part1*0x6C078965;
uint seed1 = part2*0x6C078965 + (uint) (seed2 >> 32);
seed1 = seed1 + (part1*0x5D588B65);
seed2 = (uint) (seed2 & 0xFFFFFFFF) + 0x269EC3;
ulong seed = (ulong) (seed1*0x100000000) + seed2;
var tempSeed = (uint) (seed >> 32);
progressSearched++;
if (!findDirectSeed)
{
var IVArray = new int[6];
MersenneTwisterFast mt;
if (roamer)
{
mt = new MersenneTwisterFast(tempSeed, 7);
mt.Nextuint();
IVArray[0] = (int) (mt.Nextuint() >> 27);
IVArray[1] = (int) (mt.Nextuint() >> 27);
IVArray[2] = (int) (mt.Nextuint() >> 27);
IVArray[4] = (int) (mt.Nextuint() >> 27);
IVArray[5] = (int) (mt.Nextuint() >> 27);
IVArray[3] = (int) (mt.Nextuint() >> 27);
}
else
{
//advance for BW2
mt = new MersenneTwisterFast(tempSeed, 6 + offset);
for (int i = 0; i < offset; ++i) mt.Nextuint();
IVArray[0] = (int) (mt.Nextuint() >> 27);
IVArray[1] = (int) (mt.Nextuint() >> 27);
IVArray[2] = (int) (mt.Nextuint() >> 27);
IVArray[3] = (int) (mt.Nextuint() >> 27);
IVArray[4] = (int) (mt.Nextuint() >> 27);
IVArray[5] = (int) (mt.Nextuint() >> 27);
}
if ((IVArray[0] >= minIVs[0] && IVArray[0] <= maxIVs[0]) &&
(IVArray[1] >= minIVs[1] && IVArray[1] <= maxIVs[1]) &&
(IVArray[2] >= minIVs[2] && IVArray[2] <= maxIVs[2]) &&
(IVArray[3] >= minIVs[3] && IVArray[3] <= maxIVs[3]) &&
(IVArray[4] >= minIVs[4] && IVArray[4] <= maxIVs[4]) &&
(IVArray[5] >= minIVs[5] && IVArray[5] <= maxIVs[5]))
{
var dsParameterFound =
new DSParameterCapture
{
ActualSeconds = testTime.Second,
VCount = cntVCount,
Timer0 = cntTimer0,
GxStat = GxStat,
VFrame = cntVFrame,
Seed = seed
};
dsParameters.Add(dsParameterFound);
refreshQueue = true;
progressFound++;
}
}
else
{
if (checkBoxHalfSeed.Checked)
{
if (tempSeed == (int) directSeed)
{
var dsParameterFound =
new DSParameterCapture
{
ActualSeconds = testTime.Second,
VCount = cntVCount,
Timer0 = cntTimer0,
GxStat = GxStat,
VFrame = cntVFrame,
Seed = seed
};
dsParameters.Add(dsParameterFound);
refreshQueue = true;
progressFound++;
}
}
else
{
if (seed == directSeed)
{
var dsParameterFound =
new DSParameterCapture
{
ActualSeconds = testTime.Second,
VCount = cntVCount,
Timer0 = cntTimer0,
GxStat = GxStat,
VFrame = cntVFrame,
Seed = seed
};
dsParameters.Add(dsParameterFound);
refreshQueue = true;
progressFound++;
}
}
}
}
}
}
}
testTime = testTime.AddSeconds(1);
}
}
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();
}
