controller

Class SmartAI

java.lang.Object

controller.Controller

controller.MinMaxAI

controller.SmartAI

All Implemented Interfaces:

GameListener

public class SmartAI
extends MinMaxAI

The SmartAI uses min-max search with reasonable heuristics to choose the next move to make.

This implementation uses a search depth of 4, only places moves adjacent to moves that have already been played, and uses a reasonable heuristic measure of goodness (described below).

Constructor Summary

Constructors

Constructor and Description
SmartAI(Player me)

Method Summary

Modifier and Type	Method and Description
int	estimate(Board b) A particular line of 5 adjacent cells is "winnable" for player p if it does not contain any of the opponent's marks.
java.lang.Iterable<Location>	moves(Board b) Return the set of locations that are adjacent to played locations, or the center of the board if no moves have been played.
boolean	reasonableMove(Board b, Location loc) Returns true iff loc is empty and has a neighbor.
int	score(Board b, Player p) return the positive score for player p
int	score(Board b, Player p, Line s) Return the score for player p, for the line s.

Methods inherited from class controller.Controller

gameChanged

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SmartAI

public SmartAI(Player me)

Method Detail

estimate

public int estimate(Board b)

A particular line of 5 adjacent cells is "winnable" for player p if it does not contain any of the opponent's marks.

We measure goodness by counting the number of winnable lines, and scoring them based on the number of the player's marks as follows:

Number of marks	Score
0	0
1	1
2	10
3	100
4	1000
5	10000

Note that overlapping segments will be counted multiple times, so that, for example, the following board:

 
       O O
       OXO
       O O
 

will count as 5 points for X, since there are 5 vertical line segments passing through X, while

       OOO
       OXO
       O O
 

will only count for 1 point, since only the line segment proceeding down from X is winnable. The estimate is the difference between the player's score and his opponent's

score

public int score(Board b,
                 Player p)

return the positive score for player p

score

public int score(Board b,
                 Player p,
                 Line s)

Return the score for player p, for the line s.

moves

public java.lang.Iterable<Location> moves(Board b)

Return the set of locations that are adjacent to played locations, or the center of the board if no moves have been played.

reasonableMove

public boolean reasonableMove(Board b,
                              Location loc)

Returns true iff loc is empty and has a neighbor.