Changeset 4550

Timestamp:

2013-07-23 11:06:44 (8 years ago)

Author:

dezhidki

Message:

Talletus.

Location:

2013/30/DenisZ/CastleMaster/CastleMaster

Files:

• CastleMaster/CastleMaster.csproj (modified) (2 diffs)
• CastleMaster/Entities/Entity.cs (modified) (5 diffs)
• CastleMaster/Entities/EntityTestMob.cs (added)
• CastleMaster/Entities/TileEntities/TileEntityBlock.cs (modified) (1 diff)
• CastleMaster/Game.cs (modified) (9 diffs)
• CastleMaster/Graphics/Camera.cs (modified) (3 diffs)
• CastleMaster/Graphics/Resources.cs (modified) (2 diffs)
• CastleMaster/Physics/BoundingRectangle.cs (modified) (2 diffs)
• CastleMaster/Players (added)
• CastleMaster/Players/Player.cs (added)
• CastleMaster/Players/PlayerReal.cs (added)
• CastleMaster/Players/Team.cs (added)
• CastleMaster/Units (added)
• CastleMaster/Units/Unit.cs (added)
• CastleMaster/World/Level.cs (modified) (6 diffs)
• CastleMaster/World/LevelTest.cs (modified) (3 diffs)
• CastleMaster/World/Tiles/Tile.cs (modified) (3 diffs)
• CastleMasterContent/CastleMasterContent.contentproj (modified) (1 diff)
• CastleMasterContent/levels/levelTest.png (modified) (previous)
• CastleMasterContent/mobs/woodcutter.png (added)

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

@@ -75 +75 @@
   <ItemGroup>
     <Compile Include="Entities\Entity.cs" />
+    <Compile Include="Entities\EntityTestMob.cs" />
     <Compile Include="Entities\TileEntities\TileEntity.cs" />
     <Compile Include="Entities\TileEntities\TileEntityBlock.cs" />
@@ -88 +89 @@
     <Compile Include="Physics\BoundingRectangle.cs" />
     <Compile Include="Physics\BoundingRectangleOwner.cs" />
+    <Compile Include="Players\Player.cs" />
+    <Compile Include="Players\PlayerReal.cs" />
+    <Compile Include="Players\Team.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Game.cs" />
+    <Compile Include="Units\Unit.cs" />
     <Compile Include="World\Level.cs" />
     <Compile Include="World\LevelBuilder.cs" />

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Entities/Entity.cs

@@ -3 +3 @@
 using CastleMaster.World;
 using Microsoft.Xna.Framework;
+using System.Collections.Generic;
+using System;
+using CastleMaster.World.Tiles;
 
 namespace CastleMaster.Entities
@@ -10 +13 @@
         protected float x, z, width = 16.0F, depth = 16.0F;
         protected Level level;
-        protected BoundingRectangle boundingRect;
+        private BoundingRectangle boundingRect;
+        protected BoundingRectangle rectOffset;
         protected Vector2 renderOffset, screenPos;
         protected bool isSolid = true;
@@ -20 +24 @@
             screenPos = Vector2.Zero;
             Removed = false;
+            rectOffset = new BoundingRectangle(-width / 2, -depth / 2, width / 2, depth / 2, null);
         }
 
@@ -47 +52 @@
             screenPos.Y = (x + z) * Viewport.Y_SCALE - renderOffset.Y;
 
