Example #1
0
    public bool RoundWin()
    {
        int enemyCount  = 0;
        int playerCount = 0;

        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
                if (chessTile)
                {
                    if (chessTile.gameObject)
                    {
                        if (chessTile.gameObject.name.Contains("NPC"))
                        {
                            enemyCount++;
                        }
                        if (chessTile.gameObject.name.Contains("Player"))
                        {
                            playerCount++;
                        }
                    }
                }
            }
        }
        // 플레이어 0명이 아니고 적이 없으면 승리
        return(playerCount != 0 && enemyCount == 0);
    }
Example #2
0
 public void DestroyPlayerList()
 {
     for (int i = 0; i < 8; i++)
     {
         for (int j = 0; j < 8; j++)
         {
             ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
             if (chessTile)
             {
                 if (chessTile.gameObject)
                 {
                     //if (chessTile.gameObject.name.Contains("Player"))
                     {
                         ChessCharacter character = chessTile.gameObject.GetComponent <ChessCharacter>();
                         if (character)
                         {
                             DestroyImmediate(character.GetHpBar().gameObject);
                         }
                         DestroyImmediate(chessTile.gameObject);
                     }
                 }
             }
         }
     }
 }
Example #3
0
    public void SpawnCharacter(string path, string name, int tileX, int tileY, eCharacter chessCharacterType, ChessCharacter.eCharacterType characterType)
    {
        GameObject character = Instantiate(Resources.Load(path)) as GameObject;

        character.name = name;
        ChessCharacter cCharacter = character.GetComponent <ChessCharacter>();

        cCharacter.SetTilePosition(new Vector3Int(tileX, tileY, 0));
        cCharacter.SetCharacterType(characterType);
        cCharacter.SetChessCharacterType(chessCharacterType);
        Debug.Log("Spawn in GameManager");
        character.transform.SetParent(tilemap.transform);

        ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(tileX, tileY, 0));

        if (chessTile != null)
        {
            chessTile.gameObject = character;
        }

        GameObject    canvas     = GameObject.Find("Canvas");
        RectTransform canvasRect = canvas.GetComponent <RectTransform>();

        //slider transform 세팅
        GameObject sliderObject = Instantiate(Resources.Load("Prefabs/UI/HpBar"), hpbarPanel.transform) as GameObject;
        //sliderObject.transform.SetParent(canvas.transform, false);

        Slider slider = sliderObject.GetComponent <Slider>();

        cCharacter.SetHpBar(slider);
    }
Example #4
0
    private bool BuyWaitCharacter(string path, string name, eCharacter characterType)
    {
        int waitPositionX = 0;

        while (waitPositionX < 8)
        {
            ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(waitPositionX, -1, 0));
            if (chessTile != null)
            {
                if (chessTile.gameObject == null)
                {
                    GameObject character = Instantiate(Resources.Load(path)) as GameObject;
                    character.name = name;
                    ChessCharacter cCharacter = character.GetComponent <ChessWaitCharacter>();
                    character.transform.SetParent(tilemap.transform);

                    cCharacter.SetTilePosition(new Vector3Int(waitPositionX, -1, 0));
                    cCharacter.SetCharacterType(ChessCharacter.eCharacterType.WAIT);
                    cCharacter.SetChessCharacterType(characterType);
                    chessTile.gameObject = character;
                    return(true);
                }
            }
            waitPositionX++;
        }
        return(false);
    }
Example #5
0
 public AbstractChessPiece(ChessBoard board, ChessColor color, ChessTile position, bool onBoard = true)
 {
     Board    = board;
     Color    = color;
     Position = position;
     InPlay   = onBoard;
 }
Example #6
0
    public bool IsFinishRound()
    {
        int enemyCount  = 0;
        int playerCount = 0;

        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
                if (chessTile)
                {
                    if (chessTile.gameObject)
                    {
                        if (chessTile.gameObject.name.Contains("NPC"))
                        {
                            enemyCount++;
                        }
                        if (chessTile.gameObject.name.Contains("Player"))
                        {
                            playerCount++;
                        }
                    }
                }
            }
        }
        // 플레이어, 적 중 하나라로 0명이면 라운드 종료
        return(playerCount == 0 || enemyCount == 0);
    }
