Method: build(int)

1: /*
2: * Copyright © 2021-2023 Fachhochschule für die Wirtschaft (FHDW) Hannover
3: *
4: * This file is part of ipspiel24-demo.
5: *
6: * Ipspiel24-demo is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
7: * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later
8: * version.
9: *
10: * Ipspiel24-demo is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
11: * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12: *
13: * You should have received a copy of the GNU General Public License along with ipspiel24-demo. If not, see
14: * <http://www.gnu.org/licenses/>.
15: */
16: package de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.impl;
17:
18: import java.util.LinkedHashMap;
19: import java.util.Map;
20: import java.util.Objects;
21: import java.util.Optional;
22:
23: import de.fhdw.gaming.core.domain.DefaultGame;
24: import de.fhdw.gaming.core.domain.DefaultObserverFactoryProvider;
25: import de.fhdw.gaming.core.domain.Game;
26: import de.fhdw.gaming.core.domain.GameBuilder;
27: import de.fhdw.gaming.core.domain.GameException;
28: import de.fhdw.gaming.core.domain.ObserverFactoryProvider;
29: import de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.MuenzwurfGameBuilder;
30: import de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.MuenzwurfPlayer;
31: import de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.MuenzwurfPlayerBuilder;
32: import de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.MuenzwurfState;
33: import de.fhdw.gaming.ipspiel24.muenzwurf.core.domain.MuenzwurfStrategy;
34: import de.fhdw.gaming.ipspiel24.muenzwurf.core.moves.MuenzwurfMove;
35: import de.fhdw.gaming.ipspiel24.muenzwurf.core.moves.impl.AbstractMuenzwurfMove;
36:
37: /**
38: * Implements {@link MuenzwurfGameBuilder}.
39: */
40: final class MuenzwurfGameBuilderImpl implements MuenzwurfGameBuilder {
41:
42: /**
43: * The {@link ObserverFactoryProvider}.
44: */
45: private ObserverFactoryProvider observerFactoryProvider;
46: /**
47: * The player using black tokens.
48: */
49: private Optional<MuenzwurfPlayer> firstPlayer;
50: /**
51: * The strategy of the player using black tokens.
52: */
53: private Optional<MuenzwurfStrategy> firstPlayerStrategy;
54: /**
55: * The player using white tokens.
56: */
57: private Optional<MuenzwurfPlayer> secondPlayer;
58: /**
59: * The strategy of the player using white tokens.
60: */
61: private Optional<MuenzwurfStrategy> secondPlayerStrategy;
62: /**
63: * The maximum computation time per move in seconds.
64: */
65: private int maxComputationTimePerMove;
66:
67: /**
68: * Creates a Muenzwurf game builder.
69: */
70: MuenzwurfGameBuilderImpl() {
71: this.observerFactoryProvider = new DefaultObserverFactoryProvider();
72: this.firstPlayer = Optional.empty();
73: this.firstPlayerStrategy = Optional.empty();
74: this.secondPlayer = Optional.empty();
75: this.secondPlayerStrategy = Optional.empty();
76: this.maxComputationTimePerMove = GameBuilder.DEFAULT_MAX_COMPUTATION_TIME_PER_MOVE;
77: }
78:
79: @Override
80: public MuenzwurfPlayerBuilder createPlayerBuilder() {
81: return new MuenzwurfPlayerBuilderImpl();
82: }
83:
84: @Override
85: public MuenzwurfGameBuilder addPlayer(final MuenzwurfPlayer player, final MuenzwurfStrategy strategy)
86: throws GameException {
87:
88: if (this.firstPlayer.isEmpty()) {
89: this.firstPlayer = Optional.of(Objects.requireNonNull(player, "player"));
90: this.firstPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "firstPlayerStrategy"));
91: } else if (this.secondPlayer.isEmpty()) {
92: this.secondPlayer = Optional.of(Objects.requireNonNull(player, "player"));
93: this.secondPlayerStrategy = Optional.of(Objects.requireNonNull(strategy, "secondPlayerStrategy"));
94: } else {
95: throw new GameException(String.format("More than two players are now allowed."));
96: }
97: return this;
98: }
99:
100: @Override
101: public MuenzwurfGameBuilder changeMaximumComputationTimePerMove(final int newMaxComputationTimePerMove) {
102: this.maxComputationTimePerMove = newMaxComputationTimePerMove;
103: return this;
104: }
105:
106: @Override
107: public MuenzwurfGameBuilder changeObserverFactoryProvider(final ObserverFactoryProvider
108: newObserverFactoryProvider) {
109: this.observerFactoryProvider = newObserverFactoryProvider;
110: return this;
111: }
112:
113: @Override
114: public Game<MuenzwurfPlayer, MuenzwurfState, MuenzwurfMove, MuenzwurfStrategy> build(final int id)
115: throws GameException, InterruptedException {
116:• if (!this.firstPlayer.isPresent() || !this.secondPlayer.isPresent()) {
117: throw new GameException("A Muenzwurf game needs two players.");
118: }
119:
120: final MuenzwurfStateImpl initialState = new MuenzwurfStateImpl(this.firstPlayer.get(), this.secondPlayer.get());
121:
122: final Map<String, MuenzwurfStrategy> strategies = new LinkedHashMap<>();
123: strategies.put(initialState.getFirstPlayer().getName(), this.firstPlayerStrategy.orElseThrow());
124: strategies.put(initialState.getSecondPlayer().getName(), this.secondPlayerStrategy.orElseThrow());
125: return new DefaultGame<>(
126: id,
127: initialState,
128: strategies,
129: this.maxComputationTimePerMove,
130: AbstractMuenzwurfMove.class::isInstance,
131: new MuenzwurfMoveGeneratorImpl(),
132: this.observerFactoryProvider);
133: }
134: }