private void randomizeLevelUpMoves(Random rnd)
        {
            // ORAS: 10682 moves learned on levelup/birth. 
            // 5593 are STAB. 52.3% are STAB. 
            // Steelix learns the most @ 25 (so many level 1)!
            // Move relearner ingame glitch fixed (52 tested), but keep below 75:
            // https://twitter.com/Drayano60/status/807297858244411397

            int[] firstMoves = { 1, 40, 52, 55, 64, 71, 84, 98, 122, 141 };
            // Pound, Poison Sting, Ember, Water Gun, Peck, Absorb, Thunder Shock, Quick Attack, Lick, Leech Life

            int[] banned = new[] { 165, 621, 464 }.Concat(Legal.Z_Moves).ToArray(); // Struggle, Hyperspace Fury, Dark Void

            // Move Stats
            Move[] moveTypes = Main.Config.Moves;

            // Set up Randomized Moves
            int[] randomMoves = Enumerable.Range(1, movelist.Length - 1).Select(i => i).ToArray();
            Util.Shuffle(randomMoves);
            int ctr = 0;

            for (int i = 0; i < CB_Species.Items.Count; i++)
            {
                CB_Species.SelectedIndex = i; // Get new Species
                int count = dgv.Rows.Count - 1;
                int species = WinFormsUtil.getIndex(CB_Species);
                if (CHK_Expand.Checked && (int)NUD_Moves.Value > count)
                    dgv.Rows.AddCopies(count, (int)NUD_Moves.Value - count);

                // Default First Move
                dgv.Rows[0].Cells[0].Value = 1;
                dgv.Rows[0].Cells[1].Value = movelist[firstMoves[rnd.Next(0, firstMoves.Length)]];
                for (int j = 1; j < dgv.Rows.Count - 1; j++)
                {
                    // Assign New Moves
                    bool forceSTAB = CHK_STAB.Checked && rnd.Next(0, 99) < NUD_STAB.Value;
                    int move = Randomizer.getRandomSpecies(ref randomMoves, ref ctr);

                    while (banned.Contains(move) /* Invalid */
                        || forceSTAB && !Main.SpeciesStat[species].Types.Contains(moveTypes[move].Type)) // STAB is required
                        move = Randomizer.getRandomSpecies(ref randomMoves, ref ctr);

                    // Assign Move
                    dgv.Rows[j].Cells[1].Value = movelist[move];
                    // Assign Level
                    if (j >= count)
                    {
                        string level = (dgv.Rows[count - 1].Cells[0].Value ?? 0).ToString();
                        ushort lv;
                        UInt16.TryParse(level, out lv);
                        if (lv > 100) lv = 100;
                        dgv.Rows[j].Cells[0].Value = lv + (j - count) + 1;
                    }
                    if (CHK_Spread.Checked)
                        dgv.Rows[j].Cells[0].Value = ((int)(j * (NUD_Level.Value / (dgv.Rows.Count - 1)))).ToString();
                }
            }
            CB_Species.SelectedIndex = 0;
            WinFormsUtil.Alert("All Pokemon's Level Up Moves have been randomized!");
        }
        private int pokemonLevelUpMovesCount()
        {
            entry = WinFormsUtil.getIndex(CB_Species);

            byte[] input = files[entry];
            if (input.Length <= 4) { files[entry] = BitConverter.GetBytes(-1); return; }
            pkm = new Learnset7(input);


        }
 private int getPkmnEggMovesCount()
 {
     entry = WinFormsUtil.getIndex(CB_Species);
     byte[] input = files[entry];
     pkm = new EggMoves7(input);
     if (pkm.Count < 1)
     {
         files[entry] = new byte[0]; return(0);
     }
     return(pkm.Count);
 }
