Life In 19x19

Code: Select all

package com.lifein19x19.pippenFuseki.engine;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Random;

/**
 * Generates a "Pippen Fuseki" based on these parameters
 * 
 * 1. Mark every intersection on the 3rd and 4th line with a number (=104
 * numbers).
 * 
 * 2. Get a random generator.
 * 
 * 3. Play the first move in the corner on x-x (my choice: 4-4).
 * 
 * 4. Then let the random generator decide the next moves under the following
 * conditions:
 * 
 * a) If a numver comes up that is already occupied by a stone then let a new
 * number be created.
 * 
 * b) If a number comes up that is (vertically or horizonally) as near as y (my
 * choice: 1) intersections on one of your own stones then let a new number be
 * created.
 * 
 * c) Stop this algorithm after your move y (my choice: 7) or if you have to
 * create a 5th number on a move.
 * 
 * 5. Continue the game according to what was dealt to you.
 * 
 * @author moyoaji
 */
public class Generator {

	/** Signifies a non-move */
	public static final Point NO_MOVE = new Point(-1, -1);

	/** The minimum distance between two of your own moves */
	private int ownDistance;

	/**
	 * The minimum distance between one of your moves and one of your opponent's
	 * moves
	 */
	private int enemyDistance;

	/** The RNG */
	private Random rand = new Random();

	/** The list of moves */
	private ArrayList<Point> moves;

	/** The list of opponent's moves */
	private ArrayList<Point> enemyMoves;

	/** The highest point on the board that a random move can be */
	private int maxHeight;

	/**
	 * Creates a generator based on parameters
	 * 
	 * @param firstMove black's first move
	 * @param secondMove white's first move
	 * @param ownDistance how far apart you want moves to be from your own
	 *            stones
	 * @param enemyDistance how far you want moves to be from opponent's stones
	 */
	public Generator(Point firstMove, Point secondMove, int ownDistance,
			int enemyDistance, int maxHeight) {
		moves = new ArrayList<Point>();
		enemyMoves = new ArrayList<Point>();

		this.ownDistance = ownDistance;
		this.enemyDistance = enemyDistance;
		this.maxHeight = maxHeight;

		// Add the first and second moves if they were given, otherwise don't
		if (!firstMove.equals(NO_MOVE)) {
			moves.add(firstMove);
		}
		if (!secondMove.equals(NO_MOVE)) {
			enemyMoves.add(secondMove);
		}
	}

	/**
	 * Inputs a move the opponent made
	 * 
	 * @param move the move the opponent just made
	 */
	public void inputMove(Point move) {
		if (move != NO_MOVE) {
			enemyMoves.add(move);
		}
	}

	/**
	 * Gets the next move as a new point and adds the new move to the move list
	 * 
	 * @return the next move
	 */
	public Point getNextMove() {
		Point move = NO_MOVE;
		boolean tooClose = true;
		long tries = 0L;
		long tooMany = 31415926L; // You got a better number in mind?

		// While the move is too close for comfort, keep getting a new one until
		// we've tried too many times. Then there probably isn't a legal move...
		while (tooClose && tries < tooMany) {
			tries++;
			tooClose = false;

			// Determines where on the line the move is (between lines 3 and 17)
			int coor1 = rand.nextInt(15) + 3;
			int coor2 = rand.nextInt(15) + 3;

			// Make sure the move isn't too high or low on the board
			if (coor1 > maxHeight && coor2 > maxHeight
					&& coor1 < 19 - maxHeight + 1 && coor2 < 19 - maxHeight + 1) {
				tooClose = true; // Mark it as too close because that's
									// effectively the same
			}

			// Mark the move as a point on the board
			move = new Point(coor1, coor2);

			// Check if the move is too close to one of our own stones
			for (int x = 0; x < moves.size() && !tooClose; x++) {
				if ((Math.abs((moves.get(x).x - move.x))) <= ownDistance
						&& (Math.abs((moves.get(x).y - move.y))) <= ownDistance) {
					tooClose = true;
				}
			}

			// Check if the move is too close to an opponent's stone
			for (int y = 0; y < enemyMoves.size() && !tooClose; y++) {
				if ((Math.abs(enemyMoves.get(y).x - move.x)) <= enemyDistance
						&& (Math.abs(enemyMoves.get(y).y - move.y)) <= enemyDistance) {
					tooClose = true;
				}
			}
		}

		// If we tried too many times, return a non-move instead.
		if (tries >= tooMany) {
			System.out.println("You're playing too many moves!");
			return NO_MOVE;
		}

		moves.add(move);

		return new Point(move.x, move.y);
	}

	/**
	 * Gets the moves generated so far as a new ArrayList
	 * 
	 * @return the moves generated so far
	 */
	public ArrayList<Point> getMoves() {
		ArrayList<Point> theMoves = new ArrayList<Point>(moves.size());
		for (int i = 0; i < moves.size(); i++) {
			theMoves.add(moves.get(i));
		}
		return theMoves;
	}

	/**
	 * Gets the moves your opponent played so far as a new ArrayList
	 * 
	 * @return the moves played so far
	 */
	public ArrayList<Point> getOppMoves() {
		ArrayList<Point> theMoves = new ArrayList<Point>(moves.size());
		for (int i = 0; i < enemyMoves.size(); i++) {
			theMoves.add(enemyMoves.get(i));
		}
		return theMoves;
	}

	/**
	 * Generates the list of moves
	 */
	public String generateList() {
		String list = "In this game I played the rare ";

		for (int i = 0; i < moves.size(); i++) {
			list = list + moves.get(i).x + "-" + moves.get(i).y;
			if (i < moves.size() - 1) {
				list = list + ", ";
			}
		}

		list = list + " opening";

		return list;
	}
}