Exemple #1
0
        /// <summary>
        /// Bot procedure.
        /// </summary>
        public async void RunBot()
        {
            try
            {
                Program.gCmdWindow.SetBotMode(true);
                while (botworking && Program.gCmdWindow.IsConnected)
                {
                    switch (botState)
                    {
                    case (int)BotState.BotStart:
                        Report("Bot: START Gen 7 Breding bot");
                        if (Mode.SelectedIndex >= 0 && Mode.SelectedIndex != 3 &&
                            Eggs.Value > 0)
                        {
                            Delg.SetValue(Slot, 1);
                            botState = BotState.SelectBox;
                        }
                        else if (Mode.SelectedIndex == 3 && (Accept.Value > 0 ||
                                                             Reject.Value > 0))
                        {
                            botState = BotState.EggSeed;
                        }
                        else
                        {
                            botresult = ErrorMessage.Finished;
                            botState  = BotState.BotExit;
                        }
                        break;

                    case BotState.SelectBox:
                        Report("Bot: Set start box");
                        waitTaskbool = Program.helper.waitNTRwrite(LookupTable
                                                                   .CurrentboxOffset, (uint)GetIndex(Box),
                                                                   Program.gCmdWindow.pid);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.ReadSlot;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.WriteError;
                            botState  = BotState.SelectBox;
                        }
                        break;

                    case BotState.ReadSlot:
                        Report("Bot: Search for empty slot");
                        waitTaskPKM = Program.helper.waitPokeRead(Box, Slot);
                        breedPoke   = await waitTaskPKM;
                        if (breedPoke == null)
                        {     // No data or invalid
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.ReadSlot;
                        }
                        else if (breedPoke.Species == 0)
                        {     // Empty space
                            Report("Bot: Empty slot");
                            attempts = 0;
                            botState = BotState.EggSeed;
                        }
                        else
                        {
                            GetNextSlot();
                            botState = BotState.ReadSlot;
                        }
                        break;

                    case BotState.EggSeed:
                        Report("Bot: Update Egg seed");
                        waitTaskbool = Program.helper.waitNTRmultiread(eggseedOff,
                                                                       0x10);
                        if (await waitTaskbool)
                        {
                            Report("Bot: Current seed - " + UpdateSeed(Program.helper
                                                                       .lastmultiread));
                            attempts = 0;
                            if (Mode.SelectedIndex != 3)
                            {
                                botState = BotState.GenerateEgg;
                            }
                            else
                            {
                                if (Accept.Value == 0 && Reject.Value == 0)
                                {
                                    botresult = ErrorMessage.Finished;
                                    botState  = BotState.BotExit;
                                }
                                else
                                {
                                    botState = BotState.GenerateEgg;
                                }
                            }
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.EggSeed;
                        }
                        break;

                    case BotState.GenerateEgg:
                        Report("Bot: Produce Egg in Nursery");
                        waitTaskbool = Program.helper.waitNTRwrite(EggOff, 0x01,
                                                                   Program.gCmdWindow.pid);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.TriggerDialog;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.WriteError;
                            botState  = BotState.GenerateEgg;
                        }
                        break;

                    case BotState.TriggerDialog:
                        Report("Bot: Start dialog");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.ButtonA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.TestDialog1;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.TriggerDialog;
                        }
                        break;

                    case BotState.TestDialog1:
                        Report("Bot: Test if dialog has started");
                        waitTaskbool = Program.helper.memoryinrange(DialogOff,
                                                                    DialogIn, 0x10000000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.ContinueDialog;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.TriggerDialog;
                        }
                        break;

                    case BotState.ContinueDialog:
                        Report("Bot: Continue dialog");
                        int maxi;
                        if (Mode.SelectedIndex == 3 && Accept.Value == 0)
                        {
                            key  = LookupTable.ButtonB;
                            maxi = 9;
                        }
                        else
                        {
                            key  = LookupTable.ButtonA;
                            maxi = 6;
                        }
                        int i;
                        for (i = 0; i < maxi; i++)
                        {
                            waitTaskbool = Program.helper.waitbutton(key);
                            if (!(await waitTaskbool))
                            {
                                break;
                            }
                        }
                        if (i == 6)
                        {
                            botState = BotState.CheckNoEgg;
                        }
                        if (i == 9)
                        {
                            botState = BotState.TestDialog2;
                        }
                        else
                        {
                            botState = BotState.FixDialog;
                        }
                        break;

                    case BotState.FixDialog:
                        waitTaskbool = Program.helper.waitbutton(key);
                        if (await waitTaskbool)
                        {
                            botState = BotState.CheckNoEgg;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.FixDialog;
                        }
                        break;

                    case BotState.CheckNoEgg:
                        waitTaskbool = Program.helper.memoryinrange(EggOff, 0x00,
                                                                    0x01);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            Report("Bot: Egg received");
                            botState = BotState.ExitDialog;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.FixDialog;
                        }
                        break;

                    case BotState.ExitDialog:
                        Report("Bot: Exit dialog");
                        await Task.Delay(1500);

                        waitTaskbool = Program.helper.waitbutton(LookupTable.ButtonB);
                        if (await waitTaskbool)
                        {
                            waitTaskbool = Program.helper.waitbutton(LookupTable
                                                                     .ButtonB);
                            if (await waitTaskbool)
                            {
                                botState = BotState.TestDialog2;
                            }
                            else
                            {
                                attempts++;
                                botresult = ErrorMessage.ButtonError;
                                botState  = BotState.ExitDialog;
                            }
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.ExitDialog;
                        }
                        break;

                    case BotState.TestDialog2:
                        waitTaskbool = Program.helper.memoryinrange(DialogOff,
                                                                    DialogOut, 0x10000000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            Report("Bot: Dialog finished");
                            if (Mode.SelectedIndex != 3)
                            {
                                botState = BotState.Filter;
                            }
                            else
                            {
                                if (Accept.Value > 0)
                                {
                                    Delg.SetValue(Accept, Accept.Value - 1);
                                }
                                else
                                {
                                    Delg.SetValue(Reject, Reject.Value - 1);;
                                }
                                botState = BotState.EggSeed;
                            }
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.ExitDialog;
                        }
                        break;

                    case BotState.Filter:
                        bool testsok = false;
                        Report("Bot: Read recevied egg");
                        waitTaskPKM = Program.helper.waitPokeRead(Box, Slot);
                        breedPoke   = await waitTaskPKM;
                        if (breedPoke == null)
                        {     // No data or invalid
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.Filter;
                        }
                        else if (breedPoke.Species == 0)
                        {     // Empty space
                            Report("Bot: Error detected - slot is empty");
                            attempts  = 11;
                            botresult = ErrorMessage.GeneralError;
                            botState  = BotState.BotExit;
                        }
                        else
                        {
                            attempts = 0;
                            Delg.SetValue(Eggs, Eggs.Value - 1);
                            if (ReadESV.Checked || Mode.SelectedIndex == 2)
                            {
                                Delg.DataGridViewAddRow(esvList, Box.Value,
                                                        Slot.Value, breedPoke.PSV.ToString("D4"));
                                if (Mode.SelectedIndex == 2)
                                {
                                    testsok = ESV_TSV_check(breedPoke.PSV);
                                }
                            }
                            if (Mode.SelectedIndex == 1)
                            {
                                filternum = CheckFilters(breedPoke, filterList);
                                testsok   = filternum > 0;
                            }
                        }
                        if (testsok)
                        {
                            botState = BotState.TestsPassed;
                            break;
                        }
                        else if (Eggs.Value > 0)
                        {
                            GetNextSlot();
                            botState = BotState.ReadSlot;
                        }
                        else
                        {
                            if (Mode.SelectedIndex == 1 || Mode.SelectedIndex == 2)
                            {
                                Report("Bot: No match found");
                                botresult = ErrorMessage.NoMatch;
                            }
                            else
                            {
                                botresult = ErrorMessage.Finished;
                            }
                            botState = BotState.BotExit;
                        }
                        break;

                    case BotState.TestsPassed:
                        if (Mode.SelectedIndex == 1)
                        {
                            Report("Bot: All tests passed");
                            botresult        = ErrorMessage.FilterMatch;
                            finishmessage[0] = (int)Box.Value;
                            finishmessage[1] = (int)Slot.Value;
                            finishmessage[2] = filternum;
                        }
                        else if (Mode.SelectedIndex == 2)
                        {
                            Report("Bot: ESV/TSV match found");
                            botresult        = ErrorMessage.SVMatch;
                            finishmessage[0] = (int)Box.Value;
                            finishmessage[1] = (int)Slot.Value;
                            finishmessage[2] = breedPoke.PSV;
                        }
                        botState = BotState.BotExit;
                        break;

                    case BotState.BotExit:
                        Report("Bot: STOP Gen 7 Breding bot");
                        botworking = false;
                        break;

                    default:
                        Report("Bot: STOP Gen 7 Breding bot");
                        botresult  = ErrorMessage.GeneralError;
                        botworking = false;
                        break;
                    }
                    if (attempts > 10)
                    { // Too many attempts
                        if (maxreconnect > 0)
                        {
                            Report("Bot: Try reconnection to fix error");
                            waitTaskbool = Program.gCmdWindow.Reconnect();
                            maxreconnect--;
                            if (await waitTaskbool)
                            {
                                await Task.Delay(2500);

                                attempts = 0;
                            }
                            else
                            {
                                botresult  = ErrorMessage.GeneralError;
                                botworking = false;
                            }
                        }
                        else
                        {
                            Report("Bot: Maximum number of reconnection attempts reached");
                            Report("Bot: STOP Gen 7 Breeding bot");
                            botworking = false;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Report("Bot: Exception detected:");
                Report(ex.Source);
                Report(ex.Message);
                Report(ex.StackTrace);
                Report("Bot: STOP Gen 7 Breeding bot");
                MessageBox.Show(ex.Message);
                botworking = false;
                botresult  = ErrorMessage.GeneralError;
            }
            if (userstop)
            {
                botresult = ErrorMessage.UserStop;
            }
            else if (!Program.gCmdWindow.IsConnected)
            {
                botresult = ErrorMessage.Disconnect;
            }
            ShowResult("Breeding bot", botresult, finishmessage);
            Delg.SetText(RunStop, "Start Bot");
            Program.gCmdWindow.SetBotMode(false);
            EnableControls();
            Delg.SetEnabled(RunStop, true);
        }