Changeset 4581

Timestamp:

2013-07-23 14:56:43 (7 years ago)

Author:

dezhidki

Message:

Talletus.

Location:

2013/30/DenisZ

Files:

• CastleMaster/CastleMaster/CastleMaster/Ai (added)
• CastleMaster/CastleMaster/CastleMaster/Ai/AStar.cs (added)
• CastleMaster/CastleMaster/CastleMaster/Ai/Node.cs (added)
• CastleMaster/CastleMaster/CastleMaster/Ai/Orders (added)
• CastleMaster/CastleMaster/CastleMaster/Ai/Orders/Order.cs (added)
• CastleMaster/CastleMaster/CastleMaster/Ai/Orders/OrderMove.cs (added)
• CastleMaster/CastleMaster/CastleMaster/CastleMaster.csproj (modified) (3 diffs)
• CastleMaster/CastleMaster/CastleMaster/Entities/Entity.cs (modified) (5 diffs)
• CastleMaster/CastleMaster/CastleMaster/Game.cs (modified) (2 diffs)
• CastleMaster/CastleMaster/CastleMaster/Graphics/Camera.cs (modified) (1 diff)
• CastleMaster/CastleMaster/CastleMaster/Physics/BoundingRectangle.cs (modified) (2 diffs)
• CastleMaster/CastleMaster/CastleMaster/Players/Player.cs (modified) (1 diff)
• CastleMaster/CastleMaster/CastleMaster/Players/PlayerReal.cs (modified) (3 diffs)
• CastleMaster/CastleMaster/CastleMaster/Units/Mobs (added)
• CastleMaster/CastleMaster/CastleMaster/Units/Mobs/Mob.cs (added)
• CastleMaster/CastleMaster/CastleMaster/Units/Mobs/MobWoodcutter.cs (added)
• CastleMaster/CastleMaster/CastleMaster/Units/Unit.cs (modified) (2 diffs)
• CastleMaster/CastleMaster/CastleMaster/World/Level.cs (modified) (12 diffs)
• CastleMaster/CastleMaster/CastleMaster/World/LevelTest.cs (modified) (3 diffs)
• CastleMaster/CastleMaster/CastleMaster/World/Tiles/Tile.cs (modified) (1 diff)
• CastleMaster/CastleMaster/CastleMaster/World/Tiles/TileWater.cs (modified) (1 diff)
• CastleMaster/CastleMaster/CastleMasterContent/levels/levelTest.png (modified) (previous)
• Release (added)
• Release/Content (added)
• Release/Content/levels (added)
• Release/Content/levels/testLevel.xnb (added)
• Release/Content/misc (added)
• Release/Content/misc/icons.xnb (added)
• Release/Content/mobs (added)
• Release/Content/mobs/units.xnb (added)
• Release/Content/tiles (added)
• Release/Content/tiles/blocks.xnb (added)
• Release/Content/tiles/king.xnb (added)
• Release/Content/tiles/tilesheet.xnb (added)
• Release/IsometricEngineTest.exe (added)
• Release/IsometricEngineTest.pdb (added)

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

@@ -74 +74 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Ai\AStar.cs" />
+    <Compile Include="Ai\Node.cs" />
+    <Compile Include="Ai\Orders\Order.cs" />
+    <Compile Include="Ai\Orders\OrderMove.cs" />
     <Compile Include="Entities\Entity.cs" />
-    <Compile Include="Entities\EntityTestMob.cs" />
     <Compile Include="Entities\TileEntities\TileEntity.cs" />
     <Compile Include="Entities\TileEntities\TileEntityBlock.cs" />
@@ -95 +98 @@
     <Compile Include="Program.cs" />
     <Compile Include="Game.cs" />
+    <Compile Include="Units\Mobs\Mob.cs" />
+    <Compile Include="Units\Mobs\MobWoodcutter.cs" />
     <Compile Include="Units\Unit.cs" />
     <Compile Include="World\Level.cs" />
@@ -142 +147 @@
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="$(MSBuildExtensionsPath)\Microsoft\XNA Game Studio\Microsoft.Xna.GameStudio.targets" />

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

