示例#1
0
        public void Draw(SpriteBatch spriteBatch, Player player)
        {
            //Desenhando o Mapa:
            //foreach (var tile in _mapInfo.MapTiles)
            //{
            //    tile.Draw(spriteBatch);
            //}

            int xPlayer = (int)player.MapPositionToDraw.X;
            int yPlayer = (int)player.MapPositionToDraw.Y;

            //Desenhando todos os tiles:
            for (int y = 0; y < _mapInfo._mapSize.Y; y++)
            {
                for (int x = (int)_mapInfo._mapSize.X - 1; x >= 0; x--)
                {
                    if (_tiles[x, y].Height == 0)
                    {
                        //Desenhando:
                        _tiles[x, y].Draw(spriteBatch);
                    }
                }
            }

            //Desenhando todos os tiles:
            for (int y = 0; y < _mapInfo._mapSize.Y; y++)
            {
                for (int x = (int)_mapInfo._mapSize.X - 1; x >= 0; x--)
                {
                    //Temos que desenhar o player?
                    if (x == xPlayer && y == yPlayer)
                    {
                        player.Draw(spriteBatch);
                    }

                    if (_tiles[x, y].Height > 0)
                    {
                        //Desenhando:
                        _tiles[x, y].Draw(spriteBatch);
                    }
                }
            }
        }
