Method: getSecondPlayer()

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