Added damage dealt number popup

src/Blaze-Brigade/Blaze_Brigade/Game.cs

@@ -55,6 +55,8 @@ namespace Controller
         private SpriteFont largeFont; // custom font 2
         private SpriteFont largestFont; // custom font 3
         private float ElapsedTime = 0f;
+        private float damageDealtTime1 = 0f;
+        private float damageDealtTime2 = 0f;
 
         #endregion
 
@@ -258,6 +260,26 @@ namespace Controller
                         }
                     }
 
+                    if (GameState.currentPlayerDamagePopup)
+                    {
+                        damageDealtTime1 += (float)gameTime.ElapsedGameTime.TotalSeconds;
+                        if (damageDealtTime1 > 2.5)
+                        {
+                            GameState.currentPlayerDamagePopup = false;
+                            damageDealtTime1 = 0f;
+                        }
+                    }
+
+                    if (GameState.enemyPlayerDamagePopup)
+                    {
+                        damageDealtTime2 += (float)gameTime.ElapsedGameTime.TotalSeconds;
+                        if (damageDealtTime2 > 2.5)
+                        {
+                            GameState.enemyPlayerDamagePopup = false;
+                            damageDealtTime2 = 0f;
+                        }
+                    }
+
                     // removes deceased units in Player 1
                     foreach (Unit unit in player1.getUnits())
                     {
@@ -333,6 +355,18 @@ namespace Controller
                     }
                     #endregion
 
+                    if (GameState.currentPlayerDamagePopup)
+                    {
+                        spriteBatch.DrawString(largestFont, GameState.CurrentPlayerDamageDealt, GameState.lastDefendingUnit.PixelCoordinates + (new Vector2(2, -65)), Color.DarkRed, 0,
+                            Vector2.Zero, 1f, SpriteEffects.None, 0f); 
+                    }
+                    if (GameState.enemyPlayerDamagePopup)
+                    {
+                        spriteBatch.DrawString(largestFont, GameState.EnemyPlayerDamageDealt, GameState.lastAttackingUnit.PixelCoordinates + (new Vector2(2, -65)), Color.DarkRed, 0,
+                            Vector2.Zero, 1f, SpriteEffects.None, 0f);
+                    }
+
+
                     #region When Unit is selected
                     //if unit is currently clicked on
                     if (GameState.playableUnitSelected)

src/Blaze-Brigade/Blaze_Brigade/GameState.cs

@@ -77,7 +77,73 @@ namespace Model
         sets and gets whether it is currently transitioning turns
         */
         public static bool transitionTurn { get; set; }
-        /*
+        /**
+        Sets and gets whether damage dealt number pops up for current player
+        */
+        public static bool currentPlayerDamagePopup { get; set; }
+        /**
+        Stores the damage dealt by current player in their most recent attack
+        */
+        private static String currentPlayerDamageDealt;
+        /**
+        Sets and gets the current player's last attack
+        */
+        public static String CurrentPlayerDamageDealt
+        {
+            get
+            {
+                return currentPlayerDamageDealt;
+            }
+            set
+            {
+                int damage = Int32.Parse(value);
+                if (damage == 0)
+                {
+                    currentPlayerDamageDealt = "Miss";
+                }
+                else {
+                    currentPlayerDamageDealt = value;
+                }
+            }
+        }
+        /**
+        Sets and gets the current unit controlled in a 2nd location, for printing damage popup AFTER selectedUnit has been updated, since damage Popup should appear for a few seconds after action has finished
+        */
+        public static Unit lastAttackingUnit { get; set; }
+        /**
+        Sets and gets whether damage dealt number pops up for enemy player
+        */
+        public static bool enemyPlayerDamagePopup { get; set; }
+        /**
+        Stores the damage dealt by enemy player in their most recent attack
+        */
+        private static String enemyPlayerDamageDealt;
+        /**
+        Sets and gets the enemy player's last attack
+        */
+        public static String EnemyPlayerDamageDealt
+        {
+            get
+            {
+                return enemyPlayerDamageDealt;
+            }
+            set
+            {
+                int damage = Int32.Parse(value);
+                if (damage == 0)
+                {
+                    enemyPlayerDamageDealt = "Miss";
+                }
+                else {
+                    enemyPlayerDamageDealt = value;
+                }
+            }
+        }
+        /**
+        Sets and gets the current unit controlled in a 2nd location, for printing damage popup AFTER unitToAttack has been updated, since damage Popup should appear for a few seconds after action has finished
+        */
+        public static Unit lastDefendingUnit { get; set; }
+        /**
         Sets and gets movable nodes that can be retrieved without calling path finding
         */
         public static LinkedList<Node> moveableNodes { get; set; }

