Esempio n. 1
0
        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();
        }
Esempio n. 2
0
 private ulong CustomCalcs(ComboBox selection, FrameResearch frame, List<FrameResearch> frames)
 {
     switch ((string) selection.SelectedItem)
     {
         case "64Bit":
             return frame.Full64;
         case "32Bit High":
             return frame.High32;
         case "32Bit Low":
             return frame.Low32;
         case "32Bit":
             return frame.Full32;
         case "16Bit High":
             return frame.High16;
         case "16Bit Low":
             return frame.Low16;
         case "Custom 1":
             return frame.Custom1;
         case "Custom 2":
             return frame.Custom2;
         case "Custom 3":
             return frame.Custom3;
         case "Custom 4":
             return frame.Custom4;
         case "Custom 5":
             return frame.Custom5;
         case "Custom 6":
             return frame.Custom6;
         case "Custom 7":
             return frame.Custom7;
         case "Previous 1":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom1;
         case "Previous 2":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom2;
         case "Previous 3":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom3;
         case "Previous 4":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom4;
         case "Previous 5":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom5;
         case "Previous 6":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom6;
         case "Previous 7":
             return frames.Count == 0 ? 0 : frames[frames.Count - 1].Custom7;
         default:
             return 0;
     }
 }