public DraughtsBoard()
{
InitializeComponent();
foreach (var width in Enumerable.Range(0, BoardWidth))
{
foreach (var height in Enumerable.Range(0, BoardHeight))
{
int convertedY = (BoardHeight - 1) - height;
var cell = new GameSquare(width, convertedY);
if (width % 2 == 0 && height % 2 == 0)
{
cell.SquareColour = LightColourBrush;
}
else if (width % 2 != 0 && height % 2 != 0)
{
cell.SquareColour = LightColourBrush;
}
else
{
cell.SquareColour = DarkColourBrush;
}
cell.MouseLeftButtonDown += PieceLeftButtonDown;
Grid.SetColumn(cell, width);
Grid.SetRow(cell, height);
Board.Children.Add(cell);
squareList.Add(cell);
}
}
SetupFromGameState(GameStateFactory.StandardStartGameState());
}
public void TestFact()
{
RaceFactory rf = RaceFactory.getRaceFactory();
Assert.IsNotNull(rf);
Race jordy = rf.getRace("human");
Race willy = rf.getRace("orc");
PlayerFactory pf = PlayerFactory.getPlayerFactory();
Player p1 = pf.createPlayer(jordy, "francois", null);
Assert.AreEqual(p1.name, "francois");
Player p2 = pf.createPlayer(willy, "aurelien", null);
Assert.AreEqual(p2.name, "aurelien");
Assert.AreEqual(p1.race.name, jordy.name);
Assert.AreEqual(p2.race.name, willy.name);
History h = HistoryFactory.getHistoryFactory().createHistory();
Assert.IsNotNull(h);
GameStateFactory gsf = GameStateFactory.getStateFactory();
GameState gs = gsf.createGameState();
h.set(gs);
h.save();
Assert.AreEqual(h.pop(), gs);
}
static void Main(string[] args)
{
var random = new Random();
Console.WriteLine("Sample run");
Console.WriteLine();
var state = GameStateFactory.GenerateDefaultState();
while (!state.IsFinished)
{
Console.WriteLine($"ActivePlayer: {state.ActivePlayer.Name}, Health: {state.ActivePlayer.Health}, Mana: {state.ActivePlayer.Mana}");
Console.WriteLine($"OpponentPlayer: {state.OpponentPlayer.Name}, Health: {state.OpponentPlayer.Health}, Mana: {state.OpponentPlayer.Mana}");
Console.WriteLine("Draw, use and next");
var activePlayer = state.ActivePlayer;
var hand = activePlayer.Hand;
hand.Draw();
Console.WriteLine($"Remaining deck count: {hand.Deck.Count}");
Console.WriteLine(@$ "Hand: {string.Join(", ", hand.Select(c =>
{
if (c is DamageCard damageCard)
{
return $"[{ damageCard.ManaCost }, { damageCard.Damage }] ";
}
return $"[{ c.ManaCost }] ";
}))}");
public IActionResult CreateGame()
{
var playerId = Guid.NewGuid().ToString();
var humanPlayer = new HumanPlayer();
IGamePlayer white;
IGamePlayer black;
if (random.Next() % 2 == 0)
{
white = humanPlayer;
black = Program.AiOpponent;
humanPlayer.PieceColour = Service.PieceColour.White;
}
else
{
white = Program.AiOpponent;
black = humanPlayer;
humanPlayer.PieceColour = Service.PieceColour.Black;
}
var match = new GameMatch(GameStateFactory.StandardStartGameState(), white, black);
humanPlayer.GameMatch = match;
humanPlayers.TryAdd(playerId, humanPlayer);
return(Ok(playerId));
}
public void SinglePieceKingWhiteGameMove()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.King;
int x = 4;
int y = 4;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
var moves = gameState.CalculateAvailableMoves();
var piece1 = moves.Single(m => m.EndGamePiece.Xcoord == x - 1 && m.EndGamePiece.Ycoord == y + 1).EndGamePiece;
var piece2 = moves.Single(m => m.EndGamePiece.Xcoord == x + 1 && m.EndGamePiece.Ycoord == y - 1).EndGamePiece;
var piece3 = moves.Single(m => m.EndGamePiece.Xcoord == x + 1 && m.EndGamePiece.Ycoord == y + 1).EndGamePiece;
var piece4 = moves.Single(m => m.EndGamePiece.Xcoord == x - 1 && m.EndGamePiece.Ycoord == y - 1).EndGamePiece;
Assert.AreEqual(4, moves.Count);
Assert.AreEqual(x - 1, piece1.Xcoord);
Assert.AreEqual(y + 1, piece1.Ycoord);
Assert.AreEqual(x + 1, piece2.Xcoord);
Assert.AreEqual(y - 1, piece2.Ycoord);
Assert.AreEqual(x + 1, piece3.Xcoord);
Assert.AreEqual(y + 1, piece3.Ycoord);
Assert.AreEqual(x - 1, piece4.Xcoord);
Assert.AreEqual(y - 1, piece4.Ycoord);
}
public void FlipTest_L()
{
var gameState = GameStateFactory.GetGameState_GivenStartingPieceType(0, Shapes.L);
var engine = new Engine(0, gameState);
flipPiece(engine);
}
public void ClearBoardTest2()
{
var colors = new List <Colors>();
for (int i = 0; i < GameConstants.WellCount; i++)
{
if (i < 10)
{
colors.Add(Colors.BLUE);
}
else if (i >= 30 && i < 40)
{
colors.Add(Colors.BLUE);
}
else
{
colors.Add(Colors.Empty);
}
}
var fList = ListModule.OfSeq(colors);
var gameState = GameStateFactory.GetGameState_GivenBoard(new System.Random(), fList);
var engine = new Engine(0, gameState);
engine.tick();
var gs = engine.ViewGameState();
var clearRows = Board.getClearRows(gs.Board);
Assert.IsTrue(!clearRows.Any());
}
GameStateBehaviour CreateState(GameState state)
{
GameStateBehaviour behaviour = GameStateFactory.Create(state);
behaviour.transform.parent = transform;
return(behaviour);
}
private void ReturnStatesToPool()
{
if (playerGameStates.Any())
{
GameStateFactory <TicTacToeGameStateImpl> .ReturnGameStates(playerGameStates);
playerGameStates.Clear();
}
}
//----------------------------------------------------------------------------
protected override void OnStateInit()
{
AddSubState(GameStateFactory.CreateState(GameStateType.GST_Loading, this));
AddSubState(GameStateFactory.CreateState(GameStateType.GST_Login, this));
AddSubState(GameStateFactory.CreateState(GameStateType.GST_Update, this));
AddSubState(GameStateFactory.CreateState(GameStateType.GST_Logo, this));
AddSubState(GameStateFactory.CreateState(GameStateType.GST_Lobby, this));
base.OnStateInit();
SetSubState((int)GameStateType.GST_Logo, null);
}
public TicTacToeGameImpl()
{
game = new TicTacToeGame();
currentGameState = GameStateFactory <TicTacToeGameStateImpl> .GetNewGameState();
currentPlayerIndex = 1;
opponent = new RandomPlayer();
//opponent = new MinimaxPlayer(new Heuristic[] { HeuristicFactory.GetHeuristicByName("ticTacToeHeuristic", 1, null) }, 6);
playerGameStates = new List <TicTacToeGameStateImpl>();
statistics = new TicTacToeGameStatistics();
}
private void OpenScoringWindow(SessionConfigParams configParams)
{
Window w = new ScoringWindow();
ScoringWindowViewModel vm = ContainerHelper.Container.Resolve <ScoringWindowViewModel>();
GameState gs = GameStateFactory.GetNewGameState(configParams);
vm.SetCurrentGameState(gs);
w.DataContext = vm;
w.Show();
NavToStartSession();
}
public static GameState.GameStateClass GetGameState(HttpContext httpContext)
{
var gameState = httpContext.Session.Get <GameState.GameStateClass>(SessionKeyGameState);
if (gameState == null)
{
gameState = GameStateFactory.GenerateNewGameState();
httpContext.Session.Set <GameState.GameStateClass>(SessionKeyGameState, gameState);
}
return(gameState);
}
void CreateGameStates()
{
GameStateFactory gsf = new GameStateFactory();
// Create only a SINGLE STATE per state type
foreach (GAME_STATE_TYPE gs in Enum.GetValues(typeof(GAME_STATE_TYPE)))
{
IState <CKGameManager> state = gsf.CreateGameState(gs);
//stateGraph.AddNode(ref state);
gameStateMap.Add(gs, state);
}
}
public void FriendlyMinionsAwayTest()
{
var move = new GameMove(
new GamePiece(PieceColour.White, PieceRank.Minion, 0, 2),
new GamePiece(PieceColour.White, PieceRank.Minion, 1, 3),
new List <GamePiece>(),
GameStateFactory.StandardStartGameState()
);
var metrics = move.CalculateGameMoveMetrics(PieceColour.White);
Assert.AreEqual(0, metrics.FriendlyMinionsAway);
}
public void OpponentMovesAvailableTest()
{
var move = new GameMove(
new GamePiece(PieceColour.White, PieceRank.Minion, 0, 2),
new GamePiece(PieceColour.White, PieceRank.Minion, 1, 3),
new List <GamePiece>(),
GameStateFactory.StandardStartGameState()
);
var metrics = move.CalculateGameMoveMetrics(PieceColour.White);
Assert.AreEqual(7, metrics.OpponentMovesAvailable);
}
public void SinglePieceBlackBlockedByBottomEdgeGameMove()
{
var pieceColour = PieceColour.Black;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
var moves = gameState.CalculateAvailableMoves();
Assert.AreEqual(0, moves.Count);
}
public override void Initialize(System.Action <ICoreService> onComplete)
{
onComplete(this);
_gameStateFactory = CreateFactory();
_graph = new GameStateDefinitionGraph(_gameStateDefinitions);
//var path = _graph.FindPathToGameState(_graph.root.gameStateDefinition, _gameStateDefinitions.Last());
//foreach (var item in path)
//{
// Debug.Log(item);
//}
}
public void SinglePieceGameState()
{
var pieceColour = PieceColour.Black;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
Assert.AreEqual(1, gameState.GamePieceList.Count);
Assert.AreEqual(pieceColour, gameState.GamePieceList.First().PieceColour);
Assert.AreEqual(pieceRank, gameState.GamePieceList.First().PieceRank);
Assert.AreEqual(x, gameState.GamePieceList.First().Xcoord);
Assert.AreEqual(y, gameState.GamePieceList.First().Ycoord);
}
public static (int[] ids, string[] errors) GetWinners(string input)
{
var gameStateBuildResult = GameStateFactory.Build(input);
if (gameStateBuildResult.Success)
{
var bestToWorstHands = gameStateBuildResult.GameState.PlayerHands.OrderBy(x => x).ToArray();
var winningHands = bestToWorstHands.Where(x => x.Equals(bestToWorstHands.First()));
var winningIds = winningHands.Select(x => x.PlayerId).OrderBy(x => x).ToArray();
return(winningIds, Array.Empty <string>());
}
else
{
return(Array.Empty <int>(), gameStateBuildResult.Errors);
}
}
public MainWindow()
{
InitializeComponent();
aiLoader = ((App)App.Current).AiLoader;
Board.WhitePlayer = SetupService.FetchWhitePlayer();
Board.BlackPlayer = SetupService.FetchBlackPlayer();
gameMatch = new GameMatch(GameStateFactory.StandardStartGameState(), Board.WhitePlayer, Board.BlackPlayer);
Info.UpdateFromGameMatch(gameMatch);
dispatcherTimer.Tick += DispatcherTimer_Tick;
dispatcherTimer.Interval = new TimeSpan(0, 0, 1);
dispatcherTimer.Start();
}
public void SinglePieceWhiteKingOnLastRow()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.Minion;
int x = 0;
int y = 6;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
var moves = gameState.CalculateAvailableMoves().Where(m => m.StartGamePiece.PieceColour == PieceColour.White).ToList();
var afterState = moves.First().PerformMove();
Assert.AreEqual(PieceRank.King, moves[0].EndGamePiece.PieceRank);
Assert.AreEqual(PieceRank.King, afterState.GamePieceList[0].PieceRank);
}
static void Main()
{
var state = GameStateFactory.CreateGameState();
StateEventDispatcher stateEventDispatcher = new StateEventDispatcher();
stateEventDispatcher.Register(new StateEventHandler());
GameStartDispatcher gameStartDispatcher = new GameStartDispatcher();
gameStartDispatcher.Register(new GameStartHandler(stateEventDispatcher));
GameWonDispatcher gameWonDispatcher = new GameWonDispatcher();
gameWonDispatcher.Register(new GameWonHandler());
GameOverDispatcher gameOverDispatcher = new GameOverDispatcher();
gameOverDispatcher.Register(new GameOverHandler());
KeyEventDispatcher keyEventDispatcher = new KeyEventDispatcher();
keyEventDispatcher.Register(new KeyEventHandler(stateEventDispatcher,
gameWonDispatcher,
gameOverDispatcher));
bool stop = false;
gameStartDispatcher.NotifyAll(state);
while (!stop)
{
var info = Console.ReadKey(true);
if (info.Key == ConsoleKey.Escape)
{
stop = true;
}
else
{
keyEventDispatcher.NotifyAll(new GameKeyEventData {
KeyInfo = info, GameState = state
});
}
}
}
private static int PlayGames(IGamePlayer contestant, IGamePlayer opponent, int gameCount)
{
int wins = 0;
foreach (var randomGameI in Enumerable.Range(0, gameCount).Where(g => !shouldClose))
{
var gameMatch = new GameMatch(
GameStateFactory.StandardStartGameState(),
contestant,
opponent);
var outcome = gameMatch.CompleteMatch();
if (outcome == GameMatchOutcome.WhiteWin)
{
wins++;
}
}
return(wins);
}
public void OpponentPiecesTakenTest()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var startGamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var endGamePiece = new GamePiece(pieceColour, pieceRank, x + 2, y + 2);
var blockingGamePiece = new GamePiece(PieceColour.Black, pieceRank, x + 1, y + 1);
var gameState = GameStateFactory.SeveralPieceGameState(startGamePiece, blockingGamePiece);
var move = new GameMove(startGamePiece, endGamePiece, new[] { blockingGamePiece }, gameState);
var metrics = move.CalculateGameMoveMetrics(PieceColour.White);
Assert.AreEqual(1, metrics.OpponentPiecesTaken);
}
public void SinglePieceBlackLeftEdgeGameMove()
{
var pieceColour = PieceColour.Black;
var pieceRank = PieceRank.Minion;
int x = 7;
int y = 7;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
var moves = gameState.CalculateAvailableMoves();
var piece1 = moves[0].EndGamePiece;
Assert.AreEqual(1, moves.Count);
Assert.AreEqual(x - 1, piece1.Xcoord);
Assert.AreEqual(y - 1, piece1.Ycoord);
}
public void SinglePieceWhitePerformMove()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var gameState = GameStateFactory.SinglePieceGameState(gamePiece);
var moves = gameState.CalculateAvailableMoves();
var afterState = moves.First().PerformMove();
Assert.AreEqual(1, afterState.GamePieceList.Count);
Assert.AreEqual(x - 1, afterState.GamePieceList[0].Xcoord);
Assert.AreEqual(y + 1, afterState.GamePieceList[0].Ycoord);
}
public void SinglePieceWhiteBlockedGameMove()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var blockingGamePiece = new GamePiece(pieceColour, pieceRank, x + 1, y + 1);
var gameState = GameStateFactory.SeveralPieceGameState(gamePiece, blockingGamePiece);
var moves = gameState.CalculateAvailableMoves();
var piece1 = moves[0].EndGamePiece;
Assert.AreEqual(3, moves.Count);
Assert.AreEqual(x - 1, piece1.Xcoord);
Assert.AreEqual(y + 1, piece1.Ycoord);
}
public void SinglePieceWhiteTakePerformMove()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.Minion;
int x = 2;
int y = 0;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var blockingGamePiece = new GamePiece(PieceColour.Black, pieceRank, x + 1, y + 1);
var gameState = GameStateFactory.SeveralPieceGameState(gamePiece, blockingGamePiece);
var moves = gameState.CalculateAvailableMoves().Where(m => m.StartGamePiece.PieceColour == PieceColour.White).ToList();
var afterState = moves.First().PerformMove();
Assert.AreEqual(1, afterState.GamePieceList.Count);
Assert.AreEqual(x + 2, afterState.GamePieceList[0].Xcoord);
Assert.AreEqual(y + 2, afterState.GamePieceList[0].Ycoord);
}
public void SinglePieceWhiteKingOnLastRowAfterDoubleJumpCheckMoveObjects()
{
var pieceColour = PieceColour.White;
var pieceRank = PieceRank.King;
int x = 3;
int y = 7;
var gamePiece = new GamePiece(pieceColour, pieceRank, x, y);
var blockingGamePiece1 = new GamePiece(PieceColour.Black, pieceRank, 4, 6);
var blockingGamePiece2 = new GamePiece(PieceColour.Black, pieceRank, 6, 6);
var gameState = GameStateFactory.SeveralPieceGameState(gamePiece, blockingGamePiece1, blockingGamePiece2);
var moves = gameState.CalculateAvailableMoves().Where(m => m.StartGamePiece.PieceColour == PieceColour.White).ToList();
var expectedPiece = new GamePiece(PieceColour.White, PieceRank.King, 7, 7);
Assert.AreEqual(2, moves.First().TakenGamePieces.Count);
Assert.AreEqual(gamePiece, moves.First().StartGamePiece);
Assert.AreEqual(expectedPiece, moves.First().EndGamePiece);
}
