Changeset 4535

Timestamp:

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

Author:

dezhidki

Message:

Uusi versio:

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

Location:

2013/30/DenisZ/CastleMaster/CastleMaster

Files:

• CastleMaster/CastleMaster.csproj (modified) (4 diffs)
• CastleMaster/Entities (added)
• CastleMaster/Entities/Entity.cs (added)
• CastleMaster/Entities/TileEntities (added)
• CastleMaster/Entities/TileEntities/TileEntity.cs (added)
• CastleMaster/Entities/TileEntities/TileEntityBlock.cs (added)
• CastleMaster/Game.cs (modified) (9 diffs)
• CastleMaster/Graphics/AnimationHelper.cs (added)
• CastleMaster/Graphics/Camera.cs (modified) (4 diffs)
• CastleMaster/Graphics/RenderHelper.cs (modified) (1 diff)
• CastleMaster/Graphics/Resources.cs (modified) (2 diffs)
• CastleMaster/Graphics/SpriteSheet.cs (modified) (1 diff)
• CastleMaster/Graphics/Viewport.cs (modified) (2 diffs)
• CastleMaster/Input/InputHandler.cs (modified) (4 diffs)
• CastleMaster/MathHelpers (added)
• CastleMaster/MathHelpers/FastFunctions.cs (added)
• CastleMaster/MathHelpers/FastRandom.cs (added)
• CastleMaster/Physics (added)
• CastleMaster/Physics/BoundingRectangle.cs (added)
• CastleMaster/Physics/BoundingRectangleOwner.cs (added)
• CastleMaster/Program.cs (modified) (1 diff)
• CastleMaster/Properties/AssemblyInfo.cs (modified) (1 diff)
• CastleMaster/World/Level.cs (modified) (6 diffs)
• CastleMaster/World/LevelBuilder.cs (added)
• CastleMaster/World/LevelTest.cs (modified) (3 diffs)
• CastleMaster/World/Tiles/Tile.cs (modified) (2 diffs)
• CastleMaster/World/Tiles/TileFloor.cs (modified) (2 diffs)
• CastleMaster/World/Tiles/TileWater.cs (added)
• CastleMasterContent/CastleMasterContent.contentproj (modified) (1 diff)
• CastleMasterContent/levels/levelTest.png (added)
• CastleMasterContent/tiles/tilesheet.png (modified) (previous)

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/CastleMaster.csproj

@@ -19 +19 @@
     <ApplicationIcon>Game.ico</ApplicationIcon>
     <Thumbnail>GameThumbnail.png</Thumbnail>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
     <PublishUrl>publish\</PublishUrl>
     <Install>true</Install>
@@ -31 +32 @@
     <ApplicationRevision>0</ApplicationRevision>
     <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
@@ -74 +74 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Entities\Entity.cs" />
+    <Compile Include="Entities\TileEntities\TileEntity.cs" />
+    <Compile Include="Entities\TileEntities\TileEntityBlock.cs" />
+    <Compile Include="Graphics\AnimationHelper.cs" />
     <Compile Include="Graphics\Camera.cs" />
     <Compile Include="Graphics\RenderHelper.cs" />
@@ -80 +84 @@
     <Compile Include="Graphics\Viewport.cs" />
     <Compile Include="Input\InputHandler.cs" />
+    <Compile Include="MathHelpers\FastFunctions.cs" />
+    <Compile Include="MathHelpers\FastRandom.cs" />
+    <Compile Include="Physics\BoundingRectangle.cs" />
+    <Compile Include="Physics\BoundingRectangleOwner.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Game.cs" />
     <Compile Include="World\Level.cs" />
+    <Compile Include="World\LevelBuilder.cs" />
     <Compile Include="World\LevelTest.cs" />
     <Compile Include="World\Tiles\Tile.cs" />
     <Compile Include="World\Tiles\TileFloor.cs" />
+    <Compile Include="World\Tiles\TileWater.cs" />
   </ItemGroup>
   <ItemGroup>

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Game.cs

@@ +1 @@
+using CastleMaster.Graphics;
+using CastleMaster.Input;
+using CastleMaster.World;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using SharpNeatLib.Maths;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Audio;
-using Microsoft.Xna.Framework.Content;
-using Microsoft.Xna.Framework.GamerServices;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework.Input;
-using Microsoft.Xna.Framework.Media;
-using CastleMaster.Input;
+using System.Text;
+using System.Windows.Forms;
 using Keys = System.Windows.Forms.Keys;
 using Viewport = CastleMaster.Graphics.Viewport;
-using System.Text;
-using CastleMaster.Graphics;
-using CastleMaster.World;
 
 namespace CastleMaster
@@ -44 +39 @@
         #endregion
 
