path: root/src/jrummikub/control/RoundControl.java

package jrummikub.control;

import static jrummikub.model.PlayerSettings.Type.*;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import jrummikub.control.turn.AIControl;
import jrummikub.control.turn.HumanTurnControl;
import jrummikub.control.turn.ITurnControl;
import jrummikub.control.turn.TurnControlFactory;
import jrummikub.control.turn.TurnMode;
import jrummikub.model.IHand;
import jrummikub.model.IPlayer;
import jrummikub.model.IRoundState;
import jrummikub.model.ITable;
import jrummikub.model.PlayerSettings.Type;
import jrummikub.model.Position;
import jrummikub.model.Score;
import jrummikub.model.Stone;
import jrummikub.model.StoneSet;
import jrummikub.util.Connection;
import jrummikub.util.Event;
import jrummikub.util.Event1;
import jrummikub.util.IEvent;
import jrummikub.util.IEvent1;
import jrummikub.util.IListener;
import jrummikub.util.IListener2;
import jrummikub.util.Pair;
import jrummikub.view.IView;
import jrummikub.view.IView.BottomPanelType;

/**
 * Controller that manages a single round of rummikub
 */
public class RoundControl {
	public enum InvalidTurnType {
		INVALID_SETS, INITIAL_MELD_ERROR, NOT_ENOUGH_POINTS
	}

	public static class InvalidTurnInfo implements Serializable {
		private static final long serialVersionUID = -3591000741414366776L;

		private ITable table;
		private InvalidTurnType type;
		private ArrayList<StoneSet> invalidSets;

		public InvalidTurnInfo(ITable table, InvalidTurnType type,
				Collection<StoneSet> invalidSets) {
			this.table = (ITable) table.clone();
			this.type = type;
			this.invalidSets = new ArrayList<StoneSet>(invalidSets);
		}

		public ITable getTable() {
			return table;
		}

		public InvalidTurnType getType() {
			return type;
		}

		public List<StoneSet> getInvalidSets() {
			return invalidSets;
		}
	}

	private ITurnControl turnControl;
	protected IRoundState roundState;
	private IView view;
	private Event restartRoundEvent = new Event();
	private Event1<IRoundState> roundStateUpdateEvent = new Event1<IRoundState>();
	private Event1<Score> endOfRoundEvent = new Event1<Score>();
	protected List<Connection> connections = new ArrayList<Connection>();
	private boolean roundFinished;
	private boolean mayPause;

	public RoundControl(IRoundState roundState, IView view) {
		this(roundState, view, true);
	}

	/**
	 * Create a new RoundControl using the given gameState and view
	 * 
	 * @param roundState
	 *          initial round state
	 * @param view
	 *          view used for user interaction
	 */
	protected RoundControl(IRoundState roundState, IView view, boolean mayPause) {
		this.roundState = roundState;
		this.view = view;
		this.mayPause = mayPause;
	}

	/**
	 * Is emitted in network when a new turn starts
	 * 
	 * @return the event
	 */
	public IEvent1<IRoundState> getRoundStateUpdateEvent() {
		return roundStateUpdateEvent;
	}

	/**
	 * End the round
	 * 
	 * @return endOfRoundEvent
	 */
	public IEvent1<Score> getEndOfRoundEvent() {
		return endOfRoundEvent;
	}

	/**
	 * Begin the round
	 */
	public void startRound() {
		if (roundState != null) {
			deal();
		}

		continueRound();
	}

	/**
	 * Continue a saved round after loading
	 */
	public void continueRound() {

		connections.add(view.getStartTurnEvent().add(new IListener() {
			@Override
			public void handle() {
				startTurn();
			}
		}));

		connections.add(view.getAcknowledgeInvalidEvent().add(new IListener() {
			@Override
			public void handle() {
				nextPlayer();
			}
		}));

		if (roundState != null) {
			prepareTurn();
		}
	}

	/**
	 * Abort round if a new one is started or a saved one is loaded
	 */
	public void abortRound() {
		removeListeners();
		if (turnControl != null) {
			turnControl.abortTurn();
			turnControl = null;
		}
	}

	protected void setRoundState(IRoundState state) {
		roundState = state;
		roundStateUpdateEvent.emit(state);
	}

