コード例 #1
0
        /// <summary>
        /// Applique les capteurs de l'agent et recupere l'etat actuelle de l'environnement
        /// </summary>
        CheckersState CaptureSignals()
        {
            // L'etat associe au dernier coup du joueur adverse
            CheckersState currentState = new CheckersState(m_board, Token.TokenColor.Black);

            return(currentState);
        }
コード例 #2
0
        Effector AlphaBetaSearch(CheckersState currentState)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            CheckersState bestNextState = MaxValue(currentState, int.MinValue, int.MaxValue, 0).Value;

            stopwatch.Stop();
            Debug.WriteLine("Elapsed Time is {0} s", stopwatch.ElapsedMilliseconds / 1000f);
            return(bestNextState.Action);
        }
コード例 #3
0
        /// <summary>
        /// Retourne la decision effectue par l'algorithme pour la meilleure action a prendre
        /// </summary>
        /// /// <param name="currentState">L'etat dans lequel l'environnement est actuellement</param>
        /// <returns>L'action la plus logique par rapport a l'etat donne</returns>
        Effector MinimaxDecision(CheckersState currentState)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            CheckersState bestNextState = MaxValue(currentState, 0).Value;

            stopwatch.Stop();
            Debug.WriteLine("Elapsed Time is {0} s", stopwatch.ElapsedMilliseconds / 1000f);
            // On retourne l'action dans les successeurs de l'etat qui retourne la valeur la plus importante
            return(bestNextState.Action);
        }
コード例 #4
0
        KeyValuePair <int, CheckersState> MaxValue(CheckersState state, int alpha, int beta, int depth)
        {
            // Si l'etat est un etat terminal de l'arbre on retourne une valeur
            if (state.Terminal || depth >= m_depthMax)
            {
                return(new KeyValuePair <int, CheckersState>(state.Utility, state));
            }

            //Debug.WriteLine("Max profondeur : "+depth);
            int           utility       = int.MinValue;
            CheckersState bestSuccessor = state;
            // Pour tous les successeurs de l'etat on recupere le successeur qui renvoie la plus grande utilite minimum
            List <CheckersState> successors = state.Successors();

            if (successors.Count == 1 && depth == 0)
            {
                return(new KeyValuePair <int, CheckersState>(successors[0].Utility, successors[0]));
            }
            foreach (CheckersState nextState in successors)
            {
                int successorUtility = MinValue(nextState, alpha, beta, depth + 1).Key;
                if (utility < successorUtility)
                {
                    utility       = successorUtility;
                    bestSuccessor = nextState;
                }

                /*else if (utility == successorUtility)
                 * {
                 *  int choose = rand.Next(0, 2);
                 *  bestSuccessor = choose > 0 ? bestSuccessor : nextState;
                 * }*/
                if (utility >= beta)
                {
                    //Debug.WriteLine("Fin max profondeur : " + depth + ", utilite : " + utility);
                    return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
                }
                alpha = Math.Max(alpha, utility);
            }
            //Debug.WriteLine("Fin max profondeur : " + depth + ", utilite : " + utility);
            return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
        }
コード例 #5
0
        /// <summary>
        /// Execute l'effecteur le plus approprie selon l'agent
        /// </summary>
        /// <returns>Faux si l'agent n'a plus de mouvement</returns>
        public bool ExecuteAMove()
        {
            // Observe l’environnement
            CheckersState currentState = CaptureSignals();

            // Construit l'arbre ? (Uniquement si pb de performance)

            // Recupere toute les actions possible
            // Defini le but actuel prioritaire
            // Pour toute les actions possible on recupere celle qui est associe a la mesure d'utilite la plus forte
            Effector nextMove = AlphaBetaSearch(currentState);//MinimaxDecision(currentState);

            // Execute le mouvement
            if (nextMove == null)
            {
                return(false);
            }
            nextMove.Execute(m_board);
            return(true);
        }
コード例 #6
0
        /// <summary>
        /// Retourne le pire etat successeurs(pour l'agent) a l'etat propose
        /// </summary>
        /// <param name="state">L'etat propose</param>
        /// <param name="depth">La profondeur dans l'arbre a laquelle on se trouve</param>
        /// <returns>Le pire etat successeurs</returns>
        KeyValuePair <int, CheckersState> MinValue(CheckersState state, int depth)
        {   // Si l'etat est un etat terminal de l'arbre on retourne une valeur
            if (state.Terminal || depth >= m_depthMax)
            {
                return(new KeyValuePair <int, CheckersState>(state.Utility, state));
            }

            int           utility       = int.MaxValue;
            CheckersState bestSuccessor = state;

            // Pour tout les successeurs de l'etat on recupere le successeur qui renvoie la plus petite utilite maximum
            foreach (CheckersState nextState in state.Successors())
            {
                int successorUtility = MaxValue(nextState, depth + 1).Key;
                if (utility > successorUtility)
                {
                    utility       = successorUtility;
                    bestSuccessor = nextState;
                }
            }
            return(new KeyValuePair <int, CheckersState>(utility, bestSuccessor));
        }