public void IsNotEndedNormally()
{
var gameState = new GameStateBuilder().Build();
var gameManager = new GameManager(gameState);
gameManager.IsEnded.Should().BeFalse();
}
public void ScoreReturnsZeroInitially()
{
var gameState = new GameStateBuilder().Build();
var gameManager = new GameManager(gameState);
gameManager.Score.Should().Be(0);
}
public void PlayAppliesTacticsWithGameState(int turnsUntilEnd)
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = BuildFinishingPlayedCards(turnsUntilEnd),
}.Build(),
Players = BuildSomePlayers(3),
}.Build();
var gameManager = new GameManager(gameState);
var tactics = new Mock <ITactics>(MockBehavior.Strict);
tactics
.Setup(t => t.CanApply(gameState))
.Returns(true);
tactics
.Setup(t => t.Apply(gameState));
var tacticsList = new List <ITactics> {
tactics.Object
};
gameManager.Play(tacticsList);
foreach (var turnIndex in Enumerable.Range(0, turnsUntilEnd))
{
tactics.Verify(t => t.Apply(gameState));
}
}
public void PlayEndsGameAfterOneRoundWhenDeckBecomesEmpty(int playerCount)
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
Deck = BuildEmptyDeck(),
}.Build(),
Players = BuildSomePlayers(playerCount),
}.Build();
var gameManager = new GameManager(gameState);
var tactics = new Mock <ITactics>(MockBehavior.Strict);
tactics
.Setup(t => t.CanApply(gameState))
.Returns(true);
tactics
.Setup(t => t.Apply(gameState));
var tacticsList = new List <ITactics>
{
tactics.Object,
};
gameManager.Play(tacticsList);
tactics.Verify(t => t.Apply(gameState), Times.Exactly(playerCount));
}
public void Perft()
{
GameState gameState = GameStateBuilder.Build();
string txt = File.ReadAllText(@"data/TestPositions.txt");
string[] positions = txt.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
long totalAmount = 0;
Stopwatch watch = new Stopwatch();
watch.Start();
foreach (string pos in positions)
{
string[] parts = pos.Split('|');
gameState.LoadPosition(parts[0]);
int amount = GenerateMoves(gameState, int.Parse(parts[1]));
totalAmount += amount;
int expectedAmount = int.Parse(parts[2]);
Assert.AreEqual(expectedAmount, amount, $"Failed on position {parts[0]}, depth {parts[1]}");
}
watch.Stop();
//nodes per second. worse than the actual value, because it only counts leaf nodes,
//and it doesn't count variations ending in mate/stalemate before the requested depth
double nps = totalAmount / ((double)watch.ElapsedMilliseconds / 1000);
Console.WriteLine($"{nps} NPS");
}
public void PlayAppliesFirstApplicableTactics()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = BuildFinishingPlayedCards(1),
}.Build(),
Players = BuildSomePlayers(),
}.Build();
var gameManager = new GameManager(gameState);
var nonApplicableTactics = new Mock <ITactics>(MockBehavior.Strict);
nonApplicableTactics
.Setup(t => t.CanApply(gameState))
.Returns(false);
var applicableTactics = new Mock <ITactics>(MockBehavior.Strict);
applicableTactics
.Setup(t => t.CanApply(gameState))
.Returns(true);
applicableTactics
.Setup(t => t.Apply(gameState));
var tacticsList = new List <ITactics>
{
nonApplicableTactics.Object,
applicableTactics.Object,
};
gameManager.Play(tacticsList);
applicableTactics.Verify(t => t.Apply(gameState), Times.Once);
}
public virtual void TestInit()
{
gameState = GameStateBuilder.Build();
evConfig = new EvaluationConfig();
evConfigPO = new PrivateObject(evConfig);
evaluator = new PositionEvaluatorWithStats(gameState, evConfig);
}
public void SpecificPosTest()
{
GameState gameState = GameStateBuilder.Build();
string fen = "rnbqkbnr/p1pppppp/8/Pp6/8/8/1PPPPPPP/RNBQKBNR b KQkq - 0 2";
gameState.LoadPosition(fen);
List <Move> legalMoves = gameState.GetLegalMoves();
}
private GameState GenerateGameState(string client1, string client2)
{
GameStateBuilder gameStateBuilder = new GameStateBuilder();
var gameStateDirector = new GameStateDirector(gameStateBuilder, client1, client2);
GameState gameState = gameStateDirector.GetResult();
return(gameState);
}
public void PlayWithoutTacticsThrowsException()
{
var gameState = new GameStateBuilder().Build();
var gameManager = new GameManager(gameState);
gameManager
.Invoking(gm => gm.Play(Enumerable.Empty <ITactics>()))
.Should()
.Throw <InvalidOperationException>();
}
public void BuilderPattern()
{
var defaultGameState = new GameState();
var builder = new GameStateBuilder();
builder.AddPlayer();
builder.AddGameMap();
var gameState = builder.GetGameState();
Assert.That(defaultGameState, Does.Not.EqualTo(gameState));
Assert.That(defaultGameState.Map, Is.Null);
Assert.That(gameState.Map, Is.Not.Null);
}
public static async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "GET", Route = null)] HttpRequest req,
[CosmosDB(
databaseName: "blazor-four-in-a-row",
collectionName: "game-actions",
ConnectionStringSetting = "CosmosDBConnection",
CreateIfNotExists = true)]
DocumentClient client, ILogger log)
{
Uri documentCollectionUri = UriFactory.CreateDocumentCollectionUri(databaseId: "blazor-four-in-a-row", collectionId: "game-actions");
var gameStateBuilder = new GameStateBuilder();
var currentGame = client.CreateDocumentQuery <GameAction>(documentCollectionUri)
.Where(g => g.GameActionType == GameActionTypes.CreateGame)
.OrderByDescending(g => g.CreatedOn)
.AsEnumerable()
.FirstOrDefault();
if (null != currentGame)
{
var gameActionsProvider = new GameActionsProvider();
var gameActions = gameActionsProvider.GetGameActions(client, currentGame.GameId);
if (!gameActions.Any(g =>
g.GameActionType == GameActionTypes.CompleteGame ||
g.GameActionType == GameActionTypes.AbandonGame))
{
//Check if game is active
if (gameActions.Any(g => g.CreatedOn > DateTime.Now.AddMinutes(-1 * currentGame.GameSettings.GameAbandonmentMinutes)))
{
return(new OkObjectResult(gameStateBuilder.BuildGameState(gameActions)));
}
await client.CreateDocumentAsync(DocumentCollectionUri, new GameAction()
{
GameActionType = GameActionTypes.AbandonGame,
GameId = currentGame.GameId,
GameActionStatus = GameActionStatuses.Valid,
});
}
}
var gameAction = await CreateNewGameAction(client);
return(new OkObjectResult(gameStateBuilder.BuildGameState(new List <GameAction>()
{
gameAction
})));
}
public void ScoreReturnsMaxForAllFives()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = EnumUtils.Values <Suite>().ToDictionary(
suite => suite,
suite => BuildFullPile(suite)),
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.Score.Should().Be(25);
}
public void ScoreReturnsTopCardsValueForOnePile()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = EnumUtils.Values <Suite>().ToDictionary(
suite => suite,
suite => suite == Suite.White ? BuildPile(suite, Number.Three) : BuildEmptyPile()),
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.Score.Should().Be(3);
}
public void IsNotEndedWhenAllButOneFivesArePlayed()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = EnumUtils.Values <Suite>()
.ToDictionary(
suite => suite,
suite => BuildPile(suite, suite == Suite.White ? Number.Four : Number.Five)),
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.IsEnded.Should().BeFalse();
}
public void IsEndedWhenAllFivesArePlayed()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = EnumUtils.Values <Suite>()
.ToDictionary(
suite => suite,
suite => BuildFullPile(suite)),
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.IsEnded.Should().BeTrue();
}
public void PlayRunsUntilGameIsEnded(int turnsUntilEnd)
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = BuildFinishingPlayedCards(turnsUntilEnd),
}.Build(),
Players = BuildSomePlayers(),
}.Build();
var gameManager = new GameManager(gameState);
var tactics = BuildSomeTactics();
gameManager.Play(tactics);
gameManager.IsEnded.Should().BeTrue();
}
public void PlayCyclesCurrentPlayer(int playerCount, int turnsUntilEnd, int finishingPlayer)
{
var players = BuildSomePlayers(playerCount);
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = BuildFinishingPlayedCards(turnsUntilEnd),
}.Build(),
Players = players,
}.Build();
var gameManager = new GameManager(gameState);
var tactics = BuildSomeTactics();
gameManager.Play(tactics);
gameState.CurrentPlayer.Should().Be(players[finishingPlayer]);
}
public void ScoreReturnsSumOfTopCardValuesForMultiplePiles()
{
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
PlayedCards = new Dictionary <Suite, IPile>
{
[Suite.White] = BuildEmptyPile(),
[Suite.Yellow] = BuildPile(Suite.Yellow, Number.One),
[Suite.Green] = BuildPile(Suite.Green, Number.Two),
[Suite.Blue] = BuildPile(Suite.Blue, Number.Three),
[Suite.Red] = BuildFullPile(Suite.Red),
},
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.Score.Should().Be(0 + 1 + 2 + 3 + 5);
}
private void startGame()
{
// these are different for clients
var commandDispatcher = new ServerCommandDispatcher(new DefaultCommandExecutor());
var requestDispatcher = new ServerRequestDispatcher(commandDispatcher);
var dispatcher = new ServerDispatcher(commandDispatcher);
var meta = new GameMeta(logger, dispatcher);
var gameState = GameStateBuilder.Generate(meta, new DefaultTilemapGenerator(logger));
var gameInstance = new GameInstance(
gameState,
new GameCamera(inputManager, meta, gameState.Level.Tilemap.Radius),
requestDispatcher
);
Parent.AddScreenLayerOnTopOf(this, new GameUI(Parent, Geometries, gameInstance, inputManager));
gameStarted = true;
Destroy();
}
public static async Task <IActionResult> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "POST", Route = null)] HttpRequestMessage req,
[CosmosDB(
databaseName: "blazor-four-in-a-row",
collectionName: "game-actions",
ConnectionStringSetting = "CosmosDBConnection",
CreateIfNotExists = true)]
DocumentClient client,
ILogger log)
{
var gamePlayer = await req.Content.ReadAsAsync <(string GameId, User User)> ();
var gameStateBuilder = new GameStateBuilder();
var gameActionsProvider = new GameActionsProvider();
var gameActions = gameActionsProvider.GetGameActions(client, gamePlayer.GameId);
var gameState = gameStateBuilder.BuildGameState(gameActions);
var gameStateManager = new GameStateManager();
if (gameStateManager.UserHasJoinedGame(gameState, gamePlayer.User))
{
return(new ConflictResult());
}
var teamToJoin = DetermineWhichTeamToJoin(gameState);
teamToJoin.Users.Add(gamePlayer.User);
await client.CreateDocumentAsync(DocumentCollectionUri, new GameAction()
{
GameActionStatus = GameActionStatuses.Valid,
GameActionType = GameActionTypes.JoinGame,
GameId = gamePlayer.GameId,
User = gamePlayer.User,
Team = teamToJoin
});
return(new OkObjectResult(teamToJoin));
}
public void IsEndedWhenFuseTokensAreFull(int tokenMaxAmount, int tokenAmount, bool isEnded)
{
var fuseTokens = new Mock <ITokens>(MockBehavior.Strict);
fuseTokens
.Setup(t => t.MaxAmount)
.Returns(tokenMaxAmount);
fuseTokens
.Setup(t => t.Amount)
.Returns(tokenAmount);
var gameState = new GameStateBuilder
{
Table = new TableBuilder
{
FuseTokens = fuseTokens.Object,
}.Build(),
}.Build();
var gameManager = new GameManager(gameState);
gameManager.IsEnded.Should().Be(isEnded);
}
public void TestInit()
{
gameState = GameStateBuilder.Build();
zobristHashUtils = new PrivateObject(gameState.ZobristHashUtils);
}
public static async Task RunAsync([CosmosDBTrigger(
databaseName: "blazor-four-in-a-row",
collectionName: "game-actions",
ConnectionStringSetting = "CosmosDBConnection",
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true,
FeedPollDelay = 200)] IReadOnlyList <Document> input,
[CosmosDB(
databaseName: "blazor-four-in-a-row",
collectionName: "game-actions",
ConnectionStringSetting = "CosmosDBConnection",
CreateIfNotExists = true)]
DocumentClient client,
[SignalR(HubName = "gameUpdates")] IAsyncCollector <SignalRMessage> signalRMessages,
ILogger log)
{
if (input != null && input.Count > 0)
{
log.LogInformation("GameActions modified " + input.Count);
var gameStateBuilder = new GameStateBuilder();
var gameActionsProvider = new GameActionsProvider();
var gameStateManager = new GameStateManager();
var updatedGameIds = new List <string>();
foreach (var document in input)
{
GameAction gameAction = (dynamic)document;
if (!updatedGameIds.Contains(gameAction.GameId))
{
updatedGameIds.Add(gameAction.GameId);
}
if (gameAction.GameActionStatus != GameActionStatuses.AwaitingValidation)
{
log.LogInformation($"Game Action {gameAction.Id} does not require validation. GameActionType: {gameAction.GameActionType}");
continue;
}
log.LogInformation($"Validating Game Action {gameAction.Id}.");
var gameActions = gameActionsProvider.GetGameActions(client, gameAction.GameId);
var gameState = gameStateBuilder.BuildGameState(gameActions);
gameAction.GameActionStatus = gameStateManager.ValidateGameColumnAction(gameState, gameAction.GameCell.Column);
ValidateGameStartLock(gameState, gameAction);
ValidateNextActionLock(gameState, gameAction);
log.LogInformation(
$"Game Action {gameAction.Id}'s status is {Enum.GetName(typeof(GameActionStatuses), gameAction.GameActionStatus)}.");
if (gameAction.GameActionStatus == GameActionStatuses.Valid)
{
foreach (var row in gameState.GameCells)
{
var gameCell = row[gameAction.GameCell.Column];
if (null == gameCell.Team)
{
gameAction.GameCell.Row = gameCell.Row;
gameCell.Team = gameAction.Team;
gameCell.User = gameAction.User;
break;
}
}
}
await client.UpsertDocumentAsync(DocumentCollectionUri, gameAction);
if (null == gameState.GameResult)
{
var gameResult = gameStateManager.CheckForGameCompletion(gameState);
if (null != gameResult)
{
var gameBuilder = new GameBuilder();
var newGameAction = gameBuilder.BuildNewGame(client);
await client.CreateDocumentAsync(DocumentCollectionUri, new GameAction()
{
GameId = gameAction.GameId,
GameActionStatus = GameActionStatuses.Valid,
GameActionType = GameActionTypes.CompleteGame,
Team = gameResult.WinningTeam,
NextGameId = newGameAction.GameId
});
await client.CreateDocumentAsync(DocumentCollectionUri, newGameAction);
}
}
}
foreach (var gameId in updatedGameIds)
{
if (string.IsNullOrEmpty(gameId))
{
continue;
}
var gameActions = gameActionsProvider.GetGameActions(client, gameId);
await signalRMessages.AddAsync(
new SignalRMessage
{
Target = "game-state-update",
Arguments = new object[] { gameStateBuilder.BuildGameState(gameActions) }
});
}
//TODO: Task.WhenAll these awaits?
}
}