@@ -17 +17 @@
         protected Vector2 renderOffset, screenPos;
         protected bool isSolid = true;
+        protected float moveSpeed = 0.0F;
 
         public Entity(Level level)
@@ -40 +41 @@
             set { z = value; }
         }
+
+        public float Width { get { return width; } }
+
+        public float Depth { get { return depth; } }
 
         public BoundingRectangle BoundingRectangle { get { return boundingRect; } }
@@ -68 +73 @@
         public bool Blocks(Entity ent)
         {
-            return isSolid || ent.isSolid || IsSolidTo(ent) || ent.IsSolidTo(this);
+            return isSolid && ent.isSolid && IsSolidTo(ent) && ent.IsSolidTo(this);
         }
 
@@ -91 +96 @@
                 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);
             }
 
@@ -99 +103 @@
         private bool MovePart(float xd, float zd)
         {
+            if (xd != 0 && zd != 0) return false;
+
             List<BoundingRectangle> collidables = level.GetCollidables(this, BoundingRectangle + new Vector2(xd, zd));
 

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

@@ -82 +82 @@
 
             input.RegisterMouseKey(MouseButtons.Middle);
+            input.RegisterMouseKey(MouseButtons.Right);
+            input.RegisterMouseKey(MouseButtons.Left);
         }
 
@@ -118 +120 @@
             camera = new Camera(level);
             AddPlayer(new PlayerReal(new Team("The men", 0), level, camera));
+            level.InitLevel();
+            camera.CenterOn(level.Width / 2 * Viewport.TILESIZE, level.Height / 2 * Viewport.TILESIZE);
         }
 

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

@@ -46 +46 @@
             set { yOffs = value - Game.HEIGHT; }
         }
+
+        public Vector2 MouseWorldPos { get { return mouseWorldPos; } }
         #endregion
 

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

@@ -39 +39 @@
         public bool Intersects(float x0, float z0, float x1, float z1)
         {
-            if (x0 >= this.x1 && x1 <= this.x0 && z0 >= this.z1 && z1 <= this.z0) return false;
+            if (x0 >= this.x1 || x1 <= this.x0 || z0 >= this.z1 || z1 <= this.z0) return false;
             return true;
         }
@@ -72 +72 @@
             return new BoundingRectangle(br.x0 + vec.X, br.z0 + vec.Y, br.x1 + vec.X, br.z1 + vec.Y, br.owner);
         }
+
+        public BoundingRectangle Scale(float s)
+        {
+            this.x0 *= s;
+            this.z0 *= s;
+            this.x1 *= s;
+            this.z1 *= s;
+
+            return this;
+        }
     }
 }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Players/Player.cs

@@ -21 +21 @@
         }
 
+        public Level Level { get { return level; } }
+
+        public Camera Camera { get { return camera; } }
+
         public Team Team { get { return team; } }
 

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Players/PlayerReal.cs

@@ -8 +8 @@
 using System.Windows.Forms;
 using Microsoft.Xna.Framework;
+using CastleMaster.Units;
 
 namespace CastleMaster.Players
@@ -15 +16 @@
         private bool moveWorldWithMouse = false;
         private Point oldMousePos;
+        private Unit selectedUnit;
 
         public PlayerReal(Team team, Level level, Camera camera)
@@ -41 +43 @@
                 else moveWorldWithMouse = false;
             }
+
+            if (InputHandler.HasMouseButtonBeenPressed(MouseButtons.Right))
+            {
+                Unit u = SelectUnit();
+                if (selectedUnit != null)
+                    selectedUnit.OnSelectLost();
+                selectedUnit = u;
+                if (selectedUnit != null)
+                    selectedUnit.OnSelectGain();
+            }
+
+            if (InputHandler.HasMouseButtonBeenPressed(MouseButtons.Left))
+            {
+                if (selectedUnit != null)
+                    selectedUnit.OnFunctionClick();
+            }
+        }
+
+        public Unit SelectUnit()
+        {
+            float mouseX = InputHandler.MouseX + camera.XLeft;
+            float mouseY = InputHandler.MouseY + camera.YTop;
+
+            float r = 1.0F;
+            List<Unit> units = level.GetUnitsWithinScreenSpace(mouseX - r, mouseY - r, mouseX + r, mouseY + r, this);
+
+            Unit current = null;
+            float dist = 0.0F;
+            foreach (Unit u in units)
+            {
+                float udist = u.DistanceFromScreenSpaceSqr(mouseX, mouseY);
+                if (current == null || udist < dist)
+                {
+                    current = u;
+                    dist = udist;
+                }
+            }
+
+            return current;
         }
     }