示例#2
0
        public List<Tile> CheckIfCanMove(MOVE_DIRECTIONS dir, STATE currentState, List<Tile> currentTiles, Player player)
        {
            //Temps:
            List<Tile> tilesToCheck = new List<Tile>();
            Vector2 position = Vector2.Zero;

            //Verificando o estado:
            switch (currentState)
            {
                #region STANDING
                case STATE.STANDING:
                    //Ocupo apenas um tile no mapa, então pegando a posição do mesmo:
                    position = currentTiles[0].MapPosition;

                    //Verificando de acordo com a direção que queremos ir:
                    switch (dir)
                    {
                        #region NORT_WEST
                        case MOVE_DIRECTIONS.NORT_WEST:
                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X, position.Y - 1)) == null ||
                               GetTile(new Vector2(position.X, position.Y - 1)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X, position.Y - 1)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X, position.Y - 2)) == null ||
                               GetTile(new Vector2(position.X, position.Y - 2)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X, position.Y - 2)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Se chegamos até aqui, adicionando os tiles:
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y - 1)));
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y - 2)));
                            break;
                        #endregion
                        #region SOUTH_WEST
                        case MOVE_DIRECTIONS.SOUTH_WEST:
                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X - 1, position.Y)) == null ||
                               GetTile(new Vector2(position.X - 1, position.Y)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X - 1, position.Y)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X - 2, position.Y)) == null ||
                               GetTile(new Vector2(position.X - 2, position.Y)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X - 2, position.Y)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Se chegamos até aqui, adicionando os tiles:
                            tilesToCheck.Add(GetTile(new Vector2(position.X - 1, position.Y)));
                            tilesToCheck.Add(GetTile(new Vector2(position.X - 2, position.Y)));
                            break;
                        #endregion
                        #region SOUTH_EAST
                        case MOVE_DIRECTIONS.SOUTH_EAST:
                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X, position.Y + 1)) == null ||
                               GetTile(new Vector2(position.X, position.Y + 1)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X, position.Y + 1)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X, position.Y + 2)) == null ||
                               GetTile(new Vector2(position.X, position.Y + 2)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X, position.Y + 2)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Se chegamos até aqui, adicionando os tiles:
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y + 1)));
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y + 2)));
                            break;
                        #endregion
                        #region NORT_EAST
                        case MOVE_DIRECTIONS.NORT_EAST:
                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X + 1, position.Y)) == null ||
                               GetTile(new Vector2(position.X + 1, position.Y)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X + 1, position.Y)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Verificando se caímos fora do mapa (Buracos ou Laterais do mapa):
                            if (GetTile(new Vector2(position.X + 2, position.Y)) == null ||
                               GetTile(new Vector2(position.X + 2, position.Y)).Type == TILE_TYPES.HOLE)
                            {
                                //Caindo e retornando nulo:
                                player.Fall(dir);
                                return null;
                            }
                            else
                            {
                                //Temos uma parede?
                                if (GetTile(new Vector2(position.X + 2, position.Y)).Type == TILE_TYPES.HEIGHT_ONE)
                                {
                                    //Não podemos nos mover:
                                    return null;
                                }
                            }

                            //Se chegamos até aqui, adicionando os tiles:
                            tilesToCheck.Add(GetTile(new Vector2(position.X + 1, position.Y)));
                            tilesToCheck.Add(GetTile(new Vector2(position.X + 2, position.Y)));
                            break;
                            #endregion
                    }
                    break;
                #endregion
                #region DIAGONAL_UP
                case STATE.DIAGONAL_UP:
                    //Verificando de acordo com a direção que queremos ir:
                    switch (dir)
                    {
                        case MOVE_DIRECTIONS.NORT_WEST:
                            //Adicionando o tile acima de cada tile atual:
                            foreach (var tile in currentTiles)
                            {
                                //Verificando se caímos:
                                if (GetTile(new Vector2(tile.MapPosition.X, tile.MapPosition.Y - 1)) == null)
                                {
                                    player.Fall(dir);
                                    return null;
                                }

                                tilesToCheck.Add(GetTile(new Vector2(tile.MapPosition.X, tile.MapPosition.Y - 1)));
                            }
                            break;
                        case MOVE_DIRECTIONS.SOUTH_EAST:
                            //Adicionando o tile abaixo de cada tile atual:
                            foreach (var tile in currentTiles)
                            {
                                //Verificando se caímos:
                                if (GetTile(new Vector2(tile.MapPosition.X, tile.MapPosition.Y + 1)) == null)
                                {
                                    player.Fall(dir);
                                    return null;
                                }

                                tilesToCheck.Add(GetTile(new Vector2(tile.MapPosition.X, tile.MapPosition.Y + 1)));
                            }
                            break;
                        case MOVE_DIRECTIONS.SOUTH_WEST:
                            //Considerando o tile com menor X:
                            position = currentTiles[0].MapPosition;

                            foreach (var tile in currentTiles)
                            {
                                if (tile.MapPosition.X < position.X)
                                    position = tile.MapPosition;
                            }

                            //Verificando se caímos:
                            if (GetTile(new Vector2(position.X - 1, position.Y)) == null)
                            {
                                player.Fall(dir);
                                return null;
                            }

                            //Pegando um tile abaixo do tile selecionado:
                            tilesToCheck.Add(GetTile(new Vector2(position.X - 1, position.Y)));
                            break;
                        case MOVE_DIRECTIONS.NORT_EAST:
                            //Considerando o tile com menor X:
                            position = currentTiles[0].MapPosition;

                            foreach (var tile in currentTiles)
                            {
                                if (tile.MapPosition.X < position.X)
                                    position = tile.MapPosition;
                            }

                            //Verificando se caímos:
                            if (GetTile(new Vector2(position.X + 2, position.Y)) == null)
                            {
                                player.Fall(dir);
                                return null;
                            }

                            //Pegando dois tiles acima do tile selecionado:
                            tilesToCheck.Add(GetTile(new Vector2(position.X + 2, position.Y)));
                            break;
                    }
                    break;
                #endregion
                #region DIAGONAL_DOWN
                case STATE.DIAGONAL_DOWN:
                    //Dos tiles ocupados, considerando o que tem o menor Y:
                    position = currentTiles[0].MapPosition;

                    foreach (var tile in currentTiles)
                    {
                        if (tile.MapPosition.Y < position.Y)
                            position = tile.MapPosition;
                    }

                    //Verificando de acordo com a direção que queremos ir:
                    switch (dir)
                    {
                        case MOVE_DIRECTIONS.NORT_WEST:
                            //Verificando se caímos:
                            if (GetTile(new Vector2(position.X, position.Y - 1)) == null)
                            {
                                player.Fall(dir);
                                return null;
                            }

                            //Pegando um tile abaixo do tile selecionado:
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y - 1)));
                            break;
                        case MOVE_DIRECTIONS.SOUTH_WEST:
                            foreach (var tile in currentTiles)
                            {
                                //Verificando se caímos:
                                if (GetTile(new Vector2(tile.MapPosition.X - 1, tile.MapPosition.Y)) == null)
                                {
                                    player.Fall(dir);
                                    return null;
                                }

                                //Adicionando o tile acima de cada tile atual:
                                tilesToCheck.Add(GetTile(new Vector2(tile.MapPosition.X - 1, tile.MapPosition.Y)));
                            }
                            break;
                        case MOVE_DIRECTIONS.SOUTH_EAST:
                            //Verificando se caímos:
                            if (GetTile(new Vector2(position.X, position.Y + 2)) == null)
                            {
                                player.Fall(dir);
                                return null;
                            }

                            //Pegando dois tiles acima do tile selecionado:
                            tilesToCheck.Add(GetTile(new Vector2(position.X, position.Y + 2)));
                            break;
                        case MOVE_DIRECTIONS.NORT_EAST:
                            //Adicionando o tile abaixo de cada tile atual:
                            foreach (var tile in currentTiles)
                            {
                                //Verificando se caímos:
                                if (GetTile(new Vector2(tile.MapPosition.X + 1, tile.MapPosition.Y)) == null)
                                {
                                    player.Fall(dir);
                                    return null;
                                }

                                tilesToCheck.Add(GetTile(new Vector2(tile.MapPosition.X + 1, tile.MapPosition.Y)));
                            }
                            break;
                    }
                    break;
                    #endregion
            }

            //Recebemos algum tile?
            if (tilesToCheck.Count > 0)
            {
                //Verificando se os tiles são passáveis:
                foreach (var tile in tilesToCheck)
                {
                    //É parede?
                    if (tile.Type == TILE_TYPES.HEIGHT_ONE)
                    {
                        return null;
                    }
                    //É buraco?
                    else if (tile.Type == TILE_TYPES.HOLE)
                    {
                        //Caindo...
                        player.Fall(dir);
                        return null;
                    }

                }
            }
            else
            {
                //Falhamos.
                return null;
            }

            //Se chegamos até aqui, retornando a lista de tiles:
            return tilesToCheck;
        }