Пример #4
0
 private async void Write_Lang_Click(object sender, EventArgs e)
 {
     Delg.SetEnabled(CB_Language, false);
     Delg.SetEnabled(Write_Lang, false);
     byte[] data = BitConverter.GetBytes(WinFormsUtil.getIndex(CB_Language));
     RAMreader = Program.helper.waitNTRwrite(LookupTable.GameLanguageOffset, data, Program.gCmdWindow.pid);
     if (!(await RAMreader))
     {
         MessageBox.Show("A error ocurred while writting data to RAM.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
     }
     Delg.SetEnabled(CB_Language, true);
     Delg.SetEnabled(Write_Lang, true);
 }
        public void randomizeEggMoves(Random rnd)
        {
            /*
             * 3111 Egg Moves Learned by 290 Species (10.73 avg)
             * 18 is the most
             * 1000 moves learned were STAB (32.1%)
             */

            int[] banned = new[] { 165, 621, 464 }.Concat(Legal.Z_Moves).ToArray(); // Struggle, Hyperspace Fury, Dark Void

            // Move Stats
            Move[] moveTypes = Main.Config.Moves;

            // Set up Randomized Moves
            int[] randomMoves = Enumerable.Range(1, movelist.Length - 1).Select(i => i).ToArray();
            Util.Shuffle(randomMoves);
            int ctr = 0;

            for (int i = 0; i < CB_Species.Items.Count; i++)
            {
                CB_Species.SelectedIndex = i; // Get new Species
                int        count   = getPkmnEggMovesCount() - 1;
                int        species = WinFormsUtil.getIndex(CB_Species);
                List <int> moves   = new List <int>();

                for (int j = 1; j < count; j++)
                {
                    // Assign New Moves
                    int move = Randomizer.getRandomSpecies(ref randomMoves, ref ctr);

                    while (banned.Contains(move))/* Invalid */
                    {
                        move = Randomizer.getRandomSpecies(ref randomMoves, ref ctr);
                    }

                    // Assign Move
                    if (move > 0 && !moves.Contains((ushort)move))
                    {
                        moves.Add(move);
                    }
                }

                pkm.Moves = moves.ToArray();

                files[entry] = pkm.Write();
            }
            CB_Species.SelectedIndex = 0;
            WinFormsUtil.Alert("All Pokemon's Egg Up Moves have been randomized!");
        }
Пример #6
0
        public async void RunBot()
        {
            try
            {
                while (botworking && Program.gCmdWindow.IsConnected)
                {
                    switch (botState)
                    {
                    case BotState.botstart:
                        Report("Bot: START Gen 7 Soft-reset bot");
                        botState = BotState.selectmode;
                        break;

                    case BotState.selectmode:
                        switch (Mode.SelectedIndex)
                        {
                        case 0:
                        case 1:
                            botState = BotState.startdialog;
                            break;

                        case 2:
                            botState = BotState.triggerbattle;
                            break;

                        case 3:
                            resetNo = resetNo == 0 ? 1 : resetNo;
                            Program.gCmdWindow.UpdateResetCounter(resetNo);
                            botState = BotState.soluna1;
                            break;

                        case 4:
                        case 5:
                            resetNo = resetNo == 0 ? 1 : resetNo;
                            Program.gCmdWindow.UpdateResetCounter(resetNo);
                            botState = BotState.writehoney;
                            break;

                        default:
                            botState = BotState.botexit;
                            break;
                        }
                        break;

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

                    case BotState.testdialog1:
                        Report("Bot: Test if dialog has started");
                        waitTaskbool = Program.helper.memoryinrange(dialogOff, dialogIn, 0x10000000);
                        if (await waitTaskbool)
                        {
                            if (Mode.SelectedIndex == 1)
                            {
                                attempts = -40;     // Type:Null dialog is longer
                            }
                            else
                            {
                                attempts = -15;
                            }
                            botState = BotState.continuedialog;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.startdialog;
                        }
                        break;

                    case BotState.continuedialog:
                        Report("Bot: Continue dialog");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.testdialog2;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.continuedialog;
                        }
                        break;

                    case BotState.testdialog2:
                        Report("Bot: Test if dialog has finished");
                        waitTaskbool = Program.helper.memoryinrange(dialogOff, dialogOut, 0x10000000);
                        if (await waitTaskbool)
                        {
                            attempts = -10;
                            botState = BotState.readparty;
                        }
                        else if (Program.helper.lastRead >= 0x3F000000 && Program.helper.lastRead < 0x40000000)
                        {
                            attempts = -10;
                            botState = BotState.exitdialog;
                        }
                        else if (Program.helper.lastRead >= 0x3D000000 && Program.helper.lastRead < 0x3E000000)
                        {
                            attempts = 0;
                            botState = BotState.nickname;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.continuedialog;
                        }
                        break;

                    case BotState.exitdialog:
                        Report("Bot: Exit dialog");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyB);
                        if (await waitTaskbool)
                        {
                            botState = BotState.readparty;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.exitdialog;
                        }
                        break;

                    case BotState.readparty:
                        Report("Bot: Try to read party");
                        waitTaskPKM = Program.helper.waitPartyRead(2);
                        srPoke      = await waitTaskPKM;
                        if (srPoke == null)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.exitdialog;
                        }
                        else if (srPoke.Species == 0)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.exitdialog;
                        }
                        else
                        {
                            attempts = 0;
                            botState = BotState.filter;
                        }
                        break;

                    case BotState.filter:
                        filternum = CheckFilters(srPoke, filterList);
                        bool testsok = filternum > 0;
                        if (testsok)
                        {
                            botState = BotState.testspassed;
                        }
                        else if (Mode.SelectedIndex == 3 || Mode.SelectedIndex == 4 || Mode.SelectedIndex == 5)
                        {
                            botState = BotState.runbattle1;
                        }
                        else
                        {
                            botState = BotState.softreset;
                        }
                        break;

                    case BotState.testspassed:
                        Report("Bot: All tests passed!");
                        if (Mode.SelectedIndex == 3 || Mode.SelectedIndex == 4 || Mode.SelectedIndex == 5)
                        {
                            botresult = ErrorMessage.BattleMatch;
                        }
                        else
                        {
                            botresult = ErrorMessage.SRMatch;
                        }
                        finishmessage = new int[] { filternum, resetNo };
                        botState      = BotState.botexit;
                        break;

                    case BotState.softreset:
                        resetNo++;
                        Report("Bot: Sof-reset #" + resetNo.ToString());
                        Program.gCmdWindow.UpdateResetCounter(resetNo);
                        waitTaskbool = Program.helper.waitSoftReset();
                        if (await waitTaskbool)
                        {
                            botState = BotState.skiptitle;
                        }
                        else
                        {
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.botexit;
                        }
                        break;

                    case BotState.skiptitle:
                        await Task.Delay(7000);

                        Report("Bot: Open Menu");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.reconnect;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.skiptitle;
                        }
                        break;

                    case BotState.reconnect:
                        Report("Bot: Try reconnect");
                        waitTaskbool = Program.gCmdWindow.Reconnect();
                        if (await waitTaskbool)
                        {
                            await Task.Delay(1000);

                            botState = BotState.connpatch;
                        }
                        else
                        {
                            botresult = ErrorMessage.GeneralError;
                            botState  = BotState.botexit;
                        }
                        break;

                    case BotState.connpatch:
                        Report("Bot: Apply NFC patch");
                        waitTaskbool = Program.helper.waitNTRwrite(LookupTable.nfcOff, LookupTable.nfcVal, Program.gCmdWindow.pid);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.startgame;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.WriteError;
                            botState  = BotState.connpatch;
                        }
                        break;

                    case BotState.startgame:
                        Report("Bot: Start the game");
                        await Task.Delay(1000);

                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            await Task.Delay(3000);

                            attempts = 0;
                            botState = BotState.selectmode;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.startgame;
                        }
                        break;

                    case BotState.nickname:
                        Report("Bot: Nickname screen");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keySTART);
                        await Task.Delay(250);

                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)

                        {
                            botState = BotState.testdialog2;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.nickname;
                        }
                        break;

                    case BotState.triggerbattle:
                        Report("Bot: Try to trigger battle");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.testdialog3;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.triggerbattle;
                        }
                        break;

                    case BotState.testdialog3:
                        Report("Bot: Test if dialog has started");
                        waitTaskbool = Program.helper.memoryinrange(dialogOff, dialogIn, 0x10000000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.continuedialog2;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.triggerbattle;
                        }
                        break;

                    case BotState.continuedialog2:
                        Report("Bot: Continue dialog");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.readopp;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.continuedialog2;
                        }
                        break;

                    case BotState.readopp:
                        Report("Bot: Try to read opponent");
                        srPoke      = null;
                        waitTaskPKM = Program.helper.waitPokeRead(opponentOff);
                        srPoke      = await waitTaskPKM;
                        if (srPoke == null)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.readopp;
                        }
                        else if (srPoke.Species == 0)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.continuedialog2;
                        }
                        else
                        {
                            attempts = 0;
                            botState = BotState.filter;
                        }
                        break;

                    case BotState.soluna1:
                        Report("Bot: Walk to legendary pokemon");
                        waitTaskbool = Program.helper.waitsitck(0, 100);
                        if (await waitTaskbool)
                        {
                            botState = BotState.soluna2;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.StickError;
                            botState  = BotState.soluna1;
                        }
                        break;

                    case BotState.soluna2:
                        Report("Bot: Trigger battle #" + resetNo);
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.soluna3;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.soluna2;
                        }
                        break;

                    case BotState.soluna3:
                        Report("Bot: Test if dialog has started");
                        waitTaskbool = Program.helper.memoryinrange(dialogOff, dialogIn, 0x10000000);
                        if (await waitTaskbool)
                        {
                            attempts = -0;
                            botState = BotState.soluna4;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.soluna2;
                        }
                        break;

                    case BotState.soluna4:
                        Report("Bot: Test if data is available");
                        waitTaskbool = Program.helper.timememoryinrange(battleOff, battleIn, 0x10000, 1000, 20000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.soluna5;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.soluna1;
                        }
                        break;

                    case BotState.soluna5:
                        Report("Bot: Try to read opponent");
                        srPoke      = null;
                        waitTaskPKM = Program.helper.waitPokeRead(opponentOff);
                        srPoke      = await waitTaskPKM;
                        if (srPoke == null)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.soluna5;
                        }
                        else if (srPoke.Species == 0)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.soluna2;
                        }
                        else
                        {
                            attempts = 0;
                            botState = BotState.filter;
                        }
                        break;

                    case BotState.runbattle1:
                        Report("Bot: Run from battle");
                        await Task.Delay(2000);

                        waitTaskbool = Program.helper.waitbutton(LookupTable.DpadDOWN);
                        if (await waitTaskbool)
                        {
                            botState = BotState.runbattle2;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.runbattle1;
                        }
                        break;

                    case BotState.runbattle2:
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.runbattle3;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.runbattle2;
                        }
                        break;

                    case BotState.runbattle3:
                        Report("Bot: Test out from battle");
                        waitTaskbool = Program.helper.timememoryinrange(battleOff, battleOut, 0x10000, 1000, 10000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            resetNo++;
                            Program.gCmdWindow.UpdateResetCounter(resetNo);
                            if (Mode.SelectedIndex == 3)
                            {
                                botState = BotState.soluna1;
                                await Task.Delay(6000);
                            }
                            else if (isub)
                            {
                                botState = BotState.dismissmsg;
                                await Task.Delay(6000);
                            }
                            else
                            {
                                botState = BotState.writehoney;
                                await Task.Delay(5000);
                            }
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.runbattle1;
                        }
                        break;

                    case BotState.writehoney:
                        if (honeynum >= 10)
                        {
                            botState = BotState.openmenu;
                        }
                        else
                        {
                            Report("Bot: Give 999 honey");
                            waitTaskbool = Program.helper.waitNTRwrite(itemOff, honey, Program.gCmdWindow.pid);
                            if (await waitTaskbool)
                            {
                                attempts = 0;
                                honeynum = 999;
                                botState = BotState.openmenu;
                            }
                            else
                            {
                                attempts++;
                                botresult = ErrorMessage.WriteError;
                                botState  = BotState.writehoney;
                            }
                        }
                        break;

                    case BotState.openmenu:
                        Report("Bot: Open Menu");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyX);
                        if (await waitTaskbool)
                        {
                            botState = BotState.testmenu;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.openmenu;
                        }
                        break;

                    case BotState.testmenu:
                        Report("Bot: Test if the menu is open");
                        waitTaskbool = Program.helper.timememoryinrange(menuOff, menuIn, 0x10000000, 1000, 5000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.openbag;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.openmenu;
                        }
                        break;

                    case BotState.openbag:
                        Report("Bot: Open Bag");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.testbag;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.openbag;
                        }
                        break;

                    case BotState.testbag:
                        Report("Bot: Test if the bag is open");
                        waitTaskbool = Program.helper.timememoryinrange(bagOff, bagIn, 0x10000, 1000, 5000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.selecthoney;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.openbag;
                        }
                        break;

                    case BotState.selecthoney:
                        Report("Bot: Select Honey");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.activatehoney;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.selecthoney;
                        }
                        break;

                    case BotState.activatehoney:
                        Report("Bot: Trigger battle #" + resetNo);
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            botState = BotState.testwild;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.openbag;
                        }
                        break;

                    case BotState.testwild:
                        Report("Bot: Test if battle is triggered");
                        waitTaskbool = Program.helper.timememoryinrange(bagOff, bagOut, 0x10000, 1000, 10000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            honeynum--;
                            botState = BotState.waitwild;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.activatehoney;
                        }
                        break;

                    case BotState.waitwild:
                        Report("Bot: Test if data is available");
                        waitTaskbool = Program.helper.timememoryinrange(battleOff, battleIn, 0x10000, 1000, 20000);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.readwild;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.activatehoney;
                        }
                        break;

                    case BotState.readwild:
                        Report("Bot: Try to read opponent");
                        srPoke      = null;
                        waitTaskPKM = Program.helper.waitPokeRead(opponentOff);
                        srPoke      = await waitTaskPKM;
                        if (srPoke == null)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.readwild;
                        }
                        else if (srPoke.Species == 0)
                        {
                            attempts++;
                            botresult = ErrorMessage.ReadError;
                            botState  = BotState.readwild;
                        }
                        else if (srPoke.Species == WinFormsUtil.getIndex(Species))
                        {
                            attempts = 0;
                            isub     = Mode.SelectedIndex == 5;
                            botState = BotState.filter;
                        }
                        else
                        {
                            attempts = 0;
                            isub     = false;
                            botState = BotState.runbattle1;
                        }
                        break;

                    case BotState.dismissmsg:
                        Report("Bot: Dismiss message");
                        waitTaskbool = Program.helper.waitbutton(LookupTable.keyA);
                        if (await waitTaskbool)
                        {
                            attempts = 0;
                            botState = BotState.writehoney;
                        }
                        else
                        {
                            attempts++;
                            botresult = ErrorMessage.ButtonError;
                            botState  = BotState.dismissmsg;
                        }
                        break;

                    case BotState.botexit:
                        Report("Bot: STOP Gen 7 Soft-reset bot");
                        botworking = false;
                        break;

                    default:
                        Report("Bot: STOP Gen 7 Soft-reset 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 Soft-reset bot");
                            botworking = false;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Report("Bot: Exception detected:");
                Report(ex.Source);
                Report(ex.Message);
                Report(ex.StackTrace);
                Report("Bot: STOP Gen 6 Soft-reset bot");
                MessageBox.Show(ex.Message);
                botworking = false;
                botresult  = ErrorMessage.GeneralError;
            }
            if (userstop)
            {
                botresult = ErrorMessage.UserStop;
            }
            else if (!Program.gCmdWindow.IsConnected)
            {
                botresult = ErrorMessage.Disconnect;
            }
            ShowResult("Soft-reset bot", botresult, finishmessage);
            Delg.SetText(RunStop, "Start Bot");
            Program.gCmdWindow.SetBotMode(false);
            EnableControls();
            Delg.SetEnabled(RunStop, true);
        }