2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Units/Unit.cs

@@ -6 +6 @@
 using CastleMaster.World;
 using CastleMaster.Players;
+using CastleMaster.Physics;
+using Microsoft.Xna.Framework;
+using CastleMaster.Graphics;
 
 namespace CastleMaster.Units
@@ -12 +15 @@
     {
         protected bool isSelectable, isSelected;
+        protected BoundingRectangle screenRect;
+        protected BoundingRectangle screenRectOffset;
+        protected Vector2 highlightOffset = Vector2.Zero;
+        protected Point spriteSize;
+        private float timer = -MathHelper.TwoPi, arrowSpeed = 0.1F;
+        private Vector2 arrowOffs = Vector2.Zero;
+        private Player owner;
 
         public Unit(Level level, Player owner)
             : base(level)
         {
+            this.owner = owner;
+
+            spriteSize = new Point(32, 32);
+            screenRectOffset = new BoundingRectangle(0, 0, spriteSize.X, spriteSize.Y, null);
             isSelectable = true;
             isSelected = false;
         }
+
+        public bool IsSelectable { get { return isSelectable; } }
+
+        public Player Owner { get { return owner; } }
+
+        public override void Init()
+        {
+            base.Init();
+        }
+
+        public virtual void OnSelectGain()
+        {
+            isSelected = true;
+        }
+
+        public virtual void OnSelectLost()
+        {
+            isSelected = false;
+        }
+
+        public virtual void OnFunctionClick() { }
+
+        public override void Update()
+        {
+            if (isSelected)
+            {
+                timer += arrowSpeed;
+                if (timer >= MathHelper.TwoPi) timer = -MathHelper.TwoPi;
+                arrowOffs.Y = (float)Math.Sin(timer) * 2.0F;
+            }
+        }
+
+        public bool IntersectsWithScreenSpace(float x0, float y0, float x1, float y1)
+        {
+            if (!isSelectable) return false;
+            screenRect = new BoundingRectangle(screenPos.X, screenPos.Y, screenPos.X, screenPos.Y, this).AddSelf(screenRectOffset).Scale(Viewport.ZOOM);
+            return screenRect.Intersects(x0, y0, x1, y1);
+        }
+
+        public float DistanceTo(float x, float z)
+        {
+            float xd = X - x;
+            float zd = Z - z;
+
+            return (float)(Math.Sqrt(xd * xd + zd * zd));
+        }
+
+        public float DistanceFromScreenSpaceSqr(float x, float y)
+        {
+            float dx = screenPos.X * Viewport.ZOOM - x;
+            float dy = screenPos.Y * Viewport.ZOOM - y;
+
+            return dx * dx + dy * dy;
+        }
+
+        public virtual void RenderHighLight(RenderHelper renderer)
+        {
+            renderer.Render((screenPos + highlightOffset + arrowOffs) * Viewport.ZOOM, 1, 0, Resources.SPRITESHEET_ICONS, Viewport.ZOOM);
+        }
+
+        public override void Render(RenderHelper renderer)
+        {
+            if (isSelected)
+                RenderHighLight(renderer);
+        }
     }
 }

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

@@ -9 +9 @@
 using Viewport = CastleMaster.Graphics.Viewport;
 using CastleMaster.Players;
+using CastleMaster.Units;
+using CastleMaster.Units.Mobs;
 
 namespace CastleMaster.World
@@ -53 +55 @@
         private List<TileEntity> tileEntities;
         private List<Entity>[] entitiesInTiles;
-        private SortedSet<Entity> entitesToRender;
+        private List<Entity> entitesToRender;
+        private List<Unit>[] units;
         private int width, height;
         protected Texture2D tileMap;
