Exemplo n.º 1
0
        /*
         *  @PieceMoves -> Movimentos possiveis da peca
         */
        public override bool[,] PieceMoves()
        {
            bool[,] mat = new bool[Board.Lines, Board.Columns];
            Position2D pos = new Position2D(0, 0);

            //TOP
            pos.GetPosition(Position.Line - 1, Position.Column);
            while (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
                if (Board.GetPiece(pos) != null && Board.GetPiece(pos).Color != Color)
                {
                    break;
                }

                pos.Line -= 1;
            }

            //DOWN
            pos.GetPosition(Position.Line + 1, Position.Column);
            while (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
                if (Board.GetPiece(pos) != null && Board.GetPiece(pos).Color != Color)
                {
                    break;
                }

                pos.Line += 1;
            }

            //RIGHT
            pos.GetPosition(Position.Line, Position.Column + 1);
            while (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
                if (Board.GetPiece(pos) != null && Board.GetPiece(pos).Color != Color)
                {
                    break;
                }

                pos.Column += 1;
            }

            //LEFT
            pos.GetPosition(Position.Line, Position.Column - 1);
            while (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
                if (Board.GetPiece(pos) != null && Board.GetPiece(pos).Color != Color)
                {
                    break;
                }

                pos.Column -= 1;
            }


            return(mat);
        }
Exemplo n.º 2
0
    private void _OnTimerTimeout()
    {
        Knife knife = knifePrefab.Instance() as Knife;
        float x     = (float)GD.RandRange(minX.GetPosition().x, maxX.GetPosition().x);

        knife.Position = new Vector2(x, minX.GetPosition().y);
        AddChild(knife);
    }
Exemplo n.º 3
0
    void NewGame()
    {
        _hud.NewGame();
        Options options = _gui.GetOptions();

        for (int index = 0; index < options.numberOfPlayers; index++)
        {
            Player player = (Player)Player.Instance();
            player.SetPlayer(options.playerOptions[index]);
            AddChild(player);
            _players.Add(player);
            player.Connect(
                "Hit",
                this,
                nameof(OnPlayerHit),
                new Godot.Collections.Array()
            {
                player
            });
        }

        if (options.numberOfPlayers == 1)
        {
            _players[0].Start(_singlePlayerStartPosition.GetPosition());
        }

        if (options.numberOfPlayers == 2)
        {
            _players[0].Start(_player1StartPosition.GetPosition());
            _players[1].Start(_player2StartPosition.GetPosition());
        }

        _enemyTimer.SetWaitTime(_enemyWaitTime);
        _gamePlayAudio.Play();
        _score = 0;
        _level = 1;

        _hud.UpdateScore(_score);
        _hud.UpdateLevel(_level);
        _startTimer.Start();
        _gui.ShowMessage("Get Ready!");
    }
