Tic Tac Toe - Computergegner

final class Best
{
    int row;
    int column;
    int val;


    public Best( int v )
      { this( v, 0, 0 ); }

    public Best( int v, int r, int c )
      { val = v; row = r; column = c; }
}

class TicTacToeSlow
{
    public static final int HUMAN        = 0;
    public static final int COMPUTER     = 1;
    public static final int EMPTY        = 2;


    public static final int HUMAN_WIN    = 0;
    public static final int DRAW         = 1;
    public static final int UNCLEAR      = 2;
    public static final int COMPUTER_WIN = 3;


        // Constructor
    public TicTacToeSlow( )
    {
        clearBoard( );
    }


    public int [ ] [ ] getBoard( )
    {
        return board;
    }


        // Find optimal move
    public Best chooseMove( int side )
    {
        int opp;              // The other side
        Best reply;           // Opponent's best reply
        int dc;               // Placeholder
        int simpleEval;       // Result of an immediate evaluation
        int bestRow = 0;
        int bestColumn = 0;
        int value;


        if( ( simpleEval = positionValue( ) ) != UNCLEAR )
            return new Best( simpleEval );


        if( side == COMPUTER )
        {
            opp = HUMAN; value = HUMAN_WIN;
        }
        else
        {
            opp = COMPUTER; value = COMPUTER_WIN;
        }


        for( int row = 0; row < 3; row++ )
            for( int column = 0; column < 3; column++ )
                if( squareIsEmpty( row, column ) )
                {
                    place( row, column, side );
                    reply = chooseMove( opp );
                    place( row, column, EMPTY );

                        // Update if side gets better position
                    if( side == COMPUTER && reply.val > value
                       ||  side == HUMAN && reply.val < value )
                    {
                        value = reply.val;
                        bestRow = row; bestColumn = column;
                    }
                }


        return new Best( value, bestRow, bestColumn );
    }




        // Play move, including checking legality
    public boolean playMove( int side, int row, int column )
    {
        if( row < 0 || row >= 3 || column < 0 || column >= 3
                || board[ row ][ column ] != EMPTY )
            return false;
        board[ row ][ column ] = side;
        return true;
    }



        // Simple supporting routines
    public void clearBoard( )
    {
        for( int i = 0; i < 3; i++ )
            for( int j = 0; j < 3; j++ )
                board[ i ][ j ] = EMPTY;
    }




    public boolean boardIsFull( )
    {
        for( int row = 0; row < 3; row++ )
            for( int column = 0; column < 3; column++ )
                if( board[ row ][ column ] == EMPTY )
                    return false;
        return true;
    }


    public boolean isAWin( int side )
    {
        int row, column;


        /* Look for all in a row */
        for( row = 0; row < 3; row++ )
        {
            for( column = 0; column < 3; column++ )
                if( board[ row ][ column ] != side )
                    break;
            if( column >= 3 )
                return true;
        }


        /* Look for all in a column */
	for( column = 0; column < 3; column++ )
        {
            for( row = 0; row < 3; row++ )
                if( board[ row ][ column ] != side )
                    break;
            if( row >= 3 )
                return true;
        }


        /* Look on diagonals */
        if( board[ 1 ][ 1 ] == side && board[ 2 ][ 2 ] == side
			&& board[ 0 ][ 0 ] == side )
            return true;


        if( board[ 0 ][ 2 ] == side && board[ 1 ][ 1 ] == side
			&& board[ 2 ][ 0 ] == side )
            return true;


        return false;
    }


    private int [ ] [ ] board = new int[ 3 ][ 3 ];


        // Play a move, possibly clearing a square
    private void place( int row, int column, int piece )
    {
        board[ row ][ column ] = piece;
    }

    private boolean squareIsEmpty( int row, int column )
    {
        return board[ row ][ column ] == EMPTY;
    }