Example #7
0
 public void StartMovement(Vector3 tilePos, ChessTile ns)
 {
     newSpot     = ns;
     endMarker   = tilePos;
     endMarker.y = this.transform.position.y;
     isMoving    = true;
 }
    public void PromotePawn(Pawn pawn, ChessTile promotionTile)
    {
        // Spawn the pawn promotion dialouge and forget about it
        GameObject promotionUI = Instantiate(pawn.isBlack ? _pawnPromotionUIPrefabBlack : _pawnPromotionUIPrefabWhite, promotionTile.transform);

        promotionUI.transform.localPosition = new Vector3(0f, 0.05f, pawn.isBlack ? -6.25f : 6.25f);
        promotionUI.GetComponent <PawnPromotionUI>().PromotionPawn = pawn;
    }
Example #9
0
    public void MovePiece(ChessTile newSpot)
    {
        // Checks if space piece is moving to is occupied, if so attacked piece is destroyed,
        // bool is true if it was a King,
        bool wasKing = false;

        if (newSpot.occupied)
        {
            if (newSpot.occupiedBy.isKing)
            {
                wasKing = true;
            }

            Destroy(newSpot.occupiedBy.gameObject);
            //newSpot.occupiedBy = selectedPiece;
        }
        // Starts LERP process for moved piece
        selectedPiece.StartMovement(newSpot.transform.position, newSpot);

        // Resets everything to do with selecting and moving a piece
        UnHighlightValidTiles(selectedPiece);
        selectedPiece.currentTile.occupied   = false;
        selectedPiece.currentTile.occupiedBy = null;
        //selectedPiece.SetLocation(newSpot);


        selectedPiece.GetComponent <Renderer>().material.color = selectedPiece.originalColor;
        if (selectedPiece.isPawn) // if a pawn was moved make onStartingTile false, so it can only move twice once
        {
            selectedPiece.GetComponent <Pawn>().onStartingTile = false;

            // If pawn reaches opposite side of board, replace it with a Queen
            if (newSpot.coordinates.z == 0f)
            {
                CreateQueen(blackTeam, queenPrefab, selectedPiece.currentTile.coordinates, selectedPiece.team);
                Destroy(selectedPiece.gameObject);
            }
            else if (newSpot.coordinates.z == 7f)
            {
                CreateQueen(whiteTeam, queenPrefab, selectedPiece.currentTile.coordinates, selectedPiece.team);
                Destroy(selectedPiece.gameObject);
            }
        }



        // If King was destroyed, end game
        if (wasKing)
        {
            // Game Over Screen
            isGameOver = true;
            whiteTeam  = null;
            blackTeam  = null;
            uiManager.GameOver();
        }

        //NewTurn();
    }
Example #10
0
    public void SelectTile(ChessTile tile)
    {
        // Make the tile this belongs to the active board
        SelectBoard(tile.Board);

        // If there is an active piece and this is a legal move make the move then deactivate the piece
        if (_activeFigure != null && _potentialMoves.Contains(tile))
        {
            MovePiece(_activeFigure, tile);
            _activeFigure = null;
            return;
        }

        foreach (ChessTile moveTile in _potentialMoves)
        {
            moveTile.Highlighted = false;                                              // Unhighlights the previously highlighted moves
        }
        // Deselect the old tile and select the new one
        if (_activeTile != null)
        {
            _activeTile.Highlighted = false;
        }
        _activeTile             = tile;
        _activeTile.Highlighted = true;

        // If there is a piece on this tile select it as well, otherwise deselect the active piece
        if (_activeTile.Figure != null)
        {
            _activeFigure      = _activeTile.Figure;
            bool[,] legalMoves = _activeFigure.LegalMoves();

            // Get the tile references for each legal move
            _potentialMoves = new List <ChessTile>();
            for (int x = 0; x < 8; x++)
            {
                for (int y = 0; y < 8; y++)
                {
                    if (legalMoves[x, y])
                    {
                        _potentialMoves.Add(_activeChessBoard.Tiles[x, y]);
                    }
                }
            }

            // Highlight those squares
            foreach (ChessTile moveTile in _potentialMoves)
            {
                moveTile.Highlighted = true;
            }
        }
        else
        {
            _activeFigure = null;
        }

        _activeChessBoard.ClearThreatArrows();
        _activeChessBoard.DrawThreatArrowsToTile(_activeTile);
    }
