I ran into one problem though using it when I was creating my art site. I had a bunch of pictures, and though Wordpress has an import function, it doesn’t support YAPB natively. That was a big problem for me – I could import all my posts, but then I’d have to go back and manually add pictures to each of my posts (around 100 of them). Um, I don’t think so.

So I set my mind to it – I was going to write myself a Wordpress plugin to make it much easier for me to be lazy! So it was written. So let it be done.

How I made it

What I basically did is rip out the exporting code (literally…like copy and paste) for Wordpress and added one extra field for the YAPB image. Then ripped out the importing code for Wordpress (literally, another copy and paste) and added functionality to read that extra field and save the image along with the post. Then wrapped up both of those in a nice little plugin.

So the importing/exporting works exactly as Wordpress does now in 2.7. The only difference is your images come along with the import/export.

This is the very first beta version of the plugin (my first plugin actually), so sorry if there isn’t any fancy image stuff. But it works! I used it for my own site.

Instructions for Use

The export function is just like Wordpress and is located under Tools -> Export YAPB. The import function is located the same place the other import functions are, Tools -> Import -> YAPB Importer. Use it exactly like you would use the default Wordpress importer.

(Disclaimer: Of course, in the interest of you-can’t-blame-me-ism, always backup your DB before doing significant changes like imports!)

This is an ASP.NET application that will play a perfect game of Tic-Tac-Toe using the AI algorithm called minimax. First a little about the game Tic-tac-toe. It is a deterministic game, meaning that all actions have a direct and knowable consequence to the game state. It is what theorists like to call a “Zero Sum” game – where the compluter has complete, or perfect information about the game state, the game space, and the environment.

As with the majority of things in AI, what the sitation boils down to is search. Here’s the components we need to have in order to complete our search of the tic-tac-toe game space:

• An initial state. For us this is an empty board
• A successor function. A method which gives us the resulting states that are accessible by making a particular action against the state we pass in.
• A terminal test. A method that determines if we are in a terminal state – i.e., whether the game is over or not. In our case it would be Player 1, Player 2, or draw (cat’s game).
• A utility function that gives a numeric value for terminal states.

Since tic-tac-toe is a turn-based, two player game, it lends itself to using the minimax algorithm to determine the best move for a given state. The minimax algorithm is a little bit confusing.  Here’s a really simple rundown:

In a normal search situation, you use a initial state and determine a sequence of moves to get you to your desired goal state. However, in turn based games, there is not just one player MAX, but the opponent player MIN that we must worry about. MIN’s moves can impact the game states that are available to us and indeed can render our desired goal state (where we, MAX win) unreachable. That of course is not satisfactory. What can we do? The MAX player, the first to make a move, must pick a move that has the highest value returned by the utility function.

However, assuming MIN plays optimally, MIN will also try to choose the best move that he can, thus minimizing MAX’s outcome. Thus, MAX should make the move that minimizes the value of MIN’s utility function. In other words, the computer MAX, should make the move which leaves its opponent capable of doing the least damage.

Hopefully that sheds some light on how the algorith works. For an in-depth discussion  of the details of how minimax works, see this article at the AI Depot. (Note that our algorithm makes use of Alpha-Beta pruning to reduce our search tree).

————-

Now that we have talked about how our AI logic works, lets look at the architecture of our application. Even though this is a small application, I made use of the N-Tier approach to web programming. Since our example is simple, we will only have 2 layers: our presentation layer, and our business logic. In laymans terms, this is just the layer that displays our information and the layer that contains our logic, respectively. The reason I did this is because it helps us modularize our code for easy re-use and modification, and makes the code much cleaner to read.

I created an ASP.NET User Control to display our tic-tac-toe board, then placed it in an ASP.NET page that configures and displays it. The User Control in turn uses a custom Board object that I created that represents the tic-tac-toe board as an object. I have methods implemented in a separate class that performs the Artificial Intelligence operations on the Board object.

Board.cs

This is the class that serves as a wrapper class around a simple integer array. The positions in the array map to positions on the board; e.g. the first three spaces on the first row map to the first 3 positions in the integer array. We also implement the ICloneable and IEnumerable interfaces. ICloneable so that we can make an exact duplicate of a board and manipulate it and not touch the original. The IEnuerable interface is optional, but it lets us use a foreach statement to traverse the board, which is handy. The class also includes helper methods like IsFull, that can tell us some information about a given board.

MinimaxAlgorithm.cs

This is where the magic happens. This is the C# implementation of the minimax algorithm with alpha-beta pruning. The class implements an IGameAlgorithm interface which is an interface I created that has on simple method in it named Solve. It take a Board object as an argument and returns the optimal move. I did this so that when calling the algorithm, we can call the interface and not the class itself. That way, if we want to swap out the algorithm for a different one (say with a Q-Learning Reinforcement Algorithm), it will be quite easy. Here’s the meat of the code:

namespace TicTacToe.Library
{
    public enum BoardPlayer
    {
        NoPlayer = 0, Player1 = 1, Player2 = 2
    }
 
    [Serializable()]
    public class Board : ICloneable, IEnumerable<BoardPlayer>
    {
        private int[] board;
 
