internal static PossibleMoves ParseResponsePossibleMoves(string response) { PossibleMoves possMoves = JsonHandler.TryDeserialize <PossibleMoves>(response); //Console.WriteLine("Response possMoves: " + "\n" + JObject.Parse(response).ToString()); return(possMoves); }
// Both players use same strategies when choosing a cell to put their stones // and execute them in the following order // 1. Can I win in this move (make 5 in a row) (offensive move) // 2. Can opponent win in the next move (defensive move) // 3. Can I align 4 my stones in a row in this move (offensive) // 4. Can opponent align 4 of his stones in a row in the next move (defensive) // 5. Can I align 3 my stones in a row in this move (offensive) // 6. Can I align 2 my stones in a row in this move (offensive) // 7. I make a move on a random empty cell (neutral?) // If a player wants to make offensive move he checks possible moves with list of his own moves // If a player wants to make defensive move he checks possible moves with list of his opponent's moves // Check on each condition is performed step by step until a matching move is found // since operations are performed with relatively small list of integers // and deep nesting of loops and statements is avoided, players make moves very quickly public static void MakeMove() { if (MoveCount % 2 == 0) // Player 1 chooses next move { if ((CurrentMove = CheckForFiveInARow(Player1Moves)) == NoSuchMove && (CurrentMove = CheckForFiveInARow(Player2Moves)) == NoSuchMove && (CurrentMove = CheckForFourInARow(Player1Moves)) == NoSuchMove && (CurrentMove = CheckForFourInARow(Player2Moves)) == NoSuchMove && (CurrentMove = CheckForThreeInARow(Player1Moves)) == NoSuchMove && (CurrentMove = CheckForTwoInARow(Player1Moves)) == NoSuchMove) { CurrentMove = GenerateRandomMove(); } Board[CurrentMove / 100, CurrentMove % 100] = 'x'; Player1Moves.Add(CurrentMove); } else // Player 2 chooses next move { if ((CurrentMove = CheckForFiveInARow(Player2Moves)) == NoSuchMove && (CurrentMove = CheckForFiveInARow(Player1Moves)) == NoSuchMove && (CurrentMove = CheckForFourInARow(Player2Moves)) == NoSuchMove && (CurrentMove = CheckForFourInARow(Player1Moves)) == NoSuchMove && (CurrentMove = CheckForThreeInARow(Player2Moves)) == NoSuchMove && (CurrentMove = CheckForTwoInARow(Player2Moves)) == NoSuchMove) { CurrentMove = GenerateRandomMove(); } Board[CurrentMove / 100, CurrentMove % 100] = 'o'; Player2Moves.Add(CurrentMove); } PossibleMoves.Remove(CurrentMove); }
//Method to Gather moves List <int[]> gatherMoves() { int[] currPos = { PosX, PosY }; int a = 0; int b = 0; //2 spaces in one dimension and 1 space in another are allowed - never 2 in both or 1 in both while (b < 3) { //trip integer int trip = 0; if (a == 0) { //a=1 b=2 First a = 1; b = 2; } else if (a == 1 || b == 2) { //If this is 4th interval - set trip if (a == -1) { trip = 1; } //a=-1 b=-2 Second OR a=1 b=-2 Fourth a = -a; b = -b; } else { //a=-1 b=2 Third b = -b; } //Adds values if they are within the board parameters int Xa = PosX + a; int Yb = PosY + b; if (Xa < 8 && Xa > 0 && Yb < 8 && Yb > 0) { PossibleMoves.Add(new int[] { Xa, Yb }); } int Xb = PosX + b; int Ya = PosY + a; if (Xb < 8 && Xb > 0 && Ya < 8 && Ya > 0) { PossibleMoves.Add(new int[] { Xb, Ya }); } b = b + trip; } //Check WriteLine("Rook Moves total: " + PossibleMoves.Count); //Send Moves return(PossibleMoves); }
private static float max(Board board, int depth, float alpha, float beta) { if (depth <= 0) { return(board.getValue(isWhite)); } float maxValue = -10000000; string pieces = board.getPieces(); for (int i = 0; i < pieces.Length; i++) { if ((board.isWhitesTurn() && char.IsUpper(pieces[i])) || (!board.isWhitesTurn() && char.IsLower(pieces[i]))) { string square = letters[i % 9] + "" + (8 - i / 9); foreach (string move in PossibleMoves.search(board, square)) { string fen = board.fen; board.movePiece(square, move); maxValue = Mathf.Max(maxValue, max(board, depth - 1, alpha, beta)); alpha = Mathf.Max(alpha, maxValue); if (beta <= alpha) { return(maxValue); } board.fen = fen; } } } return(maxValue); }
private CellState[][] GetRefreshedField(PossibleMoves possibleMove, CellState[][] field, Team team) { var newField = Copy(field); foreach (var move in possibleMove.Moves) { var directionX = move.FromPoint.X < move.ToPoint.X ? 1 : -1; var directionY = move.FromPoint.Y < move.ToPoint.Y ? 1 : -1; var initialChecker = field[move.FromPoint.Y][move.FromPoint.X]; var targetX = move.FromPoint.X; var targetY = move.FromPoint.Y; do { newField[targetY][targetX] = CellState.EmptyCell; targetX = (byte)(targetX + directionX); targetY = (byte)(targetY + directionY); } while (targetY != move.ToPoint.Y && targetX != move.ToPoint.X); newField[move.ToPoint.Y][move.ToPoint.X] = initialChecker; } return(newField); }
public override void EliminateIllegalMoves() { PossibleMoves.RemoveAll(m => m.GetMovePos().ThreateningPieces.Any(p => p.PieceOwner != this.PieceOwner)); foreach (var threateningPiece in _board[this.CurrentPosition].ThreateningPieces) { var tiles = threateningPiece.XRay(this); this.PossibleMoves.RemoveAll(m => tiles.Any(t => t.Position == m.GetMovePos().Position)); } var castleMovesToRemove = new List <IMove>(); foreach (var move in CastleMoves) { if (move.Value.Any(bt => bt.ThreateningPieces.Any(p => p.PieceOwner != this.PieceOwner))) { castleMovesToRemove.Add(move.Key); } } foreach (var move in castleMovesToRemove) { CastleMoves.Remove(move); } }
public void MyHandHasThreePossibleSameSuitMeld_GiveMeThatMeldAndTheDiscardMoves() { var cards = new[] { new Card(5, Suit.Hearts), new Card(10, Suit.Clubs), new Card(12, Suit.Spades), new Card(1, Suit.Diamonds), new Card(2, Suit.Diamonds), new Card(3, Suit.Diamonds), new Card(4, Suit.Diamonds), new Card(6, Suit.Diamonds) }; GameState gs = CreateGamesStateWithPlayerOneHaving(cards, State.Player1MeldLayDiscard); var pa = new PossibleMoves(Player.One, gs); var moves = pa.Moves(); Assert.AreEqual(11, moves.Count); CollectionAssert.Contains(moves, new MeldMove(Player.One, new Meld(Suit.Diamonds, 1, 3))); CollectionAssert.Contains(moves, new MeldMove(Player.One, new Meld(Suit.Diamonds, 2, 3))); CollectionAssert.Contains(moves, new MeldMove(Player.One, new Meld(Suit.Diamonds, 1, 4))); }
public void MyHandHasTwoPossibleLayOff_GiveMeThatLayOffsAndTheDiscardMoves() { var cards = new[] { new Card(6, Suit.Clubs), new Card(10, Suit.Clubs), new Card(12, Suit.Spades) }; List <Meld> playerOneMelds = new List <Meld>(); Meld m = new Meld(Suit.Clubs, 7, 3); playerOneMelds.Add(m); GameState gs = CreateGamesStateWithPlayerOneHavingCardsAndMelds(cards, playerOneMelds, State.Player1MeldLayDiscard); var pa = new PossibleMoves(Player.One, gs); var moves = pa.Moves(); Assert.AreEqual(5, moves.Count); CollectionAssert.Contains(moves, new LayOffMove(Player.One, new Card(10, Suit.Clubs), m)); CollectionAssert.Contains(moves, new LayOffMove(Player.One, new Card(6, Suit.Clubs), m)); }
//Method to Gather moves List <int[]> gatherMoves() { int[] currPos = { PosX, PosY }; //Single dimensional movement is free (so long as space is not occupied) for (int i = 1; i <= 8 - PosX; i++) { PossibleMoves.Add(new int[] { PosX + i, PosY }); } for (int i = 1; i <= 8 - PosY; i++) { PossibleMoves.Add(new int[] { PosX, PosY + i }); } //As is negative movement for (int i = -1; i >= PosX - 8; i--) { PossibleMoves.Add(new int[] { PosX + i, PosY }); } for (int i = -1; i >= PosY - 8; i--) { PossibleMoves.Add(new int[] { PosX, PosY + i }); } //Check WriteLine("Rook Moves total: " + PossibleMoves.Count); //Send Moves return(PossibleMoves); }
public void MyHandHasOnePossibleSameRankMeld_GiveMeThatMeldAndTheDiscardMoves() { var cards = new[] { new Card(1, Suit.Clubs), new Card(1, Suit.Diamonds), new Card(3, Suit.Diamonds), new Card(1, Suit.Spades) }; GameState gs = CreateGamesStateWithPlayerOneHaving(cards, State.Player1MeldLayDiscard); var pa = new PossibleMoves(Player.One, gs); var moves = pa.Moves(); Assert.AreEqual(5, moves.Count); CollectionAssert.Contains(moves, new DiscardMove(Player.One, cards[0])); CollectionAssert.Contains(moves, new DiscardMove(Player.One, cards[1])); CollectionAssert.Contains(moves, new DiscardMove(Player.One, cards[2])); CollectionAssert.Contains(moves, new DiscardMove(Player.One, cards[3])); CollectionAssert.Contains(moves, new MeldMove(Player.One, new Meld(new[] { Suit.Clubs, Suit.Diamonds, Suit.Spades }, 1))); }
/// <summary> /// Tries to move Pawn that belongs to CurrentPlayer from Band (if any). /// </summary> /// <returns>Whether we should skip player's turn (because he has pawns on band) or not. protected bool MovePawnFromBand() { if (Band) { bool bKeepTrying = false; bool bBandHasPawns = false; bool bIsDiceAvailable = false; do { bBandHasPawns = Band.HasPawns(CurrentPlayer); bIsDiceAvailable = IsDiceAvailable(); bKeepTrying = bBandHasPawns && bIsDiceAvailable; if (bKeepTrying) { // Since we're here, it means that there are our pawns on Band // and dices still can be used for moves. // Trying to find new moves that start from Band PossibleMoves = new PossibleMoves(this, Band, Dices, true); // If we found any moves, we can do first one. if (PossibleMoves.HasAnyMoves()) { // Doing first available move, we've found PossibleMoves.DoFirstMove(); // bKeepTrying is already set to true, // so we don't need to do with it anything else // as we want to repeat whole process remove all // our pawns from Band } else { // If we reached this place, it means that the we still // have at least one pawn placed on the Band. Since we // couldn't move it (had no possible moves) we have to skip // our turn according to backgammon rules. bKeepTrying = false; } } }while (bKeepTrying); bBandHasPawns = Band.HasPawns(CurrentPlayer); bIsDiceAvailable = IsDiceAvailable(); if (bBandHasPawns || !bIsDiceAvailable) { return(true); } } else { Logger.Error(this, "Couldn't move pawns from Band because reference to it is null."); } return(false); }
public async Task ApplyMove(BoardPosition position) { try { String path = @"C:\Users\Nick\Documents\TimeWithAlphaBeta.txt"; var possMoves = mBoard.GetPossibleMoves() as IEnumerable <OthelloMove>; foreach (var move in possMoves) { if (move.Position.Equals(position)) { mBoard.ApplyMove(move); break; } } RebindState(); if (Players == NumberOfPlayers.One && !mBoard.IsFinished) { //Initialize Time DateTime start = DateTime.Now; DateTime end; var bestMove = await Task.Run(() => mGameAi.FindBestMove(mBoard)); //Record finish time end = DateTime.Now; System.IO.File.AppendAllText(path, "Move " + (++mCount) + ": " + (end - start).ToString() + Environment.NewLine); //file.WriteLine((end - start)); if (bestMove != null) { mBoard.ApplyMove(bestMove); RebindState(); } } } catch (Exception e) { Console.WriteLine(e.Message); } if (mBoard.PassCount == 2) { GameFinished?.Invoke(this, new EventArgs()); } if (PossibleMoves.Count == 1 && PossibleMoves.First().Row == -1) { CurrentPlayerMustPass?.Invoke(this, new EventArgs()); } if (PossibleMoves.Count == 0 || mBoard.IsFinished) { GameFinished?.Invoke(this, new EventArgs()); } }
public HumanPlayer(string playerName, IUserInterface userInterface) { _userInterface = userInterface; var moveKeys = string.Join(',', PossibleMoves.Select(x => x.Key)); _askForInputtext = $"{playerName} input ({moveKeys}):"; }
public IMove GetMove() { var currentMove = _nextMove; _userInterface.Display($"{_playerName}:{currentMove.Key}"); _nextMove = PossibleMoves.Single(x => x.Beats(currentMove)); return(currentMove); }
private void SetCurrentMove(PossibleMoves currentMove, int x, int y) { if (SetCurrentMove(currentMove)) { _50437079C366407D978Fe4Afd60C535F.MoveDestinationX = x; _50437079C366407D978Fe4Afd60C535F.MoveDestinationY = y; } }
public void ShowPossibleMoves(Piece piece) { foreach (var move in CalcPossibleMoves(piece)) { move.End.IsPossibileSquare = true; PossibleMoves.Add(move); } }
public override void findPossibleMoves() //can move along file or rank, as long as it is not blocked { PossibleMoves.Clear(); Coordinate pTmp = new Coordinate(Position); string color; Action <int> checkFile = (direction) => { pTmp = new Coordinate(Position); for (; pTmp.changeFile(direction);) { color = board.CheckColor(pTmp); if (color == "none") //no piece, continue normally { PossibleMoves.Add(pTmp); } else if (color != Color) //opposite piece, add its position and stop { PossibleMoves.Add(pTmp); break; } else //same color piece, don't add and stop { break; } pTmp = new Coordinate(pTmp); } pTmp = new Coordinate(Position); //new coordinate object, resets position as well }; Action <int> checkRank = (direction) => { pTmp = new Coordinate(Position); for (; pTmp.changeRank(direction);) { color = board.CheckColor(pTmp); if (color == Color) { break; } else if (color == "none") { PossibleMoves.Add(pTmp); pTmp = new Coordinate(pTmp); } else //opposite piece, add its position and stop { //bug occurs somewhere here, goes one position further than it should, or perhaps even past PossibleMoves.Add(pTmp); Console.WriteLine("Ocuured attempting position " + pTmp); break; } } pTmp = new Coordinate(Position); //new coordinate object, resets position as well }; checkFile(1); //check right checkFile(-1); //check left checkRank(1); //check up checkRank(-1); //check down }
public RandomAICardsController(IGameUIServices uiServices, FanCanvas shape, GameState gameState, Player player) : base(uiServices, shape, gameState, player, false) { AutoPlay = true; possibleMoves = new PossibleMoves(player, gameState); gameState.MoveHappened += gameState_PlayerActed; InitMoveSelectorsPriorityList(); }
private bool SetCurrentMove(PossibleMoves currentMove) { if (_50437079C366407D978Fe4Afd60C535F.CurrentMove == PossibleMoves.Idling) { _50437079C366407D978Fe4Afd60C535F.CurrentMove = currentMove; return(true); } return(false); }
public void getPossibleMoves(string playerDir, string enemyDir, string[] playerExpected, string[] enemyExpected, string rawBoard) { List <string> playerExpectedList = playerExpected.ToList(); List <string> enemyExpectedList = enemyExpected.ToList(); Board b = SnakeTestUtils.generateBoard(rawBoard, playerDir, enemyDir); PossibleMoves m = SnakeAPILogic.getPossibleMoves(b); Assert.True(SnakeTestUtils.comparePossibleMoves(m.playerMoves, playerExpectedList)); Assert.True(SnakeTestUtils.comparePossibleMoves(m.enemyMoves, enemyExpectedList)); }
public void MoveComparer_Compare_Turning_To_Walking_Should_Return_Negative(PossibleMoves turning, PossibleMoves walking) { // Arrange var moveComparer = new MoveComparer(); // Act var result = moveComparer.Compare(turning, walking); // Assert result.Should().BePositive(); }
public bool isCheck(char king) { string pieces = getPieces(); string kingPos = letters[pieces.IndexOf(king) % 9] + "" + (8 - pieces.IndexOf(king) / 9); if (PossibleMoves.isAttacked(this, kingPos)) { return(true); } return(false); }
public override void findPossibleMoves() //move forward one, direction dependent on color. can also capture diagonally { PossibleMoves.Clear(); int direction = 0; if (Color == "white") { direction = 1; } else if (Color == "black") { direction = -1; } Coordinate mPosition = new Coordinate(Position); //creates a duplicate of pawn's position mPosition.changeRank(direction); //to check one in front of the pawn string front = board.CheckColor(mPosition); if (front == "none") //has opposite colored piece or no piece { PossibleMoves.Add(mPosition); if (hasMoved == false) //can move two spaces up if it has not yet moved and there is no piece already in front of it { mPosition = new Coordinate(mPosition); mPosition.changeRank(direction); if (board.CheckColor(mPosition) == "none") { PossibleMoves.Add(mPosition); } } } mPosition = new Coordinate(Position); mPosition.changeRank(direction); if (mPosition.changeFile(1)) //checks in front and to the right of the pawn { if (isOppositeColor(mPosition)) //must have an opposite colored piece { PossibleMoves.Add(mPosition); } } mPosition = new Coordinate(Position); mPosition.changeRank(direction); if (mPosition.changeFile(-1)) //checks in front and to the left of the pawn { if (isOppositeColor(mPosition)) { PossibleMoves.Add(mPosition); } } }
public void MoveComparer_Compare_Identical_PossibleMoves_Should_Return_Zero(PossibleMoves move) { // Arrange var moveComparer = new MoveComparer(); // Act var result = moveComparer.Compare(move, move); // Assert result.Should().BeZero(); }
public GameState PickAMove(Move move) { if (!PossibleMoves.Contains(move)) { throw new System.Exception("Can't play an impossible move: " + move); } var newBoard = m_board.SetCellOwner(CurrentPlayer, move.Target); return(new GameState(CurrentPlayer.Other, newBoard)); }
public override void Sorcery(ref Cell[,] gameBoard) { Logic.DetermineUsableCells(CellTypes.Player2, CellTypes.Player1); GetPossibleMoves(gameBoard, ref PossibleMoves); Cell selected = GetRandomCell(); if (selected != null) { gameBoard[selected.Y, selected.X].Type = CellTypes.Selected; } PossibleMoves.Clear(); }
public ProceduralPathArrow() { prevArrow = null; nextArrow = null; PossibleMoves = new PossibleMoves { Up = true, Down = true, Left = true, Right = true }; }
public Warrior(MapCoordinates position, int team, string name) { Hp = 20; AttackRange = 1; AttackStrength = 5; CollisionStrength = 5; AttackRange = 1; ActualPosition = position; this.Team = team; MaxSteps = 2; UiPlannedMoves = new PossibleMoves[MaxSteps]; Name = name; }
private void CheckAndSetPossibleMoves(MoveDirection direction, int stepsX, int stepsY, bool inBetweenSteps, int iterationX = 1, int iterationY = 1) { Board board = Scene.GetObject <Board>(); if (board == null) { throw new NullReferenceException("No board found"); } if (!inBetweenSteps) { iterationX = stepsX; iterationY = stepsY; } int side = ControllingUnit == ControllingUnit.Human ? -1 : 1; int left = Convert.ToInt32(((direction & MoveDirection.Left) == MoveDirection.Left)) * iterationX; int right = Convert.ToInt32(((direction & MoveDirection.Right) == MoveDirection.Right)) * iterationX * -1; int up = Convert.ToInt32(((direction & MoveDirection.Up) == MoveDirection.Up)) * iterationY * side; int down = Convert.ToInt32(((direction & MoveDirection.Down) == MoveDirection.Down)) * iterationY * side * -1; int x = (CurrentNode.Xindex + left + right); int y = (CurrentNode.Yindex + up + down); bool markForAdd = false; if (board.Nodes.IsInBounds(x, y)) { Node newNode = board.Nodes[x, y]; if (newNode.IsFree) { markForAdd = true; } else { if (newNode.Piece.ControllingUnit != ControllingUnit) { markForAdd = true; } } } if (markForAdd) { PossibleMoves.Add(board.Nodes[x, y]); if ((iterationX < stepsX || stepsX == 0) && (iterationY < stepsY || stepsY == 0)) { CheckAndSetPossibleMoves(direction, stepsX, stepsY, inBetweenSteps, ++iterationX, ++iterationY); } } }
public void RecursiveMovesGet(Board board, int position, int direction) { int pieceColor = 0; if (Color == "white") { pieceColor = 1; } else { pieceColor = -1; } //first handle out of bounds if (!(board.OutOfBoundsArea.ToList().IndexOf(position + direction * pieceColor * -1) != -1)) { //now that we know not out of bounds let's try each way the piece moves over and over until we are either out of bounds or blocked or a capture is possible //Are we blocked? if (board.Pieces[position + direction * pieceColor * -1] == null) { //okay we're not blocked if (isLegalMove((direction * pieceColor * -1) + position, board, pieceColor)) { PossibleMoves.Add((direction * pieceColor * -1) + position); RecursiveMovesGet(board, -1 * pieceColor * (direction) + position, (direction)); } else { return; } } else if (board.Pieces[position + direction * pieceColor * -1] != null) { //okay we're blocked, but is the block an enemy piece? if (board.Pieces[position + direction * pieceColor * -1].Color != Color && board.Pieces[position + direction * pieceColor * -1].Color != null) { if (isLegalMove((direction * pieceColor * -1) + position, board, pieceColor)) { PossibleMoves.Add((direction * pieceColor * -1) + position); } } return; } } else { return; } //return new List<int>(); }
static List <MoveScore> CalcMoveFreeDegs(SnakeBoard board) { PossibleMoves possMoves = game.GetPossibleMoves(board); List <MoveScore> moves = new List <MoveScore>(3); foreach (string direction in possMoves.playerMoves) { moves.Add(new MoveScore() { dir = direction, score = DegreesOfFreedom(board, direction) }); } return(moves); }