Method: outcomeToState(Double)

1: package de.schereSteinPapier.domain.impl;
2:
3: import java.util.LinkedHashMap;
4: import java.util.LinkedHashSet;
5: import java.util.Map;
6: import java.util.Objects;
7: import java.util.Set;
8:
9: import de.fhdw.gaming.core.domain.GameException;
10: import de.fhdw.gaming.core.domain.PlayerState;
11: import de.schereSteinPapier.domain.SSPPlayer;
12: import de.schereSteinPapier.domain.SSPState;
13:
14: /**
15: * Implements {@link SSPState}.
16: */
17: public final class SSPStateImpl implements SSPState {
18:
19: /**
20: * The first player.
21: */
22: private final SSPPlayer firstPlayer;
23: /**
24: * The second player.
25: */
26: private final SSPPlayer secondPlayer;
27:
28: /**
29: * Creates a SSP state.
30: *
31: * @param firstPlayer The first player.
32: * @param secondPlayer The second player.
33: * @throws GameException if the state cannot be created according to the rules of the game.
34: */
35: SSPStateImpl(final SSPPlayer firstPlayer, final SSPPlayer secondPlayer)
36: throws GameException {
37:
38: this.firstPlayer = Objects.requireNonNull(firstPlayer, "firstPlayer");
39: this.secondPlayer = Objects.requireNonNull(secondPlayer, "secondPlayer");
40:
41: if (this.firstPlayer.getName().equals(this.secondPlayer.getName())) {
42: throw new IllegalArgumentException(
43: String.format("Both players have the same name '%s'.", this.firstPlayer.getName()));
44: }
45: }
46:
47: /**
48: * Creates a SSP state by copying an existing one.
49: *
50: * @param source The state to copy.
51: */
52: SSPStateImpl(final SSPStateImpl source) {
53: this.firstPlayer = source.firstPlayer.deepCopy();
54: this.secondPlayer = source.secondPlayer.deepCopy();
55: }
56:
57: /**
58: * Returns the first player.
59: */
60: @Override
61: public SSPPlayer getFirstPlayer() {
62: return this.firstPlayer;
63: }
64:
65: /**
66: * Returns the second player.
67: */
68: @Override
69: public SSPPlayer getSecondPlayer() {
70: return this.secondPlayer;
71: }
72:
73: @Override
74: public String toString() {
75: return String.format("SSPState[firstPlayer=%s, secondPlayer=%s]", this.firstPlayer, this.secondPlayer);
76: }
77:
78: @Override
79: public boolean equals(final Object obj) {
80: if (obj instanceof SSPStateImpl) {
81: final SSPStateImpl other = (SSPStateImpl) obj;
82: return this.firstPlayer.equals(other.firstPlayer) && this.secondPlayer.equals(other.secondPlayer);
83: }
84: return false;
85: }
86:
87: @Override
88: public SSPState deepCopy() {
89: return new SSPStateImpl(this);
90: }
91:
92: @Override
93: public int hashCode() {
94: return Objects.hash(this.firstPlayer, this.secondPlayer);
95: }
96:
97: @Override
98: public Map<String, SSPPlayer> getPlayers() {
99: final Map<String, SSPPlayer> result = new LinkedHashMap<>();
100: result.put(this.firstPlayer.getName(), this.firstPlayer);
101: result.put(this.secondPlayer.getName(), this.secondPlayer);
102: return result;
103: }
104:
105: @Override
106: public Set<SSPPlayer> computeNextPlayers() {
107: final Set<SSPPlayer> playersWithoutMove = new LinkedHashSet<>();
108: if (this.firstPlayer.getAnswer().isEmpty()) {
109: playersWithoutMove.add(this.firstPlayer);
110: }
111: if (this.secondPlayer.getAnswer().isEmpty()) {
112: playersWithoutMove.add(this.secondPlayer);
113: }
114: return playersWithoutMove;
115: }
116:
117: @Override
118: public void nextTurn() {
119: final Set<SSPPlayer> playersWithoutMove = this.computeNextPlayers();
120: if (playersWithoutMove.isEmpty()) {
121: final String answerOfFirstPlayer = this.firstPlayer.getAnswer().orElseThrow();
122: final String answerOfSecondPlayer = this.secondPlayer.getAnswer().orElseThrow();
123:
124: final Double outcomeOfFirstPlayer = this.firstPlayer.getPossibleOutcomes().get(answerOfFirstPlayer)
125: .get(answerOfSecondPlayer);
126: this.firstPlayer.setState(outcomeToState(outcomeOfFirstPlayer));
127: this.firstPlayer.setOutcome(outcomeOfFirstPlayer);
128:
129: final Double outcomeOfSecondPlayer = this.secondPlayer.getPossibleOutcomes().get(answerOfFirstPlayer)
130: .get(answerOfSecondPlayer);
131: this.secondPlayer.setState(outcomeToState(outcomeOfSecondPlayer));
132: this.secondPlayer.setOutcome(outcomeOfSecondPlayer);
133: }
134: }
135:
136: /**
137: * Computes a player state from an outcome.
138: *
139: * @param outcome The player's outcome.
140: */
141: private static PlayerState outcomeToState(final Double outcome) {
142:• return outcome > 0.0 ? PlayerState.WON : outcome < 0.0 ? PlayerState.LOST : PlayerState.DRAW;
143: }
144: }