source: 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Level.cs @ 4535

using CastleMaster.Entities;
using CastleMaster.Entities.TileEntities;
using CastleMaster.Graphics;
using CastleMaster.Physics;
using CastleMaster.World.Tiles;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Collections.Generic;
using Viewport = CastleMaster.Graphics.Viewport;

namespace CastleMaster.World
{

    public class EntityComprarer : Comparer<Entity>
    {
        /// <summary>
        /// Compares entities between them.
        /// </summary>
        /// <param name="e1">Entity 1.</param>
        /// <param name="e2">Entity 2.</param>
        /// <returns>-1 = e1 render before e2 (e1 -> e2). +1 = e1 render after e2 (e2 -> e1).</returns>
        public override int Compare(Entity e1, Entity e2)
        {
            BoundingRectangle br1 = e1.BoundingRectangle;
            BoundingRectangle br2 = e2.BoundingRectangle;

            if (br1.ZFar >= br2.ZNear)
            {
                if ((e1.Z + e1.X - e1.RenderOffset.Y) - e1.RenderOffset.Y < (e2.Z + e2.X - e2.RenderOffset.Y) - e2.RenderOffset.Y) return -1;
                return +1;
            }
            if (br1.ZNear <= br2.ZFar)
                return -1;
            if (br1.XRight <= br2.XLeft)
                return -1;
            if (br1.XLeft >= br2.XRight)
                return +1;

            return 0;
        }
    }

    public class Level
    {
        public const int TILE_VOID = 0;
        public const int UPDATES_IN_TICK = 50;
        protected List<Tile> registeredTiles;
        protected int[] tiles;
        protected byte[] data;

        private List<Entity> entities;
        private List<TileEntity> tileEntities;
        private List<Entity>[] entitiesInTiles;
        private SortedSet<Entity> entitesToRender;
        private int width, height;
        protected Texture2D tileMap;
        private EntityComprarer comparer = new EntityComprarer();
        private AnimationHelper waterAnimation = new AnimationHelper(10, 2);

        public Level(Texture2D tileMap)
        {
            this.tileMap = tileMap;
            width = tileMap.Width;
            height = tileMap.Height;

            tiles = new int[width * height];
            data = new byte[width * height];
            registeredTiles = new List<Tile>();

            new Tile(this);
            InitTiles();

            entities = new List<Entity>();
            tileEntities = new List<TileEntity>();
            entitiesInTiles = new List<Entity>[width * height];
            for (int i = 0; i < width * height; i++)
                entitiesInTiles[i] = new List<Entity>();
            entitesToRender = new SortedSet<Entity>(comparer);

            InitLevel();
        }

        public int Width { get { return width; } }

        public int Height { get { return height; } }

        public List<Tile> RegisteredTiles { get { return registeredTiles; } }

        public int WaterTimer { get { return waterAnimation.CurrentFrame; } }

        protected virtual void InitTiles() { }

        protected virtual void InitLevel() { }

        public void RenderBackground(Camera camera, RenderHelper renderer)
        {
            float w = (Game.WIDTH / Viewport.FLOOR_TILE_WIDTH) / Viewport.ZOOM;
            float h = (Game.HEIGHT / Viewport.Y_STEP) / Viewport.ZOOM;

            int x0 = (int)((camera.XLeft / Viewport.FLOOR_TILE_WIDTH) / Viewport.ZOOM) - 3;
            int y0 = (int)((camera.YTop / Viewport.Y_STEP) / Viewport.ZOOM) - 5;
            int x1 = (int)(x0 + w) + 5;
            int y1 = (int)(y0 + h) + 7;

            renderer.SetOffset(camera);
            int tp;
            for (int y = y0; y < y1; y++)
            {
                for (int x = x0; x < x1; x++)
                {
                    int xTile = x + (y >> 1) + (y & 1);
                    int zTile = (y >> 1) - x;

                    if (xTile >= 0 && zTile >= 0 && xTile < width && zTile < height)
                    {
                        tp = xTile + zTile * width;
                        Tile t = registeredTiles[tiles[tp]];
                        if (t.ID != TILE_VOID)
                            t.Render(renderer, this, new Vector2((x * Viewport.FLOOR_TILE_WIDTH + (y & 1) * Viewport.X_STEP) * Viewport.ZOOM, (y * Viewport.Y_STEP + Viewport.Y_STEP) * Viewport.ZOOM), xTile, zTile, data[tp]);
                        entitiesInTiles[tp].ForEach(ent => entitesToRender.Add(ent));
                    }
                }
            }

            renderer.SetOffset();
        }

