예제 #1
0
        public float Render(float depth)
        {
            _depth = depth;

            if (_previousPosition.X != _map.Position.X || _previousPosition.X != _map.Position.X || UpdateTileMap)
            {
                Array.Clear(_screenToTileMap, 0, _screenToTileMap.Length);
            }

#if SlowRender
            var j = 0;
#endif

            for (var x = 0; x < Constants.BoardSize + Constants.BoardOverrun; x++)
            {
                for (var y = 0; y < Constants.BoardSize + Constants.BoardOverrun; y++)
                {
#if SlowRender
                    j++;

                    if (j >= i)
                    {
                        i++;

                        return(_depth);
                    }
#endif

                    var position = Translations.BoardToScreen(x, y);

                    var tile = _map.GetTile(x, y);

                    if (tile == null)
                    {
                        continue;
                    }

                    var baseHeight = Math.Min(_map.GetTile(x + 1, y)?.Height ?? tile.Height, _map.GetTile(x, y + 1)?.Height ?? tile.Height);

                    if (baseHeight > tile.Height)
                    {
                        baseHeight = tile.Height;
                    }

                    if (x == 0 || y == 0 || _map.GetTile(x - 1, y) == null || _map.GetTile(x, y - 1) == null)
                    {
                        var skyBase = position.Y - Constants.SkySpriteHeight - Constants.SeaFloor * Constants.BlockHeight + Constants.TileHeightHalf;

                        if (x == 0 || _map.GetTile(x - 1, y) == null && _map.GetTile(x - 1, y - 1) == null)
                        {
                            _spriteBatch.Draw(_sky,
                                              new Vector2(position.X, skyBase),
                                              new Rectangle(Constants.SkySpriteWidth, 0, Constants.SkySpriteWidth, Constants.SkySpriteHeight),
                                              new Color(GameState.Brightness, GameState.Brightness, GameState.Brightness), 0, Vector2.Zero, Vector2.One, SpriteEffects.None, _depth);
                        }

                        _depth += Constants.DepthIncrement;

                        if (y == 0 || _map.GetTile(x, y - 1) == null && _map.GetTile(x - 1, y - 1) == null)
                        {
                            _spriteBatch.Draw(_sky,
                                              new Vector2(position.X, skyBase),
                                              new Rectangle(0, 0, Constants.SkySpriteWidth, Constants.SkySpriteHeight),
                                              new Color(GameState.Brightness, GameState.Brightness, GameState.Brightness), 0, Vector2.Zero, Vector2.One, SpriteEffects.None, _depth);
                        }

                        _depth += Constants.DepthIncrement;
                    }

                    for (var h = baseHeight; h <= tile.Height; h++)
                    {
                        Draw(position.X, position.Y, h, h > tile.Height - 2 ? tile.TerrainType : tile.IsEdge?TerrainType.Rock: Map.GetDefaultTerrainType(h + tile.EdgeOffset), x, y, tile.IsEdge);
                    }

                    if (tile.SceneryType != null)
                    {
                        DrawScenery(position.X, position.Y, tile.Height, tile.SceneryType.Value);
                    }

                    var edge = tile.IsEdge || x == Constants.BoardSize - 1 + Constants.BoardOverrun || y == Constants.BoardSize - 1 + Constants.BoardOverrun;

                    if (edge && AppSettings.Instance.Rendering.RenderBoardEdges)
                    {
                        for (var h = Constants.SeaFloor; h <= tile.Height; h++)
                        {
                            if (_map.GetTile(x, y + 1) == null || y == Constants.BoardSize + Constants.BoardOverrun - 1)
                            {
                                DrawEdge(position.X, position.Y, h, tile.IsEdge ? TerrainType.Rock : Map.GetDefaultTerrainType(h + tile.EdgeOffset), true);
                            }

                            if (_map.GetTile(x + 1, y) == null || x == Constants.BoardSize + Constants.BoardOverrun - 1)
                            {
                                DrawEdge(position.X, position.Y, h, tile.IsEdge ? TerrainType.Rock : Map.GetDefaultTerrainType(h + tile.EdgeOffset), false);
                            }
                        }

                        if (tile.IsEdge && GameState.WaterLevel > tile.Height)
                        {
                            var colour = new Color(GameState.Brightness, GameState.Brightness, GameState.Brightness) * 0.6f;

                            if (_map.GetTile(x, y + 1) == null && _map.GetTile(x + 1, y + 1) == null)
                            {
                                for (var h = tile.Height + 1; h > -((Constants.ScreenBufferHeight - position.Y) / Constants.BlockHeight); h--)
                                {
                                    // TODO: Magic number -2
                                    DrawEdge(position.X, position.Y + 5, h, TerrainType.WaterLeftEdge, true, colour, -2);
                                }
                            }

                            if (_map.GetTile(x + 1, y) == null && _map.GetTile(x + 1, y + 1) == null)
                            {
                                for (var h = tile.Height + 1; h > -((Constants.ScreenBufferHeight - position.Y) / Constants.BlockHeight); h--)
                                {
                                    // TODO: Magic number -2
                                    DrawEdge(position.X, position.Y + 5, h, TerrainType.WaterRightEdge, false, colour, -2);
                                }
                            }
                        }
                    }

                    if (tile.Height < GameState.WaterLevel)
                    {
                        Draw(position.X, position.Y, GameState.WaterLevel, TerrainType.Water);

                        if (edge)
                        {
                            for (var i = GameState.WaterLevel; i > tile.Height; i--)
                            {
                                if (_map.GetTile(x, y + 1) == null || y == Constants.BoardSize - 1)
                                {
                                    Draw(position.X, position.Y, i, TerrainType.WaterLeftEdge);
                                }

                                if (_map.GetTile(x + 1, y) == null || x == Constants.BoardSize - 1)
                                {
                                    Draw(position.X, position.Y, i, TerrainType.WaterRightEdge);
                                }
                            }
                        }
                    }
                }
            }

            var mouseState = Mouse.GetState();

            SelectedTile = null;

            if (mouseState.X >= 0 && mouseState.X < Constants.ScreenBufferWidth && mouseState.Y >= 0 && mouseState.Y < Constants.ScreenBufferHeight)
            {
                var tile = _screenToTileMap[mouseState.X, mouseState.Y];

                if (tile != null)
                {
                    var position = Translations.BoardToScreen(tile.X, tile.Y);

                    var mapTile = _map.GetTile(tile.X, tile.Y);

                    if (mapTile != null)
                    {
                        Draw(position.X, position.Y, mapTile.Height, TerrainType.Highlight);

                        SelectedTile = tile;
                    }
                }
            }

            _previousPosition = _map.Position;

            UpdateTileMap = false;

            return(_depth);
        }