-            boundingRect = new BoundingRectangle(x - width / 2, z - depth / 2, x + width / 2, z + depth / 2, this);
+            boundingRect = new BoundingRectangle(x, z, x, z, this).AddSelf(rectOffset);
+        }
+
+        public void AddBoundingRect(ref List<BoundingRectangle> list, Entity ent)
+        {
+            if (ent != this)
+                list.Add(BoundingRectangle);
+        }
+
+        public virtual bool IsSolidTo(Entity ent)
+        {
+            return isSolid;
+        }
+
+        public bool Blocks(Entity ent)
+        {
+            return isSolid || ent.isSolid || IsSolidTo(ent) || ent.IsSolidTo(this);
+        }
+
+        public bool Move(float xd, float zd)
+        {
+            if (BoundingRectangle.XRight + xd > level.Width * Viewport.TILESIZE) return false;
+            if (BoundingRectangle.XLeft + xd < 0.0F) return false;
+            if (BoundingRectangle.ZFar + zd < 0.0F) return false;
+            if (BoundingRectangle.ZNear + zd > level.Height * Viewport.TILESIZE) return false;
+
+            int moveSteps = (int)(Math.Sqrt(xd * xd + zd * zd) + 1);
+
+            bool hasMoved = false;
+            for (int i = 0; i < moveSteps; i++)
+            {
+                hasMoved |= MovePart(xd / moveSteps, 0);
+                hasMoved |= MovePart(0, zd / moveSteps);
+            }
+
+            if (hasMoved)
+            {
+                screenPos.X = (x - z) * Viewport.X_SCALE - renderOffset.X;
+                screenPos.Y = (x + z) * Viewport.Y_SCALE - renderOffset.Y;
+                BoundingRectangle.Update(x, z, x, z).AddSelf(rectOffset);
+            }
+
+            return hasMoved;
+        }
+
+        private bool MovePart(float xd, float zd)
+        {
+            List<BoundingRectangle> collidables = level.GetCollidables(this, BoundingRectangle + new Vector2(xd, zd));
+
+            foreach (BoundingRectangle collidable in collidables)
+            {
+                collidable.Owner.OnTouchedBy(this);
+                OnTouched(collidable.Owner);
+            }
+
+            collidables.RemoveAll(br => SkipCollisionCheck(br.Owner));
+
+            if (collidables.Count > 0)
+            {
+                foreach (BoundingRectangle collidable in collidables)
+                {
+                    OnCollidedWith(collidable.Owner);
+                    collidable.Owner.OnCollidedBy(this);
+                }
+
+                return false;
+            }
+
+            x += xd;
+            z += zd;
+
+            BoundingRectangle.Update(x, z, x, z).AddSelf(rectOffset);
+
+            return true;
+        }
+
+        private bool SkipCollisionCheck(BoundingRectangleOwner collidableOwner)
+        {
+            if (typeof(Entity).IsAssignableFrom(collidableOwner.GetType()))
+                return !((Entity)collidableOwner).Blocks(this);
+            if (typeof(Tile).IsAssignableFrom(collidableOwner.GetType()))
+                return false;
+            return true;
         }
 
@@ -63 +150 @@
 
         public virtual void OnRemoved() { }
+
     }
 }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Entities/TileEntities/TileEntityBlock.cs

@@ -14 +14 @@
             this.spriteY = spriteY;
 
-            renderOffset.Y = 8;
+            renderOffset.Y = 16;
         }
 

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

@@ -10 +10 @@
 using Keys = System.Windows.Forms.Keys;
 using Viewport = CastleMaster.Graphics.Viewport;
+using CastleMaster.Players;
 
 namespace CastleMaster
@@ -20 +21 @@
         public const int WIDTH = 800;
         public const int HEIGHT = 600;
-        public const string TITLE = "Castle Master Alpha 0.1";
+        public const string TITLE = "Castle Master Alpha 0.2";
 
         private const string UPS_TEXT = " UPS: ";
@@ -31 +32 @@
         private Camera camera;
         private LevelTest level;
-        private int cameraSpeed = 10;
+        private Player[] players;
 
         #region Counter
@@ -47 +48 @@
             input = new InputHandler(Window);
             Random = new FastRandom();
+            players = new Player[2];
         }
 
@@ -59 +61 @@
             graphics.PreferredBackBufferWidth = WIDTH;
             graphics.PreferredBackBufferHeight = HEIGHT;
-            graphics.SynchronizeWithVerticalRetrace = false;
+            graphics.SynchronizeWithVerticalRetrace = true;
             graphics.ApplyChanges();
             Window.Title = TITLE;
@@ -80 +82 @@
 
             input.RegisterMouseKey(MouseButtons.Middle);
+        }
+
+        private void AddPlayer(Player p)
+        {
+            players[p.Team.ID] = p;
+            level.SetPlayer(p, p.Team.ID);
         }
 
@@ -109 +117 @@
             level = new LevelTest(Resources.LEVEL_TEST);
             camera = new Camera(level);
+            AddPlayer(new PlayerReal(new Team("The men", 0), level, camera));
         }
 
