public Match3Tile SpawnTileAt(Match3BoardPiece boardPiece, BoardCoord boardPos, GameObject tilePrefab) { // Destroy previous tile from board piece (if present). if (boardPiece.EditorTile != null) { // Remove the first spawn rule entry for this tile if it corresponds to its type. SetBoardPieceSpawnRuleForTile(boardPiece, boardPiece.EditorTile, true); GameObject.DestroyImmediate(boardPiece.EditorTile.gameObject); } GameObject newTileGO = PrefabUtility.InstantiatePrefab(tilePrefab) as GameObject; PrefabUtility.DisconnectPrefabInstance(newTileGO); Match3Tile newTile = newTileGO.GetComponent <Match3Tile>(); newTile.name = string.Format("[{0},{1}] {2}", boardPos.row, boardPos.col, newTile.name); newTile.transform.parent = boardRenderer.transform; newTile.transform.localPosition = boardPiece.transform.localPosition - boardRenderer.transform.forward * 2f; boardPiece.EditorTile = newTile; // Add the first spawn rule entry for with this tile's type. SetBoardPieceSpawnRuleForTile(boardPiece, boardPiece.EditorTile); return(newTile); }
public override List <BoardCoord> CalculateTemplateMoves() { List <BoardCoord> moves = new List <BoardCoord>(); int xModifier, yModifier; for (int i = 0; i <= 7; i++) { chessGame.GetMoveDirectionModifiers(this, (MoveDirection)i, out xModifier, out yModifier); BoardCoord coord = GetBoardPosition() + new BoardCoord(xModifier, yModifier); while (chessGame.board.ContainsCoord(coord)) { if (chessGame.board.GetCoordInfo(coord).occupier != null) { BoardCoord grasshopperMove = chessGame.TryGetSpecificMove(this, coord + new BoardCoord(xModifier, yModifier)); if (grasshopperMove != BoardCoord.NULL) { moves.Add(grasshopperMove); } break; } coord.x += xModifier; coord.y += yModifier; } } return(moves); }
/// <summary> /// Gets all possible check threats against the piece-to-check. This should vary between game-modes /// that involve pieces that don't move directionally. /// </summary> /// <param name="pieceToCheck">Piece to check (usually the current or opposing royal piece).</param> /// <returns>A list of chess pieces that can check the piece-to-check.</returns> protected virtual List <ChessPiece> GetAllPossibleCheckThreats(ChessPiece pieceToCheck) { List <ChessPiece> possibleCheckThreats = new List <ChessPiece>(); for (int i = (int)MoveDirection.Up; i <= (int)MoveDirection.DownRight; i++) { int xModifier, yModifier; GetMoveDirectionModifiers(pieceToCheck, (MoveDirection)i, out xModifier, out yModifier); BoardCoord coord = pieceToCheck.GetBoardPosition() + new BoardCoord(xModifier, yModifier); while (board.ContainsCoord(coord)) { if (IsThreat(pieceToCheck, coord)) { possibleCheckThreats.Add(board.GetCoordInfo(coord).occupier); } coord.x += xModifier; coord.y += yModifier; } } foreach (Knight knight in GetPiecesOfType <Knight>()) { if (IsThreat(pieceToCheck, knight.GetBoardPosition())) { possibleCheckThreats.Add(knight); } } return(possibleCheckThreats); }
public Vector2 PositionForBoardCoord(BoardCoord boardCoord) { Vector2 pos = new Vector2((boardCoord.col * boardSquareSize.width) + (boardSquareSize.width * 0.5f), (boardCoord.row * boardSquareSize.height) + (boardSquareSize.height * 0.5f)); pos += boardStartOffset; return(pos); }
public override bool MovePiece(ChessPiece mover, BoardCoord destination) { // Try make the move if (MakeMove(mover, destination)) { // Check castling moves if (mover is King && mover.MoveCount == 1) { if (mover.GetBoardPosition() == new BoardCoord(1, WHITE_BACKROW)) { aSideWhiteRook = (Rook)PerformCastle(aSideWhiteRook, new BoardCoord(2, WHITE_BACKROW)); } else if (mover.GetBoardPosition() == new BoardCoord(2, BLACK_BACKROW)) { hSideBlackRook = (Rook)PerformCastle(hSideBlackRook, new BoardCoord(1, BLACK_BACKROW)); } } else if (mover is Pawn) { ChessPiece promotedPiece = CheckPawnPromotion((Pawn)mover); if (promotedPiece != null) { mover = promotedPiece; } } return(true); } return(false); }
public ArrayList FillGapsWithNewTiles(LevelData level, GameManager gameManager) { // This array will hold all the new tiles, split into ordered columns. // We use this for animating the drop down after we change the data model here. ArrayList columns = new ArrayList(); for (int col = 0; col < boardSize.numCols; col++) { ArrayList column = new ArrayList(); columns.Add(column); // Scan from bottom to top looking for any remaining board squares with no tile for (int row = 0; row < boardSize.numRows; row++) { BoardCoord boardCoord = new BoardCoord(col, row); if (CanHaveTileAtCoord(boardCoord) && !IsTileAtCoord(boardCoord)) { // Put in the new tile at this coord Tile newTile = CreateTile(boardCoord, level.GetRandomTileType(), gameManager); tiles[col, row] = newTile; column.Add(newTile); // Set the appearance so it is ready to drop in to place newTile.PrepareForNewDrop(); newTile.transform.localPosition = PositionForBoardCoord(new BoardCoord(col, boardSize.numRows + 1)); } } } return(columns); }
public override List <BoardCoord> CalculateAvailableMoves(ChessPiece mover) { BoardCoord[] templateMoves = mover.CalculateTemplateMoves().ToArray(); List <BoardCoord> availableMoves = new List <BoardCoord>(templateMoves.Length); for (int i = 0; i < templateMoves.Length; i++) { if (IsPieceInCheckAfterThisMove(currentRoyalPiece, mover, templateMoves[i]) == false) { availableMoves.Add(templateMoves[i]); } } if (mover is King && mover.MoveCount == 0) { availableMoves.AddRange(TryAddAvailableCastleMoves(mover)); } else if (mover is Pawn) { BoardCoord enPassantMove = TryAddAvailableEnPassantMove((Pawn)mover); if (enPassantMove != BoardCoord.NULL) { availableMoves.Add(enPassantMove); } } return(availableMoves); }
public override bool MovePiece(ChessPiece mover, BoardCoord destination) { BoardCoord oldPos = mover.GetBoardPosition(); // Try make the move if (MakeMove(mover, destination)) { // Check castling moves if (mover is King && mover.MoveCount == 1) { TryPerformCastlingRookMoves(mover); } else if (mover is Pawn) { ((Pawn)mover).validEnPassant = (mover.MoveCount == 1 && mover.GetRelativeBoardCoord(0, -1) != oldPos); CheckPawnEnPassantCapture((Pawn)mover); ChessPiece promotedPiece = CheckPawnPromotion((Pawn)mover); if (promotedPiece != null) { mover = promotedPiece; } } return(true); } return(false); }
public static TilePosition BoardCoordToTile(BoardCoord boardCoord) { var tilePosition = new TilePosition(); switch (boardCoord.YRank) { case "8": tilePosition.X = 0; break; case "7": tilePosition.X = 1; break; case "6": tilePosition.X = 2; break; case "5": tilePosition.X = 3; break; case "4": tilePosition.X = 4; break; case "3": tilePosition.X = 5; break; case "2": tilePosition.X = 6; break; case "1": tilePosition.X = 7; break; } tilePosition.Y = PositionCharToInt(boardCoord.XRank); return tilePosition; }
bool InputFilter(AbstractTile selectedTile, AbstractTile destinationTile, TileMoveDirection moveDirection) { if (pieceToMove == null || pieceToMoveDestination == null) { return true; } AbstractTile tileToMove = pieceToMove.Tile; AbstractTile tileToMoveDest = pieceToMoveDestination.Tile; if (destinationTile == null) { Match3BoardGameLogic boardLogic = Match3BoardGameLogic.Instance; BoardCoord targetBoardPos = selectedTile.BoardPiece.BoardPosition; targetBoardPos.OffsetByAndClamp(boardLogic.tilesMoveDirections[(int)moveDirection], boardLogic.boardData.NumRows - 1, boardLogic.boardData.NumColumns - 1); destinationTile = boardLogic.boardData[targetBoardPos].Tile; } if (tileToMove == selectedTile && tileToMoveDest == destinationTile || tileToMove == destinationTile && tileToMoveDest == selectedTile) { disableTutorial = true; TileSwitchInput.Instance.InputFilter = null; return true; } return false; }
/// <summary> /// Moves a chess piece from it's current position to the destination. /// </summary> /// <param name="mover"></param> /// <param name="destination"></param> /// <returns></returns> protected bool MakeMove(ChessPiece mover, BoardCoord destination) { BoardCoord previousPosition = mover.GetBoardPosition(); bool wasThreat = IsThreat(mover, destination); if (mover.MakeMoveTo(destination)) { if (wasThreat) { mover.CaptureCount++; } numConsecutiveCapturelessMoves = (wasThreat == false && (mover is Pawn) == false) ? numConsecutiveCapturelessMoves + 1 : 0; UpdateSquareOccupiers(previousPosition, mover.GetBoardPosition()); if (mover.GetTeam() == Team.WHITE) { lastMovedWhitePiece = mover; } else { lastMovedBlackPiece = mover; } return(true); } return(false); }
/// <summary> /// Simulates a move being played. NOTE: Must be followed by RevertSimulatedMove. /// </summary> /// <param name="mover">Piece to move.</param> /// <param name="dest">Destination to move to.</param> /// <param name="originalOccupier">The occupier at the destination prior to this simulated move.</param> /// <param name="originalLastMover">The last moved piece prior to this simulated move.</param> protected void SimulateMove(ChessPiece mover, BoardCoord dest, ChessPiece originalOccupier, out ChessPiece originalLastMover) { originalLastMover = null; if (AssertContainsCoord(dest)) { if (mover.GetTeam() == Team.WHITE) { if (lastMovedWhitePiece != null) { originalLastMover = lastMovedWhitePiece; } lastMovedWhitePiece = mover; } else { if (lastMovedBlackPiece != null) { originalLastMover = lastMovedBlackPiece; } lastMovedBlackPiece = mover; } if (originalOccupier != null) { originalOccupier.IsAlive = false; } board.GetCoordInfo(mover.GetBoardPosition()).occupier = null; board.GetCoordInfo(dest).occupier = mover; mover.SetBoardPosition(dest); } }
protected override BoardCoord TryAddAvailableEnPassantMove(Pawn mover) { const int LEFT = -1; const int RIGHT = 1; if (mover.canEnPassantCapture) { for (int i = LEFT; i <= RIGHT; i += 2) { int modulusRelativeX = MathExtensions.mod(i, BOARD_WIDTH); BoardCoord coord = TryGetSpecificMove(mover, mover.GetRelativeBoardCoord(modulusRelativeX, 0), threatOnly: true); if (board.ContainsCoord(coord)) { ChessPiece piece = board.GetCoordInfo(coord).occupier; if (piece is Pawn && piece == LastMovedOpposingPiece(mover) && ((Pawn)piece).validEnPassant) { if (IsPieceInCheckAfterThisMove(currentRoyalPiece, mover, mover.GetRelativeBoardCoord(modulusRelativeX, 1)) == false) { return(TryGetSpecificMove(mover, mover.GetRelativeBoardCoord(modulusRelativeX, 1))); } } } } } return(BoardCoord.NULL); }
public void Move(Vector2 pos) { BoardTile = Helpers.TileToBoardCoord((int)pos.X, (int)pos.Y); Position = Helpers.TileToPixel((int)pos.X, (int)pos.Y); TilePosition = new TilePosition() { X = (int)pos.Y, Y = (int)pos.X }; CollisionRect = new Rectangle((int)Position.X, (int)Position.Y, 132, 132); }
public override List <BoardCoord> CalculateAvailableMoves(ChessPiece mover) { BoardCoord[] templateMoves = mover.CalculateTemplateMoves().ToArray(); List <BoardCoord> availableMoves = new List <BoardCoord>(templateMoves.Length); for (int i = 0; i < templateMoves.Length; i++) { if (IsPieceInCheckAfterThisMove(currentRoyalPiece, mover, templateMoves[i]) == false) { availableMoves.Add(templateMoves[i]); } } if (mover is Pawn) { BoardCoord enPassantMove = TryAddAvailableEnPassantMove((Pawn)mover); if (enPassantMove != BoardCoord.NULL) { availableMoves.Add(enPassantMove); } if (checkingForCheck == false && CanPromote((Pawn)mover, availableMoves.ToArray())) { OnDisplayPromotionUI(true); } } return(availableMoves); }
public void Move(BoardCoord originCoord, BoardCoord targetCoord, Action onFinish) { IChessmanController icc; if (TryGetChessman(originCoord, out icc)) { IChessmanController targeticc; if (TryGetChessman(targetCoord, out targeticc)) { icc.Move(targetCoord, () => { targeticc.Destroy(); _chessmans.Remove(targeticc); onFinish(); }); } else { icc.Move(targetCoord, onFinish); } } else { onFinish(); } }
public void OnTileTapped(AbstractTile tile) { BoardCoord targetCoord = tile.BoardPiece.BoardPosition; if (selectedTile == typeof(BombTile)) { GameObject.Destroy(tile.gameObject); BombTile newTile = Match3BoardRenderer.Instance.SpawnSpecificTileAt(targetCoord, selectedTile, TileColorType.None) as BombTile; newTile.TileColor = RuleEntry.genericColors[Random.Range(0, Match3BoardRenderer.maxNumBoardColors)]; newTile.UpdateMaterial(); } else if (selectedTile == typeof(DirectionalDestroyTile)) { GameObject.Destroy(tile.gameObject); DirectionalDestroyTile newTile = null; if (Random.value > 0.5f) { newTile = Match3BoardRenderer.Instance.SpawnSpecificTileAt(targetCoord, typeof(RowDestroyTile), TileColorType.None) as DirectionalDestroyTile; } else { newTile = Match3BoardRenderer.Instance.SpawnSpecificTileAt(targetCoord, typeof(ColumnDestroyTile), TileColorType.None) as DirectionalDestroyTile; } newTile.TileColor = RuleEntry.genericColors[Random.Range(0, Match3BoardRenderer.maxNumBoardColors)]; newTile.UpdateMaterial(); } else if (selectedTile == typeof(ColorBombTile)) { GameObject.Destroy(tile.gameObject); ColorBombTile newTile = Match3BoardRenderer.Instance.SpawnSpecificTileAt(targetCoord, selectedTile, TileColorType.None) as ColorBombTile; } }
private void CreateBoardObjects(LevelData level, GameManager gameManager) { boardSquares = new BoardSquare[boardSize.numCols, boardSize.numRows]; tiles = new Tile[boardSize.numCols, boardSize.numRows]; for (int row = 0; row < boardSize.numRows; row++) { for (int col = 0; col < boardSize.numCols; col++) { BoardCoord boardCoord = new BoardCoord(col, row); // Create a board square of right type for this coordinate BoardSquareType boardSquareType = (BoardSquareType)level.tiles[col, row]; if (boardSquareType == BoardSquareType.Blocker && IsCoordEdgeOfBoard(boardCoord)) { boardSquareType = BoardSquareType.Edge; } boardSquares[col, row] = CreateBoardSquare(boardCoord, boardSquareType); // Create a tile if we should depending on type of board square if (CanHaveTileAtCoord(boardCoord)) { int tileType = level.GetRandomTileType(); tiles[col, row] = CreateTile(boardCoord, tileType, gameManager); } } } }
/// <summary> /// Reverts a simulated move. NOTE: Must be preceeded by SimulateMove. /// </summary> /// <param name="mover">Piece to move.</param> /// <param name="dest">Destination to move to.</param> /// <param name="originalOccupier">The occupier at the destination prior to this simulated move.</param> /// <param name="originalLastMover">The last moved piece prior to this simulated move.</param> /// <param name="oldPos">The position of the mover prior to this simulated move.</param> protected void RevertSimulatedMove(ChessPiece mover, BoardCoord dest, ChessPiece originalOccupier, ChessPiece originalLastMover, BoardCoord oldPos) { if (AssertContainsCoord(dest)) { mover.SetBoardPosition(oldPos); board.GetCoordInfo(mover.GetBoardPosition()).occupier = mover; if (originalOccupier != null) { originalOccupier.IsAlive = true; board.GetCoordInfo(dest).occupier = originalOccupier; } else { board.GetCoordInfo(dest).occupier = null; } if (mover.GetTeam() == Team.WHITE) { lastMovedWhitePiece = originalLastMover; } else { lastMovedBlackPiece = originalLastMover; } } }
// TODO : 손좀 보자 public BoardCoord GetClickedCoord() { float mousePositionX = float.MaxValue; float mousePositionZ = float.MaxValue; BoardCoord clickedCoord = new BoardCoord(-1, -1); //if (!Camera.main) ; if (Camera.main) { RaycastHit hit; float raycastDistance = 1000.0f; if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit, raycastDistance, LayerMask.GetMask("ChessBoard"))) { mousePositionX = hit.point.x - transform.position.x; mousePositionZ = hit.point.z - transform.position.z; } else { return(clickedCoord); } if (!((float)BoardEdge.LEFT <= mousePositionX && mousePositionX <= (float)BoardEdge.RIGHT && (float)BoardEdge.Bottom <= mousePositionZ && mousePositionZ <= (float)BoardEdge.Top)) { return(clickedCoord); } return(new BoardCoord(mousePositionX, mousePositionZ)); } return(clickedCoord); }
/// <summary> /// Преобразовать позицию на доске в позицию на экране /// </summary> /// <param name="coord">позиция на доске</param> /// <returns></returns> public Vector3 BoardCoordToTransformPosition(BoardCoord coord) { float x = rectTransform.position.x + coord.column * CurrentCellSize + CurrentCellSize / 2; float y = rectTransform.position.y + coord.row * CurrentCellSize + CurrentCellSize / 2; return(new Vector3(x, y, 0)); }
public static int Distance(BoardCoord origin, BoardCoord target) { BoardCoord displacement = target - origin; int squaredDistance = displacement.col * displacement.col + displacement.row * displacement.row; int shift = 2; int shiftedSquaredDinstance = squaredDistance >> shift; while (shiftedSquaredDinstance != 0 && shiftedSquaredDinstance != squaredDistance) { ++shift; ++shift; shiftedSquaredDinstance = squaredDistance >> shift; } --shift; --shift; int distance = 0; while (shift >= 0) { distance = distance << 1; int candidateDistance = distance + 1; if (candidateDistance * candidateDistance <= (squaredDistance >> shift)) { distance = candidateDistance; } shift = shift - 2; } return(distance); }
/// <summary> /// Parses the name of the coordinate from the name of a board piece which must use a valid format like: [3,4] BoardPiece. /// </summary> /// <returns> /// The parsed BoardCoord from the given board piece name. /// </returns> /// <param name='strName'> /// Board piece game object name. /// </param> public static BoardCoord ParseCoordFromString(string strName) { BoardCoord result = new BoardCoord(-1, -1); //TODO: this can be optimized with a regex expression (no time to implement this now) // Extract the board piece name from the gameobject name (TODO: note to self: use regex expression for faster and cleaner results) string[] strParts = strName.Split(','); if (strParts.Length != 2) { Debug.LogError("[BoardCoord] Invalid board piece naming format: " + strName); } else { string strPart1 = strParts[0]; string strRow = strPart1.Substring(strPart1.IndexOf('[') + 1).Trim(); string strPart2 = strParts[1]; string strCol = strPart2.Substring(0, strPart2.IndexOf(']')).Trim(); result.row = int.Parse(strRow); result.col = int.Parse(strCol); } return(result); }
public Pawn(Team team, BoardCoord position, bool canEnPassantCapture = true, uint initialMoveLimit = 2) : base(team, position) { m_pieceType = Piece.Pawn; this.validEnPassant = false; this.canEnPassantCapture = canEnPassantCapture; this.initialMoveLimit = initialMoveLimit; }
public override List <BoardCoord> CalculateAvailableMoves(ChessPiece mover) { BoardCoord[] templateMoves = mover.CalculateTemplateMoves().ToArray(); List <BoardCoord> availableMoves = new List <BoardCoord>(templateMoves.Length); for (int i = 0; i < templateMoves.Length; i++) { availableMoves.Add(templateMoves[i]); } if (mover is King && mover.MoveCount == 0) { availableMoves.AddRange(TryAddAvailableCastleMoves(mover)); } else if (mover is Pawn) { BoardCoord enPassantMove = TryAddAvailableEnPassantMove((Pawn)mover); if (enPassantMove != BoardCoord.NULL) { availableMoves.Add(enPassantMove); } if (checkingForCheck == false && CanPromote((Pawn)mover, availableMoves.ToArray())) { OnDisplayPromotionUI(true); } } return(availableMoves); }
public Vector3 GetBoardPosition(BoardCoord coord) { return(new Vector3( _collider.transform.position.x + (((float)coord.X - 0.5f) * _collider.size.x / 8) - _collider.size.x / 2, 0, _collider.transform.position.z + (((float)coord.Y - 0.5f) * _collider.size.z / 8) - _collider.size.z / 2 )); }
public virtual void InitComponent(AbstractBoardRenderer _boardRenderer) { // Board = owner; BoardPosition = new BoardCoord(-1, -1); BoardRenderer = _boardRenderer; // Parent this board piece to the owner's transform. cachedTransform.parent = BoardRenderer.cachedTransform; }
public AbstractBoardPiece this[BoardCoord boardPos] { get { return(this[boardPos.row, boardPos.col]); } set { this[boardPos.row, boardPos.col] = value; } }
public void UpdateBoardPieceGridTransform(Match3BoardPiece boardPiece, BoardCoord newGridPos) { Vector3 gridOffset = Vector3.zero; gridOffset.x = newGridPos.col * boardRenderer.horizontalTileDistance + boardRenderer.horizontalTileOffset; gridOffset.y = -newGridPos.row * boardRenderer.verticalTileDistance + boardRenderer.verticalTileOffset; boardPiece.transform.localPosition = gridOffset; }
public void Setup(BoardCoord boardCoord, BoardSquareType boardSquareType) { this.boardSquareType = boardSquareType; gameObject.name = boardSquareType.ToString() + "_" + boardCoord.col + "_" + boardCoord.row; boardSquareView.SetSpriteForBoardSquare(boardSquareType); }
public void SetCustomBoardCoordinateKey(BoardCoord coordToChange, string newAlgebraicKey) { if (ContainsCoord(coordToChange)) { coordinates[coordToChange].algebraicKey = newAlgebraicKey; coordinates[coordToChange].boardChunk.name = newAlgebraicKey; } }
private bool IsPieceInCheckMateAfterThisMove(ChessPiece pieceToCheck, ChessPiece mover, BoardCoord dest) { if (AssertContainsCoord(dest)) { if (checkingForCheckmate) { return(false); } // Temporarily simulate the move actually happening ChessPiece originalOccupier = board.GetCoordInfo(dest).occupier; ChessPiece originalLastMover; BoardCoord oldPos = mover.GetBoardPosition(); SimulateMove(mover, dest, originalOccupier, out originalLastMover); ChessPiece occupier = null; if (mover is Pawn) { occupier = CheckPawnEnPassantCapture((Pawn)mover); } // Check whether the piece is checkmated after this temporary move bool hasAnyMoves = false; checkingForCheckmate = true; foreach (ChessPiece piece in GetPieces(pieceToCheck.GetTeam())) { if (piece.IsAlive && hasAnyMoves == false) { BoardCoord[] availableMoves = CalculateAvailableMoves(piece).ToArray(); for (int i = 0; i < availableMoves.Length; i++) { if (IsPieceInCheckAfterThisMove(pieceToCheck, piece, availableMoves[i])) { continue; } else { hasAnyMoves = true; } } } } checkingForCheckmate = false; if (occupier != null) { board.GetCoordInfo(occupier.GetBoardPosition()).occupier = occupier; occupier.IsAlive = true; occupier.gameObject.SetActive(true); } // Revert the temporary move back to normal RevertSimulatedMove(mover, dest, originalOccupier, originalLastMover, oldPos); return(hasAnyMoves == false); } return(false); }
/// <summary> /// Initialize game board /// </summary> /// <returns></returns> public bool InitBoard() { boardStatus = new GameObject[NUM_BOARD_ROW][]; for (int i = 0; i < NUM_BOARD_ROW; i++) { boardStatus[i] = new GameObject[NUM_BOARD_COL]; } for (int i = 0; i < 8; i++) { boardStatus[i][0] = Instantiate(heroCards[i].heroModelPrefab, BoardCoord.GetBoardCoordVector3(i, 0), heroCards[i].heroModelPrefab.transform.rotation, pieceZone.transform); boardStatus[i][0].GetComponent <Piece>().Initialize(TeamColor.White, heroCards[i]); boardStatus[i][0].GetComponent <Piece>().MovePosition(new BoardCoord(i, 0)); boardStatus[i][NUM_BOARD_ROW - 1] = Instantiate(heroCards[i + NUM_PIECE_PREFABS / 2].heroModelPrefab, BoardCoord.GetBoardCoordVector3(i, NUM_BOARD_COL - 1), heroCards[i + NUM_PIECE_PREFABS / 2].heroModelPrefab.transform.rotation, pieceZone.transform); boardStatus[i][NUM_BOARD_ROW - 1].GetComponent <Piece>().Initialize(TeamColor.Black, heroCards[i + NUM_PIECE_PREFABS / 2]); boardStatus[i][NUM_BOARD_ROW - 1].GetComponent <Piece>().MovePosition(new BoardCoord(i, NUM_BOARD_COL - 1)); } kingBlack = boardStatus[3][7].GetComponent <Piece>(); kingWhite = boardStatus[3][0].GetComponent <Piece>(); // code for when num of user's piece set are 18 if (NUM_PIECE_PREFABS == 18) { for (int i = 0; i < NUM_PIECE_PREFABS / 2 - 1; i++) // instantiate pawn { boardStatus[i][1] = Instantiate(heroCards[8].heroModelPrefab, BoardCoord.GetBoardCoordVector3(i, 1), heroCards[8].heroModelPrefab.transform.rotation, pieceZone.transform); boardStatus[i][1].GetComponent <Piece>().Initialize(TeamColor.White, heroCards[8]); boardStatus[i][1].GetComponent <Piece>().MovePosition(new BoardCoord(i, 1)); boardStatus[i][NUM_BOARD_ROW - 2] = Instantiate(heroCards[8 + NUM_PIECE_PREFABS / 2].heroModelPrefab, BoardCoord.GetBoardCoordVector3(i, NUM_BOARD_COL - 2), heroCards[8 + NUM_PIECE_PREFABS / 2].heroModelPrefab.transform.rotation, pieceZone.transform); boardStatus[i][NUM_BOARD_ROW - 2].GetComponent <Piece>().Initialize(TeamColor.Black, heroCards[8 + NUM_PIECE_PREFABS / 2]); boardStatus[i][NUM_BOARD_ROW - 2].GetComponent <Piece>().MovePosition(new BoardCoord(i, NUM_BOARD_COL - 2)); } } ResetPiecesMovableCount(); return(true); }
/// <summary> /// Gets the next pattern coordinate for this pattern shape. /// It will return null when there are no more points available for this pattern. /// </summary> /// <returns> /// The next pattern coordinate. /// </returns> public override bool GetNextPatternCoord(out BoardCoord result) { result.row = 0; result.col = 0; if ( (startRow <= endRow && iteratorIdx <= endRow) || (startRow > endRow && iteratorIdx >= startRow) ) { result.row = (startRow < endRow) ? iteratorIdx++ : iteratorIdx--; result.col = columnIdx; // result = new BoardCoord(startRow < endRow ? iteratorIdx++ : iteratorIdx--, columnIdx); return true; } return false; }
public Piece(string stringType, PieceColour pieceColour, Vector2 pos) { //Constants mPieceTexture = Content.Load<Texture2D>(stringType); Type = Helpers.GetPieceType(stringType); Colour = pieceColour; //Updated on move BoardTile = Helpers.TileToBoardCoord((int)pos.X,(int)pos.Y); Position = Helpers.TileToPixel((int) pos.X, (int) pos.Y); TilePosition = new TilePosition(){ X = (int)pos.Y,Y = (int)pos.X}; CollisionRect = new Rectangle((int)Position.X, (int)Position.Y, 64, 64); }
protected BoardCoord ConvertToBoardCoord(Vector3 position) { BoardCoord returnValue = new BoardCoord(-1, -1); position.x /= Screen.width; position.y /= Screen.height; Vector3 worldSpacePosition = Match3BoardGameLogic.Instance.gameCamera.ViewportToWorldPoint(position); Vector3 boardSpacePosition = Match3BoardRenderer.Instance.transform.InverseTransformPoint(worldSpacePosition); returnValue.col = Convert.ToInt32(boardSpacePosition.x / Match3BoardRenderer.Instance.horizontalTileDistance); returnValue.row = Convert.ToInt32(-boardSpacePosition.y / Match3BoardRenderer.Instance.verticalTileDistance); // Debug.LogWarning("[BoardPieceTouchController] Found: " + returnValue.col + " " + returnValue.row); return returnValue; }
public void OffsetBy(BoardCoord offset) { row += offset.row; col += offset.col; }
public Match3Tile SpawnTileAt(BoardCoord boardPos, bool offBoardTile = false, bool noLockedTiles = false, bool isBoardSetup = false) { return SpawnTileAt(boardPos.row, boardPos.col, offBoardTile, noLockedTiles); }
public abstract bool GetNextPatternCoord(out BoardCoord result);
public Match3Tile SpawnSpecificTileAt(BoardCoord spawnPos, System.Type tileType, TileColorType prefabDefaultColor, bool offBoardTile, bool isBoardSetup) { return SpawnSpecificTileAt(spawnPos.row, spawnPos.col, tileType, prefabDefaultColor, offBoardTile, isBoardSetup); }
/// <summary> /// Parses the name of the coordinate from the name of a board piece which must use a valid format like: [3,4] BoardPiece. /// </summary> /// <returns> /// The parsed BoardCoord from the given board piece name. /// </returns> /// <param name='strName'> /// Board piece game object name. /// </param> public static BoardCoord ParseCoordFromString(string strName) { BoardCoord result = new BoardCoord(-1, -1); //TODO: this can be optimized with a regex expression (no time to implement this now) // Extract the board piece name from the gameobject name (TODO: note to self: use regex expression for faster and cleaner results) string[] strParts = strName.Split(','); if (strParts.Length != 2) { Debug.LogError("[BoardCoord] Invalid board piece naming format: " + strName); } else { string strPart1 = strParts[0]; string strRow = strPart1.Substring(strPart1.IndexOf('[') + 1).Trim(); string strPart2 = strParts[1]; string strCol = strPart2.Substring(0, strPart2.IndexOf(']')).Trim(); result.row = int.Parse(strRow); result.col = int.Parse(strCol); } return result; }
public BoardCoord(BoardCoord other) { row = other.row; col = other.col; }
public AbstractBoardPiece this[BoardCoord boardPos] { get { return this[boardPos.row, boardPos.col]; } set { this[boardPos.row, boardPos.col] = value; } }
/// <summary> /// Raises the board piece button pressed event when pressing a level editor button in the Unity scene view. /// </summary> /// <param name='refBoardPiece'> /// Board piece. /// </param> /// <param name='rowIdx'> /// Row index. /// </param> /// <param name='colIdx'> /// Col index. /// </param> void OnBoardPieceButtonPressed(ref Match3BoardPiece refBoardPiece, BoardCoord boardPos) { // Validate the current board tool selection (the currently selected prefab) // editor.selectedBoardTool = Selection.activeGameObject; object selectedToolObj = null; if (editor.selectedBoardTool != null) { if (editor.selectedBoardTool.GetComponent<Match3BoardPiece>()) { selectedToolObj = editor.selectedBoardTool.GetComponent<Match3BoardPiece>(); } if (editor.selectedBoardTool.GetComponent<Match3Tile>()) { selectedToolObj = editor.selectedBoardTool.GetComponent<Match3Tile>(); } } if ( selectedToolObj is Match3BoardPiece ) { // Get the currently selected board tool type if ( !LevelEditorUtils.IsPrefabInArray(editor.boardRenderer.prefabsPieces, editor.selectedBoardTool) ) { EditorUtility.DisplayDialog("Level Editor", "The selected board prefab is not added to the Match3BoardRenderer pieces prefab list!", "Ok"); return; } // Spawn a new board piece editor.SpawnBoardPieceAt(boardPos, editor.selectedBoardTool); } else if ( selectedToolObj is Match3Tile ) { // Get the currently selected board tool type if ( !LevelEditorUtils.IsPrefabInArray(editor.boardRenderer.tilesPrefabs, editor.selectedBoardTool) ) { EditorUtility.DisplayDialog("Level Editor", "The selected board prefab is not added to the Match3BoardRenderer tiles prefab list!", "Ok"); return; } else if (refBoardPiece == null) { // Spawn a default board piece if none found at the current board position. editor.SpawnBoardPieceAt(boardPos, editor.defaultBoardPiece.gameObject); editor.UpdateBoardPieceGridTransform(refBoardPiece, boardPos); } // Spawn a new tile on the selected board piece. editor.SpawnTileAt(refBoardPiece, boardPos, editor.selectedBoardTool); } else { EditorUtility.DisplayDialog("Level Editor", "The selected board prefab type is not supported!", "Ok"); return; } }
public void OffsetByAndClamp(BoardCoord offset, int clampToMaxRow, int clampToMaxColumn) { OffsetByAndClamp(offset.row, offset.col, clampToMaxRow, clampToMaxColumn); }
protected void CheckBoardTouch(Vector3 position, CustomInput.TouchInfo touchInfo) { boardCoord = ConvertToBoardCoord(position); if(boardCoord.row < 0 || boardCoord.row >= Match3BoardRenderer.Instance.Board.NumRows || boardCoord.col < 0 || boardCoord.col >= Match3BoardRenderer.Instance.Board.NumColumns) { return; } CustomInput.TouchInfo modifiedTouchInfo = new CustomInput.TouchInfo(touchInfo); modifiedTouchInfo.position = position; if(prevBoardCoord != boardCoord) { boardPiece = Match3BoardRenderer.Instance.Board[boardCoord.row, boardCoord.col]; RaiseOnNewBoardPieceSelected(boardPiece, modifiedTouchInfo); prevBoardCoord = boardCoord; } }
public static BoardCoord TileToBoardCoord(int x, int y) { var boardCoord = new BoardCoord(); switch (y) { case 0: boardCoord.YRank = "8"; break; case 1: boardCoord.YRank = "7"; break; case 2: boardCoord.YRank = "6"; break; case 3: boardCoord.YRank = "5"; break; case 4: boardCoord.YRank = "4"; break; case 5: boardCoord.YRank = "3"; break; case 6: boardCoord.YRank = "2"; break; case 7: boardCoord.YRank = "1"; break; } switch (x) { case 0: boardCoord.XRank = "a"; break; case 1: boardCoord.XRank = "b"; break; case 2: boardCoord.XRank = "c"; break; case 3: boardCoord.XRank = "d"; break; case 4: boardCoord.XRank = "e"; break; case 5: boardCoord.XRank = "f"; break; case 6: boardCoord.XRank = "g"; break; case 7: boardCoord.XRank = "h"; break; } return boardCoord; }
public static BoardCoord MoveXY(string XRank, int Xquantity, string YRank, int Yquantity) { var x = PositionCharToInt(XRank); var y = Convert.ToInt32(YRank); x += Xquantity; XRank = PositionIntToChar(x); x = PositionCharToInt(XRank); y += Yquantity; BoardCoord newPosition = new BoardCoord() {XRank=XRank,YRank=y.ToString()}; return newPosition; }