src/Blaze-Brigade/Blaze_Brigade/MouseHandler.cs

@@ -456,16 +456,12 @@ namespace Controller
                     button.Active = false;
                     unit.getButtonType(ButtonType.Move).Active = false;     // move button is no longer active
                     unit.getButtonType(ButtonType.Attack).Active = false;   // attack button is no longer active
-                    int attackDirection = 0;
-                    int counterAttackDirection = 0;
                     //Gets attack anaimation direction
                     #region Attack animation Direction
                     Direction attackDir = Direction.Up;
                     Direction counterAttackDir = Direction.Up;
                     if (unit.Position.Item1 < unit2.Position.Item1) //attack right
                     {
-                        attackDirection = 0;
-                        counterAttackDirection = 1;
                         attackDir = Direction.Right;
                         counterAttackDir = Direction.Left;
                         unit.setCurrentFrame(7);
@@ -473,8 +469,6 @@ namespace Controller
                     }
                     else if (unit.Position.Item1 > unit2.Position.Item1) //attack left
                     {
-                        attackDirection = 1;
-                        counterAttackDirection = 0;
                         attackDir = Direction.Left;
                         counterAttackDir = Direction.Right;
                         unit.setCurrentFrame(4);
@@ -482,8 +476,6 @@ namespace Controller
                     }
                     else if (unit.Position.Item2 < unit2.Position.Item2) //attack down
                     {
-                        attackDirection = 2;
-                        counterAttackDirection = 3;
                         attackDir = Direction.Down;
                         counterAttackDir = Direction.Up;
                         unit.setCurrentFrame(1);
@@ -491,15 +483,12 @@ namespace Controller
                     }
                     else if (unit.Position.Item2 > unit2.Position.Item2) //attack up
                     {
-                        attackDirection = 3;
-                        counterAttackDirection = 2;
                         attackDir = Direction.Up;
                         counterAttackDir = Direction.Down;
                         unit.setCurrentFrame(10);
                         unit2.setCurrentFrame(1);
                     }
                     #endregion
-                    attackAnimation(attackDir, unit);
 
                     bool attackType = false;
 
@@ -507,15 +496,22 @@ namespace Controller
                     attackType = findAttackType(unit);
 
                     int damageDealt = DamageCalculations.finalDamage(unit, unit2, attackType); //gets damage dealt
+                    GameState.lastAttackingUnit = unit;
+                    GameState.lastDefendingUnit = unit2;
+                    GameState.CurrentPlayerDamageDealt = damageDealt.ToString();
                     unit2.Hp = unit2.Hp - damageDealt; //updates hp
+                    GameState.currentPlayerDamagePopup = true;
+                    attackAnimation(attackDir, unit);
 
                     if (unit2.Alive && (GameFunction.isEnemyUnitInRange(graph, unit2, unit))) //if unit 2 is still alive, perform a counter attack
                     {
                         Thread.Sleep(750);
-                        attackAnimation(counterAttackDir, unit2);
                         attackType = findAttackType(unit2); //gets attack type 
                         int damageTaken = DamageCalculations.finalDamage(unit2, unit, attackType); //damage dealt
+                        GameState.EnemyPlayerDamageDealt = damageTaken.ToString();
                         unit.Hp = unit.Hp - damageTaken; //update hp
+                        GameState.enemyPlayerDamagePopup = true;
+                        attackAnimation(counterAttackDir, unit2);
                     }
                     GameState.attackConfirmOpen = false;
                     setSelectedUnit(null, false);