        /// <summary>
        /// Constructor - initializes empty board and hash key
        /// </summary>
        public Board()
        {
            board = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        }
 
        /// <summary>
        /// Gets the value at the specified 0-based index
        /// </summary>
        /// <param name="index">Index to retrieve</param>
        /// <returns>BoardPlayer</returns>
        public BoardPlayer this[int index]
        {
            get { return (BoardPlayer) board[index]; }
            set { board[index] = (int) value; }
        }
 
        /// <summary>
        /// Gets the value based on x,y coordinates, where 0,0 is
        /// the top left.
        /// </summary>
        /// <param name="x">X coordinate</param>
        /// <param name="y">Y coordinate</param>
        /// <returns>BoardPlayer</returns>
        public BoardPlayer this[int x, int y]
        {
            get { return (BoardPlayer) board[y * 3 + x]; }
            set { board[y * 3 + x] = (int) value; }
        }
 
        /// <summary>
        /// Boolean based on if there is a player on the board.
        /// </summary>
        /// <returns>True if board is empty.</returns>
        public bool IsEmpty()
        {
            foreach (int i in board)
            {
                if (i != 0) return false;
            }
            return true;
        }
 
        /// <summary>
        /// Boolean based on if there the board is full or not.
        /// </summary>
        /// <returns>True if board is full.</returns>
        public bool IsFull()
        {
            foreach (int i in board)
            {
                if (i == 0) return false;
            }
            return true;
        }
 
        /// <summary>
        /// Gets all board spots that are not taken.
        /// </summary>
        /// <returns>Array of indices that are free on the board.</returns>
        public int[] GetValidMoves()
        {
            List<int> moves = new List<int>();
            for (int i = 0; i < 9; i++)
            {
                if (board[i] == 0)
                    moves.Add(i);
            }
            return moves.ToArray();
        }
 
        /// <summary>
        /// Evaluates if player has won or not
        /// </summary>
        /// <param name="player">BoardPlayer</param>
        /// <returns>True if given player has won.</returns>
        public bool Evaluate(BoardPlayer player)
        {
            int x = 0;
            // check columns
            for (int i = 0; i < 3; i++)
            {
                x = 0;
                for (int j = 0; j < 3; j++)
                    if ((int) this[i, j] == (int)player) x++;
                if (x == 3) return true;
            }
            // check rows
            for (int i = 0; i < 3; i++)
            {
                x = 0;
                for (int j = 0; j < 3; j++)
                    if ((int)this[j, i] == (int)player) x++;
                if (x == 3) return true;
            }
            // check diagonal
            x = 0;
            for (int i = 0; i < 3; i++)
            {
                if ((int)this[i, i] == (int)player) x++;
                if (x == 3) return true;
            }
            // check diagonal the other way
            x = 0;
            for (int i = 2, j = 0; i >= 0; i--, j++)
            {
                if ((int)this[i, j] == (int)player) x++;
                if (x == 3) return true;
            }
            return false;
        }
 
        /// <summary>
        /// Default ToString
        /// </summary>
        /// <returns>String representation of object</returns>
        public override string ToString()
        {
            StringBuilder str = new StringBuilder();
            for (int i = 0, j = 0; i < 9; i++, j++)
            {
                // set player symbol
                if (board[i] == (int)BoardPlayer.NoPlayer)
                    str.Append(" ");
                else
                    str.Append(board[i].ToString());
 
                // start a new line
                if (j == 2 && i < 6)
                {
                    str.Append(string.Format("{0}-+-+-{0}", System.Environment.NewLine ));
                    j = -1;
                }
                else
                {
                    if (j != 2)
                        str.Append("|");
                }
            }
            return str.ToString();
        }
 
        /// <summary>
        /// Determines if another board is equal to given board
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override bool Equals(object obj)
        {
            if (this == obj)
                return true;
            if (!(obj is Board))
                return false;
            Board other = (Board)obj;
            for (int i = 0; i < 9; i++)
            {
                if (board[i] != other.board[i])
                    return false;
            }
            return true;
        }
 
        /// <summary>
        /// Get hash code for object
        /// </summary>
        /// <returns></returns>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
 
        #region ICloneable Members
 
        public object Clone()
        {
            Board newBoard = (Board)base.MemberwiseClone();
            newBoard.board = (int[])board.Clone();
            return newBoard;
        }
 
        #endregion
 
        #region IEnumerable<BoardPlayer> Members
 
        public IEnumerator<BoardPlayer> GetEnumerator()
        {
            // returns board, but as BoardPlayers instead of integers
            BoardPlayer[] newBoard = Array.ConvertAll<int, BoardPlayer>(board, new Converter<int, BoardPlayer>(
                delegate(int i) { return (BoardPlayer)i; }
            ));
            // return iterator for new board
            return (newBoard as IEnumerable<BoardPlayer>).GetEnumerator();
        }
 
        #endregion
 
        #region IEnumerable Members
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
 
        #endregion
    }
}

As you can see the code is not very complex or long. It’s just very recursive, which can be confusing in its own right.

BoardManager.cs

