How to use

AbstractGame

in

com.jtbdevelopment.games.state

private Map<ID, Player<ID>> createIDMap(final U game) {
 return game.getAllPlayers().stream().collect(Collectors.toMap(Player::getId, p -> p));
}

 @Override
 protected IMPL handleActionInternal(
   final P player,
   final IMPL game,
   final Object param) {
  if (!game.getGamePhase().equals(GamePhase.RoundOver)) {
   throw new GameIsNotAvailableToRematchException();
  }

  game.setGamePhase(GamePhase.NextRoundStarted);
  return game;
 }
}

public int hashCode() {
 String idAsString = getIdAsString();
 return idAsString == null ? 0 : idAsString.hashCode();
}

@SuppressWarnings("WeakerAccess")
protected void copyFromPreviousGame(final IMPL previousGame, final IMPL newGame) {
 newGame.setRound(previousGame.getRound() + 1);
 newGame.setPreviousId(previousGame.getId());
}

protected void copyUnmaskedData(final U game, final M playerMaskedGame) {
 playerMaskedGame.setCompletedTimestamp(convertTime(game.getCompletedTimestamp()));
 playerMaskedGame.setCreated(convertTime(game.getCreated()));
 playerMaskedGame.setLastUpdate(convertTime(game.getLastUpdate()));
 playerMaskedGame.getFeatures().addAll(game.getFeatures());
 playerMaskedGame.setId(game.getIdAsString());
 playerMaskedGame.setGamePhase(game.getGamePhase());
 playerMaskedGame.setRound(game.getRound());
 playerMaskedGame.setPreviousId(game.getPreviousIdAsString());
}

 @SuppressWarnings("unused")
 protected IMPL changeStateAndReevaluate(final GamePhase transitionTo, final IMPL game) {
  game.setGamePhase(transitionTo);
  return evaluateGame(game);
 }
}

@Override
public IMPL evaluateGame(final IMPL game) {
 switch (game.getGamePhase()) {
  case Challenged:
   return evaluateChallengedPhase(game);
  case Setup:
   return evaluateSetupPhase(game);
  case Playing:
   return evaluatePlayingPhase(game);
  case RoundOver:
   return evaluateRoundOverPhase(game);
  case Declined:
   return evaluateDeclinedPhase(game);
  case NextRoundStarted:
   return evaluateNextRoundStartedPhase(game);
  case Quit:
   return evaluateQuitPhase(game);
 }
 return null;
}

public boolean equals(final Object o) {
 if (!(o instanceof Game)) {
  return false;
 }
 final Game game = (Game) o;
 return getId().equals(game.getId());
}

@SuppressWarnings("WeakerAccess")
protected void validatePlayerForGame(final IMPL game, final P player) {
 if (game instanceof MultiPlayerGame) {
  if (!game.getAllPlayers().contains(player)) {
   throw new PlayerNotPartOfGameException();
  }
 } else if (game instanceof SinglePlayerGame) {
  if (!((SinglePlayerGame) game).getPlayer().equals(player)) {
   throw new PlayerNotPartOfGameException();
  }
 }
}

@Override
public void gameChanged(
  final IMPL game,
  final P initiatingPlayer,
  final boolean initiatingServer) {
 if (initiatingServer) {
  ClusterMessage message = new ClusterMessage();
  message.setGameId(game.getIdAsString());
  message.setClusterMessageType(ClusterMessageType.GameUpdate);
  if (initiatingPlayer != null) {
   message.setPlayerId(initiatingPlayer.getIdAsString());
  }
  internalPublish(message);
 }
}