Merge branch 'master' of github.com:sippeangelo/DepthsBelow

Conflicts:
	DepthsBelow/DepthsBelow/Core.cs

DepthsBelow/DepthsBelow/Core.cs

@@ -23,6 +23,7 @@ namespace DepthsBelow
 
 		public Camera Camera;
 
+        public bool PlayerTurn = true;
 		public static MouseInput MouseInput;
         public static KeyboardInput KeyboardInput;
 		public List<Soldier> Squad;
@@ -86,6 +87,8 @@ namespace DepthsBelow
 			MouseInput.LoadContent();
             KeyboardInput = new KeyboardInput(this);
 
+            TestMonster.X = 12;
+            TestMonster.Y = 4;
 			// Test GUI frames
 			var frame = new GUI.Button()
 				            {
@@ -134,11 +137,24 @@ namespace DepthsBelow
             foreach (var body in Swarm)
                 body.Update(gameTime);
 
+            TestMonster.Update(gameTime);
 			GUIManager.Update(gameTime);
 
 			base.Update(gameTime);
 		}
 
+        public int FindDistance(Vector2 target, Vector2 start)
+        {
+            Vector2 combine = new Vector2(target.X - start.X, target.Y - start.Y);
+            
+            int result = 0;
+            int firstRestult = (int)Math.Sqrt((int)combine.X^2 + (int)combine.Y^2);
+
+            result = (int)Vector2.Distance(target, start);
+
+            return result;
+        }
+
 		/// <summary>
 		/// This is called when the game should draw itself.
 		/// </summary>

DepthsBelow/DepthsBelow/KeyboardInput.cs