	protected void prepareTurn() {
		doPrepareTurn();

		boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
				.getType() == HUMAN;
		boolean oneHuman = roundState.getGameSettings().oneHuman();
		boolean isAI = (turnControl instanceof AIControl);

		if (isAI || (isHuman && oneHuman)) {
			startTurn();
		}
	}

	protected void doPrepareTurn() {
		updateSidePanel();

		boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
				.getType() == HUMAN;
		boolean oneHuman = roundState.getGameSettings().oneHuman();

		if (isHuman && !oneHuman) {
			view.setBottomPanel(BottomPanelType.START_TURN_PANEL);
		}

		view.getTablePanel().setStoneSets(roundState.getTable().clone());
		view.setCurrentPlayerName(roundState.getActivePlayer().getPlayerSettings()
				.getName());
		view.setCurrentPlayerColor(roundState.getActivePlayer().getPlayerSettings()
				.getColor());
		view.setCurrentPlayerHasLaidOut(roundState.getActivePlayer().getLaidOut());

		turnControl = createTurnControl(roundState.getActivePlayer()
				.getPlayerSettings().getType());
	}

	protected void startTurn() {
		if (turnControl == null) {
			doPrepareTurn();
		}

		boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
				.getType() == HUMAN;

		view.setBottomPanel(isHuman ? BottomPanelType.HUMAN_HAND_PANEL
				: BottomPanelType.NONHUMAN_HAND_PANEL);

		TurnMode turnMode = TurnMode.NORMAL_TURN;

		view.getTablePanel().setStoneSets(roundState.getTable().clone());

		if (roundState.getTurnNumber() < 1) {
			view.setStoneCollectionHidden(true);
			turnMode = TurnMode.INSPECT_ONLY;
			if (roundState.getActivePlayer().getHand().getIdenticalStoneCount() >= 3) {
				turnMode = TurnMode.MAY_REDEAL;
			}
		}

		if (isHuman) {
			view.getPlayerPanel().setEndTurnMode(turnMode);
		}

		turnControl.setup(
				new ITurnControl.TurnInfo(roundState, turnMode, mayPause),
				roundState.getGameSettings(), view);
		turnControl.getEndOfTurnEvent().add(
				new IListener2<IRoundState, InvalidTurnInfo>() {
					@Override
					public void handle(IRoundState newState,
							InvalidTurnInfo invalidTurnInfo) {
						setRoundState(newState);
						endOfTurn(invalidTurnInfo);
					}
				});
		turnControl.getRedealEvent().add(new IListener() {
			@Override
			public void handle() {
				redeal();
			}
		});
		addTurnControlListeners(turnControl);

		turnControl.startTurn();
	}

	private void updateSidePanel() {
		view.showSidePanel(true);
		view.getSidePanel().setGameSettings(roundState.getGameSettings());
		List<IPlayer> players = new ArrayList<IPlayer>();
		for (int i = 1; i < roundState.getPlayerCount(); i++) {
			players.add(roundState.getNthNextPlayer(-i));
		}
		view.getSidePanel().setPlayers(players);
		view.getSidePanel().setHeapCapacity(
				roundState.getGameSettings().getTotalStones());
		view.getSidePanel().setHeapSize(roundState.getGameHeap().getSize());
	}

	/** Override this */
	protected void addTurnControlListeners(ITurnControl turnControl) {
	}

	protected ITurnControl createTurnControl(Type type) {
		return TurnControlFactory.getFactory(type).create();
	}

	protected void deal() {
		for (int i = 0; i < roundState.getPlayerCount(); i++) {
			IHand hand = roundState.getNthNextPlayer(i).getHand();
			for (int j = 0; j < roundState.getGameSettings().getNumberOfStonesDealt(); j++) {
				hand.drop(roundState.getGameHeap().drawStone(), new Position(0, 0));
			}
		}

		view.getSidePanel().setHeapSize(roundState.getGameHeap().getSize());
	}