Example #11
0
        void StartSettings_FormClosing(object sender, FormClosingEventArgs e)
        {
            stepTime = ss.StepTime;
            isWhite  = ss.IsWhite;
            botVSbot = ss.BotVSbot;
            botsWar  = ss.BotsWar;

            tile = new ChessTile(ss.BotVSbot, ss.IsWhite, ss.PawnWeightOpp1, ss.RookWeightOpp1, ss.BishopWeightOpp1, ss.KnightWeightOpp1, ss.QueenWeightOpp1, ss.KingWeightOpp1, ss.PawnWeightOpp2, ss.RookWeightOpp2, ss.BishopWeightOpp2, ss.KnightWeightOpp2, ss.QueenWeightOpp2, ss.KingWeightOpp2);
        }
Example #12
0
 // Moves Piece to a tile and tells tile who it is occupied by
 public void SetLocation(ChessTile tile)
 {
     currentTile              = tile;
     transform.localPosition  = tile.transform.localPosition;
     currentTile.occupied     = true;
     currentTile.occupiedBy   = this;
     this.transform.position += new Vector3(0, GetComponent <MeshFilter>().mesh.bounds.extents.y, 0);
     //print("Hello");
 }
Example #13
0
 public void AddMoveIfLegal(int x, int y, ref ChessTile[,] tiles, ref bool[,] moveArray)
 {
     if (MoveOnBoard(x, y))
     {
         ChessTile toTile           = tiles[x, y];
         bool      noThreatAndEmpty = toTile.ThreatenedBy(isBlack).Count == 0 && !toTile.HasPiece();
         bool      canTake          = toTile.HasEnemyPiece(isBlack) && toTile.Figure.ProtectedBy().Count == 0;
         moveArray[x, y] = noThreatAndEmpty || canTake;
     }
 }
Example #14
0
    private void OnMouseDown()
    {
        if (tile.moveable == true)
        {
            ChessBoard board = tile.GetBoard();

            // simple lambda function to allow code reuse in the statements below
            System.Action <ChessPiece, ChessTile> movePiece = (p, t) =>
            {
                board.GetBoardArray()[p.X, p.Y].Piece = null; // set the previous tile's piece information to null
                t.Piece = p;                                  // store the piece into the tile
                p.Move(t.X, t.Y);                             // move the piece's game object into the tile's position
            };

            //hardcoded castling algorithm
            if (board.pieceInfo is King && Mathf.Abs(tile.X - board.pieceInfo.X) > 1)
            {
                ChessTile t = (tile.X - board.pieceInfo.X > 0) ? board.GetBoardArray()[tile.X - 1, tile.Y] : board.GetBoardArray()[tile.X + 1, tile.Y];
                Rook      r = (tile.X - board.pieceInfo.X > 0) ? board.GetBoardArray()[tile.X + 1, tile.Y].Piece as Rook : board.GetBoardArray()[tile.X - 2, tile.Y].Piece as Rook;
                movePiece(r, t);

                movePiece(board.pieceInfo, tile); // move king
            }

            //hardcoded en passant algorithm
            else if (board.pieceInfo is Pawn && tile.Piece == null && tile.X != board.pieceInfo.X && ((Pawn)board.pieceInfo).promoted == null)
            {
                ChessTile t = (board.pieceInfo.GetTeam() == Team.White) ? board.GetBoardArray()[tile.X, tile.Y - 1] : board.GetBoardArray()[tile.X, tile.Y + 1];

                board.RemoveFromBoard(t.Piece); // remove the piece from board
                t.Piece.Enabled = false;        // disable the piece interaction
                t.Piece         = null;         // set the previous tile's piece information to null

                movePiece(board.pieceInfo, tile);
            }

            //hardcoded promotion algorithm
            else if (board.pieceInfo is Pawn && (tile.Y == 0 || tile.Y == board.GetBoardArray().GetLength(1) - 1) && ((Pawn)board.pieceInfo).promoted == null)
            {
                movePiece(board.pieceInfo, tile);

                Pawn p = board.pieceInfo as Pawn;
                board.uiPromotion.Show(board, p);
            }

            // normal move
            else if (board.pieceInfo != null)
            {
                movePiece(board.pieceInfo, tile); // move the piece
            }

            board.onMoveListener();
        }
    }
Example #15
0
    // Creates a tile for the board
    private void CreateTile(IntVector2 coordinates, ChessTile tile, Color color)
    {
        ChessTile newTile = Instantiate(tile) as ChessTile;

        tiles[coordinates.x, coordinates.z] = newTile;
        newTile.coordinates             = coordinates;
        newTile.originalColor           = color;
        newTile.name                    = "Board Tile " + coordinates.x + ", " + coordinates.z;
        newTile.transform.parent        = transform;
        newTile.transform.localPosition = new Vector3(coordinates.x - size.x * 0.5f + 0.5f, 0f, coordinates.z - size.z * 0.5f + 0.5f);
    }