@@ -13,6 +13,8 @@ namespace DepthsBelow
     public class KeyboardInput
     {
         Core core;
+        bool Enter = false;
+        bool turn;
 
         public KeyboardInput(Core core)
         {
@@ -23,12 +25,53 @@ namespace DepthsBelow
         {
             KeyboardState ks = Keyboard.GetState();
 
-            if (ks.IsKeyDown(Keys.Enter)) 
+            if (ks.IsKeyUp(Keys.Enter) && Enter == true) 
             {
-                foreach (var unit in core.Squad)
+                Enter = false;
+            }
+
+            if (ks.IsKeyDown(Keys.Enter) && Enter == false) 
+            {
+                Enter = true;
+                if (core.PlayerTurn == false)
                 {
-                    unit.step = 0;
+                    core.PlayerTurn = true;
+                    foreach (var unit in core.Squad)
+                    {
+                        unit.step = 0;
+                    }
                 }
+                else
+                {
+                    core.TestMonster.step = 0;
+                    core.PlayerTurn = false;
+                    Point target = Point.Zero;
+                    int distance = 7000;
+                    foreach (var unit in core.Squad)
+                    {
+                        Vector2 soldier = new Vector2(unit.Transform.Grid.X, unit.Transform.Grid.Y);
+                        Vector2 monster = new Vector2(core.TestMonster.Transform.Grid.X, core.TestMonster.Transform.Grid.Y);
+
+                        int newDistance = core.FindDistance(soldier, monster);
+                        if (newDistance < distance)
+                        {
+                            target = unit.Transform.Grid;
+                            distance = newDistance;
+                        }
+                    }
+                    core.TestMonster.GetComponent<Component.PathFinder>().Goal = target;
+                    distance = 7000;
+                }
+            }
+            if (ks.IsKeyDown(Keys.A)) 
+            {
+                /*foreach (var unit in core.Swarm)
+                {
+                    unit.X = 200;
+                    unit.Y = 200;
+                }*/
+                core.TestMonster.X = 12;
+                core.TestMonster.Y = 4;
             }
         }
     }

DepthsBelow/DepthsBelow/MouseInput.cs

@@ -49,112 +49,117 @@ namespace DepthsBelow
 			MouseState ms = Mouse.GetState();
 			Vector2 mouseWorldPos = core.Camera.ScreenToWorld(new Vector2(ms.X, ms.Y));
 			KeyboardState ks = Keyboard.GetState();
+            if (core.PlayerTurn == true)
+            {
+                // Selection rectangle
+                if (ms.LeftButton == ButtonState.Pressed)
+                {
 
-			// Selection rectangle
+                    if (selectionRectangle == Rectangle.Empty)
-			if (ms.LeftButton == ButtonState.Pressed)
-			{
-                
-				if (selectionRectangle == Rectangle.Empty)
-				{
-                    directionStart = mouseWorldPos;
-					selectionRectangle = new Rectangle((int)mouseWorldPos.X, (int)mouseWorldPos.Y, 0, 0);
-                    readjust = false;
-				}
-				else
-				{
-                    if (mouseWorldPos.X > directionStart.X && mouseWorldPos.Y < directionStart.Y || mouseWorldPos.X < directionStart.X && mouseWorldPos.Y > directionStart.Y)
                     {
-                        int rectangleX = (int)mouseWorldPos.X - ((int)mouseWorldPos.X - (int)directionStart.X);
+                        directionStart = mouseWorldPos;
-                        int rectangleY = (int)mouseWorldPos.Y;
+                        selectionRectangle = new Rectangle((int)mouseWorldPos.X, (int)mouseWorldPos.Y, 0, 0);
-                        int rectangleWidth = (int)mouseWorldPos.X - (int)directionStart.X;
+                        readjust = false;
-                        int rectangleHeight = (int)directionStart.Y - (int)mouseWorldPos.Y;
-                        selectionRectangle = new Rectangle(rectangleX, rectangleY, rectangleWidth, rectangleHeight);
-                        readjust = true;
                     }
                     else
                     {
-                        if (readjust == true)
+                        if (mouseWorldPos.X > directionStart.X && mouseWorldPos.Y < directionStart.Y || mouseWorldPos.X < directionStart.X && mouseWorldPos.Y > directionStart.Y)
                         {
-                            selectionRectangle = new Rectangle((int)directionStart.X, (int)directionStart.Y, 0, 0);
+                            int rectangleX = (int)mouseWorldPos.X - ((int)mouseWorldPos.X - (int)directionStart.X);
-                        }
+                            int rectangleY = (int)mouseWorldPos.Y;
-                        selectionRectangle.Width = (int)mouseWorldPos.X - selectionRectangle.X;
+                            int rectangleWidth = (int)mouseWorldPos.X - (int)directionStart.X;
-                        selectionRectangle.Height = (int)mouseWorldPos.Y - selectionRectangle.Y;
+                            int rectangleHeight = (int)directionStart.Y - (int)mouseWorldPos.Y;
-                        readjust = false;
+                            selectionRectangle = new Rectangle(rectangleX, rectangleY, rectangleWidth, rectangleHeight);
-                    }
+                            readjust = true;
-				}
-			}
-			// When the mouse is released
-			if (ms.LeftButton == ButtonState.Released && selectionRectangle != Rectangle.Empty)
-			{
-				// Deselect all units
-				if (!ks.IsKeyDown(Keys.LeftControl))
-				{
-					foreach (var unit in core.Squad)
-						unit.Selected = false;
-				}
-
-				// Select all units in the rectangle
-				foreach (var unit in core.Squad)
-				{
-					if (selectionRectangle.Intersects(unit.GetComponent<Component.Collision>().Rectangle))
-						unit.Selected = true;
-				}
-
-				// Hide the selection rectangle
-				selectionRectangle = Rectangle.Empty;
-			}
-
-			// Send orders with right click
-			if (ms.RightButton == ButtonState.Released && lastMouseState.RightButton == ButtonState.Pressed)
-			{
-				foreach (var unit in core.Squad)
-                    if (unit.Selected) 
-                    {
-						unit.GetComponent<Component.PathFinder>().Goal = Grid.WorldToGrid(mouseWorldPos);
-                    }
-
-			}
-            if (ms.RightButton == ButtonState.Pressed)
-            {
-                foreach (var unit in core.Squad)
-                {
-                    if (unit.Selected && gridRectangle.Intersects(unit.GetComponent<Component.Collision>().Rectangle))
-                    {
-                        checkingDirection = true;
-                        directionStart = unit.Transform.World + unit.Transform.World.Origin;
-                    }
-                }
-            }
-            if (checkingDirection == true && ms.RightButton == ButtonState.Pressed)
-            {
-                foreach (var unit in core.Squad)
-                    if (unit.Selected)
-                    {
-                        directionNow.X = mouseWorldPos.X;
-                        directionNow.Y = mouseWorldPos.Y;
-                        float directionX = mouseWorldPos.X - unit.Transform.World.X;
-                        float directionY = mouseWorldPos.Y - unit.Transform.World.Y;
-                        var mouseDirection = mouseWorldPos;
-                        mouseDirection.Normalize();
-                        //float angle = (float)Math.Acos(Vector2.Dot(new Vector2(0, 1), mouseDirection)) * MathHelper.TwoPi;
-                        /*if (directionX < 0)
-                        {
-                            directionX *= -1;
-                            unit.GetComponent<Component.Transform>().World.Rotation = (float)Math.Atan(directionY / directionX);
                         }
                         else
                         {
-                            */unit.GetComponent<Component.Transform>().World.Rotation = (float)Math.Atan2(mouseWorldPos.Y - unit.Transform.World.Y - unit.Transform.World.Origin.Y, mouseWorldPos.X - unit.Transform.World.X - unit.Transform.World.Origin.X);/*
+                            if (readjust == true)
-                        }*/
+                            {
-                        //Console.WriteLine(angle);
+                                selectionRectangle = new Rectangle((int)directionStart.X, (int)directionStart.Y, 0, 0);
-                        //unit.GetComponent<Component.Transform>().World.Rotation = angle;
+                            }
+                            selectionRectangle.Width = (int)mouseWorldPos.X - selectionRectangle.X;
+                            selectionRectangle.Height = (int)mouseWorldPos.Y - selectionRectangle.Y;
+                            readjust = false;
+                        }
+                    }
+                }
+                // When the mouse is released
+                if (ms.LeftButton == ButtonState.Released && selectionRectangle != Rectangle.Empty)
+                {
+                    // Deselect all units
+                    if (!ks.IsKeyDown(Keys.LeftControl))
+                    {
+                        foreach (var unit in core.Squad)
+                            unit.Selected = false;
                     }
-            }
-            else
-            {
-                checkingDirection = false;
-            }
 
+                    // Select all units in the rectangle
+                    foreach (var unit in core.Squad)
+                    {
+                        if (selectionRectangle.Intersects(unit.GetComponent<Component.Collision>().Rectangle))
+                            unit.Selected = true;
+                    }
+
+                    // Hide the selection rectangle
+                    selectionRectangle = Rectangle.Empty;
+                }
+
+                // Send orders with right click
+                if (ms.RightButton == ButtonState.Released && lastMouseState.RightButton == ButtonState.Pressed)
+                {
+                    if (checkingDirection == false)
+                    {
+                        foreach (var unit in core.Squad)
+                            if (unit.Selected)
+                            {
+                                unit.GetComponent<Component.PathFinder>().Goal = Grid.WorldToGrid(mouseWorldPos);
+                            }
+                    }
+
+                }
+                if (ms.RightButton == ButtonState.Pressed)
+                {
+                    foreach (var unit in core.Squad)
+                    {
+                        if (unit.Selected && gridRectangle.Intersects(unit.GetComponent<Component.Collision>().Rectangle))
+                        {
+                            checkingDirection = true;
+                            directionStart = unit.Transform.World + unit.Transform.World.Origin;
+                        }
+                    }
+                }
+                if (checkingDirection == true && ms.RightButton == ButtonState.Pressed)
+                {
+                    foreach (var unit in core.Squad)
+                        if (unit.Selected)
+                        {
+                            directionNow.X = mouseWorldPos.X;
+                            directionNow.Y = mouseWorldPos.Y;
+                            float directionX = mouseWorldPos.X - unit.Transform.World.X;
+                            float directionY = mouseWorldPos.Y - unit.Transform.World.Y;
+                            var mouseDirection = mouseWorldPos;
+                            mouseDirection.Normalize();
+                            //float angle = (float)Math.Acos(Vector2.Dot(new Vector2(0, 1), mouseDirection)) * MathHelper.TwoPi;
+                            /*if (directionX < 0)
+                            {
+                                directionX *= -1;
+                                unit.GetComponent<Component.Transform>().World.Rotation = (float)Math.Atan(directionY / directionX);
+                            }
+                            else
+                            {
+                                */
+                            unit.GetComponent<Component.Transform>().World.Rotation = (float)Math.Atan2(mouseWorldPos.Y - unit.Transform.World.Y - unit.Transform.World.Origin.Y, mouseWorldPos.X - unit.Transform.World.X - unit.Transform.World.Origin.X);/*
+                        }*/
+                            //Console.WriteLine(angle);
+                            //unit.GetComponent<Component.Transform>().World.Rotation = angle;
+                        }
+                }
+                else
+                {
+                    checkingDirection = false;
+                }
+            }
 			// Grid highlighting
 			Point mouseGridPos = Grid.WorldToGrid(mouseWorldPos);
 			Vector2 rectWorldPos = Grid.GridToWorld(mouseGridPos);