@@ -119 +128 @@
         {
             input.Update();
-            camera.Update();
 
             if (InputHandler.HasKeyBeenPressed(Keys.F4))
                 IsFixedTimeStep = !IsFixedTimeStep;
-
             if (InputHandler.HasKeyBeenPressed(Keys.Escape))
                 this.Exit();
-            if (InputHandler.IsKeyDown(Keys.W))
-                camera.YTop -= cameraSpeed;
-            if (InputHandler.IsKeyDown(Keys.S))
-                camera.YTop += cameraSpeed;
-            if (InputHandler.IsKeyDown(Keys.A))
-                camera.XLeft -= cameraSpeed;
-            if (InputHandler.IsKeyDown(Keys.D))
-                camera.XLeft += cameraSpeed;
 
             if (InputHandler.MouseScrollDelta > 1)
@@ -139 +138 @@
             else if (InputHandler.MouseScrollDelta < 0)
                 camera.Zoom(-Viewport.ZOOM_STEP);
+
+            foreach (Player p in players)
+                if (p != null)
+                    p.Update();
+
+            camera.Update();
 
             level.Update();

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

@@ -10 +10 @@
         private int xOffs = 0, yOffs = 0;
         private Vector2 mouseWorldPos, selectorPos, selectorPosZoomed;
-        private Point mouseTilePos, oldMousePos;
+        private Point mouseTilePos;
         private Level level;
-        private bool moveWorldWithMouse = false;
 
         public Camera(Level level)
@@ -21 +20 @@
             selectorPosZoomed = Vector2.Zero;
             mouseTilePos = Point.Zero;
-            oldMousePos = Point.Zero;
         }
 
@@ -52 +50 @@
         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);

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

@@ -9 +9 @@
         public static int SPRITESHEET_ICONS { get; private set; }
         public static Texture2D LEVEL_TEST { get; private set; }
+        public static int SPRITESHEET_WOODCUTTER { get; private set; }
 
         public static void LoadResources(ContentManager cm, RenderHelper renderer)
@@ -14 +15 @@
             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));
+            SPRITESHEET_WOODCUTTER = renderer.RegisterSpriteSheet(new SpriteSheet(cm.Load<Texture2D>("mobs/woodcutter"), 32, 32));
             LEVEL_TEST = cm.Load<Texture2D>("levels/levelTest");
         }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Physics/BoundingRectangle.cs

@@ -1 +1 @@
 
+using Microsoft.Xna.Framework;
 namespace CastleMaster.Physics
 {
@@ -47 +48 @@
         }
 
+        public BoundingRectangle AddSelf(float x0, float z0, float x1, float z1)
+        {
+            this.x0 += x0;
+            this.z0 += z0;
+            this.x1 += x1;
+            this.z1 += z1;
+
+            return this;
+        }
+
+        public BoundingRectangle AddSelf(BoundingRectangle br)
+        {
+            this.x0 += br.x0;
+            this.z0 += br.z0;
+            this.x1 += br.x1;
+            this.z1 += br.z1;
+
+            return this;
+        }
+
+        public static BoundingRectangle operator +(BoundingRectangle br, Vector2 vec)
+        {
+            return new BoundingRectangle(br.x0 + vec.X, br.z0 + vec.Y, br.x1 + vec.X, br.z1 + vec.Y, br.owner);
+        }
     }
 }

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

@@ -8 +8 @@
 using System.Collections.Generic;
 using Viewport = CastleMaster.Graphics.Viewport;
+using CastleMaster.Players;
 
 namespace CastleMaster.World
@@ -57 +58 @@
         private EntityComprarer comparer = new EntityComprarer();
         private AnimationHelper waterAnimation = new AnimationHelper(10, 2);
+        private Player[] players;
 
         public Level(Texture2D tileMap)
@@ -64 +66 @@
             height = tileMap.Height;
 
+            players = new Player[2];
             tiles = new int[width * height];
             data = new byte[width * height];
@@ -80 +83 @@
             InitLevel();
         }
+
+        public Player[] Players { get { return players; } }
 
         public int Width { get { return width; } }
@@ -181 +186 @@
         }
 
+        public void SetPlayer(Player player, int id)
+        {
+            players[id] = player;
+        }
+
         public void SetTile(int tileX, int tileZ, int tileID)
         {
@@ -242 +252 @@
         }
 
