예제 #1
0
        // event. (ajouté dynamiquement)
        private void GetRightClickPosition_Event(object sender, EventArgs e)
        {
            Point MousePos = GamePanel.PointToClient(Cursor.Position);

            AddTrajetStep("RIGHTCLICK::" + MousePos.X + "x" + MousePos.Y);

            if (SimulateMoveCheckBox.Checked)
            {
                FakeClick.RightClickOnPoint(GameProcess.MainWindowHandle, MousePos); // right click
            }
            MouseRightClickBtn.LostFocus -= this.GetRightClickPosition_Event;
            this.Cursor = Cursors.Default;
        }
예제 #2
0
        // ClosePopUps(...) : ferme les fenêtres popup du jeu
        public static bool ClosePopUps(IntPtr GameHandle, Log Log)
        {
            bool popupsClosed = false;

            foreach (Popup popup in Settings.Popups)
            {
                if (Pixel.HasColor(popup.Position, popup.Color, GameHandle))
                {
                    Log.Debug("Closing Popup : " + popup.Name);
                    FakeClick.ClickOnPoint(GameHandle, new Point(popup.Position.X, popup.Position.Y));
                    Thread.Sleep(100);
                    popupsClosed = true;
                }
            }

            return(popupsClosed);
        }
예제 #3
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        // CloseFight() : ferme le combat
        private void CloseFight()
        {
            if (Settings.CloseFight)
            {
                Log.Title(Log.Level.Debug, "CloseFight");
                Log.Debug("CloseFight Pixel " + Tools.pointToString(Settings.CloseFightPixel.Position) + " " + Tools.colorToString(Settings.CloseFightPixel.Color));

                if (Pixel.HasColor(Settings.CloseFightPixel.Position, Settings.CloseFightPixel.Color, GameHandle))
                {
                    FakeClick.ClickOnPoint(GameHandle, Settings.CloseFightPixel.Position);
                    Wait(); // on attend une seconde
                    Log.Debug("Fight Closed.");
                }
                else
                {
                    Log.Debug("Fight Already Closed.");
                }
            }
        }
예제 #4
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        // DisableSpectatorMode() : désactive le mode spectateur
        private void DisableSpectatorMode()
        {
            if (Settings.DisableSpectatorMode)
            {
                Log.Title(Log.Level.Debug, "DisableSpectatorMode");
                Log.Debug("DisableSpectatorMode Pixel " + Tools.pointToString(Settings.DisableSpectatorModePixel.Position) + " " + Tools.colorToString(Settings.DisableSpectatorModePixel.Color));

                if (Pixel.HasColor(Settings.DisableSpectatorModePixel.Position, Settings.DisableSpectatorModePixel.Color, GameHandle))
                {
                    FakeClick.ClickOnPoint(GameHandle, Settings.DisableSpectatorModePixel.Position);
                    Wait(); // on attend une seconde
                    Log.Debug("SpectatorMode Disabled.");
                }
                else
                {
                    Log.Debug("SpectatorMode Already Disabled.");
                }
            }
        }
예제 #5
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
 // ClickOn(...) : effectue un click sur la zone/position spécifiée
 private void ClickOn(String ClickPosition, bool RightClick = false)
 {
     try
     {
         // découpage des coordonnées de la position de click
         string[] clickXY    = Regex.Split(ClickPosition, "x");
         Point    ClickPoint = new Point(Int32.Parse(clickXY[0]), Int32.Parse(clickXY[1]));
         if (RightClick)
         {
             FakeClick.RightClickOnPoint(GameHandle, ClickPoint);
         }
         else
         {
             FakeClick.ClickOnPoint(GameHandle, ClickPoint);
         }
     }
     catch (Exception ex)
     {
         Log.Debug(ex.Message);
     }
 }
