Method: changeMaximumComputationTimePerMove(int)

1: package de.fhdw.gaming.ipspiel23.ht.domain.impl;
2:
3: import java.util.ArrayList;
4: import java.util.LinkedHashMap;
5: import java.util.List;
6: import java.util.Map;
7: import java.util.stream.IntStream;
8:
9: import de.fhdw.gaming.core.domain.DefaultObserverFactoryProvider;
10: import de.fhdw.gaming.core.domain.GameBuilder;
11: import de.fhdw.gaming.core.domain.GameException;
12: import de.fhdw.gaming.core.domain.ObserverFactoryProvider;
13: import de.fhdw.gaming.ipspiel23.ht.domain.IHTGame;
14: import de.fhdw.gaming.ipspiel23.ht.domain.IHTGameBuilder;
15: import de.fhdw.gaming.ipspiel23.ht.domain.IHTPlayer;
16: import de.fhdw.gaming.ipspiel23.ht.domain.IHTPlayerBuilder;
17: import de.fhdw.gaming.ipspiel23.ht.domain.IHTState;
18: import de.fhdw.gaming.ipspiel23.ht.moves.HTBaseMove;
19: import de.fhdw.gaming.ipspiel23.ht.strategy.IHTStrategy;
20:
21: /**
22: * Represents a builder for {@link IHTGame}s.
23: */
24: final class HTGameBuilder implements IHTGameBuilder {
25:
26: /**
27: * The {@link ObserverFactoryProvider}.
28: */
29: private final ObserverFactoryProvider observerFactoryProvider;
30:
31: /**
32: * The players of the game.
33: */
34: private final List<IHTPlayer> players = new ArrayList<>(2);
35:
36: /**
37: * The strategies of the players.
38: */
39: private final List<IHTStrategy> playerStrategies = new ArrayList<>(2);
40:
41: /**
42: * The maximum computation time per move in seconds.
43: */
44: private int maxComputationTimePerMove;
45:
46: /**
47: * Creates a new instance of {@link HTGameBuilder}.
48: */
49: public HTGameBuilder() {
50: observerFactoryProvider = new DefaultObserverFactoryProvider();
51: maxComputationTimePerMove = GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE;
52: }
53:
54: @Override
55: public HTGameBuilder changeMaximumComputationTimePerMove(final int newMaxComputationTimePerMove) {
56: this.maxComputationTimePerMove = newMaxComputationTimePerMove;
57: return this;
58: }
59:
60: @Override
61: public IHTGame build(final int id) throws GameException, InterruptedException {
62: if (players.size() != 2 || playerStrategies.size() != 2) {
63: throw new GameException("Exactly two players are required for 'Heads or Tails'.");
64: }
65:
66: final IHTState initial = new HTState(this.players.get(0), this.players.get(1));
67: final Map<String, IHTStrategy> strategies = new LinkedHashMap<>(2);
68: IntStream.range(0, 2)
69: .forEachOrdered(i -> strategies.put(this.players.get(i).getName(), this.playerStrategies.get(i)));
70: return new HTGame(id, initial, strategies, this.maxComputationTimePerMove,
71: HTBaseMove.class::isInstance, this.observerFactoryProvider);
72: }
73:
74: @Override
75: public IHTPlayerBuilder createPlayerBuilder() {
76: return new HTPlayerBuilder();
77: }
78:
79: @Override
80: public IHTGameBuilder addPlayer(final IHTPlayer player, final IHTStrategy strategy) throws GameException {
81: if (this.players.size() >= 2) {
82: throw new GameException("Cannot handle more than two players.");
83: }
84: this.players.add(player);
85: this.playerStrategies.add(strategy);
86: return this;
87: }
88: }