        // Compute static value of current position (win, draw, etc.)
    private int positionValue( )
    {
        return isAWin( COMPUTER ) ? COMPUTER_WIN :
               isAWin( HUMAN )    ? HUMAN_WIN :
               boardIsFull( )     ? DRAW         : UNCLEAR;
    }
}

import java.awt.Frame;
import java.awt.Panel;
import java.awt.Button;
import java.awt.*;
import java.awt.GridLayout;


import java.awt.event.WindowAdapter;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.WindowEvent;


public class TicTacMainSlow extends Frame
{
    public TicTacMainSlow( )
    {
        add( new TicTacPanel( ) );

        addWindowListener( new WindowAdapter( ) 
        {
            public void windowClosing( WindowEvent event ) 
            {
                System.exit( 0 );
            }                 
        } );
    }


    public static void main( String [ ] args )
    {
        Frame f = new TicTacMainSlow( );
        f.pack( );
        f.setVisible(true);
    }


    private static class TicTacPanel extends Panel implements ActionListener
    {
        public TicTacPanel( )
        {
            setLayout( new GridLayout( 3, 3 ) );
            for( int i = 0; i < 3; i++ )
               for( int j = 0; j < 3; j++ )
               {
            	   Button b = new Button();
            	   b.setFont(new Font("SansSerif",Font.BOLD,18));
                   squares[ i ][ j ] = b;

                   add( squares[ i ][ j ] );
                   squares[ i ][ j ].addActionListener( this );
               }


            resetBoard( );
        }


        public void resetBoard( )
        {
            t = new TicTacToeSlow( );
            for( int i = 0; i < 3; i++ )
               for( int j = 0; j < 3; j++ )
               {
                   squares[ i ][ j ].setLabel( "" );
                   squares[ i ][ j ].setEnabled( true );
               }
        }


        private int gameNum = 0;


        public void doCompMove( boolean thinkAboutIt )
        {
            Best compMove;


            if( thinkAboutIt )
                compMove = t.chooseMove( TicTacToeSlow.COMPUTER );
            else
            {
                compMove = new Best( 0, gameNum % 3, gameNum / 3 );
                gameNum = ( gameNum + 1 ) % 9;
            }


            System.out.println( " ROW = " + compMove.row +
                                " COL = " + compMove.column );


            squares[ compMove.row ][ compMove.column ].setLabel( computerSide );
            squares[ compMove.row ][ compMove.column ].setEnabled( false );
            t.playMove( TicTacToeSlow.COMPUTER, compMove.row, compMove.column );
        }


        public boolean resetIfDone( boolean condition, String message, boolean compMoves )
        {
            if( condition )
            {
                System.out.println( message );
                System.out.println( "Restarting..." );
                resetBoard( );
                if( compMoves )
                {
                    System.out.println( "I go first..." );
                    computerSide = "X";
                    humanSide = "O";
                    doCompMove( false );
                }
                else
                {
                    humanSide = "X";
                    computerSide = "O";
                    System.out.println( "You go first..." );
                }
            }
            return condition;
        }




        public void actionPerformed( ActionEvent evt )
        {
            if( evt.getSource( ) instanceof Button )
            {
                ( (Button)evt.getSource( ) ).setLabel( humanSide );
                ( (Button)evt.getSource( ) ).setEnabled( false );


                for( int i = 0; i < 3; i++ )
                    for( int j = 0; j < 3; j++ )
                        if( evt.getSource( ) == squares[ i ][ j ] )
                            t.playMove( TicTacToeSlow.HUMAN, i, j );


                if( resetIfDone( t.boardIsFull( ), "DRAW", true ) )
                    return;
                doCompMove( true );           
                resetIfDone( t.isAWin( TicTacToeSlow.COMPUTER ), "I WIN!!", true );
                resetIfDone( t.boardIsFull( ), "DRAW", false );


                return;
            }
        }


        private Button [ ][ ]  squares = new Button[ 3 ][ 3 ];
        private TicTacToeSlow t;
        private String computerSide = "O";
        private String humanSide    = "X";
    }
}