+        public List<BoundingRectangle> GetCollidables(Entity ent, BoundingRectangle entBR)
+        {
+            List<BoundingRectangle> result = new List<BoundingRectangle>();
+
+            int x0 = (int)(entBR.XLeft / Viewport.TILESIZE);
+            int z0 = (int)(entBR.ZFar / Viewport.TILESIZE);
+            int x1 = (int)(entBR.XRight / Viewport.TILESIZE);
+            int z1 = (int)(entBR.ZNear / Viewport.TILESIZE);
+
+            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;
+
+                    foreach (Entity e in entitiesInTiles[x + z * width])
+                    {
+                        if (e != ent && entBR.Intersects(e.BoundingRectangle))
+                            e.AddBoundingRect(ref result, ent);
+                    }
+
+                    Tile t = registeredTiles[tiles[x + z * width]];
+                    if (t.ID != TILE_VOID && t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR))
+                        t.AddBoundingRect(ref result, x, z);
+                }
+            }
+
+            return result;
+        }
+
         private bool IsValidPos(int tileX, int tileZ)
         {

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

@@ -2 +2 @@
 using CastleMaster.World.Tiles;
 using Microsoft.Xna.Framework.Graphics;
+using CastleMaster.Entities;
 
 namespace CastleMaster.World
@@ -24 +25 @@
             LevelBuilder lb = new LevelBuilder(this, tileMap);
 
+            lb.AddTile(0xFFFF0000, TILE_FLOOR);
             lb.AddTile(0xFF404040, TILE_FLOOR);
             lb.AddTile(0xFF0094FF, TILE_WATER);
@@ -36 +38 @@
             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.AddEntity(0xFFFF6A00, typeof(TileEntityBlock), 8.0F, 8.0F, this, 0, 0);
+            lb.AddEntity(0xFFE55B00, typeof(TileEntityBlock), 8.0F, 8.0F, this, 4, 1);
+            lb.AddEntity(0xFF00B200, typeof(TileEntityBlock), 8.0F, 8.0F, this, 2, 2);
+            lb.AddEntity(0xFF00CC00, typeof(TileEntityBlock), 8.0F, 8.0F, this, 1, 2);
+            lb.AddEntity(0xFF00E500, typeof(TileEntityBlock), 8.0F, 8.0F, this, 0, 2);
+            lb.AddEntity(0xFF00FF00, typeof(TileEntityBlock), 8.0F, 8.0F, this, 6, 0);
+            lb.AddEntity(0xFFFF0000, typeof(EntityTestMob), 0.0F, 0.0F, this);
 
             lb.BuildLevel();

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

@@ -1 +1 @@
 using CastleMaster.Graphics;
 using Microsoft.Xna.Framework;
+using CastleMaster.Physics;
+using CastleMaster.Entities;
+using System.Collections.Generic;
 
 namespace CastleMaster.World.Tiles
 {
-    public class Tile
+    public class Tile : BoundingRectangleOwner
     {
         private int id;
@@ -10 +13 @@
         public Tile(Level level)
         {
+            IsSolid = false;
             level.RegisteredTiles.Add(this);
             id = level.RegisteredTiles.Count - 1;
@@ -16 +20 @@
         public int ID { get { return id; } }
 
+        public bool IsSolid { get; protected set; }
+
+        public virtual BoundingRectangle GetBoundingRect(int xTile, int zTile)
+        {
+            return new BoundingRectangle(xTile * Viewport.ZOOM, zTile * Viewport.ZOOM, (xTile + 1) * Viewport.ZOOM, (zTile + 1) * Viewport.ZOOM, this);
+        }
+
+        public virtual void AddBoundingRect(ref List<BoundingRectangle> list, int xTile, int zTile)
+        {
+            list.Add(new BoundingRectangle(xTile * Viewport.ZOOM, zTile * Viewport.ZOOM, (xTile + 1) * Viewport.ZOOM, (zTile + 1) * Viewport.ZOOM, this));
+        }
+
         public virtual void Update(Level level, int tileX, int tileZ) { }
 
         public virtual void Render(RenderHelper renderer, Level level, Vector2 screenPos, int tileX, int tileZ, byte dataVal) { }
+
+        public virtual void OnTouched(BoundingRectangleOwner touching) { }
+
+        public virtual void OnTouchedBy(BoundingRectangleOwner toucher) { }
+
+        public virtual void OnCollidedWith(BoundingRectangleOwner colliding) { }
+
+        public virtual void OnCollidedBy(BoundingRectangleOwner collidable) { }
     }
 }

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

@@ -71 +71 @@
       <Processor>TextureProcessor</Processor>
     </Compile>
-    <Compile Include="mobs\units.png">
-      <Name>units</Name>
+    <Compile Include="mobs\woodcutter.png">
+      <Name>woodcutter</Name>
       <Importer>TextureImporter</Importer>
       <Processor>TextureProcessor</Processor>