+        public static FastRandom Random { get; private set; }
+
         public Game()
         {
@@ -49 +46 @@
             Content.RootDirectory = "Content";
             input = new InputHandler(Window);
+            Random = new FastRandom();
         }
 
@@ -61 +59 @@
             graphics.PreferredBackBufferWidth = WIDTH;
             graphics.PreferredBackBufferHeight = HEIGHT;
-            graphics.SynchronizeWithVerticalRetrace = true;
+            graphics.SynchronizeWithVerticalRetrace = false;
             graphics.ApplyChanges();
             Window.Title = TITLE;
-            IsMouseVisible = true;
 
             InitializeInput();
@@ -80 +77 @@
             input.RegisterKeyboardKey(Keys.Z);
             input.RegisterKeyboardKey(Keys.X);
+            input.RegisterKeyboardKey(Keys.F4);
+
+            input.RegisterMouseKey(MouseButtons.Middle);
         }
 
@@ -107 +107 @@
             base.BeginRun();
 
-            camera = new Camera();
-            level = new LevelTest(128, 128);
+            level = new LevelTest(Resources.LEVEL_TEST);
+            camera = new Camera(level);
         }
 
@@ -121 +121 @@
             camera.Update();
 
+            if (InputHandler.HasKeyBeenPressed(Keys.F4))
+                IsFixedTimeStep = !IsFixedTimeStep;
+
             if (InputHandler.HasKeyBeenPressed(Keys.Escape))
                 this.Exit();
@@ -131 +134 @@
             if (InputHandler.IsKeyDown(Keys.D))
                 camera.XLeft += cameraSpeed;
-            if (InputHandler.HasKeyBeenPressed(Keys.Z))
-                Viewport.ZOOM += Viewport.ZOOM_STEP;
-            if (InputHandler.HasKeyBeenPressed(Keys.X))
-                Viewport.ZOOM -= Viewport.ZOOM_STEP;
+
+            if (InputHandler.MouseScrollDelta > 1)
+                camera.Zoom(Viewport.ZOOM_STEP);
+            else if (InputHandler.MouseScrollDelta < 0)
+                camera.Zoom(-Viewport.ZOOM_STEP);
+
+            level.Update();
 
             updates++;
@@ -159 +165 @@
 
             level.RenderBackground(camera, renderer);
+            camera.RenderSelelctor(renderer);
+            level.RenderEntities(camera, renderer);
 
+            camera.RenderCursor(renderer);
             renderer.EndRender();
 

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/Camera.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using CastleMaster.Input;
+using CastleMaster.World;
 using Microsoft.Xna.Framework;
-using CastleMaster.Input;
+using System.Windows.Forms;
 
 namespace CastleMaster.Graphics
