Changeset 4535 for 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Level.cs

Timestamp:

2013-07-22 22:52:24 (8 years ago)

Author:

dezhidki

Message:

Uusi versio:

• Tason luonti valmis
• Piirtojärjestys toimii
• Palikoiden lisääminen ja muokkaus toimii
• Esivalmistelut liikkumista varten

File:

• 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Level.cs (modified) (6 diffs)

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Level.cs

@@ -1 @@
-using System;
+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 System.Linq;
-using System.Text;
-using CastleMaster.World.Tiles;
-using CastleMaster.Graphics;
-using Microsoft.Xna.Framework;
+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;
-
-        public Level(int width, int height)
-        {
-            this.width = width;
-            this.height = 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];
@@ -29 +71 @@
             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();
         }
@@ -37 +86 @@
 
         public List<Tile> RegisteredTiles { get { return registeredTiles; } }
+
+        public int WaterTimer { get { return waterAnimation.CurrentFrame; } }
 
         protected virtual void InitTiles() { }
@@ -66 +117 @@
                         Tile t = registeredTiles[tiles[tp]];
                         if (t.ID != TILE_VOID)
-                            t.Render(renderer, 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]);
+                            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));
                     }
                 }
@@ -74 +126 @@
         }
 
+        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)
         {
@@ -96 +203 @@
         }
 
+        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)
         {