Exemplo n.º 4
0
        /*
         *  @PieceMoves -> Movimentos possiveis da peca
         */

        public override bool[,] PieceMoves()
        {
            bool[,] mat = new bool[Board.Lines, Board.Columns];
            Position2D pos = new Position2D(0, 0);

            //cima
            pos.GetPosition(Position.Line - 1, Position.Column);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //ne
            pos.GetPosition(Position.Line - 1, Position.Column + 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //direita
            pos.GetPosition(Position.Line, Position.Column + 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //se
            pos.GetPosition(Position.Line + 1, Position.Column + 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //abaixo
            pos.GetPosition(Position.Line + 1, Position.Column);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //so
            pos.GetPosition(Position.Line + 1, Position.Column - 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //esquerda
            pos.GetPosition(Position.Line, Position.Column - 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //no
            pos.GetPosition(Position.Line - 1, Position.Column - 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            // #JOGADASESPECIAIS ->

            if (Moves == 0 && !match.Xeque)
            {
                //ROQUE PEQUENO
                Position2D posRook1 = new Position2D(Position.Line, Position.Column + 3);
                if (IsCastling(posRook1))
                {
                    Position2D pos1 = new Position2D(Position.Line, Position.Column + 1);
                    Position2D pos2 = new Position2D(Position.Line, Position.Column + 2);

                    if (Board.GetPiece(pos1) == null && Board.GetPiece(pos2) == null)
                    {
                        mat[Position.Line, Position.Column + 2] = true;
                    }
                }

                //ROQUE GRANDE
                Position2D posRook2 = new Position2D(Position.Line, Position.Column - 4);
                if (IsCastling(posRook2))
                {
                    Position2D pos1 = new Position2D(Position.Line, Position.Column - 1);
                    Position2D pos2 = new Position2D(Position.Line, Position.Column - 2);
                    Position2D pos3 = new Position2D(Position.Line, Position.Column - 3);

                    if (Board.GetPiece(pos1) == null &&
                        Board.GetPiece(pos2) == null &&
                        Board.GetPiece(pos3) == null)
                    {
                        mat[Position.Line, Position.Column - 2] = true;
                    }
                }
            }


            return(mat);
        }
Exemplo n.º 5
0
        public override bool[,] PieceMoves()
        {
            bool[,] mat = new bool[Board.Lines, Board.Columns];
            Position2D pos = new Position2D(0, 0);

            //CIMA ESQUERDA
            pos.GetPosition(Position.Line - 2, Position.Column - 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //CIMA DIREITA
            pos.GetPosition(Position.Line - 2, Position.Column + 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //ESQUERDA CIMA
            pos.GetPosition(Position.Line - 1, Position.Column - 2);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //DIREITA CIMA
            pos.GetPosition(Position.Line + 1, Position.Column - 2);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //BAIXO ESQUERDA
            pos.GetPosition(Position.Line + 2, Position.Column - 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //BAIXO DIREITA
            pos.GetPosition(Position.Line + 2, Position.Column + 1);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //DIREITA CIMA
            pos.GetPosition(Position.Line - 1, Position.Column + 2);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            //DIREITA BAIXO
            pos.GetPosition(Position.Line + 1, Position.Column + 2);
            if (Board.ValidatePosition(pos) && CanMove(pos))
            {
                mat[pos.Line, pos.Column] = true;
            }

            return(mat);
        }
Exemplo n.º 6
0
        /*
         * @PieceMoves -> Movimentos possiveis da peca
         */
        public override bool[,] PieceMoves()
        {
            bool[,] mat = new bool[Board.Lines, Board.Columns];
            Position2D pos = new Position2D(0, 0);

            if (Color == Colors.White)
            {
                pos.GetPosition(Position.Line - 1, Position.Column);
                if (Board.ValidatePosition(pos) && IsFree(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line - 2, Position.Column);
                if (Board.ValidatePosition(pos) && IsFree(pos) && Moves == 0)
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line - 1, Position.Column - 1);
                if (Board.ValidatePosition(pos) && HasEnemy(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line - 1, Position.Column + 1);
                if (Board.ValidatePosition(pos) && HasEnemy(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                // #JOGADAS ESPECIAIS ->
                // En Passant

                if (Position.Line == 3)
                {
                    Position2D left = new Position2D(Position.Line, Position.Column - 1);
                    if (Board.ValidatePosition(left) && HasEnemy(left) && Board.GetPiece(left) == match.IsEnPassant)
                    {
                        mat[left.Line - 1, left.Column] = true;
                    }

                    Position2D right = new Position2D(Position.Line, Position.Column + 1);
                    if (Board.ValidatePosition(right) && HasEnemy(right) && Board.GetPiece(right) == match.IsEnPassant)
                    {
                        mat[right.Line - 1, right.Column] = true;
                    }
                }
            }
            else
            {
                pos.GetPosition(Position.Line + 1, Position.Column);
                if (Board.ValidatePosition(pos) && IsFree(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line + 2, Position.Column);
                if (Board.ValidatePosition(pos) && IsFree(pos) && Moves == 0)
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line + 1, Position.Column - 1);
                if (Board.ValidatePosition(pos) && HasEnemy(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                pos.GetPosition(Position.Line + 1, Position.Column + 1);
                if (Board.ValidatePosition(pos) && HasEnemy(pos))
                {
                    mat[pos.Line, pos.Column] = true;
                }

                // #JOGADAS ESPECIAIS ->
                // En Passant

                if (Position.Line == 4)
                {
                    Position2D left = new Position2D(Position.Line, Position.Column - 1);
                    if (Board.ValidatePosition(left) && HasEnemy(left) && Board.GetPiece(left) == match.IsEnPassant)
                    {
                        mat[left.Line + 1, left.Column] = true;
                    }

                    Position2D right = new Position2D(Position.Line, Position.Column + 1);
                    if (Board.ValidatePosition(right) && HasEnemy(right) && Board.GetPiece(right) == match.IsEnPassant)
                    {
                        mat[right.Line + 1, right.Column] = true;
                    }
                }
            }


            return(mat);
        }