com.barrybecker4.game.twoplayer.go.board.analysis.CandidateMoveAnalyzer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bb4-go Show documentation
bb4-games java code.
There is a newer version: 1.6
/** Copyright by Barry G. Becker, 2000-2011. Licensed under MIT License: http://www.opensource.org/licenses/MIT  */
package com.barrybecker4.game.twoplayer.go.board.analysis;

import com.barrybecker4.game.common.board.BoardPosition;
import com.barrybecker4.game.twoplayer.go.board.GoBoard;
import com.barrybecker4.game.twoplayer.go.board.elements.position.GoBoardPosition;

/**
 * Creates a set of reasonable next moves for a given player.
 * In theory, all empties should be considered, but in practice, we keep
 * a shorter list of reasonable moves lest things get intractable.
 * Immutable.
 *
 * @author Barry Becker
 */
public class CandidateMoveAnalyzer {

    /** Distance from already played stones that we will splat a footprint of candidate stones to add. */
    private static final int CANDIDATE_MOVE_OFFSET = 2;

    private final GoBoard board_;

    private final int size_;

    /** this is an auxiliary structure to help determine candidate moves. */
    private final boolean[][] candidateMoves_;

    /**
     * Constructor.
     */
    public CandidateMoveAnalyzer(GoBoard board) {
        board_ = board;
        size_ = board.getNumRows();
        candidateMoves_ = new boolean[size_ + 1][size_ + 1];
        initialize();
    }

    /**
     * If there is any chance at all that this could be a reasonable move, true is returned.
     *
     * @return true if this position is a reasonable next move.
     */
    public final boolean isCandidateMove( int row, int col ) {
        return candidateMoves_[row][col];
    }

    /**
     * @return number of candidate moves found.
     */
    public final int getNumCandidates() {
        int num = 0;
        for (int i = 1; i <= size_; i++ ) {
            for (int j = 1; j <= size_; j++ ) {
                if ( isCandidateMove(i, j) )  num++;
            }
        }
        return num;
    }

    /**
     * we start with a default list of good starting moves, and
     * add to it all moves within 2 spaces of those that have already been played.
     *
     * Fill a 2 stone wide strip on the 3rd and 4rth lines of the board.
     * This includes the star points and many others as candidates to consider
     */
    private void initialize() {
        for (int i = 3; i <= size_ - 2; i++ ) {
             tryToAddCandidateMove(board_.getPosition(i, 3));
             tryToAddCandidateMove(board_.getPosition(i, 4));
             tryToAddCandidateMove(board_.getPosition(i, size_ - 2));
             tryToAddCandidateMove(board_.getPosition(i, size_ - 3));
        }
        for (int j = 5; j <= size_ - 4; j++ ) {
            tryToAddCandidateMove(board_.getPosition(3, j));
            tryToAddCandidateMove(board_.getPosition(4, j));
            tryToAddCandidateMove(board_.getPosition(size_ - 2, j));
            tryToAddCandidateMove(board_.getPosition(size_ - 3, j));
        }
        // also make the center space a candidate move
        tryToAddCandidateMove(board_.getPosition(((size_ + 1) >> 1), ((size_ + 1) >> 1)));

        determineAdjacentCandidates();
    }


    /**
     * this method splats a footprint of trues around the current moves.
     * later we look for empty spots that are true for candidate moves
     */
    private void determineAdjacentCandidates() {
        for (int i = 1; i <= size_; i++ ) {
            for (int j = 1; j <= size_; j++ ) {
                GoBoardPosition pos = (GoBoardPosition) board_.getPosition(i,j);
                if ( pos.isOccupied() ) {
                    addCandidateMoves(pos);
                }
            }
        }
    }

    /**
     * This method splats a footprint of trues around the specified move.
     * @param stone position to add candidate moves around.
     */
    private void addCandidateMoves( GoBoardPosition stone ) {
        int startrow = Math.max( stone.getRow() - CANDIDATE_MOVE_OFFSET, 1 );
        int stoprow = Math.min( stone.getRow() + CANDIDATE_MOVE_OFFSET, size_ );
        int startcol = Math.max( stone.getCol() - CANDIDATE_MOVE_OFFSET, 1 );
        int stopcol = Math.min( stone.getCol() + CANDIDATE_MOVE_OFFSET, size_ );
        // set the footprint
        for (int i = startrow; i <= stoprow; i++ ) {
            for (int j = startcol; j <= stopcol; j++ )  {
                GoBoardPosition pos = (GoBoardPosition) board_.getPosition(i,j);
                 tryToAddCandidateMove(pos);
            }
        }
    }

    /**
     * Add only if unoccupied and not an unconditionally alive eye.
     * never add a stone from either side to an unconditionally alive eye. There is no advantage to it.
     * @param position the position to try adding as a possible candidate move.
     */
    private void tryToAddCandidateMove(BoardPosition position) {
        GoBoardPosition pos = (GoBoardPosition) position;

        if (pos.isUnoccupied() && !(pos.getEye() != null && pos.getEye().isUnconditionallyAlive())) {
            candidateMoves_[pos.getRow()][pos.getCol()] = true;
        }
    }
}