Method: changeMaximumComputationTimePerMove(int)

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