public ActionResult AI_vs_AI(string id, int?version, int[] difficulty)
{
VariantService variants = GetService <VariantService>();
VariantVersion versionToPlay = DeterminePlayVersion(id, version, variants);
if (versionToPlay == null)
{
return(HttpNotFound("Cannot determine variant version to play"));
}
var model = new GamePlayModel(versionToPlay, GameMode.AI_vs_AI);
var AIs = variants.ListAiDifficulties();
model.Players = new PlayerModel[versionToPlay.Variant.PlayerCount];
for (var i = 0; i < model.Players.Length && i < difficulty.Length; i++)
{
model.Players[i] = AIs.Single(ai => ai.ID == difficulty[i]);
}
for (var i = difficulty.Length; i < model.Players.Length; i++)
{
model.Players[i] = model.Players[difficulty.Length];
}
return(View("Play", model));
}
async Task IGameDeckHelper.PopulateDeckAsync(int?userId, GameModel game, GamePlayModel gamePlay, CancellationToken cancellationToken)
{
if (!userId.HasValue)
{
return;
}
await _gameDataService.PopulateGameUsersAsync(game, cancellationToken : cancellationToken);
var uid = game.UserIds.SingleOrDefault(x => x == userId.Value);
if (uid != default)
{
var gameDeck = await _gameDeckRepository.GetGameDeckByGameAndUserIdAsync(game.Id, uid, cancellationToken : cancellationToken);
var deckCards = await _gameDeckRepository.GetGameDeckCardCollectionAsync(gameDeck.Id, cancellationToken : cancellationToken);
gamePlay.GameDeckId = gameDeck.Id;
gamePlay.GameDeck = _gameDeckMapper.Map(gameDeck);
gamePlay.GameDeck.CardCollection = deckCards.Select(_gameDeckCardCollectionMapper.Map).ToArray();
//TODO: Replace with data layer
var cardFilter = new Abstractions.CardSearchFilter
{
Ids = deckCards.Select(x => x.CardId).ToArray(),
};
var cards = await _cardService.GetCardsAsync(cardFilter, cancellationToken : cancellationToken);
foreach (var cc in gamePlay.GameDeck.CardCollection)
{
cc.Card = cards.Results.SingleOrDefault(x => x.Id == cc.CardId);
}
}
}
public ActionResult Pass(GamePlayModel game)
{
RememberInputFieldValues(game);
// Not implemented yed
return(View(Game));
}
void Awake()
{
var russianWordsChecker = new RussianWordsChecker(allRussianWordsTextFile);
_gamePlayModel = new GamePlayModel(russianWordsChecker);
_gamePlayModel.OnCurrentWordChanged += (cw) => { _currentWordText.text = cw; };
_gamePlayModel.OnCurrentWordScoreChanged += (wp) => { _currentWordScoreText.text = wp.HasValue ? wp.ToString() : string.Empty; };
_gamePlayModel.OnCurrentSessionScoreChanged += (cs) => { _totalScoreText.text = cs.ToString(); };
}
public GamePlayState(GamePlayMediator mediator)
{
this.Mediator = mediator;
this.GamePlayModel = mediator._gamePlayModel;
this.View = mediator._view;
this.ProjectSettings = mediator._projectSettings;
this.RemoteDataModel = mediator._remoteDataModel;
this.Animals = mediator._animalViews;
}
private void ApplyUserMove(GamePlayModel game)
{
var newMove = game.NewMove.Trim().ToLower();
if (!string.IsNullOrEmpty(newMove))
{
newMove = newMove.Substring(0, 1);
Game.Moves.Add(newMove);
Game.Word = Game.Word + newMove;
Game.NewMove = "";
}
}
async Task <GamePlayModel> IGamePlayService.GetGamePlayByIdAsync(int id, int?userId, CancellationToken cancellationToken)
{
var filter = new Abstractions.GameSearchFilter
{
GameId = id,
};
var game = (await _gameDataService.GetGamesAsync(filter, userId: userId, cancellationToken: cancellationToken)).Results.SingleOrDefault();
if (game == null)
{
throw new InvalidGameException($"Game { id } does not exist.");
}
var gamePlay = new GamePlayModel
{
Game = game,
};
if (userId.HasValue)
{
await _gameDataService.PopulateGameUsersAsync(game, cancellationToken : cancellationToken);
var uid = game.UserIds.SingleOrDefault(x => x == userId.Value);
if (uid != default)
{
var gameDeck = await _gameDeckRepository.GetGameDeckByGameAndUserIdAsync(id, uid, cancellationToken : cancellationToken);
var deckCards = await _gameDeckRepository.GetGameDeckCardCollectionAsync(gameDeck.Id, cancellationToken : cancellationToken);
gamePlay.GameDeckId = gameDeck.Id;
gamePlay.GameDeck = _gameDeckMapper.Map(gameDeck);
gamePlay.GameDeck.CardCollection = deckCards.Select(_gameDeckCardCollectionMapper.Map).ToArray();
//TODO: Replace with data layer
var cardFilter = new Abstractions.CardSearchFilter
{
Ids = deckCards.Select(x => x.CardId).ToArray(),
};
var cards = await _cardService.GetCardsAsync(cardFilter, cancellationToken : cancellationToken);
foreach (var cc in gamePlay.GameDeck.CardCollection)
{
cc.Card = cards.Results.SingleOrDefault(x => x.Id == cc.CardId);
}
}
}
return(gamePlay);
}
public ActionResult Play(GamePlayModel game)
{
if (Request.Params["command"] != null && Request.Params["command"].Equals("Pass"))
{
return(RedirectToAction("Pass", Game));
}
RememberInputFieldValues(game);
// Human user move
ApplyUserMove(game);
var state = new GameStateModel {
Word = Game.Word
};
var analysis = Utilities.Analize(state);
if (analysis.HasWinner)
{
TakeNoteOfWinner(analysis);
// End the game
return(RedirectToAction("Results", "EndGame", Game));
}
// IA move
var newState = Utilities.NextMove(state);
ApplyComputerMove(newState, analysis);
state = new GameStateModel {
Word = Game.Word
};
analysis = Utilities.Analize(state);
if (analysis.HasWinner)
{
TakeNoteOfWinner(analysis);
// End the game
return(RedirectToAction("Results", "EndGame", Game));
}
return(View(Game));
}
async Task <GamePlayModel> IGamePlayService.GetGamePlayByIdAsync(int id, int?userId, CancellationToken cancellationToken)
{
var filter = new Abstractions.GameSearchFilter
{
GameId = id,
};
var game = (await _gameDataService.GetGamesAsync(filter, userId: userId, cancellationToken: cancellationToken)).Results.SingleOrDefault();
if (game == null)
{
throw new InvalidGameException($"Game { id } does not exist.");
}
var gamePlay = new GamePlayModel
{
Game = game,
};
await _gameDeckHelper.PopulateDeckAsync(userId, game, gamePlay, cancellationToken : cancellationToken);
return(gamePlay);
}
public ActionResult Offline(string id, int?version)
{
VariantService variants = GetService <VariantService>();
VariantVersion versionToPlay = DeterminePlayVersion(id, version, variants);
if (versionToPlay == null)
{
return(HttpNotFound("Cannot determine variant version to play"));
}
var model = new GamePlayModel(versionToPlay, GameMode.Offline);
model.Players = new PlayerModel[versionToPlay.Variant.PlayerCount];
for (int i = 0; i < model.Players.Length; i++)
{
model.Players[i] = new PlayerModel()
{
IsLocal = true
}
}
;
return(View("Play", model));
}
private void RememberInputFieldValues(GamePlayModel game)
{
Game.ShowPlayerHelp = game.ShowPlayerHelp;
Game.NewMove = game.NewMove;
}
private void CreateGame(PlayerNameModel playerName)
{
var player = new PlayerModel(playerName.Name);
Game = new GamePlayModel(player);
}
public GamePlayState(GamePlayMediator mediator) : base(mediator)
{
Mediator = mediator;
GamePlayModel = mediator._gamePlayModel;
View = mediator._view;
}