DepthsBelow/DepthsBelow/SmallEnemy.cs

@@ -18,6 +18,18 @@ namespace DepthsBelow
 
         private PathFinder.Node nextNode;
 
+        public int numberOfSteps = 5;
+        public int currentStep = 0;
+
+        public int step
+        {
+            get { return currentStep; }
+            set
+            {
+                currentStep = value;
+            }
+        }
+
         public SmallEnemy(Core core, ref List<SmallEnemy> swarm)
             : base(core)
         {
@@ -58,7 +70,7 @@ namespace DepthsBelow
         {
             base.Update(gameTime);
 
-            /*float elapsed = gameTime.ElapsedGameTime.Milliseconds / 1000.0f;
+            float elapsed = gameTime.ElapsedGameTime.Milliseconds / 1000.0f;
 
             if (nextNode == null)
                 nextNode = GetComponent<PathFinder>().Next();
@@ -81,7 +93,18 @@ namespace DepthsBelow
                     }
                 }
 
-
+                foreach (var soldier in core.Squad)
+                {
+                    var pathFinder = soldier.GetComponent<PathFinder>();
+                    var position = nextNode.Position;
+                    if (soldier.Transform.Grid == position)
+                    {
+                        soldierCollisions.Add(soldier.Transform.Grid);
+                        GetComponent<PathFinder>().RecreatePath(soldierCollisions);
+                        nextNode = GetComponent<PathFinder>().Next();
+                        break;
+                    }
+                }
 
                 if (nextNode != null)
                 {
@@ -98,10 +121,22 @@ namespace DepthsBelow
                         Transform.World.Y -= speed;
 
                     if (Transform.World == nodeWorldPos)
-                        nextNode = GetComponent<PathFinder>().Next();
+                    {
+                        if (currentStep < numberOfSteps)
+                        {
+                            currentStep++;
+                            //lastLastNode = lastNode;
+                            //lastNode = nextNode;
+                            nextNode = GetComponent<PathFinder>().Next();
+                        }
+                        else
+                        {
+                            GetComponent<PathFinder>().Stop();
+                        }
+                    }
                 }
 
-            }*/
+            }
         }
     }
 }

DepthsBelow/DepthsBelow/Soldier.cs

@@ -25,10 +25,7 @@ namespace DepthsBelow
 
         public int step 
         {
-            get
+            get { return currentStep; }
-            {
-                return currentStep;
-            }
             set 
             {
                 currentStep = value;