Method: legalMoveApplied(Game, State, Player, Move)

1: package de.fhdw.gaming.memory.impl;
2:
3: import java.util.ArrayList;
4: import java.util.List;
5: import java.util.Map;
6: import java.util.Optional;
7: import java.util.Set;
8:
9: import de.fhdw.gaming.core.domain.Game;
10: import de.fhdw.gaming.core.domain.Move;
11: import de.fhdw.gaming.core.domain.Observer;
12: import de.fhdw.gaming.core.domain.Player;
13: import de.fhdw.gaming.core.domain.State;
14: import de.fhdw.gaming.core.domain.Strategy;
15: import de.fhdw.gaming.memory.Key;
16:
17: /**
18: * An observer implementation that interacts with the memory brain to remember game outcomes.
19: */
20: public class MemoryObserverImpl implements Observer {
21:
22: @Override
23: public void started(Game<?, ?, ?, ?> game, State<?, ?> state) throws InterruptedException {
24: MemoryBrainImpl.getInstance().setMemoryLength(5);
25: System.out.println("Game started!");
26: }
27:
28: @Override
29: public void nextPlayersComputed(Game<?, ?, ?, ?> game, State<?, ?> state, Set<? extends Player<?>> players)
30: throws InterruptedException {
31: // System.out.println("Computed next player.");
32: }
33:
34: @Override
35: public void illegalPlayerRejected(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> player)
36: throws InterruptedException {
37: // System.out.println("Illegal player rejected!");
38: }
39:
40: @Override
41: public void legalMoveApplied(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> player, Move<?, ?> move)
42: throws InterruptedException {
43:
44: // System.out.println("Legal move applied!");
45:
46: Player<?> opponent = null;
47:• for (Map.Entry<String, ?> entry : game.getPlayers().entrySet()) {
48: final Player<?> possibleOpponent = (Player<?>) entry.getValue();
49:• if (!possibleOpponent.getName().equals(player.getName())) {
50: opponent = possibleOpponent;
51: }
52: }
53:
54: final Strategy<?, ?, ?> usedStrategy = game.getStrategies().get(player.getName());
55: final Strategy<?, ?, ?> opponentStrategy = game.getStrategies().get(opponent.getName());
56:
57: final Key currentKey1 = new MemoryKeyImpl(player, opponent, usedStrategy);
58: final Key currentKey2 = new MemoryKeyImpl(opponent, player, opponentStrategy);
59:
60: MemoryBrainImpl.getInstance().rememberMyMove(currentKey1, move);
61: MemoryBrainImpl.getInstance().rememberOpponentMove(currentKey2, move);
62:
63: }
64:
65: @Override
66: public void illegalMoveRejected(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> player,
67: Optional<Move<?, ?>> move, String reason) throws InterruptedException {
68: System.err.println("Illegal move rejected! " + reason);
69: }
70:
71: @Override
72: public void overdueMoveRejected(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> player,
73: Optional<Move<?, ?>> chosenMove) throws InterruptedException {
74: // System.out.println("overdueMoveRejected!");
75: }
76:
77: @Override
78: public void playerResigned(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> player) throws InterruptedException {
79: // System.out.println("Player resigned!");
80: }
81:
82: @Override
83: public void playerOvertaken(Game<?, ?, ?, ?> game, State<?, ?> state, Player<?> overtakenPlayer,
84: Player<?> overtakingPlayer) throws InterruptedException {
85: // Not implemented
86: }
87:
88: /**
89: * Every time a game finished the outcome will be remembered by the brain.
90: */
91: @Override
92: public void finished(Game<?, ?, ?, ?> game, State<?, ?> state) throws InterruptedException {
93: System.out.println("Game finished!");
94: MemoryBrainImpl.getInstance().rememberOutcome(game);
95:
96: final Map<String, ? extends Strategy<?, ?, ?>> tempStrategies = game.getStrategies();
97: final Map<String, ? extends Player<?>> tempPlayers = game.getPlayers();
98: final List<String> playerNames = new ArrayList<>(tempPlayers.keySet());
99:
100: final Key currentKey1 = new MemoryKeyImpl(tempPlayers
101: .get(playerNames.get(0)), tempPlayers.get(playerNames.get(1)), tempStrategies.get(playerNames.get(0)));
102:
103: final Key currentKey2 = new MemoryKeyImpl(tempPlayers
104: .get(playerNames.get(1)), tempPlayers.get(playerNames.get(0)), tempStrategies.get(playerNames.get(1)));
105:
106: // System.out.println(MemoryBrainImpl.getInstance().getMemory(currentKey1).show());
107: // System.out.println(MemoryBrainImpl.getInstance().getMemory(currentKey2).show().toString());
108:
109: final List<MemorySaveEntryImpl> pairList = MemoryBrainImpl.getInstance().getMemory(currentKey1).show();
110: final List<MemorySaveEntryImpl> pairList2 = MemoryBrainImpl.getInstance().getMemory(currentKey2).show();
111:
112: // MemorySaveEntryImpl testPair1 = MemoryBrainImpl.getInstance().getMemory(currentKey1).show().get(0);
113: // MemorySaveEntryImpl testPair2 = MemoryBrainImpl.getInstance().getMemory(currentKey2).show().get(0);
114:
115: System.out.println("My view");
116: pairList.forEach(pair -> System.out.print(pairList.indexOf(pair) + ". [" + pair.toString() + "] \n"));
117: System.out.println("");
118:
119: System.out.println("Opponents view");
120: pairList2.forEach(pair -> System.out.print(pairList2.indexOf(pair) + ". [" + pair.toString() + "] \n"));
121: System.out.println("");
122:
123: }
124:
125: }