@@ -11 +9 @@
     {
         private int xOffs = 0, yOffs = 0;
-        private Vector2 mouseWorldPos = Vector2.Zero;
-        private Point oldMousePos = Point.Zero;
+        private Vector2 mouseWorldPos, selectorPos, selectorPosZoomed;
+        private Point mouseTilePos, oldMousePos;
+        private Level level;
+        private bool moveWorldWithMouse = false;
 
-        public Camera()
+        public Camera(Level level)
         {
+            this.level = level;
+            mouseWorldPos = Vector2.Zero;
+            selectorPos = Vector2.Zero;
+            selectorPosZoomed = Vector2.Zero;
+            mouseTilePos = Point.Zero;
+            oldMousePos = Point.Zero;
         }
 
@@ -46 +52 @@
         public void Update()
         {
+            if (InputHandler.HasMouseButtonBeenPressed(MouseButtons.Middle) || moveWorldWithMouse)
+            {
+                if (!moveWorldWithMouse)
+                {
+                    moveWorldWithMouse = true;
+                    oldMousePos = InputHandler.MousePos;
+                }
+
+                if (InputHandler.IsMouseButtonDown(MouseButtons.Middle))
+                {
+                    xOffs -= (InputHandler.MousePos.X - oldMousePos.X);
+                    yOffs -= (InputHandler.MousePos.Y - oldMousePos.Y);
+
+                    oldMousePos = InputHandler.MousePos;
+                }
+                else moveWorldWithMouse = false;
+            }
+
             mouseWorldPos = Viewport.ScreenToWorld(InputHandler.MouseX + xOffs, InputHandler.MouseY + yOffs);
+            int xTile = (int)(mouseWorldPos.X / Viewport.TILESIZE);
+            int zTile = (int)(mouseWorldPos.Y / Viewport.TILESIZE);
+            if (xTile < 0) xTile = 0;
+            else if (xTile >= level.Width) xTile = level.Width - 1;
+            if (zTile < 0) zTile = 0;
+            else if (zTile >= level.Height) zTile = level.Height - 1;
+
+            if (xTile != mouseTilePos.X || zTile != mouseTilePos.Y)
+            {
+                mouseTilePos.X = xTile;
+                mouseTilePos.Y = zTile;
+                selectorPos.X = (xTile - zTile) * Viewport.X_STEP;
+                selectorPos.Y = (xTile + zTile) * Viewport.Y_STEP + Viewport.Y_STEP;
+                selectorPosZoomed = selectorPos * Viewport.ZOOM;
+            }
+
+            
         }
 
@@ -53 +94 @@
             Viewport.ZOOM += factor;
 
-            xOffs = (int)((mouseWorldPos.X - mouseWorldPos.Y) * Viewport.X_SCALE_ZOOMED);
-            yOffs = (int)((mouseWorldPos.X + mouseWorldPos.Y) * Viewport.Y_SCALE_ZOOMED);
+            xOffs = (int)((mouseWorldPos.X - mouseWorldPos.Y + Viewport.TILESIZE) * Viewport.X_SCALE_ZOOMED) - InputHandler.MouseX;
+            yOffs = (int)((mouseWorldPos.X + mouseWorldPos.Y + Viewport.TILESIZE) * Viewport.Y_SCALE_ZOOMED) - InputHandler.MouseY;
+            selectorPosZoomed = selectorPos * Viewport.ZOOM;
+        }
+
+        public void CenterOn(float x, float z)
+        {
+            xOffs = (int)((x - z + Viewport.TILESIZE) * Viewport.X_SCALE_ZOOMED) - Game.WIDTH / 2;
+            yOffs = (int)((x + z + Viewport.TILESIZE) * Viewport.Y_SCALE_ZOOMED) - Game.HEIGHT / 2;
+        }
+
+        public void RenderSelelctor(RenderHelper renderer)
+        {
+            renderer.SetOffset(this);
+            renderer.Render(selectorPosZoomed, 3, 1, Resources.SPRITESHEET_TILES, Viewport.ZOOM);
+            renderer.SetOffset();
+        }
+
+        public void RenderCursor(RenderHelper renderer)
+        {
+            renderer.Render(InputHandler.MouseX, InputHandler.MouseY, 0, 0, Resources.SPRITESHEET_ICONS, Color.White, 3.0F);
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/RenderHelper.cs

@@ -1 @@
-using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework;
 
 namespace CastleMaster.Graphics

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/Resources.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Content;
 using Microsoft.Xna.Framework.Graphics;
 
@@ -11 +7 @@
     {
         public static int SPRITESHEET_TILES { get; private set; }
+        public static int SPRITESHEET_ICONS { get; private set; }
+        public static Texture2D LEVEL_TEST { get; private set; }
 
         public static void LoadResources(ContentManager cm, RenderHelper renderer)
         {
             SPRITESHEET_TILES = renderer.RegisterSpriteSheet(new SpriteSheet(cm.Load<Texture2D>("tiles/tilesheet"), 32, 32));
+            SPRITESHEET_ICONS = renderer.RegisterSpriteSheet(new SpriteSheet(cm.Load<Texture2D>("misc/icons"), 16, 16));
+            LEVEL_TEST = cm.Load<Texture2D>("levels/levelTest");
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/SpriteSheet.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework;
 
 namespace CastleMaster.Graphics

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Graphics/Viewport.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework;
 
 namespace CastleMaster.Graphics
@@ -49 +45 @@
             float yRegion = (y / ZOOM) / Y_SCALE;
 
-            return new Vector2((xRegion + yRegion) / 2, (yRegion - xRegion) / 2);
+            return new Vector2((xRegion + yRegion) / 2 - Viewport.TILESIZE, (yRegion - xRegion) / 2);
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Input/InputHandler.cs

@@ -1 @@
-using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Input;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Windows.Forms;
-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Input;
-
 using Keys = System.Windows.Forms.Keys;
 
@@ -41 +37 @@
         private static Dictionary<Keys, Key> registeredKeys;
         private static Dictionary<MouseButtons, Key> registeredMouseButtons;
-        private static int x, y;
+        private static int oldMouseScroll = 0, mouseScrollDelta;
+        private static Point mousePos = Point.Zero;
 
         private Control windowControl;
@@ -87 +84 @@
 
             MouseState state = Mouse.GetState();
-            x = state.X;
-            y = state.Y;
+            mousePos.X = state.X;
+            mousePos.Y = state.Y;
+            mouseScrollDelta = state.ScrollWheelValue - oldMouseScroll;
+            oldMouseScroll = state.ScrollWheelValue;
 
             foreach (Key k in registeredMouseButtons.Values)
@@ -137 +136 @@
         }
 
-        public static int MouseX { get { return x; } }
+        public static int MouseX { get { return mousePos.X; } }
 
-        public static int MouseY { get { return y; } }
+        public static int MouseY { get { return mousePos.Y; } }
+
+        public static int MouseScrollDelta { get { return mouseScrollDelta; } }
+
+        public static Point MousePos { get { return mousePos; } }
     }
 }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Program.cs

