public PieceMove GetNextMove(Vector3 StartLoc, BoardPiece cat, BoardSpace moveSpace, Board.Direction direction) { //movesIndex += 1; PieceMove move = Moves[movesIndex]; if (move.GetMyType() == "Walk" && Board.GetBoardDistance(move.moveSpace.GetSpaceByDirection(direction).GetCenterPoint(), cat.transform.position) > 0.1f) { moveSpace = moveSpace.GetSpaceByDirection(direction); Debug.Log("flipped " + moveSpace.name + " " + move.moveSpace.name); Board.Direction flippedDir = Board.FlipDirection(direction); cat.pieceDirection = flippedDir; GetMoveFlipped(flippedDir, moveSpace); return(move); } else if (movesIndex + 1 >= Moves.Count) { isActive = false; return(null); } else { movesIndex += 1; initializeMove(StartLoc, cat, moveSpace, direction, movesIndex); return(GetMove()); } }
private static State MaxSearch(State state, int depth, int side, int alpha, int beta) { if (depth <= 0) { state.EvaluateValue(); return(state); } var newAlpha = alpha; var newBeta = beta; var moveList = state.GenerateAllMoves(side); var it = moveList.GetEnumerator(); var maxState = new State(); maxState.SetValue(newAlpha); while (it.MoveNext()) { var newState = PieceMove.MovePiece(state, it.Current); var newValue = MinSearch(newState, depth - 1, ChangeSide(side), newAlpha, newBeta).GetValue(); if (newValue > newAlpha) { maxState = newState; newAlpha = newValue; maxState.SetValue(newValue); } if (newBeta <= newAlpha) { return(maxState); } } return(maxState); }
private void OnTurnStarted() { Invoke((MethodInvoker)delegate { Text = $"{chessboard.CurrentPlayerTurn}'s turn"; }); if (MatchMaker.PlaySoundOnMove) { soundPlayer.Play(); } UpdateBoard(); if (chessboard.Moves.Count == 0) { return; } PieceMove recentMove = chessboard.Moves.Peek().Moves[0]; recentMoveFrom = recentMove.Source; recentMoveTo = recentMove.Destination; ResetAllTableStyling(); }
private static State MinSearch(State state, int depth, int side) { if (depth <= 0) { state.EvaluateValue(); return(state); } var moveList = state.GenerateAllMoves(side); var it = moveList.GetEnumerator(); State minState = null; var value = int.MaxValue; while (it.MoveNext()) { var newState = PieceMove.MovePiece(state, it.Current); var newValue = MaxSearch(newState, depth - 1, ChangeSide(side)).GetValue(); if (newValue < value) { minState = newState; value = newValue; minState.SetValue(newValue); } } return(minState); }
/// <summary> /// If forced a roll /// </summary> /// <param name="node"></param> private IEnumerator ForcedWayAction(TileNode node) { PieceMove requestedMove = new PieceMove(firstSelection, new MoveSet.Move(firstSelection, false, node), moves); if (requestedMove.Execute()) { moveHistory.Add(requestedMove); GameObject.Find("MoveHistoryPanel").GetComponent <MoveHistoryHandler>().addMove(moveHistory[moveHistory.Count - 1]); // unhighlight the way moves foreach (TileNode moveTile in moves) { moveTile.unhighlight(); } if (requestedMove.Result == PieceMove.ResultType.Win) { SceneManager.LoadScene("EndMenu"); } // Wait for overstack yield return(new WaitUntil(() => OverstackUI.done)); state = State.Playing; firstSelection = null; NextTurn(); } }
public override PieceMove MoveModifier(PieceMove move) { if (isProtectedPieceSafeAfterMove(move)) { return move; } return null; }
private void PublishPieceMovedEvent(string gameId, PieceMove move) { serviceBus.Publish(new PieceMovedEvent { GameId = gameId, PieceMove = move.AsDto() }); }
public override PieceMove MoveModifier(PieceMove move) { if (Board.IsInRange(Position + move.Shift)) { return(move); } return(null); }
protected void AcceptMove(PieceMove move) { if (move.IsPartOf(drawer.board)) { //drawer.SwitchBoard (move.GetNextBoard ()); handler.ApplyBoard(move.GetNextBoard()); } }
void Start() { pieceMove = GetComponent <PieceMove>(); boxes.Add(this); m_Renderer = GetComponent <SpriteRenderer>(); originalColor = m_Renderer.color; gameController = GameObject.Find("GameController"); gameControl = gameController.GetComponent <GameControl>(); }
private void SaveAndPublishLastMove(string gameId, MovesLog movesLog) { var lastMove = movesLog.LastMove; var pieceMove = new PieceMove(lastMove.SequenceNumber, lastMove.Move.From, lastMove.Move.To); SaveMove(gameId, pieceMove); PublishPieceMovedEvent(gameId, pieceMove); }
void Start() { pieceMove = GetComponent <PieceMove>(); animators = GetComponentsInChildren <Animator>(); foreach (Animator animator in animators) { animator.speed = 1 / fixingTime; } }
protected void SetUp() { GameObject go = new GameObject(); BoardLocation bl = new BoardLocation(go.transform, 1, 1); BoardLocation bl2 = new BoardLocation(go.transform, 2, 2); pM1 = new PieceMove(bl); pM2 = new PieceMove(bl, bl2); }
protected override bool CanMove(PieceMove move) { if (!base.CanMove(move)) return false; if (IsCaptureMove(move.Target)) return this.Board[move.Target] != null || this.IsEnPassantCapture(move.Target); return this.Board[move.Target] == null; }
public void TestGenerateAllMoveAtMidState() { var fromX = 1; var fromY = 7; var toX = 4; var toY = 7; var midState = PieceMove.MovePiece(State, fromX, fromY, toX, toY); var newMoveList = Cannon.GenerateAllMove(midState, toX, toY); Assert.AreEqual(8, newMoveList.Count); }
public void TestPieceListPrint() { var stringBefore = State.ToString(State.GetPieceList()); int fromX = 1; int fromY = 9; int toX = 2; int toY = 7; State midState = PieceMove.MovePiece(State, fromX, fromY, toX, toY); String stringAfter = midState.ToString(midState.GetPieceList()); Assert.AreNotEqual(stringBefore, stringAfter); }
//Moves piece to location. If it is an enemy it destroys the piece. If it moves to and edge of board, it kings the piece. public void movePiece(string location) { PieceMove move = getMove(location); //Converts string to PieceMove if (move != null) //ugly, but probably avoiding bugs //Kills enemy piece { List <PieceMove> moveAgain = new List <PieceMove>(); if (move.pieceTaken != null) { Destroy(move.pieceTaken.piece, 0.25f); move.pieceTaken.piece = null; moveAgain = getLegalMoves(move.moveTo).Where(x => x.pieceTaken != null).ToList(); //returns a list of moves that involve taking another piece } //Kings piece if (move.kingPiece) { selectedPiece.piece.GetComponent <PieceHandler>().king = true; selectedPiece.piece.transform.GetChild(0).gameObject.active = true; } //Moves the piece //selectedPiece.piece.GetComponent<PieceHandler>().target = move.moveTo.boardLocation.transform.position; //selectedPiece.piece.GetComponent<PieceHandler>().currentLerpTime = 0f; //selectedPiece.piece.transform = move.moveTo.boardLocation.transform.position; Vector3 target = move.moveTo.boardLocation.transform.position; //Debug.Log (target); GameObject _checker = selectedPiece.piece; //PieceHandler _ph = selectedPiece.piece.GetComponent<PieceHandler> (); //_ph.PrintMe (); _checker.GetComponent <PieceHandler>().Move(target); _checker.transform.position = target; CmdChangeTargetPosition(_checker, target); //Reassigns reference move.moveTo.piece = selectedPiece.piece; selectedPiece.piece = null; // toggleCurrentPlayer(); } //resets the board values. resetBoardDisplay(); selectedPiece = null; currentLegalMoves.Clear(); }
public void TestLegalMoveSuicide() { var fromX = 1; var fromY = 7; var toX = 1; var toY = 9; var midState = PieceMove.MovePiece(State, fromX, fromY, toX, toY); var toXFinal = 1; var toYFinal = 9; Assert.AreEqual(false, Cannon.IsLegalMove(midState, toX, toY, toXFinal, toYFinal)); }
public override bool ValidateNewMove(PieceMove move) { if (!InnerPieceDecorator.ValidateNewMove(move)) { return(false); } if (move.MoveTypes.Contains(MoveType.Move) && move.Shift == LongMove.Shift) { return(CanLongMove()); } return(true); }
public PieceMove RecursiveRate(List <PieceMove> moves, ChessBoard initial, PlayerColor color, int level) { var enemy = color == PlayerColor.white ? PlayerColor.black : PlayerColor.white; var score = ScorePlayer(initial, enemy); PieceMove best = moves[0]; float mscore = float.MinValue; foreach (var move in moves) { var nboard = move.GetNextBoard(); move.score += (score - ScorePlayer(nboard, enemy)) * 3; move.score += nboard.GetAllPlayerMoves(color, false).Count * 0.5f; move.score += nboard.GetAllPlayerMoves(enemy, false).Count * 0.25f; if (nboard.IsChecked(enemy)) { move.score += 0.5f; var nextMoves = nboard.GetAllPlayerMoves(enemy, true); if (nextMoves.Count < 1) { move.score = float.MaxValue; best = move; mscore = move.score; return(move); } //Debug.Log (move.score + " : " + move.id + " level : " + level); //Debug.Log(); } if (level > 0) { var nmoves = nboard.GetAllPlayerMoves(enemy, true); if (nmoves.Count < 1) { // a.k.a enemy has no moves but he is not checked. move.score = float.MinValue; continue; } move.score -= RecursiveRate(nmoves, nboard, enemy, level - 1).score; } if (move.score >= mscore) { best = move; mscore = move.score; } } return(best); }
public void HighlightLabel(ChessMoveClick moveClick, PieceMove move) { label.Click -= eventHandler; eventHandler = (sender, e) => moveClick(move); label.Click += eventHandler; if (label.Image == null) { label.BackColor = highlightColor; } else { label.BackColor = targetColor; } }
private bool IsPathClear(Position destination, PieceMove move) { for ( Position checkedPosition = Position + move.Shift; checkedPosition != destination; checkedPosition += move.Shift) { if (Board.GetPiece(checkedPosition) != null) { return(false); } } return(true); }
public void TestCloningCap() { var fromX = 1; var fromY = 7; var toX = 1; var toY = 0; var before = State.ToString(); PieceMove.MovePiece(State, fromX, fromY, toX, toY); var after = State.ToString(); Assert.AreEqual(before, after); }
public void TestPieceListSimple() { int fromX = 1; int fromY = 9; int toX = 2; int toY = 7; var pieceListBefore = State.GetPieceList(); var midState = PieceMove.MovePiece(State, fromX, fromY, toX, toY); var pieceListAfter = midState.GetPieceList(); var piece1 = pieceListBefore.Get(Utility.GetOneDimention(fromX, fromY)); var piece2 = pieceListAfter.Get(Utility.GetOneDimention(fromX, fromY)); Console.WriteLine(midState); Assert.AreNotEqual(piece1.GetNumber(), piece2.GetNumber()); }
public void TestMovePieceSimple() { var states = new State(); states = PieceMove.MovePiece(states, 7, 7, 4, 7);//user Debug.WriteLine(states.ToString()); //states = PieceMove.MovePiece(states, 1, 2, 1, 9);//com states = (AlphaBetaSearch.DoSearch(states, 1)); Debug.WriteLine(states.ToString()); states = PieceMove.MovePiece(states, 0, 9, 1, 9);//user Debug.WriteLine(states.ToString()); Assert.AreEqual(30, states.GetPieceList().Count); var piece = PieceFactory.GetPiece(23, 1, 9); Assert.AreEqual(typeof(Rook), piece.GetType()); }
public override GameAction act() { //if ( Input.GetMouseButtonDown(0) ) if ( Input.touches.Length == 1 ) { Touch touchedFinger = Input.touches[0]; // Get input of touches if ( touchedFinger.phase == TouchPhase.Ended ) //if ( true ) { m_Ray = Camera.main.ScreenPointToRay( touchedFinger.position ); //m_Ray = Camera.main.ScreenPointToRay ( Input.mousePosition ); if (Physics.Raycast(m_Ray.origin, m_Ray.direction, out m_RayCastHit, Mathf.Infinity)) { GameAction incoming = null; switch (m_RayCastHit.transform.tag) { case "Attacker": Piece touchedAttacker = m_RayCastHit.collider.gameObject.GetComponent<Piece>(); incoming = new PieceSelection(touchedAttacker.index, true); break; case "Defender": case "King": Piece touchedDefender = m_RayCastHit.collider.gameObject.GetComponent<Piece>(); incoming = new PieceSelection(touchedDefender.index, false); break; case "Square": if (Game.turnState == TurnState.PIECE_SELECTED) { Square touchedSquare = m_RayCastHit.collider.gameObject.GetComponent<Square>(); incoming = new PieceMove(touchedSquare.coord); }else Game.audio.playError (); break; } return incoming; }else Game.audio.playError (); } } return null; }
public void AddKingMoves(List <PieceMove> validMoves) { if (type == PieceType.King) { List <PieceMove> moves = node.board.GetAllPlayerMoves(OppositeTeam(), false); // if the king didnt move a.k.a he is at the start pos, and he isn't attacked. // we can do the rook king thing, so this is the logic to check if its valid move. if (!moved && !PieceMove.CheckOverlap(moves, node)) { var board = node.board; var rook = board.nodes[node.x - 3, node.y]; if (rook.piece != null && !rook.piece.moved && rook.piece.type == PieceType.Rook) { var rookEndCord = board.nodes[node.x - 1, node.y]; var kingEndCord = board.nodes[node.x - 2, node.y]; if (rookEndCord.piece == null && kingEndCord.piece == null) { if (!PieceMove.CheckOverlap(moves, rookEndCord) && !PieceMove.CheckOverlap(moves, kingEndCord)) { validMoves.Add(new ComplexMove(node, kingEndCord, rook, rookEndCord, true)); } } } rook = board.nodes[node.x + 4, node.y]; if (rook.piece != null && !rook.piece.moved && rook.piece.type == PieceType.Rook) { var rookEndCord = board.nodes[node.x + 1, node.y]; var kingEndCord = board.nodes[node.x + 2, node.y]; var lastPos = board.nodes[node.x + 3, node.y]; if (rookEndCord.piece == null && kingEndCord.piece == null && lastPos.piece == null) { if (!PieceMove.CheckOverlap(moves, rookEndCord) && !PieceMove.CheckOverlap(moves, kingEndCord) && !PieceMove.CheckOverlap(moves, lastPos)) { validMoves.Add(new ComplexMove(node, kingEndCord, rook, rookEndCord, true)); } } } } } }
public override bool ValidateNewMove(PieceMove move) { if (!InnerPieceDecorator.ValidateNewMove(move)) { return(false); } var pieceAtDestination = Board.GetPiece(Position + move.Shift); var containsMove = move.MoveTypes.Contains(MoveType.Kill); if (pieceAtDestination != null && pieceAtDestination.Color != Color && !containsMove) { return(false); } if ((pieceAtDestination == null || pieceAtDestination.Color == Color) && containsMove) { return(false); } return(true); }
public void TestPieceList() { Setup(); var fromX = 1; var fromY = 9; var toX = 2; var toY = 7; var midState = PieceMove.MovePiece(State, fromX, fromY, toX, toY); var pieceList = midState.GetPieceList(); var sizeBefore = pieceList.Count; var toXkillTeamMate = 3; var toYkillTeamMate = 9; midState = PieceMove.MovePiece(midState, toX, toY, toXkillTeamMate, toYkillTeamMate); pieceList = midState.GetPieceList(); var sizeAfter = pieceList.Count; Assert.AreEqual(sizeBefore, sizeAfter + 1); }
//public void InitializeMoving() //{ //} public bool MovePiece()//bool isStarting, bool forward, Board.Direction direction, MoveSet moveSet) { //if (isStarting) InitializeMoves(direction, moveSet); PieceMove move = moveSet.GetMove(); Vector3 moveVector = move.ForwardVector(); float friction = currentBoardLoc.GetFriction(transform.position.x, transform.position.z); moveVector = friction * Speed * Time.deltaTime * moveVector; float remainingDistance = Vector3.Distance(transform.position, move.GetEndLoc()); if (remainingDistance > moveVector.magnitude) { transform.position += moveVector; } else { //PieceMove nextMove = moveSet.GetNextMove(transform.position, this, currentBoardLoc, pieceDirection); if (moveSet.HasNextMove()) { BoardSpace nextSpace = currentBoardLoc.GetSpaceByDirection(pieceDirection); pieceDirection = move.Direction; PieceMove nextMove = moveSet.GetNextMove(transform.position, this, currentBoardLoc, pieceDirection); //currentBoardLoc = nextSpace; move = nextMove; float deltaTime = Time.deltaTime * moveVector.magnitude / remainingDistance; moveVector = move.ForwardVector(); friction = 1; //currentBoardLoc.GetFriction() moveVector = friction * Speed * deltaTime * moveVector; } else { transform.position = move.GetEndLoc(); PieceStat = PieceStats.idle; return(false); } } return(true); }
private Move.MoveStatus HandleUserMove(State state, int fromX, int fromY, int toX, int toY) { var move = Move.MoveStatus.NoError; var fromK = Utility.GetOneDimention(fromX, fromY); var piece = CurrentState.GetPieceList().Get(fromK); if (piece.GetSide() == State.EmptySpace) { move = Move.MoveStatus.WrongPiece; } else if (piece.GetSide() != State.UserTurn) { move = Move.MoveStatus.WrongPiece; } else if (!PieceMove.MovePieceLegal(state, fromX, fromY, toX, toY)) { move = Move.MoveStatus.Illegal; } PieceMove.MovePiece(state, fromX, fromY, toX, toY); return(move); }
public override PieceMove MoveModifier(PieceMove move) { var pieceAtDestination = Board.GetPiece(Position + move.Shift); if (pieceAtDestination == null || pieceAtDestination.Color == Color || move.MoveTypes.Contains(MoveType.Kill)) { if (pieceAtDestination != null && pieceAtDestination.Color != Color) { move.MoveTypes = new MoveType[] { MoveType.Kill }; } else { move.MoveTypes = move.MoveTypes.Where(m => m != MoveType.Kill).ToArray(); if (move.MoveTypes.Length == 0) { return(null); } } return(move); } return(null); }
private void connection_PieceMoved(PieceMove move) { this.Board.Move(move.Source, move.Target, move.PawnPromotedTo); }
protected override bool CanMove(PieceMove move) { return base.CanMove(move) && !this.Board.IsUnderAttack(move.Target, move.Piece.Player.Opponent()); }
public override GameAction act() { // Do RayCast m_Ray = new Ray (m_Camera.position, m_Camera.forward); //m_Ray = Camera.main.ScreenPointToRay ( Input.mousePosition ); Selectable newSelectable = null; if ( Physics.Raycast ( m_Ray.origin, m_Ray.direction, out m_RayCastHit, Mathf.Infinity ) ) newSelectable = m_RayCastHit.collider.gameObject.GetComponent<Selectable>(); // Check change of pointed object if ( (selectablePointed && ! selectablePointed.Equals ( newSelectable )) || (! selectablePointed && newSelectable ) ) { if ( validHit ) selectablePointed.rollOver ( false ); // Reset previous Selectable (if any) validHit = false; if ( newSelectable ) { if ( newSelectable.tag != "Square" ) validHit = true; else if ( Game.turnState == TurnState.PIECE_SELECTED ) { Square sqrPointed = (Square)newSelectable; if ( sqrPointed.state == SquareState.VALID || sqrPointed.state == SquareState.VALID_TRACED ) validHit = true; } if ( validHit ) newSelectable.rollOver ( true ); // Call RollOver according to "Hit" and "TurnState" } selectablePointed = newSelectable; // Assign selectablePointed } if ( Input.touches.Length == 1 ) // Check cardboard's button input (for v2.0) //if ( true ) { Touch touchedFinger = Input.touches[0]; // Get input of touches GameAction incoming = null; if ( touchedFinger.phase == TouchPhase.Ended ) //if ( Input.GetMouseButtonDown(0) ) { if ( validHit ) { switch ( selectablePointed.tag ) { case "Attacker": incoming = new PieceSelection ( ((Piece)selectablePointed).index, true ); break; case "Defender": case "King": incoming = new PieceSelection ( ((Piece)selectablePointed).index, false ); break; case "Square": incoming = new PieceMove ( ((Square)selectablePointed).coord ); break; } selectablePointed.rollOver (false); selectablePointed = null; validHit = false; return incoming; // Create and return GameAction according to "Hit" & "TurnState" } else Game.audio.playError (); } } return null; }
private void board_PieceMoved(PieceMove move) { this.Enqueue(new MoveAction(move.Source, move.Target, move.PawnPromotedTo)); }
/// <summary> /// Adds an item to the possible selections. /// </summary> public void Add(PieceMove Move, Board Board) { this._Items.Add(new _Possible() { Move = Move, Board = Board }); }