@@ -74 +77 @@
             InitTiles();
 
+            units = new List<Unit>[2];
+            units[0] = new List<Unit>();
+            units[1] = new List<Unit>();
+
             entities = new List<Entity>();
             tileEntities = new List<TileEntity>();
@@ -79 +86 @@
             for (int i = 0; i < width * height; i++)
                 entitiesInTiles[i] = new List<Entity>();
-            entitesToRender = new SortedSet<Entity>(comparer);
-
-            InitLevel();
+            entitesToRender = new List<Entity>();
         }
 
@@ -96 +101 @@
         protected virtual void InitTiles() { }
 
-        protected virtual void InitLevel() { }
+        public virtual void InitLevel() { }
 
         public void RenderBackground(Camera camera, RenderHelper renderer)
@@ -135 +140 @@
             if (entitesToRender.Count > 0)
             {
+                entitesToRender.Sort(comparer);
+
                 renderer.SetOffset(camera);
 
@@ -168 +175 @@
                 ent.Update();
 
-                if (ent.Removed)
-                {
-                    RemoveEntity(ent);
-                    TakeEntity(ent, xTile_old, zTile_old);
-                    continue;
-                }
+                //if (ent.Removed)
+                //{
+                //    RemoveEntity(ent);
+                //    TakeEntity(ent, xTile_old, zTile_old);
+                //    continue;
+                //}
 
                 int xTile = (int)(ent.X / Viewport.TILESIZE);
@@ -230 +237 @@
                 entities.Add(ent);
 
+            if(typeof(Unit).IsAssignableFrom(ent.GetType()))
+            {
+                Unit u = (Unit)ent;
+                units[u.Owner.Team.ID].Add(u);
+            }
+
             InsertEntity(ent, xTile, zTile);
         }
@@ -252 +265 @@
         }
 
-        public List<BoundingRectangle> GetCollidables(Entity ent, BoundingRectangle entBR)
+        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>();
 
-            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);
+            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++)
@@ -268 +296 @@
                     if (x < 0 || x >= width) continue;
 
-                    foreach (Entity e in entitiesInTiles[x + z * width])
+                    List<Entity> entits = entitiesInTiles[x + z * width];
+
+                    foreach (Entity e in entits)
                     {
                         if (e != ent && entBR.Intersects(e.BoundingRectangle))
@@ -275 +305 @@
 
                     Tile t = registeredTiles[tiles[x + z * width]];
-                    if (t.ID != TILE_VOID && t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR))
+                    if (t.IsSolid && t.GetBoundingRect(x, z).Intersects(entBR))
                         t.AddBoundingRect(ref result, x, z);
                 }
@@ -287 +317 @@
             return (tileX >= 0 && tileZ >= 0 && tileX < width && tileZ < height);
         }
+
+        public bool[] BuildSolidnessTable(Mob mob)
+        {
+            bool[] result = new bool[tiles.Length];
+
+            for (int i = 0; i < tiles.Length; i++)
+            {
+                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;
+        }
     }
 }

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

@@ -3 +3 @@
 using Microsoft.Xna.Framework.Graphics;
 using CastleMaster.Entities;
+using CastleMaster.Units;
+using CastleMaster.Units.Mobs;
 
 namespace CastleMaster.World
@@ -21 +23 @@
         }
 
-        protected override void InitLevel()
+        public override void InitLevel()
         {
             LevelBuilder lb = new LevelBuilder(this, tileMap);
@@ -44 +46 @@
             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.AddEntity(0xFFFF0000, typeof(MobWoodcutter), 8.0F, 8.0F, this, Players[0]);
 
             lb.BuildLevel();

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

@@ -24 +24 @@
         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);
+            float x = xTile * Viewport.TILESIZE;
+            float z = zTile * Viewport.TILESIZE;
+
+            return new BoundingRectangle(x, z, x + Viewport.TILESIZE, z + Viewport.TILESIZE, 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));
+            list.Add(GetBoundingRect(xTile, zTile));
         }
 

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

@@ -9 +9 @@
             : base(level)
         {
+            IsSolid = true;
         }