This class encapsulates the different actions that we want to perform on the Board. If we want to make a move on the board, or compute the next best minimax move, this class handles that through a bunch of static functions. It helps to have all of this code localized into one place.

namespace TicTacToe.Library
{
    public class BoardManager
    {
        private static IGameAlgorithm gameAlgorithm = new MinimaxAlgorithm();
 
        /// <summary>
        /// Sets the algorithm used by ComputeBestMove(). By default it is
        /// the Minimax Algorithm.
        /// </summary>
        /// <param name="algorithm">Algorith to use for computing</param>
        public static void SetGameAlgorithm(IGameAlgorithm algorithm)
        {
            gameAlgorithm = algorithm;
        }
 
        /// <summary>
        /// Determines if the board can be played further.
        /// </summary>
        /// <param name="board">Board to evaluate</param>
        /// <returns>True if the game is over</returns>
        public static bool IsGameComplete(Board board)
        {
            if (board.Evaluate(BoardPlayer.Player1) ||
                board.Evaluate(BoardPlayer.Player2) ||
                board.IsFull())
                return true;
            else
                return false;
        }
 
        /// <summary>
        /// Determines the player who won the current board.
        /// The result can be no-player.
        /// </summary>
        /// <param name="board">Board to evaluate</param>
        /// <returns></returns>
        public static BoardPlayer GetWinner(Board board)
        {
            if (board.Evaluate(BoardPlayer.Player1))
                return BoardPlayer.Player1;
            else if (board.Evaluate(BoardPlayer.Player2))
                return BoardPlayer.Player2;
            else
                return BoardPlayer.NoPlayer;
        }
 
        /// <summary>
        /// Make a move on the given board.
        /// </summary>
        /// <param name="board">Board to make move on</param>
        /// <param name="player">Player who is making the move</param>
        /// <param name="position">Positon the player make the move to</param>
        public static void MakeMoveOnBoard(Board board, BoardPlayer player, int position)
        {
            board[position] = player;
        }
 
        /// <summary>
        /// Computes the best move for the board using the algorithm set by
        /// SetGameAlgorithm. If not set, it defaults to Minimax algorithm.
        /// </summary>
        /// <param name="board">Board to evaluate.</param>
        /// <returns>Index of the best board move.</returns>
        public static int ComputeBestMove(Board board)
        {
            return gameAlgorithm.Solve(board);
        }
 
        /// <summary>
        /// Returns a random move o nthe board.
        /// </summary>
        /// <returns>Index of the random board move.</returns>
        public static int ComputeRandomMove()
        {
            Random r = new Random();
            return r.Next(8);
        }
    }
}

As I mentioned, all the methods that we need to interact with a Board are handled in this class. This is our true “business logic” component of the system. It functions more like a facade design pattern than anything else.

Continue on to the next page to get the rest and the source code…

]]> http://www.thehomeofjon.net/programming/2007/11/tic-tac-toe-using-minimax-and-asp-net/feed/ 2 http://www.thehomeofjon.net/programming/2007/10/tic-tac-toe-applet/ http://www.thehomeofjon.net/programming/2007/10/tic-tac-toe-applet/#comments Sat, 20 Oct 2007 18:14:57 +0000 Jon http://www.thehomeofjon.net/blog/title/tic-tac-toe-applet.html Training in the remotest parts of the galaxy, TicTacToeTron (also known as T4 for those who are down) has relentlessly sought the highest point of perfection in the mind-bending process that some call the game “Tic-Tac-Toe”.

This is the Tic-Tac-Toe Applet. The AI player will play a human player using the AI  minimax algorithm. Using this algorithm the computer can look forward into the future and determine the consequence of every move it makes – and since tic-tac-toe is a pretty simplistic game, TicTacToeTron will be able to make his moves with perfect accuracy. He can never lose. See this link for a deeper explanation of the minimax algorithm.

See this link to see a more complete description of A* search. This implementation of A* uses 4 simple heuristics (that is, guesses the robot can make about the best path to take based on knowledge of its environment):

1) the straightline distance between where the robot is and there the goal is.
2) the distance between where the robot is and there the goal is on the x-axis.
3) the distance between where the robot is and there the goal is on the y-axis.
4) the best of all value of any given heuristics.

One of the best ways to implement A* is using a priority queue. That is because of the following. As the search generates steps that it can take, it will store each step in a data structure. The most easiest and abstract way to handle this is to have a priority queue, so that when you enter a new step or move the robot can take, it will be inserted automatically (by order of the cost it will take to get there) in the sequence of moves it has already generated. Thus, when you remove the first element from the queue, it will be the best and lowest costing move.

The internals of the priority queue is based on a heap structure. (See a good applet for a visual explanation and this article describing it). This heap is a binary tree which allows for quick access and retrieval. The most attractive feature is that it lets me find the the lowest costing node in constant time because I am not searching for it.

Writing a queue in any real language isn’t so hard. But writing it in a low level language like C proved to be a challenge. In the case anyone else can use this implementation, I’ve posted it here for general availability. It should be known that I am no expert C programmer – so if anyone has any improvements or ideas, let me know!