	protected void endOfTurn(InvalidTurnInfo invalidTurnInfo) {
		boolean wasAI = turnControl instanceof AIControl;
		boolean wasHuman = turnControl instanceof HumanTurnControl;

		turnControl = null;

		view.getTablePanel().setStoneSets(invalidTurnInfo.getTable());

		if (invalidTurnInfo.getType() != null) {
			if (wasHuman) {
				view.setBottomPanel(BottomPanelType.INVALID_TURN_PANEL);
			}

			view.setInvalidStoneSets(invalidTurnInfo.getInvalidSets());

			switch (invalidTurnInfo.getType()) {
				case INITIAL_MELD_ERROR:
					view.setInitialMeldFirstError();
					break;
				case INVALID_SETS:
					view.setStoneCollectionHidden(true);
					break;
				case NOT_ENOUGH_POINTS:
					view.setInitialMeldError(roundState.getGameSettings()
							.getInitialMeldThreshold());
					break;
			}

			if (wasAI) {
				nextPlayer();
			}
			return;
		}

		if (roundState.getActivePlayer().getHand().getSize() == 0) {
			endOfRound();
			return;
		}

		view.setBottomPanel(BottomPanelType.NONHUMAN_HAND_PANEL);
		view.getPlayerPanel().setTime(roundState.getGameSettings().getTotalTime(),
				roundState.getGameSettings().getTotalTime());

		if (wasHuman || wasAI) {
			nextPlayer();
		}
	}

	protected void nextPlayer() {
		view.setSelectedStones(Collections.<Stone> emptyList());
		view.setInvalidStoneSets(Collections.<StoneSet> emptyList());
		view.setStoneCollectionHidden(false);
		if (roundState.getLastPlayer() == null) {
			if (roundState.getGameHeap().getSize() == 0) {
				roundState.setLastPlayer(roundState.getActivePlayer());
				roundState.nextPlayer();
				roundState.nextTurn();
			} else {
				roundState.nextPlayer();
				roundState.nextTurn();
			}
		} else {
			if (roundState.getActivePlayer() == roundState.getLastPlayer()) {
				endOfRound();
			} else {
				roundState.nextPlayer();
				roundState.nextTurn();
			}
		}
		if (!roundFinished) {
			prepareTurn();
		}
	}

	void endOfRound() {
		removeListeners();
		Score roundScore = score();
		endOfRoundEvent.emit(roundScore);
		roundFinished = true;
	}

	private void removeListeners() {
		for (Connection c : connections) {
			c.remove();
		}
	}

	private Score score() {
		List<Boolean> winners = new ArrayList<Boolean>();
		List<Integer> points = new ArrayList<Integer>();

		boolean foundRegularWinner = false;
		int winnerPlayerNumber = 0;
		Pair<Integer, Integer> bestScore = new Pair<Integer, Integer>(
				Integer.MIN_VALUE, Integer.MAX_VALUE);
		int pointSum = 0;
		for (int i = 0; i < roundState.getPlayerCount(); i++) {
			IPlayer player = roundState.getNthPlayer(i);
			IHand playerHand = player.getHand();
			boolean isWinner = playerHand.getSize() == 0;
			winners.add(isWinner);
			if (isWinner) {
				foundRegularWinner = true;
				winnerPlayerNumber = i;
			}
			int stonePoints = 0;

			if (!player.getLaidOut()) {
				stonePoints = playerHand.isInitialMeldPossible(roundState
						.getGameSettings()) ? 200 : 100;
			} else {
				stonePoints = playerHand.getStonePoints(roundState.getGameSettings());
			}

			bestScore = updateBestScore(bestScore, -stonePoints, playerHand.getSize());

			points.add(-stonePoints);
			pointSum += stonePoints;
		}

		if (foundRegularWinner) {
			points.set(winnerPlayerNumber, pointSum);
		} else {
			for (int i = 0; i < roundState.getPlayerCount(); i++) {
				if (bestScore.equals(new Pair<Integer, Integer>(points.get(i),
						roundState.getNthPlayer(i).getHand().getSize()))) {
					winners.set(i, true);
				}
			}
		}
		return new Score(winners, points);
	}

	private static Pair<Integer, Integer> updateBestScore(
			Pair<Integer, Integer> bestScore, int stonePoints, int size) {
		if (bestScore.getFirst() == stonePoints) {
			return new Pair<Integer, Integer>(stonePoints, Math.min(
					bestScore.getSecond(), size));
		} else if (bestScore.getFirst() < stonePoints) {
			return new Pair<Integer, Integer>(stonePoints, size);
		}
		return bestScore;
	}

	/**
	 * Emitted when the round is aborted and needs to be restarted
	 * 
	 * @return the event
	 */
	public IEvent getRestartRoundEvent() {
		return restartRoundEvent;
	}

	private void redeal() {
		turnControl = null;
		for (Connection c : new ArrayList<Connection>(connections)) {
			c.remove();
		}
		restartRoundEvent.emit();
	}
}