예제 #6
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        // FightIA(...) : IA de combat du bot
        private void FightIA(String action)
        {
            // si le bot n'a pas été arrêté
            if (!_shutdownEvent.WaitOne(0))
            {
                // action IA
                Log.Debug("FightIA action : " + action);

                try
                {
                    // découpage des données
                    string[] actionSplited = Regex.Split(action, "::");

                    // si l'action attendu par l'IA n'est pas la bonne on saute/ignore l'action en cours
                    if (Fight.IA.NextAction.Count > 0 && !Fight.IA.NextAction.Contains(actionSplited[0]))
                    {
                        Log.Debug("FightIA NextAction : " + Fight.IA.NextActionToString());
                        Log.Debug("FightIA action Ignored.");
                        return;
                    }

                    // initialisation/rénitialisation
                    Fight.IA.NextAction.Clear();

                    // exécution de l'action
                    switch (actionSplited[0])
                    {
                    case "SPELL":
                        int spellRelaunchTurn = Int32.Parse(actionSplited[3]);
                        int spellLaunchTurn   = Int32.Parse(actionSplited[4]);
                        // si c'est le bon tour pour lancer le sort
                        if (Fight.Turn >= spellLaunchTurn && (Fight.Turn == 1 || Fight.Turn % spellRelaunchTurn == 0))
                        {
                            // on lance le sort
                            string[] spellPosition = Regex.Split(actionSplited[2], "x");
                            FakeClick.ClickOnPoint(GameHandle, new Point(Int32.Parse(spellPosition[0]), Int32.Parse(spellPosition[1])));
                            Fight.IA.Next(new string[] { "TARGET" });     // la prochaine action doit être une cible
                        }
                        else
                        {
                            Fight.IA.Next(new string[] { "SPELL", "WAIT" });     // la prochaine action doit être un sort ou bien un WAIT
                        }
                        break;

                    case "TARGET":
                        string[] targetPosition = Regex.Split(actionSplited[1], "x");
                        FakeClick.ClickOnPoint(GameHandle, new Point(Int32.Parse(targetPosition[0]), Int32.Parse(targetPosition[1])));
                        break;

                    case "WAIT":
                        Wait(Int32.Parse(actionSplited[1]));
                        break;

                    default:
                        Log.Error("Erreur sur l'IA de combat.");
                        Suspend();
                        break;
                    }

                    // on attend une seconde
                    Wait(IA.ActionWaitTimeout);

                    Log.Debug("FightIA action Done.");
                }
                catch (Exception ex)
                {
                    Log.Debug("Execption occured : " + ex.Message);
                    Log.Error("Erreur sur l'IA de combat.");
                    Suspend();
                }
            }
        }