Example #16
0
 public void ResetTilePath(string keyName)
 {
     for (int i = 0; i < 8; i++)
     {
         for (int j = 0; j < 8; j++)
         {
             ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
             chessTile.ResetTileData(keyName);
         }
     }
 }
Example #17
0
    private ChessCharacter FindAdjacentTarget(int findRange)
    {
        _cCharacter.ClearPathFindQueue();

        GameManager.gameInstance.ResetTilePath(_cCharacter.name);

        ChessTile startTile;

        startTile = GameManager.gameInstance.tilemap.GetTile <ChessTile>(_cCharacter.GetTilePosition());
        startTile.SetPrevPathTileNodeMap(_cCharacter.name, startTile);
        _cCharacter.PushPathFindTile(startTile);

        ChessTile nextQueueTile = _cCharacter.PopPathFindTile();

        while (nextQueueTile != null) //###남은 갯수 체크가 아닌 PopPathFindTile 반환 값으로 판별하도록 개선 가능
        {
            ChessTile currentTile = nextQueueTile;

            //가장 인근의 캐릭터 반환
            if (currentTile.gameObject != null && currentTile.GetDistanceWeight() != 0)
            {
                ChessCharacter targetCharacter = currentTile.gameObject.GetComponent <ChessCharacter>();
                if (_cCharacter.GetCharacterType() != targetCharacter.GetCharacterType() && targetCharacter.GetCharacterType() != ChessCharacter.eCharacterType.WAIT) // 적일 때만 탐색 성공 시킨다.
                {
                    return(targetCharacter);
                }
            }
            else if (currentTile.GetDistanceWeight() == findRange + 1)
            {
                return(null);
            }
            else
            {
                for (int i = 0; i < (int)ChessCharacter.Direction.MAXSIZE; i++)
                {
                    ChessCharacter.Direction direction = (ChessCharacter.Direction)i;
                    Vector3Int nextTilePos             = currentTile.GetTilePosition() + _cCharacter.GetDirectionTileNext(direction);
                    ChessTile  nextTile = GameManager.gameInstance.tilemap.GetTile <ChessTile>(nextTilePos);
                    if (_cCharacter.IsInWall(nextTilePos) && //맵 안에 있을 때 분기
                        nextTile.GetPrevPathTileNodeMap(_cCharacter.name) == null)    // 이미 이전 타일 세팅 안되있을 때 분기
                    {
                        nextTile.SetPrevPathTileNodeMap(_cCharacter.name, currentTile);
                        nextTile.SetDistanceWeight(currentTile.GetDistanceWeight() + 1);
                        _cCharacter.PushPathFindTile(nextTile);
                    }
                }
            }

            nextQueueTile = _cCharacter.PopPathFindTile();
        }
        return(null);
    }
Example #18
0
 public void AllTilesLog()
 {
     for (int i = 0; i < 8; i++)
     {
         for (int j = 0; j < 8; j++)
         {
             ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
             if (chessTile != null)
             {
                 Debug.Log("tile[" + j + "," + i + "] : " + tilemap.GetColliderType(chessTile.GetTilePosition()));
             }
         }
     }
 }
Example #19
0
    public void SetTileObject(Vector3Int tilePosition, GameObject gameObject)
    {
        if (tilePosition.x < 0 || tilePosition.x > 7 ||
            tilePosition.y < 0 || tilePosition.y > 7)
        {
            //Debug.Log("Tile 범위 초과 : GetTileObject");
        }
        ChessTile chessTile = tilemap.GetTile <ChessTile>(tilePosition);

        if (chessTile != null)
        {
            chessTile.gameObject = gameObject;
        }
    }
