public void FanRankFileAmbiguationPositiveTest()
{
// Tests both knights moving to same square for Rank ambiguity
const string fen = "8/6k1/8/8/8/8/1K1N1N2/8 w - - 0 1";
const EMoveNotation notation = EMoveNotation.Fan;
var movingPiece = new Piece(EPieces.WhiteKnight);
var fromOneSquare = new Square(ESquare.d2);
var fromTwoSquare = new Square(ESquare.f2);
var toSquare = new Square(ESquare.e4);
var uniChar = movingPiece.GetUnicodeChar();
var toSquareString = toSquare.GetSquareString();
var expectedPrimary = $"{uniChar}{fromOneSquare.FileChar()}{toSquareString}";
var expectedSecondary = $"{uniChar}{fromTwoSquare.FileChar()}{toSquareString}";
var pos = new Position();
var g = GameFactory.Create(pos);
g.NewGame(fen);
var w1 = new Move(movingPiece, fromOneSquare, toSquare);
var w2 = new Move(movingPiece, fromTwoSquare, toSquare);
var actualPrimary = w1.ToNotation(g.Position, notation);
var actualSecondary = w2.ToNotation(g.Position, notation);
Assert.Equal(expectedPrimary, actualPrimary);
Assert.Equal(expectedSecondary, actualSecondary);
}
static void Main(string[] args)
{
const int numberOfGames = 100;
for (var i = 0; i < numberOfGames; i++)
{
var gameRules = GameRules.Create();
var game = GameFactory.Create(gameRules.NumberOfPlayers, gameRules.NumberOfRounds, gameRules.NumberOfPlayers);
PlayGame(game);
var gameResult = new GameResult
(
gameId: game.Id,
numberOfPlayers: gameRules.NumberOfPlayers,
wipLimit: gameRules.WipLimit,
numberOfDoneTickets: game.GetResult()
);
gameResultRepository.Save(gameResult);
}
var resultList = gameResultRepository.Get();
csvService.Save(resultList);
}
public static IPerft Create(Action <string> boardPrintCallback = null, IEnumerable <IPerftPosition> positions = null)
{
positions ??= Enumerable.Empty <IPerftPosition>();
var perft = new Perft(GameFactory.Create(), positions);
return(perft);
}
public async Task StartConsoleGame(ConsoleGameOptions options)
{
var logger = Log.Logger.ForContext <ConsoleGameMain>();
if (options.Player1Index < 0 || options.Player1Index >= PlayerList.Players.Length)
{
logger.Error("Player 1 index is invalid. Must be between 1 and {NumberOfPlayers}", PlayerList.Players.Length - 1);
}
if (options.Player2Index < 0 || options.Player2Index >= PlayerList.Players.Length)
{
logger.Error("Player 2 index is invalid. Must be between 1 and {NumberOfPlayers}", PlayerList.Players.Length - 1);
}
var gf = new GameFactory(new RandomBoardFiller());
var game = gf.Create(options.Player1Index, options.Player2Index);
var p1 = PlayerList.Players[options.Player1Index].Create();
var p2 = PlayerList.Players[options.Player2Index].Create();
while (game.GetWinner(BattleshipBoard.Ships) == Winner.NoWinner)
{
await p1.GetShot(game.GameId, PlayerList.Players[options.Player2Index].Name, game.ShootingBoards[0],
location => Task.FromResult(game.Shoot(1, location)));
await p2.GetShot(game.GameId, PlayerList.Players[options.Player1Index].Name, game.ShootingBoards[1],
location => Task.FromResult(game.Shoot(2, location)));
}
Console.WriteLine(game.GetWinner(BattleshipBoard.Ships) switch
{
Winner.Draw => "We have a draw!",
Winner.Player1 => "Player 1 is the winner",
Winner.Player2 => "Player 2 is the winner",
_ => "No winner? this should never happen"
});
public void FoolsCheckMateTest()
{
// generate moves
var moves = new List <Move>(4)
{
Move.Create(Squares.f2, Squares.f3),
Move.Create(Squares.e7, Squares.e5),
Move.Create(Squares.g2, Squares.g4),
Move.Create(Squares.d8, Squares.h4)
};
// construct game and start a new game
var board = new Board();
var pieceValue = new PieceValue();
var position = new Position(board, pieceValue);
var game = GameFactory.Create(position);
game.NewGame();
var state = new State();
// make the moves necessary to create a mate
foreach (var move in moves)
{
position.MakeMove(move, state);
}
// verify in check is actually true
Assert.True(position.InCheck);
var resultingMoves = position.GenerateMoves();
// verify that no legal moves actually exists.
Assert.True(!resultingMoves.Any());
}
public void MoveListToStringTest()
{
var pos = new Position();
var game = GameFactory.Create(pos);
game.NewGame();
var result = new StringBuilder(1024 * 16);
var expected = new StringBuilder(1024 * 16);
var moves = new List <Move>(256);
var rngeezuz = new Random(DateTime.Now.Millisecond);
// generate 256 random moves
for (var i = 0; i < 256; i++)
{
Square rndSquareFrom = (ESquare)rngeezuz.Next((int)ESquare.a1, (int)ESquare.h8);
Square rndSquareTo = (ESquare)rngeezuz.Next((int)ESquare.a1, (int)ESquare.h8);
moves.Add(new Move(rndSquareFrom, rndSquareTo));
expected.Append(' ');
expected.Append(rndSquareFrom.ToString());
expected.Append(rndSquareTo.ToString());
}
// generate a bitch string for them all.
foreach (var move in moves)
{
result.Append(' ');
game.MoveToString(move, result);
}
Assert.Equal(expected.ToString(), result.ToString());
}
public void FoolsCheckMateTest()
{
// generate moves
var moves = new List <Move>(4)
{
new Move(EPieces.WhitePawn, ESquare.f2, ESquare.f3),
new Move(EPieces.BlackPawn, ESquare.e7, ESquare.e5, EMoveType.Doublepush, EPieces.NoPiece),
new Move(EPieces.WhitePawn, ESquare.g2, ESquare.g4, EMoveType.Doublepush, EPieces.NoPiece),
new Move(EPieces.BlackQueen, ESquare.d8, ESquare.h4)
};
// construct game and start a new game
var position = new Position();
var game = GameFactory.Create(position);
game.NewGame();
// make the moves necessary to create a mate
foreach (var move in moves)
{
Assert.True(game.MakeMove(move));
}
// verify in check is actually true
Assert.True(game.Position.InCheck);
var moveList = game.Position.GenerateMoves();
// verify that no legal moves actually exists.
Assert.Empty(moveList);
}
private void StartButton_OnClick(object sender, RoutedEventArgs e)
{
var provider = new FuncInitialStateProvider(() =>
{
var state = new int[Constants.FieldSize, Constants.FieldSize];
for (var i = 0; i < Constants.FieldSize; ++i)
{
for (var j = 0; j < Constants.FieldSize; ++j)
{
if (string.IsNullOrWhiteSpace(_textBoxes[i, j].Text))
{
state[i, j] = 0;
}
else
{
state[i, j] = int.Parse(_textBoxes[i, j].Text);
}
}
}
return(new InitialFieldState(state));
});
var game = GameFactory.Create(provider);
game.Step += GameOnStep;
game.GameCompleted += GameOnGameCompleted;
Task.Run(() => game.Run());
}
public void Create_CorrectNumber_IsNotNull()
{
IGameFactory gameFactory = new GameFactory(new RngService());
var game = gameFactory.Create(null);
Assert.IsNotNull(game.CorrectNumber);
}
public void Create_TurnsLeft_ShouldStartAt3()
{
IGameFactory gameFactory = new GameFactory(new RngService());
var game = gameFactory.Create(null);
Assert.AreEqual(3, game.TurnsLeft);
}
public void Create_GameState_ShouldBeOnGoing()
{
IGameFactory gameFactory = new GameFactory(new RngService());
var game = gameFactory.Create(null);
Assert.AreEqual(GameState.OnGoing, game.GameState);
}
public void CreateGame_WithValidArguments_SuccessfullyCreatesNewGame()
{
var quiz = new Quiz("testquiz", new Question("question", new Choice("choice", 10)));
var game = GameFactory.Create(quiz);
Assert.That(game, Is.Not.Null);
Assert.That(game.Quiz, Is.EqualTo(quiz));
}
public void ShouldNotRemainInCurrentLocationWhenCurrentLocationIsAMazeAndRandomNumberDoesExceedProbability()
{
var game = GameFactory.Create("forest", () => 0.9);
var originalLocation = game.Location;
game.Move("n");
Assert.NotEqual(originalLocation, game.Location);
}
public void SetFenTest()
{
var expected = new FenError(0, 0);
var position = new Position();
var game = GameFactory.Create(position);
var actual = game.NewGame();
Assert.Equal(expected, actual);
}
public void SetFenTest()
{
var board = new Board();
var pieceValue = new PieceValue();
var pos = new Position(board, pieceValue);
var game = GameFactory.Create(pos);
game.NewGame();
}
public void Create_Players(int players)
{
IGameFactory gameFactory = new GameFactory(new RngService());
var game = gameFactory.Create(new GameSetting()
{
Players = players
});
Assert.AreEqual(players, game.Players);
}
private static void Main()
{
var initialStateProvider = GetInitialStateProvider();
var game = GameFactory.Create(initialStateProvider);
game.Step += GameOnStep;
game.GameCompleted += GameOnGameCompleted;
game.Run();
}
public XyzGame getGame(Room room)
{
Guid id;
string type;
GameConfig config;
List <Guid> users = new List <Guid>();
string lastState = "";
string query = "SELECT id, game_type, game_config FROM game WHERE room_id = @room_id AND deleted_at is null ORDER BY created_at DESC LIMIT 1";
using (var cmd = new NpgsqlCommand(query, _connection, _transaction))
{
cmd.Parameters.AddWithValue("room_id", room.ID);
NpgsqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
id = reader.GetGuid(0);
type = reader.GetString(1);
config = reader.GetFieldValue <GameConfig>(2);
}
else
{
return(null);
}
reader.Close();
}
query = "SELECT user_id FROM room_player WHERE room_id = @room_id AND deleted_at is null";
using (var cmd = new NpgsqlCommand(query, _connection, _transaction))
{
cmd.Parameters.AddWithValue("room_id", room.ID);
NpgsqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Guid userID = reader.GetGuid(0);
users.Add(userID);
}
reader.Close();
}
query = "SELECT state FROM game_move WHERE game_id = @game_id ORDER BY created_at DESC limit 1";
using (var cmd = new NpgsqlCommand(query, _connection, _transaction))
{
cmd.Parameters.AddWithValue("game_id", id);
NpgsqlDataReader reader = cmd.ExecuteReader();
if (reader.Read())
{
lastState = reader.GetString(0);
}
reader.Close();
}
return(GameFactory.Create(type, users, config, lastState, new PostgresUserRepository(_connection, _transaction)));
}
public TicTacToeTest()
{
amir = User.NewUser("Amir");
budi = User.NewUser("Budi");
List <User> users = new List <User>();
users.Add(amir);
users.Add(budi);
game = GameFactory.Create("tic-tac-toe", users);
}
public PoolGroup Build()
{
PoolFactory poolFactory = new PoolFactory();
TeamFactory teamFactory = new TeamFactory();
GameFactory gameFactory = new GameFactory();
_poolGroup.Pools = poolFactory.Create(_numOfPools);
_poolGroup.Pools = teamFactory.Create(_poolGroup.Pools, _numOfTeams, _seedMethod);
_poolGroup.Pools = gameFactory.Create(_poolGroup.Pools, _numOfRounds);
return(_poolGroup);
}
public void Create_ParametersArePassedOnToCreatedGame(int fieldWidth, int fieldHeight, int mineCount)
{
_gameFactory.FieldWidth = fieldWidth;
_gameFactory.FieldHeight = fieldHeight;
_gameFactory.MineCount = mineCount;
var game = _gameFactory.Create();
Assert.AreEqual(game.FieldWidth, _gameFactory.FieldWidth);
Assert.AreEqual(game.FieldHeight, _gameFactory.FieldHeight);
Assert.AreEqual(game.MineCount, _gameFactory.MineCount);
}
public static void Main(string[] args)
{
graphicsLoop = GraphicsLoop.CreateWithNewWindow(1280, 720, InitFlags.DisableVerticalSync | InitFlags.EnableDebugStats);
var gameFactory = new GameFactory();
game = gameFactory.Create();
player = game.EntityService.CreateEntity();
game.EntityService.AddEntityComponent(player, new MovementComponent {
WorldPosition = new DoubleVector3(-450, -450, 0),
BaseRadius = 30,
BaseSpeed = 100,
IsPathfindingEnabled = true,
PathingDestination = new DoubleVector3(-450, -450, 0)
});
baddie = game.EntityService.CreateEntity();
game.EntityService.AddEntityComponent(baddie, new MovementComponent {
WorldPosition = new DoubleVector3(0, 0, 0),
BaseRadius = 30,
BaseSpeed = 100,
IsPathfindingEnabled = true,
PathingDestination = new DoubleVector3(0, 0, 0)
});
var r = new Random(0);
for (var i = 0; i < 10; i++)
{
var rock = game.EntityService.CreateEntity();
game.EntityService.AddEntityComponent(rock, new MovementComponent {
WorldPosition = new DoubleVector3(r.Next(-500, 500), r.Next(-500, 500), 0),
BaseRadius = 10,
BaseSpeed = 100,
IsPathfindingEnabled = false
});
rocks.Add(rock);
}
var scene = new Scene();
debugCanvas = new Canvas3DDebugMultiCanvasHost.Canvas3DDebugCanvas(graphicsLoop.GraphicsFacade, graphicsLoop.Presets, scene);
for (var frame = 0; graphicsLoop.IsRunning(out var renderer, out var input); frame++)
{
scene.Clear();
Step(graphicsLoop, game, input, scene);
Render(scene, renderer);
}
}
public void ValidateCastleling()
{
// position only has pawns, rooks and kings
const string fen = "r3k2r/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1";
const PositionValidationTypes validationType = PositionValidationTypes.Castleling;
var game = GameFactory.Create();
game.NewGame(fen);
var validator = game.Pos.Validate(validationType);
Assert.True(validator.IsOk);
Assert.True(validator.ErrorMsg.IsNullOrEmpty());
}
public void TopLeftCornerNoNeighbors_Can_Move_East()
{
GameFactory gameFactory = new GameFactory();
Game game = gameFactory.Create(MAX_X, MAX_Y);
Console.WriteLine($"starting position {game.PastMoves.Last().X}/{game.PastMoves.Last().Y}");
Assert.IsTrue(CanMoveEast(game));
Tick(game);
var lastMove = game.PastMoves.Last();
Console.WriteLine($"Next position {lastMove.X}/{lastMove.Y}");
Assert.AreEqual(1, lastMove.X);
Assert.AreEqual(0, lastMove.Y);
}
public void MoveFromUciBasicTest()
{
const string uciMove = "a2a3";
var expected = new Rudz.Chess.Types.Move(Squares.a2, Squares.a3);
var uci = new Uci();
var game = GameFactory.Create();
game.NewGame();
var actual = uci.MoveFromUci(game.Pos, uciMove);
actual.Should().Be(expected);
}
public void Guess_ShouldReturnClosestGuest()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
var result = guessService.Guess(GuessModel.Create(game, 1, 9));
Assert.AreEqual(2, result.PlayerId);
}
public void BlockedThree()
{
const string fen = "5k2/8/8/p1p1pPp1/P1P1P1P1/8/8/4K3 w - - 0 1";
const bool expected = true;
var g = GameFactory.Create();
g.NewGame(fen);
var pos = g.Pos;
var actual = BlockageFactory.IsBlocked(pos);
Assert.Equal(expected, actual);
}
public void BlockedTwo()
{
const string fen = "4k3/5p2/1p1p1P1p/1P1P1P1P/3P4/8/4K3/8 w - - 0 1";
const bool expected = true;
var g = GameFactory.Create();
g.NewGame(fen);
var pos = g.Pos;
var actual = BlockageFactory.IsBlocked(pos);
Assert.Equal(expected, actual);
}
public void OpenThree()
{
const string fen = "8/2p5/kp2p1p1/p1p1P1P1/P1P2P2/1P4K1/8/8 w - - 0 1";
const bool expected = false;
var g = GameFactory.Create();
g.NewGame(fen);
var pos = g.Pos;
var actual = BlockageFactory.IsBlocked(pos);
Assert.Equal(expected, actual);
}
public void Guess_CorrectGuess_GameStateEqualsCompleted()
{
var rngServiceMock = new Mock <IRngService>();
rngServiceMock.Setup(x => x.Generate(It.IsAny <int>(), It.IsAny <int>())).Returns(10);
IGameFactory gameFactory = new GameFactory(rngServiceMock.Object);
var game = gameFactory.Create(null);
IGuessService guessService = new GuessService();
guessService.Guess(GuessModel.Create(game, 1, 10));
Assert.AreEqual(GameState.Completed, game.GameState);
}
