Matthias Schiffer
af3661fea0
git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@380 72836036-5685-4462-b002-a69064685172
367 lines
9.3 KiB
Java
367 lines
9.3 KiB
Java
package jrummikub.control;
|
|
|
|
import static jrummikub.control.turn.TurnControlFactory.Type.*;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import jrummikub.control.turn.ITurnControl;
|
|
import jrummikub.control.turn.TurnControlFactory;
|
|
import jrummikub.control.turn.TurnMode;
|
|
import jrummikub.model.Hand;
|
|
import jrummikub.model.IHand;
|
|
import jrummikub.model.IPlayer;
|
|
import jrummikub.model.IRoundState;
|
|
import jrummikub.model.ITable;
|
|
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.Pair;
|
|
import jrummikub.view.IView;
|
|
import jrummikub.view.IView.BottomPanelType;
|
|
|
|
/**
|
|
* Controller that manages a single round of rummikub
|
|
*/
|
|
public class RoundControl {
|
|
IRoundState roundState;
|
|
private IView view;
|
|
private ITable clonedTable;
|
|
IHand clonedHand;
|
|
private Event restartRoundEvent = new Event();
|
|
private Event1<Score> endOfRoundEvent = new Event1<Score>();
|
|
private List<Connection> connections = new ArrayList<Connection>();
|
|
private ITurnControl turnControl;
|
|
private boolean roundFinished;
|
|
|
|
/**
|
|
* Create a new RoundControl using the given gameState and view
|
|
*
|
|
* @param roundState
|
|
* initial round state
|
|
* @param view
|
|
* view used for user interaction
|
|
*/
|
|
public RoundControl(IRoundState roundState, IView view) {
|
|
this.roundState = roundState;
|
|
this.view = view;
|
|
}
|
|
|
|
/**
|
|
* End the round
|
|
*
|
|
* @return endOfRoundEvent
|
|
*/
|
|
public IEvent1<Score> getEndOfRoundEvent() {
|
|
return endOfRoundEvent;
|
|
}
|
|
|
|
/**
|
|
* Begin the round
|
|
*/
|
|
public void startRound() {
|
|
deal();
|
|
|
|
connections.add(view.getStartTurnEvent().add(new IListener() {
|
|
@Override
|
|
public void handle() {
|
|
startTurn();
|
|
}
|
|
}));
|
|
|
|
prepareTurn();
|
|
}
|
|
|
|
private void prepareTurn() {
|
|
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
|
.getTurnControlType() == HUMAN;
|
|
clonedTable = (ITable) roundState.getTable().clone();
|
|
clonedHand = (IHand) roundState.getActivePlayer().getHand().clone();
|
|
|
|
view.setBottomPanel(isHuman ? BottomPanelType.START_TURN_PANEL
|
|
: BottomPanelType.COMPUTER_HAND_PANEL);
|
|
|
|
view.getTablePanel().setStoneSets(clonedTable.clone());
|
|
view.setCurrentPlayerName(roundState.getActivePlayer().getPlayerSettings()
|
|
.getName());
|
|
view.setCurrentPlayerColor(roundState.getActivePlayer().getPlayerSettings()
|
|
.getColor());
|
|
view.setCurrentPlayerHasLaidOut(roundState.getActivePlayer().getLaidOut());
|
|
|
|
if (!isHuman)
|
|
startTurn();
|
|
}
|
|
|
|
private void startTurn() {
|
|
if (turnControl != null)
|
|
return;
|
|
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
|
.getTurnControlType() == HUMAN;
|
|
|
|
TurnMode turnMode = TurnMode.NORMAL_TURN;
|
|
|
|
if (roundState.getTurnNumber() < 1) {
|
|
turnMode = TurnMode.INSPECT_ONLY;
|
|
if (clonedHand.getIdenticalStoneCount() >= 3) {
|
|
turnMode = TurnMode.MAY_REDEAL;
|
|
}
|
|
}
|
|
|
|
if (isHuman) {
|
|
view.getPlayerPanel().setEndTurnMode(turnMode);
|
|
}
|
|
turnControl = TurnControlFactory.getFactory(
|
|
roundState.getActivePlayer().getPlayerSettings().getTurnControlType())
|
|
.create();
|
|
turnControl.setup(new ITurnControl.TurnInfo(clonedTable, clonedHand,
|
|
roundState.getActivePlayer().getLaidOut(), turnMode), roundState
|
|
.getGameSettings(), view);
|
|
turnControl.getEndOfTurnEvent().add(new IListener() {
|
|
@Override
|
|
public void handle() {
|
|
endOfTurn();
|
|
}
|
|
});
|
|
|
|
turnControl.getRedealEvent().add(new IListener() {
|
|
@Override
|
|
public void handle() {
|
|
redeal();
|
|
}
|
|
});
|
|
turnControl.startTurn();
|
|
}
|
|
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean laidOutValidPoints() {
|
|
List<StoneSet> newSets = tableSetDifference(roundState.getTable(),
|
|
clonedTable);
|
|
|
|
int totalValue = 0;
|
|
for (StoneSet set : newSets) {
|
|
totalValue += set.classify(roundState.getGameSettings()).getSecond();
|
|
}
|
|
|
|
return totalValue == 0
|
|
|| totalValue >= roundState.getGameSettings().getInitialMeldThreshold();
|
|
}
|
|
|
|
private void endOfTurn() {
|
|
turnControl = null;
|
|
if (roundState.getTurnNumber() >= 1) {
|
|
checkTurn();
|
|
}
|
|
|
|
if (roundState.getLastPlayer() == null) {
|
|
if (roundState.getGameHeap().getSize() == 0) {
|
|
roundState.setLastPlayer(roundState.getNthNextPlayer(0));
|
|
roundState.nextPlayer();
|
|
roundState.nextTurn();
|
|
} else {
|
|
roundState.nextPlayer();
|
|
roundState.nextTurn();
|
|
}
|
|
} else {
|
|
if (roundState.getActivePlayer() == roundState.getLastPlayer()) {
|
|
endOfRound();
|
|
} else {
|
|
roundState.nextPlayer();
|
|
roundState.nextTurn();
|
|
}
|
|
}
|
|
if (!roundFinished) {
|
|
prepareTurn();
|
|
}
|
|
}
|
|
|
|
private void checkTurn() {
|
|
roundState.getActivePlayer().setHand(clonedHand);
|
|
|
|
if (!clonedTable.isValid()) {
|
|
rejectMove();
|
|
return;
|
|
}
|
|
if (!roundState.getActivePlayer().getLaidOut()) {
|
|
// Player touched forbidden stones
|
|
if (!tableSetDifference(clonedTable, roundState.getTable()).isEmpty()) {
|
|
rejectMove();
|
|
return;
|
|
}
|
|
if (!laidOutValidPoints()) {
|
|
rejectMove();
|
|
return;
|
|
}
|
|
}
|
|
Set<Stone> tableDiff = tableDifference(roundState.getTable(), clonedTable);
|
|
|
|
roundState.setTable(clonedTable);
|
|
|
|
if (tableDiff.isEmpty()) {
|
|
// Player hasn't made a move
|
|
dealStone();
|
|
} else {
|
|
roundState.getActivePlayer().setLaidOut(true);
|
|
if (roundState.getActivePlayer().getHand().getSize() == 0) {
|
|
endOfRound();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void rejectMove() {
|
|
Set<Stone> tableDiff = tableDifference(roundState.getTable(), clonedTable);
|
|
// deal penalty, reset
|
|
roundState.getGameHeap().putBack(tableDiff);
|
|
dealPenalty(tableDiff.size());
|
|
|
|
}
|
|
|
|
static Set<Stone> tableDifference(ITable oldTable, ITable newTable) {
|
|
Set<Stone> ret = new HashSet<Stone>();
|
|
|
|
for (Pair<StoneSet, Position> entry : newTable) {
|
|
for (Stone stone : entry.getFirst()) {
|
|
ret.add(stone);
|
|
}
|
|
}
|
|
for (Pair<StoneSet, Position> entry : oldTable) {
|
|
for (Stone stone : entry.getFirst()) {
|
|
ret.remove(stone);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static List<StoneSet> tableSetDifference(ITable oldTable, ITable newTable) {
|
|
List<StoneSet> ret = new ArrayList<StoneSet>();
|
|
|
|
for (Pair<StoneSet, Position> entry : newTable) {
|
|
ret.add(entry.getFirst());
|
|
}
|
|
for (Pair<StoneSet, Position> entry : oldTable) {
|
|
ret.remove(entry.getFirst());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void dealStones(int count) {
|
|
IHand hand = roundState.getActivePlayer().getHand();
|
|
int rowCount = hand.getRowCount();
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
if (hand.getFreeRowSpace(rowCount - 1) == 0) {
|
|
rowCount++;
|
|
}
|
|
|
|
hand.drop(roundState.getGameHeap().drawStone(), new Position(
|
|
Hand.WIDTH - 1, rowCount - 1));
|
|
}
|
|
}
|
|
|
|
private void dealStone() {
|
|
dealStones(1);
|
|
}
|
|
|
|
private void dealPenalty(int count) {
|
|
dealStones(count + 3);
|
|
}
|
|
|
|
void endOfRound() {
|
|
for (Connection c : connections) {
|
|
c.remove();
|
|
}
|
|
Score roundScore = score();
|
|
endOfRoundEvent.emit(roundScore);
|
|
roundFinished = true;
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|