Method: addPlayer(FzgPlayer, FzgStrategy)

1: package de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.impl;
2:
3: import java.util.LinkedHashMap;
4: import java.util.Map;
5: import java.util.Objects;
6: import java.util.Optional;
7:
8: import de.fhdw.gaming.core.domain.DefaultObserverFactoryProvider;
9: import de.fhdw.gaming.core.domain.GameBuilder;
10: import de.fhdw.gaming.core.domain.GameException;
11: import de.fhdw.gaming.core.domain.ObserverFactoryProvider;
12: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.FzgGame;
13: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.FzgGameBuilder;
14: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.FzgPlayer;
15: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.FzgPlayerBuilder;
16: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.domain.FzgStrategy;
17: import de.fhdw.gaming.ipspiel23.freizeitgestaltung.move.impl.AbstractAnswer;
18:
19: /**
20: * Builds a Game, implements {@link FzgGameBuilder}.
21: *
22: */
23: public class FzgGameBuilderImpl implements FzgGameBuilder {
24:
25: /**
26: * The {@link ObserverFactoryProvider}.
27: */
28: private ObserverFactoryProvider observerFactoryProvider;
29: /**
30: * The first player.
31: */
32: private Optional<FzgPlayer> firstPlayer;
33: /**
34: * The strategy of the first player.
35: */
36: private Optional<FzgStrategy> firstPlayerStrategy;
37: /**
38: * The second player.
39: */
40: private Optional<FzgPlayer> secondPlayer;
41: /**
42: * The strategy of the second player.
43: */
44: private Optional<FzgStrategy> secondPlayerStrategy;
45: /**
46: * The maximum computation time per move in seconds.
47: */
48: private int maxComputationTimePerMove;
49:
50: /**
51: * Constructor, creates a FzgGameBuilder.
52: */
53: public FzgGameBuilderImpl() {
54: this.observerFactoryProvider = new DefaultObserverFactoryProvider();
55: this.firstPlayer = Optional.empty();
56: this.firstPlayerStrategy = Optional.empty();
57: this.secondPlayer = Optional.empty();
58: this.secondPlayerStrategy = Optional.empty();
59: this.maxComputationTimePerMove = GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE;
60: }
61:
62: @Override
63: public FzgPlayerBuilder createPlayerBuilder() {
64: return new FzgPlayerBuilderImpl();
65: }
66:
67: @Override
68: public FzgGameBuilder changeMaximumComputationTimePerMove(final int newMaxComputationTimePerMove) {
69: this.maxComputationTimePerMove = newMaxComputationTimePerMove;
70: return this;
71: }
72:
73: @Override
74: public FzgGameBuilder addPlayer(final FzgPlayer player, final FzgStrategy strategy) throws GameException {
75:• if (this.firstPlayer.isEmpty()) {
76: this.firstPlayer = Optional.of(Objects.requireNonNull(player, "player"));
77: this.firstPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "firstPlayerStrategy"));
78:• } else if (this.secondPlayer.isEmpty()) {
79: this.secondPlayer = Optional.of(Objects.requireNonNull(player, "player"));
80: this.secondPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "secondPlayerStrategy"));
81: } else {
82: throw new GameException(String.format("More than two players are not allowed."));
83: }
84: return this;
85: }
86:
87: @Override
88: public FzgGameBuilder changeObserverFactoryProvider(final ObserverFactoryProvider newObserverFactoryProvider) {
89: this.observerFactoryProvider = newObserverFactoryProvider;
90: return this;
91: }
92:
93: @Override
94: public FzgGame build(final int id) throws GameException, InterruptedException {
95: if (!this.firstPlayer.isPresent() || !this.secondPlayer.isPresent()) {
96: throw new GameException("Freizeitgestaltung needs two players.");
97: }
98:
99: final FzgStateImpl initialState = new FzgStateImpl(this.firstPlayer.get(), this.secondPlayer.get());
100:
101: final Map<String, FzgStrategy> strategies = new LinkedHashMap<>();
102: strategies.put(initialState.getFirstPlayer().getName(), this.firstPlayerStrategy.orElseThrow());
103: strategies.put(initialState.getSecondPlayer().getName(), this.secondPlayerStrategy.orElseThrow());
104: return new FzgGameImpl(
105: id,
106: initialState,
107: strategies,
108: this.maxComputationTimePerMove,
109: AbstractAnswer.class::isInstance,
110: this.observerFactoryProvider);
111: }
112: }