예제 #7
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        //=========================================================================================================================
        //                                                  Fight méthodes
        //=========================================================================================================================

        #region Fight
        // GoFight(...) : gère le(s) combat(s) du bot
        private void GoFight()
        {
            Log.Title(Log.Level.Debug, "GoFight");

            Log.Entry("Combat en cours...");
            Fight.OnGoing = true;

            try
            {
                // on ferme le combat (si ouvert)
                CloseFight();

                // on désactive le mode spectateur (si activé)
                DisableSpectatorMode();

                // on clic sur Prêt
                Log.Debug("Start Fight");
                FakeClick.ClickOnPoint(GameHandle, Settings.StartPassTurnPosition);
                Thread.Sleep(100); //Wait();

                // on clic ailleur pour que la détection de fin de combat fonctionne correctement
                FakeClick.ClickOnPoint(GameHandle, new Point(10, 10));
                Wait(Fight.WaitTimeAfterStartFight);

                // initialisation
                Fight.Turn = 0;

                // boucle de combat (tant que le combat n'est pas terminé)
                while (!CheckFightEnd())
                {
                    _pauseEvent.WaitOne();
                    if (_shutdownEvent.WaitOne(0))
                    {
                        break;
                    }

                    // on attend le début du tour du bot
                    if (!_shutdownEvent.WaitOne(0) && WaitForBotTurn()) // si le bot n'a pas été arrêté + c'est le tour du bot
                    {
                        // si le bot n'a pas été arrêté
                        if (!_shutdownEvent.WaitOne(0))
                        {
                            // on abandonne le combat s'il se prolonge beaucoup
                            if (Fight.Turn >= Settings.ExitFightTurn)
                            {
                                FakeClick.ClickOnPoint(GameHandle, Settings.ExitFightPosition);
                                Wait();
                                Log.Entry("Combat abandonné.");
                                break;
                            }

                            // Lecture du fichier d'IA
                            string[] actions = File.ReadAllLines(Fight.IA.File);

                            // Parcours des actions de l'IA
                            foreach (string action in actions)
                            {
                                _pauseEvent.WaitOne();
                                if (_shutdownEvent.WaitOne(0))
                                {
                                    break;
                                }

                                // on vérifie si le combat est terminé, si oui on sort de la boucle d'IA
                                if (CheckFightEnd())
                                {
                                    break;
                                }

                                // on fait appel à l'IA de combat du bot
                                FightIA(action);
                            }

                            // si le bot n'a pas été arrêté
                            if (!_shutdownEvent.WaitOne(0))
                            {
                                // on vérifie si le combat est terminé, si oui on sort de la boucle while
                                if (CheckFightEnd())
                                {
                                    break;
                                }

                                // on passe le tour
                                Log.Debug("Pass Turn");
                                FakeClick.ClickOnPoint(GameHandle, Settings.StartPassTurnPosition);
                                Thread.Sleep(100); //Wait();

                                // on clic ailleur pour que la détection de fin de combat fonctionne correctement
                                FakeClick.ClickOnPoint(GameHandle, new Point(10, 10));
                                Wait(Fight.WaitTimeAfterPassTurn);
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                }

                // si le bot n'a pas été arrêté
                if (!_shutdownEvent.WaitOne(0))
                {
                    // on ferme la fenêtre de fin de combat/level up
                    CheckPopUps();

                    Log.Entry("Combat terminé. [durée: " + Fight.Turn + " tour(s)]");
                    Fight.OnGoing = false;

                    BotStatePictureBox.Image = Pixus.Properties.Resources.load;

                    // si combat abandonné, on arrête le bot (pour le moment)
                    if (Fight.Turn >= Settings.ExitFightTurn)
                    {
                        Suspend();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Debug("Execption occured : " + ex.Message);
            }

            Log.Divider(Log.Level.Debug);
        }
예제 #8
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        // GetPod() : récupère le pod en pourcentage et fait avancé la progressbar
        public void GetPod()
        {
            Log.Title(Log.Level.Debug, "GetPod");

            try
            {
                // Click sur l'inventaire pour l'ouvrir
                FakeClick.ClickOnPoint(GameHandle, Settings.InventoryPosition);
                Wait();

                // Nouvelle Image de la Map
                Bitmap MapImage = EmbedWindow.GetWindowImage(GameHandle);

                // MapBitmap
                LockBitmap MapBitmap = new LockBitmap(MapImage);
                MapBitmap.LockBits();

                Color?PodBarColor = null;
                int   PodValue    = 0;

                // Get PodValue
                for (int x = Pod.PodBarX; x < Pod.PodBarEndX; x++)
                {
                    _pauseEvent.WaitOne();
                    if (_shutdownEvent.WaitOne(0))
                    {
                        break;
                    }

                    if (PodBarColor == null) // on récupère la couleur dominente
                    {
                        PodBarColor = MapBitmap.GetPixel(x, Pod.PodBarY);
                    }

                    // si la couleur est toujours dominente on continue
                    if (MapBitmap.GetPixel(x, Pod.PodBarY) == PodBarColor)
                    {
                        PodValue++;
                    }
                    else // si nn on s'arrete
                    {
                        break;
                    }
                }

                MapBitmap.UnlockBits();

                if (!_shutdownEvent.WaitOne(0)) // si le bot n'a pas été arrêté
                {
                    // Set Pod PercentValue (%)
                    Pod.PercentValue = (int)((float)((float)PodValue / Pod.PodBarWidth) * 100);
                    Log.Debug("Pod PodValue: " + PodValue + " PercentValue: " + Pod.PercentValue + "%");

                    // Set Progressbar FillProcent
                    PodProgressBar.BarFillProcent = Pod.PercentValue;

                    // ReClick sur l'inventaire pour le fermer
                    FakeClick.ClickOnPoint(GameHandle, Settings.InventoryPosition);
                    Wait();
                }
            }
            catch (Exception ex)
            {
                Log.Debug("Execption occured : " + ex.Message);
            }
            finally
            {
                Log.Divider(Log.Level.Debug);
            }
        }
예제 #9
0
파일: Bot.cs 프로젝트: Aursen/Pixus-Bot
        //=========================================================================================================================
        //                                                  Job méthodes
        //=========================================================================================================================

        #region Job
        // DoJob(...) : gère le métier du bot
        private void DoJob(String AreaFile)
        {
            Log.Title(Log.Level.Debug, "DoJob");
            //Log.Debug("AreaFile Path : " + AreaFile);

            try
            {
                // Lecture du fichier des ressources
                string[] resources = File.ReadAllLines(AreaFile);

                // Parcours des emplacements des ressources
                List <Point> resourceLocations = new List <Point>();
                foreach (string resource in resources)
                {
                    _pauseEvent.WaitOne();
                    if (_shutdownEvent.WaitOne(0))
                    {
                        break;
                    }

                    Log.Debug("Resource : " + resource);

                    // découpage des données de la ressource
                    string[] resourceData = Regex.Split(resource, "::");
                    string[] resourceXY   = Regex.Split(resourceData[1], "x");
                    string[] resourceRGB  = Regex.Split(resourceData[2], ",");

                    int   resourceX        = Int32.Parse(resourceXY[0]);
                    int   resourceY        = Int32.Parse(resourceXY[1]);
                    Point resourceLocation = new Point(resourceX, resourceY);

                    Color ResourceColor      = Color.FromArgb(Int32.Parse(resourceRGB[0]), Int32.Parse(resourceRGB[1]), Int32.Parse(resourceRGB[2]));
                    bool  checkResourceColor = Tools.stringToBool(resourceData[3]);

                    // s'il faut vérifier la couleur de la ressource + le pixel n'a pas la bonne couleur, on saute cette ressource alors
                    if (checkResourceColor && !Pixel.HasColor(resourceLocation, ResourceColor, GameHandle))
                    {
                        continue;
                    }

                    resourceLocations.Add(resourceLocation);
                }

                // si ressource(s) trouvée(s)
                if (resourceLocations.Count > 0)
                {
                    // affichage des positions des ressources sur la Minimap
                    foreach (Point loc in resourceLocations)
                    {
                        Minimap.NewPin(MinimapPictureBox, GamePanel.Size, loc, Minimap.ResourcePinColor);
                    }

                    // Au boulot !
                    foreach (Point location in resourceLocations)
                    {
                        _pauseEvent.WaitOne();
                        if (_shutdownEvent.WaitOne(0))
                        {
                            break;
                        }

                        // vérification de la connexion
                        if (!Connection.State())
                        {
                            Log.Error("Connexion perdue");
                            Suspend();
                            break;
                        }

                        // on s'assure que toutes les fenêtres popup sont fermés
                        CheckPopUps();

                        // on collecte/récolte la ressource si possible
                        if (location.X > 0 && location.Y > 0)
                        {
                            Log.Debug("Collecting Resource (X: " + location.X + " Y: " + location.Y + ")");

                            FakeClick.ClickOnPoint(GameHandle, location);
                            Wait(Job.MaxCollectTime);
                            Minimap.RemovePin(MinimapPictureBox, GamePanel.Size, location);
                            Job.CollectedResourceCount++;
                        }

                        // on vérifie si un combat est en cours
                        CheckFight();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Debug("Execption occured : " + ex.Message);
            }

            if (!_shutdownEvent.WaitOne(0)) // si le bot n'a pas été arrêté
            {
                Log.Debug("CollectedResourceCount : " + Job.CollectedResourceCount);

                Log.Divider(Log.Level.Debug);
            }
        }
예제 #10
0
 // Step(...) : Bouge le Bot
 private static void Step(IntPtr GameHandle, Point to)
 {
     FakeClick.ClickOnPoint(GameHandle, to);
 }