Example #20
0
    private void FindPath(Vector3Int targetTilePosition)
    {
        _cCharacter.ClearPathFindQueue();
        _cCharacter.ClearPathStack();
        GameManager.gameInstance.ResetTilePath(_cCharacter.name);

        ChessTile startTile;

        startTile = GameManager.gameInstance.tilemap.GetTile <ChessTile>(_cCharacter.GetTilePosition());
        startTile.SetPrevPathTileNodeMap(_cCharacter.name, startTile);
        _cCharacter.PushPathFindTile(startTile);

        ChessTile nextQueueTile = _cCharacter.PopPathFindTile();

        while (nextQueueTile != null)
        {
            ChessTile currentTile = nextQueueTile;

            //목표 타일에 도달하면 반환
            if (currentTile.GetTilePosition() == targetTilePosition)
            {
                ChessTile pathTile = currentTile;
                while (pathTile.GetPrevPathTileNodeMap(_cCharacter.name) != null && pathTile.GetPrevPathTileNodeMap(_cCharacter.name) != pathTile)
                {
                    _cCharacter.PushPathStackTile(pathTile);
                    pathTile   = pathTile.GetPrevPathTileNodeMap(_cCharacter.name);
                    targetTile = pathTile;
                }
                Debug.Log("@@@@@path finish1!!!");
                return;
            }
            else
            {
                for (int i = 0; i < (int)ChessCharacter.Direction.MAXSIZE; i++)
                {
                    ChessCharacter.Direction direction = (ChessCharacter.Direction)i;
                    Vector3Int nextTilePos             = currentTile.GetTilePosition() + _cCharacter.GetDirectionTileNext(direction);
                    ChessTile  nextTile = GameManager.gameInstance.tilemap.GetTile <ChessTile>(nextTilePos);
                    if (_cCharacter.IsInWall(nextTilePos) && nextTile.GetPrevPathTileNodeMap(_cCharacter.name) == null)
                    {
                        nextTile.SetPrevPathTileNodeMap(_cCharacter.name, currentTile);
                        //Debug.Log("nextTile : " + nextTile.position + "direction : " + direction);
                        _cCharacter.PushPathFindTile(nextTile);
                    }
                }
            }
            nextQueueTile = _cCharacter.PopPathFindTile();
        }
    }
Example #21
0
    /// <summary>
    /// Creates a Chessboard with the specified tileSize, height and with
    /// </summary>
    /// <returns>The chess board.</returns>
    /// <param name="boardParams">Board parameters.</param>
    public Dictionary <TileIndex, ChessTile> CreateChessBoard(ChessBoardParams boardParams)
    {
        var chessBoard = new Dictionary <TileIndex, ChessTile>();

        for (int i = 0; i < boardParams.height; i++)
        {
            for (int j = 0; j < boardParams.width; j++)
            {
                ChessTile tile = ChessTile.Init(tilePrototype).SetPosition().SetColor();

                TileIndex index = new TileIndex(j, i);
                chessBoard.Add(index, tile);
            }
        }
        return(chessBoard);
    }
Example #22
0
    public GameObject GetTileObject(Vector3Int tilePosition)
    {
        GameObject gameObject = null;

        if (tilePosition.x < 0 || tilePosition.x > 7 ||
            tilePosition.y < 0 || tilePosition.y > 7)
        {
            return(null);
        }

        ChessTile chessTile = tilemap.GetTile <ChessTile>(tilePosition);

        if (chessTile != null)
        {
            gameObject = chessTile.gameObject;
        }
        return(gameObject);
    }
Example #23
0
    public override void SetPosition(ChessTile tile)
    {
        if (!HasMoved) // If this is the first move
        {
            int castleY = isBlack ? 7 : 0;
            ChessTile[,] tiles = tile.Board.Tiles;

            // Move the Queenside rook or kingside rook if castling
            if (tile.xCoord == 2)
            {
                tiles[0, castleY].Figure.SetPosition(tiles[3, castleY]);
            }
            else if (tile.xCoord == 6)
            {
                tiles[7, castleY].Figure.SetPosition(tiles[5, castleY]);
            }
        }
        base.SetPosition(tile);
    }
Example #24
0
    // Move this directly to a tile
    public virtual void SetPosition(ChessTile tile)
    {
        // Reposition this in Unity
        this.transform.parent        = tile.transform;
        this.transform.localPosition = Vector3.zero;
        this.transform.localScale    = Scale;

        // Any movement from a player removes their EnPassant tile
        if (isBlack)
        {
            tile.Board.BlackEnPassantTile = null;
        }
        else
        {
            tile.Board.WhiteEnPassantTile = null;
        }

        HasMoved = true;
    }
    public bool CanMoveTile(Vector3Int tilePos)
    {
        if (tilePos.x < 0 || tilePos.x > 7 ||
            tilePos.y < 0 || tilePos.y > 7)
        {
            return(false);
        }

        if ((int)tilemap.GetColliderType(tilePos) > (int)Tile.ColliderType.None)
        {
            return(false);
        }
        ChessTile chessTile = tilemap.GetTile <ChessTile>(tilePos);

        if (chessTile.gameObject != null)
        {
            return(false);
        }
        return(true);
    }
