Show in start turn panel if a player has redealed or drawn the last stone
git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@570 72836036-5685-4462-b002-a69064685172
This commit is contained in:
parent
62a55c0a91
commit
d6c4da6224
20 changed files with 358 additions and 252 deletions
|
|
@ -69,7 +69,7 @@ public class MockRoundState implements IRoundState {
|
|||
}
|
||||
|
||||
@Override
|
||||
public StoneHeap getGameHeap() {
|
||||
public StoneHeap getStoneHeap() {
|
||||
return gameHeap;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
package jrummikub.util;
|
||||
|
||||
import java.util.HashSet;
|
||||
|
||||
/**
|
||||
* Mock class for Events
|
||||
*/
|
||||
|
|
@ -27,7 +28,7 @@ public class MockEvent implements IEvent {
|
|||
|
||||
/** */
|
||||
public void emit() {
|
||||
for (IListener listener : listeners) {
|
||||
for (IListener listener : new HashSet<IListener>(listeners)) {
|
||||
listener.handle();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ public class MockEvent1<T> implements IEvent1<T> {
|
|||
* the event parameter
|
||||
*/
|
||||
public void emit(T value) {
|
||||
for (IListener1<T> listener : listeners) {
|
||||
for (IListener1<T> listener : new HashSet<IListener1<T>>(listeners)) {
|
||||
listener.handle(value);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -38,7 +38,8 @@ public class MockEvent2<T1, T2> implements IEvent2<T1, T2> {
|
|||
* the second event parameter
|
||||
*/
|
||||
public void emit(T1 value1, T2 value2) {
|
||||
for (IListener2<T1, T2> listener : listeners) {
|
||||
for (IListener2<T1, T2> listener : new HashSet<IListener2<T1, T2>>(
|
||||
listeners)) {
|
||||
listener.handle(value1, value2);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,7 +42,8 @@ public class MockEvent3<T1, T2, T3> implements IEvent3<T1, T2, T3> {
|
|||
* the third event parameter
|
||||
*/
|
||||
public void emit(T1 value1, T2 value2, T3 value3) {
|
||||
for (IListener3<T1, T2, T3> listener : listeners) {
|
||||
for (IListener3<T1, T2, T3> listener : new HashSet<IListener3<T1, T2, T3>>(
|
||||
listeners)) {
|
||||
listener.handle(value1, value2, value3);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -320,4 +320,15 @@ public class MockView implements IView {
|
|||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
public void setRedealedPlayerName(String name) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLastStonePlayerName(String name) {
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import jrummikub.model.GameSettings;
|
|||
import jrummikub.model.GameState;
|
||||
import jrummikub.model.IPlayer;
|
||||
import jrummikub.model.IRoundState;
|
||||
import jrummikub.model.PlayerSettings;
|
||||
import jrummikub.model.RoundState;
|
||||
import jrummikub.model.Score;
|
||||
import jrummikub.util.Connection;
|
||||
|
|
@ -183,14 +184,15 @@ public class GameControl {
|
|||
roundControl.getEndOfRoundEvent().add(new IListener1<Score>() {
|
||||
@Override
|
||||
public void handle(Score roundScore) {
|
||||
gameState.setLastPlayerRedealed(null);
|
||||
endOfRound(roundScore);
|
||||
}
|
||||
});
|
||||
|
||||
roundControl.getRestartRoundEvent().add(new IListener() {
|
||||
|
||||
roundControl.getRestartRoundEvent().add(new IListener1<PlayerSettings>() {
|
||||
@Override
|
||||
public void handle() {
|
||||
public void handle(PlayerSettings player) {
|
||||
gameState.setLastPlayerRedealed(player);
|
||||
restartRound();
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -8,7 +8,6 @@ import java.util.Collection;
|
|||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import jrummikub.control.turn.AIControl;
|
||||
import jrummikub.control.turn.ITurnControl;
|
||||
import jrummikub.control.turn.TurnControlFactory;
|
||||
import jrummikub.control.turn.TurnMode;
|
||||
|
|
@ -16,15 +15,14 @@ import jrummikub.model.IHand;
|
|||
import jrummikub.model.IPlayer;
|
||||
import jrummikub.model.IRoundState;
|
||||
import jrummikub.model.ITable;
|
||||
import jrummikub.model.PlayerSettings;
|
||||
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;
|
||||
|
|
@ -113,7 +111,7 @@ public class RoundControl {
|
|||
private ITurnControl turnControl;
|
||||
protected IRoundState roundState;
|
||||
private IView view;
|
||||
private Event restartRoundEvent = new Event();
|
||||
private Event1<PlayerSettings> restartRoundEvent = new Event1<PlayerSettings>();
|
||||
private Event1<IRoundState> roundStateUpdateEvent = new Event1<IRoundState>();
|
||||
private Event1<Score> endOfRoundEvent = new Event1<Score>();
|
||||
protected List<Connection> connections = new ArrayList<Connection>();
|
||||
|
|
@ -180,7 +178,6 @@ public class RoundControl {
|
|||
* Continue a saved round after loading
|
||||
*/
|
||||
public void continueRound() {
|
||||
|
||||
connections.add(view.getStartTurnEvent().add(new IListener() {
|
||||
@Override
|
||||
public void handle() {
|
||||
|
|
@ -222,6 +219,35 @@ public class RoundControl {
|
|||
roundStateUpdateEvent.emit(state);
|
||||
}
|
||||
|
||||
protected BottomPanelType showStartTurnPanel() {
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
||||
.getType() == HUMAN;
|
||||
boolean oneHuman = roundState.getGameSettings().oneHuman();
|
||||
|
||||
if (!isHuman) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (roundState.getLastPlayer() != null) {
|
||||
view.setLastStonePlayerName(roundState.getLastPlayer()
|
||||
.getPlayerSettings().getName());
|
||||
return BottomPanelType.START_LAST_TURN_PANEL;
|
||||
}
|
||||
|
||||
if (roundState.getTurnNumber() < 1
|
||||
&& roundState.getGameState().getLastPlayerRedealed() != null) {
|
||||
view.setRedealedPlayerName(roundState.getGameState()
|
||||
.getLastPlayerRedealed().getName());
|
||||
return BottomPanelType.START_REDEAL_TURN_PANEL;
|
||||
}
|
||||
|
||||
if (oneHuman) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return BottomPanelType.START_TURN_PANEL;
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepare a player's turn by checking the player types and setting the
|
||||
* correct turn control
|
||||
|
|
@ -229,12 +255,7 @@ public class RoundControl {
|
|||
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)) {
|
||||
if (showStartTurnPanel() == null) {
|
||||
startTurn();
|
||||
}
|
||||
}
|
||||
|
|
@ -245,12 +266,9 @@ public class RoundControl {
|
|||
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);
|
||||
BottomPanelType startTurnPanel = showStartTurnPanel();
|
||||
if (startTurnPanel != null) {
|
||||
view.setBottomPanel(startTurnPanel);
|
||||
}
|
||||
|
||||
view.getTablePanel().setStoneSets(roundState.getTable().clone());
|
||||
|
|
@ -259,19 +277,13 @@ public class RoundControl {
|
|||
view.setCurrentPlayerColor(roundState.getActivePlayer().getPlayerSettings()
|
||||
.getColor());
|
||||
view.setCurrentPlayerHasLaidOut(roundState.getActivePlayer().getLaidOut());
|
||||
|
||||
turnControl = createTurnControl(roundState.getActivePlayer()
|
||||
.getPlayerSettings().getType());
|
||||
}
|
||||
|
||||
/**
|
||||
* Start a players turn with the correct turn control
|
||||
*/
|
||||
protected void startTurn() {
|
||||
if (turnControl == null) {
|
||||
doPrepareTurn();
|
||||
}
|
||||
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
||||
.getType() == HUMAN;
|
||||
|
||||
|
|
@ -294,6 +306,7 @@ public class RoundControl {
|
|||
view.getPlayerPanel().setEndTurnMode(turnMode);
|
||||
}
|
||||
|
||||
turnControl = createTurnControl();
|
||||
turnControl.setup(
|
||||
new ITurnControl.TurnInfo(roundState, turnMode, mayPause),
|
||||
roundState.getGameSettings(), view);
|
||||
|
|
@ -330,7 +343,7 @@ public class RoundControl {
|
|||
view.getSidePanel().setPlayers(players);
|
||||
view.getSidePanel().setHeapCapacity(
|
||||
roundState.getGameSettings().getTotalStones());
|
||||
view.getSidePanel().setHeapSize(roundState.getGameHeap().getSize());
|
||||
view.getSidePanel().setHeapSize(roundState.getStoneHeap().getSize());
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -349,8 +362,9 @@ public class RoundControl {
|
|||
* of the new turn control
|
||||
* @return the new turn control
|
||||
*/
|
||||
protected ITurnControl createTurnControl(Type type) {
|
||||
return TurnControlFactory.getFactory(type).create();
|
||||
protected ITurnControl createTurnControl() {
|
||||
return TurnControlFactory.getFactory(
|
||||
roundState.getActivePlayer().getPlayerSettings().getType()).create();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -361,11 +375,11 @@ public class RoundControl {
|
|||
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));
|
||||
hand.drop(roundState.getStoneHeap().drawStone(), new Position(0, 0));
|
||||
}
|
||||
}
|
||||
|
||||
view.getSidePanel().setHeapSize(roundState.getGameHeap().getSize());
|
||||
view.getSidePanel().setHeapSize(roundState.getStoneHeap().getSize());
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -429,7 +443,7 @@ public class RoundControl {
|
|||
}
|
||||
|
||||
if (roundState.getLastPlayer() == null) {
|
||||
if (roundState.getGameHeap().getSize() == 0) {
|
||||
if (roundState.getStoneHeap().getSize() == 0) {
|
||||
roundState.setLastPlayer(roundState.getActivePlayer());
|
||||
roundState.nextPlayer();
|
||||
roundState.nextTurn();
|
||||
|
|
@ -547,7 +561,7 @@ public class RoundControl {
|
|||
*
|
||||
* @return the event
|
||||
*/
|
||||
public IEvent getRestartRoundEvent() {
|
||||
public IEvent1<PlayerSettings> getRestartRoundEvent() {
|
||||
return restartRoundEvent;
|
||||
}
|
||||
|
||||
|
|
@ -556,10 +570,12 @@ public class RoundControl {
|
|||
* to do so
|
||||
*/
|
||||
protected void redeal() {
|
||||
view.setBottomPanel(BottomPanelType.NONHUMAN_HAND_PANEL);
|
||||
|
||||
turnControl = null;
|
||||
for (Connection c : new ArrayList<Connection>(connections)) {
|
||||
c.remove();
|
||||
}
|
||||
restartRoundEvent.emit();
|
||||
restartRoundEvent.emit(roundState.getActivePlayer().getPlayerSettings());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,7 +4,6 @@ import jrummikub.control.RoundControl;
|
|||
import jrummikub.control.turn.ITurnControl;
|
||||
import jrummikub.model.IRoundState;
|
||||
import jrummikub.model.ITable;
|
||||
import jrummikub.model.PlayerSettings.Type;
|
||||
import jrummikub.util.IListener;
|
||||
import jrummikub.util.IListener1;
|
||||
import jrummikub.view.IView;
|
||||
|
|
@ -14,6 +13,7 @@ import jrummikub.view.IView;
|
|||
*/
|
||||
public class NetworkRoundControl extends RoundControl {
|
||||
private IConnectionControl connectionControl;
|
||||
private boolean wasActive;
|
||||
private boolean currentlyActive;
|
||||
|
||||
/**
|
||||
|
|
@ -33,6 +33,7 @@ public class NetworkRoundControl extends RoundControl {
|
|||
super(roundState, view, false);
|
||||
|
||||
this.connectionControl = connectionControl;
|
||||
wasActive = startActive;
|
||||
currentlyActive = startActive;
|
||||
|
||||
connections.add(connectionControl.getRoundStateUpdateEvent().add(
|
||||
|
|
@ -40,17 +41,16 @@ public class NetworkRoundControl extends RoundControl {
|
|||
@Override
|
||||
public void handle(IRoundState state) {
|
||||
setRoundState(state);
|
||||
prepareTurn();
|
||||
}
|
||||
}));
|
||||
connections.add(connectionControl.getTurnStartEvent().add(
|
||||
new IListener() {
|
||||
connections.add(connectionControl.getTurnStartEvent().add(new IListener() {
|
||||
@Override
|
||||
public void handle() {
|
||||
startTurn();
|
||||
NetworkRoundControl.super.startTurn();
|
||||
}
|
||||
}));
|
||||
connections.add(connectionControl.getNextPlayerEvent().add(
|
||||
new IListener() {
|
||||
connections.add(connectionControl.getNextPlayerEvent().add(new IListener() {
|
||||
@Override
|
||||
public void handle() {
|
||||
NetworkRoundControl.super.nextPlayer();
|
||||
|
|
@ -69,8 +69,17 @@ public class NetworkRoundControl extends RoundControl {
|
|||
}
|
||||
|
||||
@Override
|
||||
protected ITurnControl createTurnControl(Type type) {
|
||||
switch (type) {
|
||||
protected ITurnControl createTurnControl() {
|
||||
if (!currentlyActive) {
|
||||
return new NetworkTurnControl(connectionControl);
|
||||
}
|
||||
|
||||
return super.createTurnControl();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void prepareTurn() {
|
||||
switch (roundState.getActivePlayer().getPlayerSettings().getType()) {
|
||||
case HUMAN:
|
||||
currentlyActive = true;
|
||||
break;
|
||||
|
|
@ -79,20 +88,20 @@ public class NetworkRoundControl extends RoundControl {
|
|||
break;
|
||||
}
|
||||
|
||||
if (!currentlyActive) {
|
||||
return new NetworkTurnControl(connectionControl);
|
||||
}
|
||||
doPrepareTurn();
|
||||
|
||||
return super.createTurnControl(type);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void prepareTurn() {
|
||||
if (showStartTurnPanel() == null) {
|
||||
if (currentlyActive) {
|
||||
connectionControl.startTurn();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
doPrepareTurn();
|
||||
@Override
|
||||
protected void startTurn() {
|
||||
if (currentlyActive) {
|
||||
connectionControl.startTurn();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -226,7 +226,7 @@ public abstract class AbstractTurnControl implements ITurnControl {
|
|||
Set<Stone> tableDiff = tableDifference(turnInfo.getOldTable(),
|
||||
turnInfo.getTable());
|
||||
// deal penalty, reset
|
||||
turnInfo.getRoundState().getGameHeap().putBack(tableDiff);
|
||||
turnInfo.getRoundState().getStoneHeap().putBack(tableDiff);
|
||||
turnInfo.getRoundState().getActivePlayer().setLastTurnInvalid(true);
|
||||
dealPenalty(tableDiff.size());
|
||||
}
|
||||
|
|
@ -240,7 +240,7 @@ public abstract class AbstractTurnControl implements ITurnControl {
|
|||
rowCount++;
|
||||
}
|
||||
|
||||
hand.drop(turnInfo.getRoundState().getGameHeap().drawStone(),
|
||||
hand.drop(turnInfo.getRoundState().getStoneHeap().drawStone(),
|
||||
new Position(Hand.WIDTH - 1, rowCount - 1));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ public class GameState implements Serializable {
|
|||
|
||||
private int firstRoundFirstPlayer;
|
||||
private ArrayList<Score> scores = new ArrayList<Score>();
|
||||
private PlayerSettings lastPlayerRedealed;
|
||||
|
||||
/**
|
||||
* Gets the number of the first player of the first round
|
||||
|
|
@ -33,6 +34,25 @@ public class GameState implements Serializable {
|
|||
this.firstRoundFirstPlayer = firstRoundFirstPlayer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the player that has redealed last
|
||||
*
|
||||
* @param lastPlayerRedealed
|
||||
* the player to set
|
||||
*/
|
||||
public void setLastPlayerRedealed(PlayerSettings lastPlayerRedealed) {
|
||||
this.lastPlayerRedealed = lastPlayerRedealed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the player that has redealed last
|
||||
*
|
||||
* @return the player
|
||||
*/
|
||||
public PlayerSettings getLastPlayerRedealed() {
|
||||
return lastPlayerRedealed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the list of players' scores in the rounds played before
|
||||
*
|
||||
|
|
@ -45,8 +65,10 @@ public class GameState implements Serializable {
|
|||
/**
|
||||
* Returns whether players have won
|
||||
*
|
||||
* @param points the player's points
|
||||
* @param wins the number of wins per player
|
||||
* @param points
|
||||
* the player's points
|
||||
* @param wins
|
||||
* the number of wins per player
|
||||
* @return whether a player has won
|
||||
*/
|
||||
private Boolean[] getWinners(Integer[] points, int[] wins) {
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ public interface IRoundState extends Serializable {
|
|||
*
|
||||
* @return heap of stones
|
||||
*/
|
||||
public StoneHeap getGameHeap();
|
||||
public StoneHeap getStoneHeap();
|
||||
|
||||
/**
|
||||
* Returns the player that would be the active player after i turns
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ public class RoundState implements IRoundState {
|
|||
private ITable table;
|
||||
private ArrayList<Player> players;
|
||||
private int activePlayer;
|
||||
private StoneHeap gameHeap;
|
||||
private StoneHeap stoneHeap;
|
||||
private IPlayer lastPlayer;
|
||||
private int turnNumber;
|
||||
|
||||
|
|
@ -38,7 +38,7 @@ public class RoundState implements IRoundState {
|
|||
turnNumber = 1 - gameSettings.getPlayerList().size();
|
||||
|
||||
activePlayer = 0;
|
||||
gameHeap = new StoneHeap(gameSettings);
|
||||
stoneHeap = new StoneHeap(gameSettings);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -94,8 +94,8 @@ public class RoundState implements IRoundState {
|
|||
}
|
||||
|
||||
@Override
|
||||
public StoneHeap getGameHeap() {
|
||||
return gameHeap;
|
||||
public StoneHeap getStoneHeap() {
|
||||
return stoneHeap;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -61,6 +61,10 @@ public interface IView {
|
|||
*/
|
||||
public void setCurrentPlayerName(String playerName);
|
||||
|
||||
public void setRedealedPlayerName(String name);
|
||||
|
||||
public void setLastStonePlayerName(String name);
|
||||
|
||||
/**
|
||||
* Sets the stones that are to be painted selected
|
||||
*
|
||||
|
|
@ -368,6 +372,10 @@ public interface IView {
|
|||
/** */
|
||||
START_TURN_PANEL,
|
||||
/** */
|
||||
START_REDEAL_TURN_PANEL,
|
||||
/** */
|
||||
START_LAST_TURN_PANEL,
|
||||
/** */
|
||||
INVALID_TURN_PANEL,
|
||||
/** */
|
||||
HUMAN_HAND_PANEL,
|
||||
|
|
|
|||
|
|
@ -23,17 +23,23 @@ import jrummikub.view.IView.BottomPanelType;
|
|||
class StartTurnPanel extends JPanel {
|
||||
private final static int PANEL_INSET = 15;
|
||||
private final static int PANEL_SEPARATOR = 10;
|
||||
private final static float PANEL_FIRST_LINE_HEIGHT = 0.375f;
|
||||
private final static float PANEL_FIRST_LINE_HEIGHT = 0.2f;
|
||||
private final static int PANEL_MAX_WIDTH = 180;
|
||||
private final static float MAX_BUTTON_FONT_SIZE = 12;
|
||||
|
||||
private JLabel startTurnLabel;
|
||||
private JLabel extraLabel;
|
||||
private JButton startTurnButton;
|
||||
|
||||
private Event startTurnEvent = new Event();
|
||||
private Event acknowledgeInvalidEvent = new Event();
|
||||
|
||||
private Event buttonEvent = startTurnEvent;
|
||||
private BottomPanelType type;
|
||||
private Color currentPlayerColor;
|
||||
private String currentPlayerName;
|
||||
private String redealedPlayerName;
|
||||
private String lastStonePlayerName;
|
||||
|
||||
/**
|
||||
* Creates a new StartTurnPanel
|
||||
|
|
@ -49,6 +55,12 @@ class StartTurnPanel extends JPanel {
|
|||
startTurnLabel.putClientProperty("html.disable", Boolean.TRUE);
|
||||
add(startTurnLabel);
|
||||
|
||||
extraLabel = new JLabel();
|
||||
extraLabel.setHorizontalAlignment(JLabel.CENTER);
|
||||
extraLabel.setVerticalAlignment(JLabel.CENTER);
|
||||
extraLabel.putClientProperty("html.disable", Boolean.TRUE);
|
||||
add(extraLabel);
|
||||
|
||||
startTurnButton = new JButton("Zug beginnen");
|
||||
startTurnButton.addActionListener(new ActionListener() {
|
||||
@Override
|
||||
|
|
@ -66,14 +78,6 @@ class StartTurnPanel extends JPanel {
|
|||
});
|
||||
}
|
||||
|
||||
void setCurrentPlayerName(String playerName) {
|
||||
startTurnLabel.setText(playerName + " ist jetzt an der Reihe.");
|
||||
}
|
||||
|
||||
void setCurrentPlayerColor(Color color) {
|
||||
startTurnLabel.setIcon(ImageUtil.createColorIcon(color, 12, 1));
|
||||
}
|
||||
|
||||
void setInitialMeldError(int points) {
|
||||
startTurnLabel.setIcon(null);
|
||||
startTurnLabel.setText("Es wurden weniger als " + points
|
||||
|
|
@ -105,34 +109,83 @@ class StartTurnPanel extends JPanel {
|
|||
|
||||
int firstLineHeight = (int) ((height - PANEL_SEPARATOR) * PANEL_FIRST_LINE_HEIGHT);
|
||||
int buttonWidth = width;
|
||||
int buttonHeight = height - PANEL_SEPARATOR - firstLineHeight;
|
||||
int buttonHeight = height - 2 * PANEL_SEPARATOR - 2 * firstLineHeight;
|
||||
float fontSize = (float) Math.sqrt(buttonWidth * buttonHeight) / 5;
|
||||
if (fontSize > MAX_BUTTON_FONT_SIZE)
|
||||
fontSize = MAX_BUTTON_FONT_SIZE;
|
||||
|
||||
if (type == BottomPanelType.START_REDEAL_TURN_PANEL
|
||||
|| type == BottomPanelType.START_LAST_TURN_PANEL) {
|
||||
startTurnLabel.setBounds(x, y, width, firstLineHeight);
|
||||
startTurnButton.setBounds(x, y + firstLineHeight + PANEL_SEPARATOR,
|
||||
extraLabel.setBounds(x, y + firstLineHeight + PANEL_SEPARATOR, width,
|
||||
firstLineHeight);
|
||||
extraLabel.setVisible(true);
|
||||
} else {
|
||||
startTurnLabel.setBounds(x, y, width, 2 * firstLineHeight
|
||||
+ PANEL_SEPARATOR);
|
||||
extraLabel.setVisible(false);
|
||||
}
|
||||
startTurnButton.setBounds(x, y + 2 * firstLineHeight + 2 * PANEL_SEPARATOR,
|
||||
buttonWidth, buttonHeight);
|
||||
startTurnButton.setFont(startTurnButton.getFont().deriveFont(fontSize));
|
||||
}
|
||||
|
||||
public void setType(BottomPanelType type) {
|
||||
void setCurrentPlayerName(String playerName) {
|
||||
currentPlayerName = playerName;
|
||||
update();
|
||||
}
|
||||
|
||||
void setCurrentPlayerColor(Color color) {
|
||||
currentPlayerColor = color;
|
||||
update();
|
||||
}
|
||||
|
||||
void setRedealedPlayerName(String name) {
|
||||
redealedPlayerName = name;
|
||||
update();
|
||||
}
|
||||
|
||||
void setLastStonePlayerName(String name) {
|
||||
lastStonePlayerName = name;
|
||||
update();
|
||||
}
|
||||
|
||||
void setType(BottomPanelType type) {
|
||||
this.type = type;
|
||||
update();
|
||||
}
|
||||
|
||||
private void update() {
|
||||
if (type == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case START_TURN_PANEL:
|
||||
startTurnLabel
|
||||
.setIcon(ImageUtil.createColorIcon(currentPlayerColor, 12, 1));
|
||||
startTurnLabel.setText(currentPlayerName + " ist jetzt an der Reihe.");
|
||||
extraLabel.setText("");
|
||||
startTurnButton.setText("Zug beginnen");
|
||||
buttonEvent = startTurnEvent;
|
||||
|
||||
switch (type) {
|
||||
case START_REDEAL_TURN_PANEL:
|
||||
extraLabel.setText(redealedPlayerName + " hat neu geben lassen.");
|
||||
break;
|
||||
|
||||
case START_LAST_TURN_PANEL:
|
||||
extraLabel.setText(lastStonePlayerName
|
||||
+ " hat den letzten Stein gezogen.");
|
||||
break;
|
||||
|
||||
case INVALID_TURN_PANEL:
|
||||
startTurnLabel.setIcon(null);
|
||||
startTurnLabel.setText("Es liegen ung\u00FCltige Serien auf dem Tisch.");
|
||||
startTurnLabel
|
||||
.setText("Es liegen ung\u00FCltige Serien auf dem Tisch.");
|
||||
startTurnButton.setText("N\u00E4chster Spieler");
|
||||
buttonEvent = acknowledgeInvalidEvent;
|
||||
break;
|
||||
}
|
||||
|
||||
rescale();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -581,6 +581,16 @@ public class View extends JFrame implements IView {
|
|||
pausePanel.setCurrentPlayerColor(color);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setRedealedPlayerName(String name) {
|
||||
startTurnPanel.setRedealedPlayerName(name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setLastStonePlayerName(String name) {
|
||||
startTurnPanel.setLastStonePlayerName(name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCurrentPlayerHasLaidOut(boolean hasLaidOut) {
|
||||
playerPanel.setHasLaidOut(hasLaidOut);
|
||||
|
|
@ -657,7 +667,9 @@ public class View extends JFrame implements IView {
|
|||
}
|
||||
|
||||
private void doSetBottomPanel(BottomPanelType type) {
|
||||
boolean showStartTurnPanel = (type == BottomPanelType.START_TURN_PANEL || type == BottomPanelType.INVALID_TURN_PANEL);
|
||||
boolean showStartTurnPanel = (type == BottomPanelType.START_TURN_PANEL
|
||||
|| type == BottomPanelType.START_REDEAL_TURN_PANEL
|
||||
|| type == BottomPanelType.START_LAST_TURN_PANEL || type == BottomPanelType.INVALID_TURN_PANEL);
|
||||
startTurnPanel.setType(type);
|
||||
startTurnPanel.setVisible(showStartTurnPanel);
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public class GameControlTest {
|
|||
view.playerPanel.endTurnEvent.emit();
|
||||
view.startTurnEvent.emit();
|
||||
view.playerPanel.redealEvent.emit();
|
||||
assertSame(BottomPanelType.START_TURN_PANEL, view.bottomPanelType);
|
||||
assertSame(BottomPanelType.START_REDEAL_TURN_PANEL, view.bottomPanelType);
|
||||
view.startTurnEvent.emit();
|
||||
assertSame(firstPlayer, gameControl.roundControl.roundState
|
||||
.getActivePlayer().getPlayerSettings());
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ import java.util.List;
|
|||
|
||||
import jrummikub.control.turn.TurnMode;
|
||||
import jrummikub.model.GameSettings;
|
||||
import jrummikub.model.GameState;
|
||||
import jrummikub.model.Hand;
|
||||
import jrummikub.model.IHand;
|
||||
import jrummikub.model.IPlayer;
|
||||
|
|
@ -22,7 +23,6 @@ import jrummikub.model.RoundState;
|
|||
import jrummikub.model.Score;
|
||||
import jrummikub.model.Stone;
|
||||
import jrummikub.model.StoneSet;
|
||||
import jrummikub.util.IListener;
|
||||
import jrummikub.util.IListener1;
|
||||
import jrummikub.util.Pair;
|
||||
import jrummikub.view.IView.BottomPanelType;
|
||||
|
|
@ -86,8 +86,9 @@ public class RoundControlTest {
|
|||
public void setup() {
|
||||
view = new MockView();
|
||||
testRoundState = new MockRoundState();
|
||||
testRoundState.gameState = new GameState();
|
||||
testRound = new RoundControl(testRoundState, view);
|
||||
Stone stone = testRoundState.getGameHeap().drawStone();
|
||||
Stone stone = testRoundState.getStoneHeap().drawStone();
|
||||
testRoundState.table.drop(new StoneSet(stone), new Position(5, 0));
|
||||
testTable = new MockTable();
|
||||
testTable.sets.add(testRoundState.table.sets.get(0));
|
||||
|
|
@ -99,24 +100,21 @@ public class RoundControlTest {
|
|||
gameSettings.getPlayerList().add(new PlayerSettings("Ida", Color.RED));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Matthias", Color.YELLOW));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Bennet", Color.BLACK));
|
||||
roundState = new RoundState(gameSettings, null);
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Bennet", Color.BLACK));
|
||||
roundState = new RoundState(gameSettings, new GameState());
|
||||
roundControl = new RoundControl(roundState, view);
|
||||
}
|
||||
|
||||
private void checkCorrectlyDealt() {
|
||||
GameSettings settings = testRoundState.getGameSettings();
|
||||
int totalStones = settings.getHighestValue()
|
||||
* settings.getStoneSetNumber()
|
||||
int totalStones = settings.getHighestValue() * settings.getStoneSetNumber()
|
||||
* settings.getStoneColors().size() + settings.getJokerNumber();
|
||||
assertEquals(
|
||||
totalStones - testRoundState.getPlayerCount()
|
||||
* settings.getNumberOfStonesDealt()
|
||||
- testRoundState.table.getSize(), testRoundState
|
||||
.getGameHeap().getSize());
|
||||
- testRoundState.table.getSize(), testRoundState.getStoneHeap()
|
||||
.getSize());
|
||||
for (int i = 0; i < testRoundState.getPlayerCount(); i++) {
|
||||
assertEquals(settings.getNumberOfStonesDealt(), testRoundState
|
||||
.getNthNextPlayer(i).getHand().getSize());
|
||||
|
|
@ -187,8 +185,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
assertEquals(14 + 6, roundState.getActivePlayer().getHand().getSize());
|
||||
}
|
||||
|
|
@ -210,8 +208,7 @@ public class RoundControlTest {
|
|||
assertFalse(roundState.getNthNextPlayer(-1).getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
|
||||
assertEquals(14 + 1, roundState.getNthNextPlayer(-1).getHand()
|
||||
.getSize());
|
||||
assertEquals(14 + 1, roundState.getNthNextPlayer(-1).getHand().getSize());
|
||||
}
|
||||
|
||||
/** Threshold=30 */
|
||||
|
|
@ -248,8 +245,7 @@ public class RoundControlTest {
|
|||
assertFalse(roundState.getNthNextPlayer(-1).getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
|
||||
assertEquals(14 + 9, roundState.getNthNextPlayer(-1).getHand()
|
||||
.getSize());
|
||||
assertEquals(14 + 9, roundState.getNthNextPlayer(-1).getHand().getSize());
|
||||
}
|
||||
|
||||
private void dropStonesOnHand(IHand hand, List<Stone> stones) {
|
||||
|
|
@ -308,8 +304,7 @@ public class RoundControlTest {
|
|||
view.acknowledgeInvalidEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(-1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 6, roundState.getNthNextPlayer(-1).getHand()
|
||||
.getSize());
|
||||
assertEquals(14 + 6, roundState.getNthNextPlayer(-1).getHand().getSize());
|
||||
}
|
||||
|
||||
/** Threshold=30 */
|
||||
|
|
@ -361,8 +356,7 @@ public class RoundControlTest {
|
|||
view.acknowledgeInvalidEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(-1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 7, roundState.getNthNextPlayer(-1).getHand()
|
||||
.getSize());
|
||||
assertEquals(14 + 7, roundState.getNthNextPlayer(-1).getHand().getSize());
|
||||
}
|
||||
|
||||
/** */
|
||||
|
|
@ -415,8 +409,7 @@ public class RoundControlTest {
|
|||
view.acknowledgeInvalidEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(-1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 3, roundState.getNthNextPlayer(-1).getHand()
|
||||
.getSize());
|
||||
assertEquals(14 + 3, roundState.getNthNextPlayer(-1).getHand().getSize());
|
||||
}
|
||||
|
||||
/** Threshold=30 */
|
||||
|
|
@ -499,8 +492,9 @@ public class RoundControlTest {
|
|||
testTable.valid = true;
|
||||
testTable.sets.clear();
|
||||
testTable.drop(
|
||||
new StoneSet(Arrays.asList(blueEight, blackEight, redEight,
|
||||
orangeEight)), new Position(0, 0));
|
||||
new StoneSet(Arrays
|
||||
.asList(blueEight, blackEight, redEight, orangeEight)),
|
||||
new Position(0, 0));
|
||||
oldTable.clonedTable = testTable;
|
||||
|
||||
view.startTurnEvent.emit();
|
||||
|
|
@ -529,7 +523,8 @@ public class RoundControlTest {
|
|||
|
||||
testTable.valid = false;
|
||||
testTable.sets.clear();
|
||||
testTable.drop(
|
||||
testTable
|
||||
.drop(
|
||||
new StoneSet(Arrays.asList(blueEight, blackEight, redEight,
|
||||
blackFour)), new Position(0, 0));
|
||||
oldTable.clonedTable = testTable;
|
||||
|
|
@ -587,8 +582,9 @@ public class RoundControlTest {
|
|||
MockTable oldTable = testRoundState.table;
|
||||
oldTable.sets.clear();
|
||||
oldTable.drop(
|
||||
new StoneSet(Arrays.asList(blueEight, blackEight, redEight,
|
||||
orangeEight)), new Position(0, 0));
|
||||
new StoneSet(Arrays
|
||||
.asList(blueEight, blackEight, redEight, orangeEight)),
|
||||
new Position(0, 0));
|
||||
|
||||
testTable.valid = false;
|
||||
testTable.sets.clear();
|
||||
|
|
@ -672,7 +668,7 @@ public class RoundControlTest {
|
|||
}
|
||||
});
|
||||
|
||||
roundState.getGameHeap().drawStones(106 - 14 * 4 - 1);
|
||||
roundState.getStoneHeap().drawStones(106 - 14 * 4 - 1);
|
||||
|
||||
roundControl.startRound();
|
||||
for (int i = 0; i < 4; i++) {
|
||||
|
|
@ -713,20 +709,19 @@ public class RoundControlTest {
|
|||
}
|
||||
|
||||
testRoundState.players.get(0).laidOut = true;
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(1).laidOut = true;
|
||||
testRoundState.players.get(1).hand.drop(new Stone(RED), new Position(0,
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(1).laidOut = true;
|
||||
testRoundState.players.get(1).hand.drop(new Stone(RED), new Position(0, 0));
|
||||
testRoundState.players.get(2).laidOut = false;
|
||||
testRoundState.players.get(2).hand.drop(new Stone(9, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(10, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(11, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(9, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(10, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(11, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(3).laidOut = true;
|
||||
|
||||
testRound.endOfRound();
|
||||
|
|
@ -760,19 +755,19 @@ public class RoundControlTest {
|
|||
}
|
||||
|
||||
testRoundState.players.get(0).laidOut = true;
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(1).laidOut = true;
|
||||
testRoundState.players.get(1).hand.drop(new Stone(3, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(1).hand.drop(new Stone(3, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).laidOut = true;
|
||||
testRoundState.players.get(2).hand.drop(new Stone(3, BLUE),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(3, BLUE), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(3).laidOut = false;
|
||||
testRoundState.players.get(3).hand.drop(new Stone(13, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(3).hand.drop(new Stone(13, RED), new Position(0,
|
||||
0));
|
||||
|
||||
testRound.endOfRound();
|
||||
assertTrue(roundEnded);
|
||||
|
|
@ -810,9 +805,9 @@ public class RoundControlTest {
|
|||
/** */
|
||||
@Test
|
||||
public void testRedeal() {
|
||||
testRound.getRestartRoundEvent().add(new IListener() {
|
||||
testRound.getRestartRoundEvent().add(new IListener1<PlayerSettings>() {
|
||||
@Override
|
||||
public void handle() {
|
||||
public void handle(PlayerSettings player) {
|
||||
roundRestarted = true;
|
||||
}
|
||||
});
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@ public class GameJoinControlTest {
|
|||
@Before
|
||||
public void setup() {
|
||||
mockConnection = new MockConnectionControl();
|
||||
mockConnection.nickname = "Karl";
|
||||
view = new MockView();
|
||||
loginData = new LoginData("Karl", "server", "password", "channel");
|
||||
networkControl = new NetworkControl(loginData, mockConnection, null, view);
|
||||
|
|
@ -52,7 +51,8 @@ public class GameJoinControlTest {
|
|||
assertEquals(SettingsMode.NETWORK_JOIN, view.settingsPanel.settingsMode);
|
||||
offerJoinedGame(id1, "Anne", "Karl");
|
||||
view.settingsPanel.changePlayerColorEvent.emit(1, Color.GRAY);
|
||||
assertEquals(Type.HUMAN, mockConnection.getCurrentGame().getGameSettings().getPlayerList().get(1).getType());
|
||||
assertEquals(Type.HUMAN, mockConnection.getCurrentGame().getGameSettings()
|
||||
.getPlayerList().get(1).getType());
|
||||
assertEquals(Color.GRAY, mockConnection.playerColor);
|
||||
|
||||
view.settingsPanel.backEvent.emit();
|
||||
|
|
@ -75,10 +75,10 @@ public class GameJoinControlTest {
|
|||
private GameData offerJoinedGame(UUID id, String host, String player) {
|
||||
GameSettings gsettings = new GameSettings();
|
||||
PlayerSettings psettings = new PlayerSettings(host, Color.BLACK);
|
||||
psettings.setType(Type.HUMAN);
|
||||
psettings.setType(Type.NETWORK);
|
||||
gsettings.getPlayerList().add(psettings);
|
||||
PlayerSettings psettings2 = new PlayerSettings(player, Color.RED);
|
||||
psettings2.setType(Type.NETWORK);
|
||||
psettings2.setType(Type.HUMAN);
|
||||
gsettings.getPlayerList().add(psettings2);
|
||||
GameData gameData = new GameData(id, gsettings, host);
|
||||
mockConnection.gameOfferEvent.emit(gameData);
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import java.util.Collections;
|
|||
import jrummikub.control.RoundControl.InvalidTurnInfo;
|
||||
import jrummikub.control.turn.AIControl;
|
||||
import jrummikub.model.GameSettings;
|
||||
import jrummikub.model.GameState;
|
||||
import jrummikub.model.IPlayer;
|
||||
import jrummikub.model.PlayerSettings;
|
||||
import jrummikub.model.PlayerSettings.Type;
|
||||
|
|
@ -21,9 +22,6 @@ import jrummikub.view.MockView;
|
|||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Tests for network round control
|
||||
*/
|
||||
public class NetworkRoundControlTest {
|
||||
private MockConnectionControl connectionControl;
|
||||
private MockView view;
|
||||
|
|
@ -32,7 +30,6 @@ public class NetworkRoundControlTest {
|
|||
|
||||
private GameSettings gameSettings;
|
||||
|
||||
/** */
|
||||
@Before
|
||||
public void setup() {
|
||||
AIControl.useBackgroundThread = false;
|
||||
|
|
@ -42,26 +39,20 @@ public class NetworkRoundControlTest {
|
|||
gameSettings.getPlayerList().add(new PlayerSettings("Ida", Color.RED));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Matthias", Color.YELLOW));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Bennet", Color.BLACK));
|
||||
|
||||
gameSettings.getPlayerList().get(1).setType(Type.COMPUTER);
|
||||
gameSettings.getPlayerList().get(2).setType(Type.NETWORK);
|
||||
gameSettings.getPlayerList().get(3).setType(Type.COMPUTER);
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Bennet", Color.BLACK));
|
||||
|
||||
view = new MockView();
|
||||
connectionControl = new MockConnectionControl();
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void testHostRound() {
|
||||
connectionControl.nickname = gameSettings.getPlayerList().get(0)
|
||||
.getName();
|
||||
gameSettings.getPlayerList().get(1).setType(Type.COMPUTER);
|
||||
gameSettings.getPlayerList().get(2).setType(Type.NETWORK);
|
||||
gameSettings.getPlayerList().get(3).setType(Type.COMPUTER);
|
||||
|
||||
testRoundState = new RoundState(gameSettings, null);
|
||||
testRoundState = new RoundState(gameSettings, new GameState());
|
||||
testRound = new NetworkRoundControl(testRoundState, view,
|
||||
connectionControl, true);
|
||||
|
||||
|
|
@ -75,8 +66,8 @@ public class NetworkRoundControlTest {
|
|||
IPlayer player = testRoundState.getNthPlayer(i);
|
||||
assertSame(gameSettings.getPlayerList().get(i),
|
||||
player.getPlayerSettings());
|
||||
assertEquals(gameSettings.getNumberOfStonesDealt(), player
|
||||
.getHand().getSize());
|
||||
assertEquals(gameSettings.getNumberOfStonesDealt(), player.getHand()
|
||||
.getSize());
|
||||
}
|
||||
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
|
|
@ -88,8 +79,7 @@ public class NetworkRoundControlTest {
|
|||
}
|
||||
}
|
||||
|
||||
assertSame(testRoundState.getNthPlayer(0),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(0), testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
|
||||
|
|
@ -104,8 +94,7 @@ public class NetworkRoundControlTest {
|
|||
connectionControl.nextPlayer = false;
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(1),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(1), testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
|
||||
|
|
@ -117,59 +106,52 @@ public class NetworkRoundControlTest {
|
|||
connectionControl.nextPlayer = false;
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(2),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(2), testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState, new InvalidTurnInfo(
|
||||
testRoundState.getTable(), null, Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(3), testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState, new InvalidTurnInfo(
|
||||
testRoundState.getTable(), null, Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(0), testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState,
|
||||
new InvalidTurnInfo(testRoundState.getTable(), null,
|
||||
Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(3),
|
||||
testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState,
|
||||
new InvalidTurnInfo(testRoundState.getTable(), null,
|
||||
Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(0),
|
||||
testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void testClientRound() {
|
||||
connectionControl.nickname = gameSettings.getPlayerList().get(2)
|
||||
.getName();
|
||||
gameSettings.getPlayerList().get(0).setType(Type.NETWORK);
|
||||
gameSettings.getPlayerList().get(1).setType(Type.COMPUTER);
|
||||
gameSettings.getPlayerList().get(3).setType(Type.COMPUTER);
|
||||
|
||||
testRoundState = new RoundState(gameSettings, null);
|
||||
testRoundState = new RoundState(gameSettings, new GameState());
|
||||
for (int i = 0; i < 4; ++i) {
|
||||
IPlayer player = testRoundState.getNthPlayer(i);
|
||||
|
||||
player.getHand()
|
||||
.drop(new Stone(StoneColor.RED), new Position(0, 0));
|
||||
player.getHand().drop(new Stone(StoneColor.RED), new Position(0, 0));
|
||||
}
|
||||
|
||||
testRound = new NetworkRoundControl(null, view, connectionControl,
|
||||
false);
|
||||
testRound = new NetworkRoundControl(null, view, connectionControl, false);
|
||||
|
||||
connectionControl.turnStarted = false;
|
||||
connectionControl.turnEnded = false;
|
||||
|
|
@ -178,39 +160,35 @@ public class NetworkRoundControlTest {
|
|||
|
||||
connectionControl.roundStateUpdateEvent.emit(testRoundState);
|
||||
|
||||
assertSame(testRoundState.getNthPlayer(0),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(0), testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState,
|
||||
new InvalidTurnInfo(testRoundState.getTable(), null,
|
||||
Collections.<StoneSet> emptyList()));
|
||||
connectionControl.turnEndEvent.emit(testRoundState, new InvalidTurnInfo(
|
||||
testRoundState.getTable(), null, Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(1),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(1), testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
||||
connectionControl.turnEndEvent.emit(testRoundState,
|
||||
new InvalidTurnInfo(testRoundState.getTable(), null,
|
||||
Collections.<StoneSet> emptyList()));
|
||||
connectionControl.turnEndEvent.emit(testRoundState, new InvalidTurnInfo(
|
||||
testRoundState.getTable(), null, Collections.<StoneSet> emptyList()));
|
||||
|
||||
assertFalse(connectionControl.nextPlayer);
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(2),
|
||||
testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
assertSame(testRoundState.getNthPlayer(2), testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
|
||||
|
|
@ -223,8 +201,7 @@ public class NetworkRoundControlTest {
|
|||
connectionControl.nextPlayer = false;
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(3),
|
||||
testRoundState.getActivePlayer());
|
||||
assertSame(testRoundState.getNthPlayer(3), testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
|
||||
|
|
@ -236,10 +213,8 @@ public class NetworkRoundControlTest {
|
|||
connectionControl.nextPlayer = false;
|
||||
|
||||
connectionControl.nextPlayerEvent.emit();
|
||||
assertSame(testRoundState.getNthPlayer(0),
|
||||
testRoundState.getActivePlayer());
|
||||
assertTrue(connectionControl.turnStarted);
|
||||
connectionControl.turnStarted = false;
|
||||
assertSame(testRoundState.getNthPlayer(0), testRoundState.getActivePlayer());
|
||||
assertFalse(connectionControl.turnStarted);
|
||||
|
||||
connectionControl.turnStartEvent.emit();
|
||||
assertFalse(connectionControl.turnEnded);
|
||||
|
|
|
|||
Reference in a new issue