public IGame CreateGame(IShip[] playerShips, IDifficultyLevel difficulty)
{
IGame game = _gameFactory.Create(playerShips, difficulty);
_gameDictionary.Add(game.Guid, game);
return(game);
}
private async Task <Game> CreateGameAsync(JoinAnyGameCommand request, GameTypeMetadata metadata)
{
if (request.MaxPlayers > metadata.MaxPlayers)
{
throw new ValidationException("Players cannot be greather than max number of players");
}
var game = _gameFactory.Create(request.GameType);
game.Status = GameStatus.WaitingForPlayers;
game.GameType = request.GameType; // add validation: check that value is part of enum values
game.MinPlayers = metadata.MinPlayers;
game.MaxPlayers = request.MaxPlayers ?? metadata.MaxPlayers;
game.MaxDuration = request.Duration ?? metadata.DefaultDuration;
game.IsOpen = request.IsOpen;
game.PlayersCount = 1;
game.Players = new List <Game.Player>()
{
new Game.Player()
{
Id = _playerIdentity.Id,
Name = _playerIdentity.Name,
AcceptedAt = DateTime.UtcNow
}
};
return(await _repository.CreateGameAsync(game));
}
public void Run()
{
var returnCode = 2;
while (returnCode == 2)
{
returnCode = _game.Start();
//Code : on quite
if (returnCode == 0)
{
_game_repository.Delete();
}
//[1] Code : on quitte en sauvegardant
//Code : lancement d'une nouvelle partie
if (returnCode == 2)
{
_displayer.Clear();
_displayer.Show("Lancement d'une nouvelle partie !");
_game_repository.Delete();
_game_model = _game_factory.Create(NUMBER_ROUND);
_game = new TicTacToeGame(_reader, _displayer, _formatter, _player_factory, _round_factory, _game_model, _game_repository);
}
}
}
public Result Create()
{
ResultBuilder resultBuilder = new ResultBuilder();
if (_gameAccessor.Game != null && _gameAccessor.Game.GameState != GameState.Finished)
{
resultBuilder.AddFeedback("Cannot create a new game when there's still a game active.", false);
return(resultBuilder.Build());
}
_gameAccessor.Game = _gameFactory.Create(new Settings
{
RuleSet = new RuleSet
{
CardsOnStart = 4,
GiveCardBehaviour = GiveCardBehaviour.Single,
StartBehaviour = StartBehaviour.RandomPlayer,
TurnBehaviour = TurnBehaviour.LastAskedPlayer
},
DeckSettings = new DeckSettings()
});
resultBuilder.AddFeedback("A new game was created.");
return(resultBuilder.Build());
}
public GameService(IGameRepository gameRepository, IGameFactory factory, int gameHeight, int snakeLength)
{
_gameRepository = gameRepository ?? throw new ApplicationException(nameof(gameRepository));
_factory = factory ?? throw new ApplicationException(nameof(factory));
_gameHeight = gameHeight;
_snakeLength = snakeLength;
_game = _factory.Create(0, gameHeight, snakeLength);
}
private int GetThroughput(int wipLimit)
{
var game = _gameFactory.Create(PlayerCount, wipLimit, wipLimit);
game.DaysPassed(DayCount);
return(game.DoneCardsCount);
}
public Program(ICommunicator communicator, IGameFactory gameFactory, IGameStatePrinter gameStatePrinter, ICommandInterpreter interpreter)
{
_communicator = communicator;
_gameFactory = gameFactory;
_gameStatePrinter = gameStatePrinter;
_interpreter = interpreter;
Game = _gameFactory.Create();
}
public void Logic()
{
_game.Logic();
if (_game.GameOver)
{
_gameRepository.Add(_game);
_game = _factory.Create(0, _gameHeight, _snakeLength);
}
}
protected void InitWithGame(Game game)
{
_game = game;
_id = new Guid();
_factory = Substitute.For <IGameFactory>();
_factory.Create(Arg.Any <string>(), Arg.Any <string>()).Returns(_game);
_repo = Substitute.For <IRepository <Game> >();
_repo.Add(Arg.Any <Game>()).Returns(_id);
_repo.Get(Arg.Any <Guid>()).Returns(_game);
_authorizer = Substitute.For <IAuthorizer>();
_logger = Substitute.For <ILogger>();
_sut = new GameApi(_factory, _repo, _authorizer, _logger);
}
public ActionResult CreateGame(NewGameViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("CreateGame", viewModel));
}
var player = _cookieManager.ExtractPlayerFromCookie(Request);
var game = _gameFactory.Create(viewModel.Name);
game.AddPlayer(player);
game.StartGame();
_gameRepository.Add(game);
return(RedirectToAction("Index", "Game", new { id = game.Id }));
}
public TicTacToeRunner (IReader reader, IDisplayer displayer, IBoardFormatter formatter, IPlayerFactory player_factory, IRoundFactory round_factory, IGameFactory game_factory, IGameRepository game_repository)
{
_reader = reader;
_displayer = displayer;
_game_repository = game_repository;
_game_factory = game_factory;
_formatter = formatter;
_round_factory = round_factory;
_player_factory = player_factory;
//on charge la partie dans le repo
_game_model = _game_repository.Load();
if(_game_model == null)
_game_model = game_factory.Create (NUMBER_ROUND);
_game = new TicTacToeGame (_reader, _displayer, formatter, player_factory, round_factory, _game_model, _game_repository);
}
public Guid Create(string player1Id, string player2Id, string userId)
{
try
{
_authorizer.AssertAuthorizedForCreate(userId);
var game = _factory.Create(player1Id, player2Id);
var id = _repo.Add(game);
_logger.Info($"Created a game between '{player1Id}' and '{player2Id}'.");
return(id);
}
catch (Exception ex)
{
_logger.Error("An error occurred creating a game", ex);
throw;
}
}
public TicTacToeRunner(IReader reader, IDisplayer displayer, IBoardFormatter formatter, IPlayerFactory player_factory, IRoundFactory round_factory, IGameFactory game_factory, IGameRepository game_repository)
{
_reader = reader;
_displayer = displayer;
_game_repository = game_repository;
_game_factory = game_factory;
_formatter = formatter;
_round_factory = round_factory;
_player_factory = player_factory;
//on charge la partie dans le repo
_game_model = _game_repository.Load();
if (_game_model == null)
{
_game_model = game_factory.Create(NUMBER_ROUND);
}
_game = new TicTacToeGame(_reader, _displayer, formatter, player_factory, round_factory, _game_model, _game_repository);
}
public bool NewGame(List <IPlayer> players)
{
lock (NewGameLock)
{
if (players == null || players.Count != 2)
{
throw new GameServerException(
"Exception occurred while creating new game. NewGame method requires not-null list of 2 players.");
}
if (GetGameByPlayerIdOrDefault(players[0].OnlineId) == null &&
GetGameByPlayerIdOrDefault(players[1].OnlineId) == null)
{
IGame game = gameFactory.Create(players);
game.State = GameState.Ready;
RunningGames.Add(game);
return(true);
}
return(false);
}
}
public GameInfo Create([FromBody] GameData gameData)
{
var gameInfo = _gameFactory.Create(gameData.SymbolsForEachCard);
var isCorrect = true;
foreach (var card in gameInfo.Cards)
{
var card1 = card;
foreach (var secondCard in gameInfo.Cards.Where(c => c != card1))
{
var secondCard1 = secondCard;
var commonSymbol = card1.Lines.Where(l => secondCard1.Lines.Contains(l));
if (commonSymbol.Count() != 1)
{
isCorrect = false;
break;
}
}
}
return(gameInfo);
}
public void TestSingleFile(string exe)
{
var badShots = 0;
var crashes = 0;
var gamesPlayed = 0;
var shots = new List <int>();
var ai = aiFactory.Create(exe, monitor);
for (var gameIndex = 0; gameIndex < settings.GamesCount; gameIndex++)
{
var map = mapGenerator.GenerateMap();
var game = gameFactory.Create(map, ai);
RunGameToEnd(game);
gamesPlayed++;
badShots += game.BadShots;
if (game.AiCrashed)
{
crashes++;
if (crashes > settings.CrashLimit)
{
break;
}
ai = aiFactory.Create(exe, monitor);
}
else
{
shots.Add(game.TurnsCount);
}
if (settings.Verbose)
{
Console.WriteLine(
"Game #{3,4}: Turns {0,4}, BadShots {1}{2}",
game.TurnsCount, game.BadShots, game.AiCrashed ? ", Crashed" : "", gameIndex);
}
}
ai.Dispose();
WriteTotal(ai, shots, crashes, badShots, gamesPlayed);
}
public void NewGame()
{
Game = _gameFactory.Create();
}
public void Restart(object sender, EventArgs e)
{
Game = gameFactory.Create(player);
mainPanel.Controls.RemoveAt(1);
mainPanel.Controls.Add(gamePanel, 0, 1);
}
public void Init(int symbolsNumber)
{
SetUp();
_gameStarted = true;
_gameInfo = _gameFactory.Create(symbolsNumber);
}
public async void StartGame(GameType type, string level = "")
{
logger.Info("Game started");
try
{
if (MoveReceived == null)
{
logger?.Error("InvalidOperationException: " + StringResources.TheGameCanNotBeStartedBecauseOfMoveReceivedIsNull());
throw new InvalidOperationException(
StringResources.TheGameCanNotBeStartedBecauseOfMoveReceivedIsNull());
}
var players = new List <IPlayer>();
switch (type)
{
case GameType.SinglePlayer:
players.Add(playerFactory.Create(PlayerType.Human, 1));
players.Add(playerFactory.Create(PlayerType.Bot, 2));
break;
case GameType.TwoPlayers:
players.Add(playerFactory.Create(PlayerType.Human, 0));
players.Add(playerFactory.Create(PlayerType.Human, 0));
break;
case GameType.Online:
if (proxy == null)
{
logger?.Error("InvalidOperationException: " +
StringResources.TheGameCanNotBeStartedBecauseOfProxyIsNull());
throw new InvalidOperationException(
StringResources.TheGameCanNotBeStartedBecauseOfProxyIsNull());
}
isOnlineGameRequestCancelled = false;
if (!isRequestingOnlineGame)
{
players = await Task.Factory.StartNew(RequestOnlinePlayer).Result;
}
if (players.Count != 2)
{
return;
}
if (players[0].Type.Equals(PlayerType.OnlinePlayer))
{
GetFirstMove(myOnlineId);
}
break;
case GameType.Bluetooth:
break;
case GameType.Wifi:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
CurrentGame = gameFactory.Create(players, level);
}
catch (TimeoutException ex)
{
string exceptionMessage = StringResources.TimeoutExceptionOccured("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (FaultException ex)
{
string exceptionMessage = StringResources.ExceptionOccuredOnServerSide("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
catch (CommunicationException ex)
{
string exceptionMessage = StringResources.CommunicationProblemOccured("StartGame", ex.Message);
logger?.Error(exceptionMessage);
throw new GameServerException(exceptionMessage, ex);
}
}
