Method: getMaxComputationTimePerMove()

1: package de.schereSteinPapier.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.schereSteinPapier.domain.SSPGame;
13: import de.schereSteinPapier.domain.SSPGameBuilder;
14: import de.schereSteinPapier.domain.SSPPlayer;
15: import de.schereSteinPapier.domain.SSPPlayerBuilder;
16: import de.schereSteinPapier.domain.SSPStrategy;
17: import de.schereSteinPapier.moves.impl.AbstractSSPMove;
18:
19: /**
20: * Implements {@link SSPGameBuilder}.
21: */
22: final class SSPGameBuilderImpl implements SSPGameBuilder {
23:
24: /**
25: * The {@link ObserverFactoryProvider}.
26: */
27: private ObserverFactoryProvider observerFactoryProvider;
28: /**
29: * The first player.
30: */
31: private Optional<SSPPlayer> firstPlayer;
32: /**
33: * The strategy of the first player.
34: */
35: private Optional<SSPStrategy> firstPlayerStrategy;
36: /**
37: * The second player.
38: */
39: private Optional<SSPPlayer> secondPlayer;
40: /**
41: * The strategy of the second player.
42: */
43: private Optional<SSPStrategy> secondPlayerStrategy;
44: /**
45: * The maximum computation time per move in seconds. Inherited from SSPGameBuilder which internally
46: * inherits it from gaming.core.
47: */
48: private int maxComputationTimePerMove;
49:
50: /**
51: * Creates a SSP game builder.
52: */
53: SSPGameBuilderImpl() {
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 SSPPlayerBuilder createPlayerBuilder() {
64: return new SSPPlayerBuilderImpl();
65: }
66:
67: @Override
68: public SSPGameBuilder addPlayer(final SSPPlayer player, final SSPStrategy strategy)
69: throws GameException {
70:
71: Objects.requireNonNull(player);
72: if (this.firstPlayer.isEmpty()) {
73: this.firstPlayer = Optional.of(player);
74: this.firstPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "firstPlayerStrategy"));
75: } else if (this.secondPlayer.isEmpty()) {
76: this.secondPlayer = Optional.of(player);
77: this.secondPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "secondPlayerStrategy"));
78: } else {
79: throw new GameException(String.format("More than two players are now allowed."));
80: }
81: return this;
82: }
83:
84: @Override
85: public SSPGameBuilder changeMaximumComputationTimePerMove(final int newMaxComputationTimePerMove) {
86: this.maxComputationTimePerMove = newMaxComputationTimePerMove;
87: return this;
88: }
89:
90: @Override
91: public SSPGameBuilder changeObserverFactoryProvider(final ObserverFactoryProvider newObserverFactoryProvider) {
92: this.observerFactoryProvider = newObserverFactoryProvider;
93: return this;
94: }
95:
96: @Override
97: public SSPGame build(final int id) throws GameException, InterruptedException {
98: if (!this.firstPlayer.isPresent() || !this.secondPlayer.isPresent()) {
99: throw new GameException("A SSP game needs two players.");
100: }
101:
102: final SSPStateImpl initialState = new SSPStateImpl(this.firstPlayer.get(), this.secondPlayer.get());
103:
104: final Map<String, SSPStrategy> strategies = new LinkedHashMap<>();
105: strategies.put(initialState.getFirstPlayer().getName(), this.firstPlayerStrategy.orElseThrow());
106: strategies.put(initialState.getSecondPlayer().getName(), this.secondPlayerStrategy.orElseThrow());
107: return new SSPGameImpl(
108: id,
109: initialState,
110: strategies,
111: this.maxComputationTimePerMove,
112: AbstractSSPMove.class::isInstance,
113: this.observerFactoryProvider);
114: }
115:
116: /**
117: * Get observerFactoryProvider.
118: * @return
119: */
120: public ObserverFactoryProvider getObserverFactoryProvider() {
121: return observerFactoryProvider;
122: }
123:
124: /**
125: * Get maxComputationTimePerMove.
126: * @return
127: */
128: public int getMaxComputationTimePerMove() {
129: return maxComputationTimePerMove;
130: }
131: }