        public void RenderEntities(Camera camera, RenderHelper renderer)
        {
            if (entitesToRender.Count > 0)
            {
                renderer.SetOffset(camera);

                foreach (Entity ent in entitesToRender)
                    ent.Render(renderer);

                renderer.SetOffset();

                entitesToRender.Clear();
            }
        }

        public void Update()
        {
            waterAnimation.UpdateStep();

            for (int i = 0; i < UPDATES_IN_TICK; i++)
            {
                int xTile = Game.Random.Next(width);
                int zTile = Game.Random.Next(height);

                registeredTiles[tiles[xTile + zTile * width]].Update(this, xTile, zTile);

                if (tileEntities.Count > 0)
                    tileEntities[Game.Random.Next(tileEntities.Count)].Update();
            }

            foreach (Entity ent in entities)
            {
                int xTile_old = (int)(ent.X / Viewport.TILESIZE);
                int zTile_old = (int)(ent.Z / Viewport.TILESIZE);

                ent.Update();

                if (ent.Removed)
                {
                    RemoveEntity(ent);
                    TakeEntity(ent, xTile_old, zTile_old);
                    continue;
                }

                int xTile = (int)(ent.X / Viewport.TILESIZE);
                int zTile = (int)(ent.Z / Viewport.TILESIZE);

                if (xTile != xTile_old || zTile != zTile_old)
                {
                    TakeEntity(ent, xTile_old, zTile_old);
                    InsertEntity(ent, xTile, zTile);
                }
            }
        }

        public void SetTile(int tileX, int tileZ, int tileID)
        {
            if (IsValidPos(tileX, tileZ))
                tiles[tileX + tileZ * width] = tileID;
        }

        public void SetData(int tileX, int tileZ, byte dataVal)
        {
            if (IsValidPos(tileX, tileZ))
                data[tileX + tileZ * width] = dataVal;
        }

        public Tile GetTile(int tileX, int tileZ)
        {
            return IsValidPos(tileX, tileZ) ? registeredTiles[tiles[tileX + tileZ * width]] : registeredTiles[TILE_VOID];
        }

        public byte GetData(int tileX, int tileZ)
        {
            return IsValidPos(tileX, tileZ) ? data[tileX + tileZ * width] : (byte)0;
        }

        public void AddEntity(Entity ent, float xPos, float zPos)
        {
            int xTile = (int)(xPos / Viewport.TILESIZE);
            int zTile = (int)(zPos / Viewport.TILESIZE);

            if (!IsValidPos(xTile, zTile)) return;

            ent.X = xPos;
            ent.Z = zPos;

            ent.Init();

            if (typeof(TileEntity).IsAssignableFrom(ent.GetType()))
                tileEntities.Add((TileEntity)ent);
            else
                entities.Add(ent);

            InsertEntity(ent, xTile, zTile);
        }

        private void InsertEntity(Entity ent, int xTile, int zTile)
        {
            entitiesInTiles[xTile + zTile * width].Add(ent);
        }

        private void TakeEntity(Entity ent, int xTile, int zTile)
        {
            entitiesInTiles[xTile + zTile * width].Remove(ent);
        }

        private void RemoveEntity(Entity ent)
        {
            ent.OnRemoved();

            entities.Remove(ent);

            TakeEntity(ent, (int)(ent.X / Viewport.TILESIZE), (int)(ent.Z / Viewport.TILESIZE));
        }

        private bool IsValidPos(int tileX, int tileZ)
        {
            return (tileX >= 0 && tileZ >= 0 && tileX < width && tileZ < height);
        }
    }
}