Method: changeMaximumComputationTimePerMove(int)

1: package de.fhdw.gaming.ipspiel21.viergewinnt.core.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.ipspiel21.viergewinnt.core.domain.VierGewinntGame;
13: import de.fhdw.gaming.ipspiel21.viergewinnt.core.domain.VierGewinntGameBuilder;
14: import de.fhdw.gaming.ipspiel21.viergewinnt.core.domain.VierGewinntPlayerBuilder;
15: import de.fhdw.gaming.ipspiel21.viergewinnt.core.domain.VierGewinntState;
16: import de.fhdw.gaming.ipspiel21.viergewinnt.core.domain.VierGewinntStrategy;
17: import de.fhdw.gaming.ipspiel21.viergewinnt.core.domain.moves.impl.AbstractMove;
18:
19: /**
20: * The Game Builder for a VierGewinnt Game.
21: *
22: * @author Robby Rabbitman
23: *
24: */
25: public class VierGewinntGameBuilderImpl implements VierGewinntGameBuilder {
26:
27: /**
28: * Time for a Player to choose his next move.
29: *
30: */
31: private int maxComputationTimePerMove;
32: /**
33: * Observer Factory Provider.
34: *
35: */
36: private ObserverFactoryProvider newObserverFactoryProvider;
37: /**
38: * The Row Size of a VierGewinnt Game.
39: *
40: */
41: private int rowSize;
42: /**
43: * The Column Size of a VierGewinnt Game.
44: *
45: */
46: private int columnSize;
47: /**
48: * player builder 1.
49: */
50: private Optional<VierGewinntPlayerBuilder> player1builder;
51: /**
52: * player strategy 1.
53: */
54: private Optional<VierGewinntStrategy> player1Strategy;
55: /**
56: * player builder 2.
57: */
58: private Optional<VierGewinntPlayerBuilder> player2builder;
59: /**
60: * player strategy 2.
61: */
62: private Optional<VierGewinntStrategy> player2Strategy;
63:
64: /**
65: * Constructor.
66: */
67: public VierGewinntGameBuilderImpl() {
68: this.player1builder = Optional.empty();
69: this.player1Strategy = Optional.empty();
70: this.player2builder = Optional.empty();
71: this.player2Strategy = Optional.empty();
72: this.newObserverFactoryProvider = new DefaultObserverFactoryProvider();
73: this.maxComputationTimePerMove = 5;
74: }
75:
76: @Override
77: public GameBuilder changeMaximumComputationTimePerMove(final int newMaxComputationTimePerMove) {
78: this.maxComputationTimePerMove = newMaxComputationTimePerMove;
79: return this;
80: }
81:
82: @Override
83: public VierGewinntPlayerBuilder createPlayerBuilder() {
84: return new VierGewinntPlayerBuilderImpl();
85: }
86:
87: @Override
88: public VierGewinntGameBuilder addPlayerBuilder(final VierGewinntPlayerBuilder playerBuilder,
89: final VierGewinntStrategy strategy) throws GameException {
90: Objects.requireNonNull(playerBuilder);
91: if (this.player1builder.isEmpty()) {
92: this.player1builder = Optional.of(playerBuilder);
93: this.player1Strategy = Optional.of(Objects.requireNonNull(strategy, "firstPlayerStrategy"));
94: } else if (this.player2builder.isEmpty()) {
95: this.player2builder = Optional.of(playerBuilder);
96: this.player2Strategy = Optional.of(Objects.requireNonNull(strategy, "secondPlayerStrategy"));
97: } else {
98: throw new GameException(String.format("More than two players are now allowed."));
99: }
100: return this;
101: }
102:
103: @Override
104: public VierGewinntGameBuilder changeColumnSize(final int newColumnSize) {
105: this.columnSize = newColumnSize;
106: return this;
107: }
108:
109: @Override
110: public VierGewinntGameBuilder changeRowSize(final int newRowSize) {
111: this.rowSize = newRowSize;
112: return this;
113: }
114:
115: @Override
116: public VierGewinntGameBuilder changeObserverFactoryProvider(final ObserverFactoryProvider provider) {
117: this.newObserverFactoryProvider = provider;
118: return this;
119: }
120:
121: @Override
122: public VierGewinntGame build(final int id)
123: throws GameException, IllegalArgumentException, InterruptedException {
124: if (!this.player1builder.isPresent() || !this.player2builder.isPresent()) {
125: throw new GameException("A game needs two players!");
126: }
127:
128: final VierGewinntState initialState =
129: new VierGewinntStateImpl(new VierGewinntBoardImpl(rowSize, columnSize), this.player1builder.get(),
130: this.player2builder.get());
131:
132: final Map<String, VierGewinntStrategy> strategies = new LinkedHashMap<>();
133: strategies.put(initialState.getYellowPlayer().getName(), this.player1Strategy.orElseThrow());
134: strategies.put(initialState.getRedPlayer().getName(), this.player2Strategy.orElseThrow());
135: return new VierGewinntGameImpl(id, initialState, strategies, this.maxComputationTimePerMove,
136: AbstractMove.class::isInstance, this.newObserverFactoryProvider);
137: }
138:
139: }