@@ -1 @@
-using System;
 
 namespace CastleMaster

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Properties/AssemblyInfo.cs

@@ -1 +1 @@
 using System.Reflection;
-using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 

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

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

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using CastleMaster.Entities.TileEntities;
 using CastleMaster.World.Tiles;
+using Microsoft.Xna.Framework.Graphics;
 
 namespace CastleMaster.World
@@ -9 +7 @@
     public class LevelTest : Level
     {
-        private int TILE_GRASS;
+        private int TILE_FLOOR, TILE_WATER;
 
-        public LevelTest(int width, int height)
-            : base(width, height)
+        public LevelTest(Texture2D tileMap)
+            : base(tileMap)
         {
         }
@@ -18 +16 @@
         protected override void InitTiles()
         {
-            TILE_GRASS = new TileFloor(this).ID;
+            TILE_FLOOR = new TileFloor(this).ID;
+            TILE_WATER = new TileWater(this).ID;
         }
 
         protected override void InitLevel()
         {
-            for (int i = 0; i < Width * Height; i++)
-                tiles[i] = TILE_GRASS;
+            LevelBuilder lb = new LevelBuilder(this, tileMap);
+
+            lb.AddTile(0xFF404040, TILE_FLOOR);
+            lb.AddTile(0xFF0094FF, TILE_WATER);
+            lb.AddTile(0xFF808080, TILE_FLOOR, 1);
+            lb.AddTile(0xFF303030, TILE_FLOOR, 2);
+            lb.AddTile(0xFF202020, TILE_FLOOR, 4);
+            lb.AddTile(0xFF202021, TILE_FLOOR, 5);
+            lb.AddTile(0xFF101010, TILE_FLOOR, 3);
+            lb.AddTile(0xFF0094FF, TILE_WATER, 8);
+            lb.AddTile(0xFF00B200, TILE_FLOOR, 6);
+            lb.AddTile(0xFF00CC00, TILE_FLOOR, 6);
+            lb.AddTile(0xFFFF0000, TILE_FLOOR);
+            lb.AddTile(0xFFFF0001, TILE_FLOOR);
+            lb.AddEntity(0xFFFF6A00, typeof(TileEntityBlock), 0.0F, 0.0F, this, 0, 0);
+            lb.AddEntity(0xFFE55B00, typeof(TileEntityBlock), 0.0F, 0.0F, this, 4, 1);
+            lb.AddEntity(0xFF00B200, typeof(TileEntityBlock), 0.0F, 0.0F, this, 2, 2);
+            lb.AddEntity(0xFF00CC00, typeof(TileEntityBlock), 0.0F, 0.0F, this, 1, 2);
+            lb.AddEntity(0xFF00E500, typeof(TileEntityBlock), 0.0F, 0.0F, this, 0, 2);
+            lb.AddEntity(0xFF00FF00, typeof(TileEntityBlock), 0.0F, 0.0F, this, 6, 0);
+
+            lb.BuildLevel();
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Tiles/Tile.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using CastleMaster.Graphics;
+using CastleMaster.Graphics;
 using Microsoft.Xna.Framework;
 
@@ -22 +18 @@
         public virtual void Update(Level level, int tileX, int tileZ) { }
 
-        public virtual void Render(RenderHelper renderer, Vector2 screenPos, int tileX, int tileZ, byte dataVal) { }
+        public virtual void Render(RenderHelper renderer, Level level, Vector2 screenPos, int tileX, int tileZ, byte dataVal) { }
     }
 }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/World/Tiles/TileFloor.cs

@@ -1 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using CastleMaster.Graphics;
+using CastleMaster.Graphics;
 using Microsoft.Xna.Framework;
 
@@ -15 +11 @@
         }
 
-        public override void Render(RenderHelper renderer, Vector2 screenPos, int tileX, int tileZ, byte dataVal)
+        public override void Render(RenderHelper renderer, Level level, Vector2 screenPos, int tileX, int tileZ, byte dataVal)
         {
-            renderer.Render(screenPos, 0, 0, Resources.SPRITESHEET_TILES, Viewport.ZOOM);
+            renderer.Render(screenPos, dataVal % 8, dataVal / 8, Resources.SPRITESHEET_TILES, Viewport.ZOOM);
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMasterContent/CastleMasterContent.contentproj

@@ -137 +137 @@
     </Compile>
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="levels\levelTest.png">
+      <Name>levelTest</Name>
+      <Importer>TextureImporter</Importer>
+      <Processor>TextureProcessor</Processor>
+    </Compile>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\$(XnaFrameworkVersion)\Microsoft.Xna.GameStudio.ContentPipeline.targets" />
   <!--  To modify your build process, add your task inside one of the targets below and uncomment it.