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

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;
using CastleMaster.Players;
using CastleMaster.Units;
using CastleMaster.Units.Mobs;
using System;

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 List<Entity> entitesToRender;
        private List<Unit>[] units;
        private int width, height;
        protected Texture2D tileMap;
        private EntityComprarer comparer = new EntityComprarer();
        private AnimationHelper waterAnimation = new AnimationHelper(10, 2).Start();
        private Player[] players;

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

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

            new Tile(this);
            InitTiles();

            units = new List<Unit>[2];
            units[0] = new List<Unit>();
            units[1] = new List<Unit>();

            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 List<Entity>();
        }

        public Player[] Players { get { return players; } }

        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() { }

        public 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)
            {
                entitesToRender.Sort(comparer);

                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)
                {
                    TileEntity te = tileEntities[Game.Random.Next(tileEntities.Count)];
                    te.Update();
                    if (te.Removed)
                    {
                        RemoveEntity(te);
                        TakeEntity(te, te.XTile, te.ZTile);
                    }
                }
            }

            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 SetPlayer(Player player, int id)
        {
            players[id] = player;
        }

        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);

            if (typeof(Unit).IsAssignableFrom(ent.GetType()))
            {
                Unit u = (Unit)ent;
                units[u.Owner.Team.ID].Add(u);
            }

            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));
        }

        //public Vector2 GetNearestEmptyTileWorldPos(int xTile, int zTile, Entity ent)
        //{
        //    int xt = 0, zt = 0;
        //    for (int z = zTile - 1; z <= zTile + 1; z++)
        //    {
        //        for (int x = xTile - 1; x <= xTile + 1; x++)
        //        {
        //            if (x == xTile && z == zTile) continue;
        //            int tp = xTile + zTile * width;

        //            if (registeredTiles[tiles[tp]].IsSolid) continue;

        //            TileEntity te = GetTileEntity(xTile, zTile);
        //            if (te != null && te.IsSolidTo(ent)) continue;
        //            xt = x;
        //            zt = z;
        //        }
        //    }

        //    if (xt != 0 || zt != 0)
        //        return new Vector2(xt * Viewport.TILESIZE + 8.0F, zt * Viewport.TILESIZE + 8.0F);

        //    return new Vector2(-1, -1);
        //}

        public TileEntity GetTileEntity(int xTile, int zTile)
        {
            List<Entity> ents = entitiesInTiles[xTile + zTile * width];
            if (ents.Count > 0)
                return ents[0] as TileEntity;

            return null;
        }

        public List<Unit> GetUnitsWithinScreenSpace(float x0, float y0, float x1, float y1, Player player)
        {
            List<Unit> result = new List<Unit>();

            foreach (Unit u in units[player.Team.ID])
            {
                if (u.IsSelectable && u.IntersectsWithScreenSpace(x0, y0, x1, y1))
                    result.Add(u);
            }

            return result;
        }

        public List<BoundingRectangle> GetCollidables(Entity ent, BoundingRectangle br = null)
        {
            List<BoundingRectangle> result = new List<BoundingRectangle>();

            BoundingRectangle entBR = br == null ? ent.BoundingRectangle : br;

            int x0 = (int)(entBR.XLeft / Viewport.TILESIZE) - 1;
            int z0 = (int)(entBR.ZFar / Viewport.TILESIZE) - 1;
            int x1 = (int)(entBR.XRight / Viewport.TILESIZE) + 1;
            int z1 = (int)(entBR.ZNear / Viewport.TILESIZE) + 1;

            for (int z = z0; z <= z1; z++)
            {
                if (z < 0 || z >= height) continue;
                for (int x = x0; x <= x1; x++)
                {
                    if (x < 0 || x >= width) continue;

                    List<Entity> entits = entitiesInTiles[x + z * width];

                    foreach (Entity e in entits)
                    {
                        if (e != ent && entBR.Intersects(e.BoundingRectangle))
                            e.AddBoundingRect(ref result, ent);
                    }

                    Tile t = registeredTiles[tiles[x + z * width]];
                    if (t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR))
                        t.AddBoundingRect(ref result, x, z);
                }
            }

            return result;
        }

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

        public bool[] BuildSolidnessTable(Mob mob, bool excludeEndSolidness = false, int xEnd = 0, int zEnd = 0)
        {
            bool[] result = new bool[tiles.Length];

            for (int i = 0; i < tiles.Length; i++)
            {
                if (excludeEndSolidness && xEnd == i % width && zEnd == i / width)
                {
                    result[i] = false;
                    continue;
                }

                result[i] = tiles[i] == TILE_VOID || registeredTiles[tiles[i]].IsSolid;

                List<Entity> entInTiles = entitiesInTiles[i];

                if (entInTiles.Count > 0)
                {
                    TileEntity te = entInTiles[0] as TileEntity;
                    result[i] = te != null && te.Blocks(mob);
                }
            }

            return result;
        }
    }
}