Example #26
0
    public void MovePiece(ChessFigure figure, ChessTile targetTile)
    {
        // Remove this piece from the old tile
        figure.Tile.Figure = null;

        // If there is a piece on the target tile destroy it
        if (targetTile.Figure != null)
        {
            Destroy(targetTile.Figure.gameObject);
        }

        // Move this piece to the new tile in Unity
        figure.SetPosition(targetTile);

        // Doubly link them:
        figure.Tile       = targetTile;
        targetTile.Figure = figure;

        // Change the turn
        figure.Tile.Board.IsBlacksTurn = !figure.Tile.Board.IsBlacksTurn;
    }
Example #27
0
 public void SavePlayerList()
 {
     lastPlayerNameList.Clear();
     for (int i = 0; i < 8; i++)
     {
         for (int j = 0; j < 8; j++)
         {
             ChessTile chessTile = tilemap.GetTile <ChessTile>(new Vector3Int(j, i, 0));
             if (chessTile)
             {
                 if (chessTile.gameObject)
                 {
                     if (chessTile.gameObject.name.Contains("Player"))
                     {
                         ChessCharacter character = chessTile.gameObject.GetComponent <ChessCharacter>();
                         lastPlayerNameList.Add(GetSpawnCharacterInfo(character.GetChessCharacterType(), chessTile.GetTilePosition().x, chessTile.GetTilePosition().y));
                     }
                 }
             }
         }
     }
 }
Example #28
0
    private void _Generate()
    {
        bool alternate = true;

        for (int x = 0; x < chessTiles.GetLength(0); x++)
        {
            alternate = !alternate;
            for (int y = 0; y < chessTiles.GetLength(1); y++)
            {
                if (alternate)
                {
                    chessTiles[x, y] = new ChessTile(this, x, y, GameManager.SpriteManager["whiteTile"]);
                }
                else
                {
                    chessTiles[x, y] = new ChessTile(this, x, y, GameManager.SpriteManager["blackTile"]);
                }
                alternate = !alternate;
            }
        }

        gameMode(this, whitePieces, blackPieces, out whiteKing, out blackKing);
    }
Example #29
0
    // Special for pawn due to EnPassant logic and promotoion
    public override void SetPosition(ChessTile tile)
    {
        base.SetPosition(tile);

        // EnPassant Logic
        if (isBlack)
        {
            // If the pawn moved two tiles this enables EnPassant on the previous tile, otherwise it eliminates previous enpassant
            tile.Board.BlackEnPassantTile = Tile.yCoord - tile.yCoord == 2 ? tile.Board.Tiles[tile.xCoord, tile.yCoord + 1] : null;

            // If this was moving to an Enpassant tile delete the pawn on the correct tile
            if (tile.Board.WhiteEnPassantTile != null && tile.Board.WhiteEnPassantTile == tile)
            {
                Destroy(tile.Board.Tiles[tile.xCoord, tile.yCoord + 1].Figure.gameObject);
            }
        }
        else
        {
            // If the pawn moved two tiles this enables EnPassant on the previous tile, otherwise it eliminates previous enpassant
            tile.Board.WhiteEnPassantTile = tile.yCoord - Tile.yCoord == 2 ? tile.Board.Tiles[tile.xCoord, tile.yCoord - 1] : null;

            // If this was moving to an Enpassant tile delete the pawn on the correct tile
            if (tile.Board.BlackEnPassantTile != null && tile.Board.BlackEnPassantTile == tile)
            {
                Destroy(tile.Board.Tiles[tile.xCoord, tile.yCoord - 1].Figure.gameObject);
            }
        }

        // If the pawn has moved to the last rank open up the promotion window
        if (tile.yCoord % 7 == 0)
        {
            // This is ran before the two-way figure-tile coupling happens in the MovePiece() logic in GameController
            GameObject controller = GameObject.FindGameObjectWithTag("GameController");
            controller.GetComponent <GameController>().PromotePawn(this, tile);
        }
    }
Example #30
0
 public void ReleaseOverTile(ChessTile tile)
 {
     //TODO: Piece Drag and drop logic
 }