Kinda improved pathfinding algorithm. Still some work TODO.

Fixed some errors in DEBUG_VAR macro.
Shadows are now drawn before any other object.
Different strings are now shown depending on the number of selected units.
Some work on calculating actions mask when different types of units are selected. Still some work TODO.

1 files changed, 81 insertions, 50 deletions

diff --git a/Unit.c b/Unit.c
index dec342d..a75097b 100644
--- a/Unit.c
+++ b/Unit.c
@@ -135,7 +135,19 @@ void UnitInit(void)
 	UnitWalkingShadowSprTable[TOWN_CENTER].color = GFX_GRAY;
 }
 
-void UnitDraw(TYPE_UNIT* ptrUnit, TYPE_CAMERA* ptrCamera, bool bHighlighted)
+void UnitDrawShadow(TYPE_UNIT *ptrUnit, TYPE_CAMERA *ptrCamera)
+{
+    uint8_t id = ptrUnit->id;
+
+    CameraApplyCoordinatesToSprite( ptrCamera,
+                                    &UnitWalkingShadowSprTable[id],
+                                    ptrUnit->x + UnitShadowOffsetTable[id - FIRST_BUILDING_ID].x,
+                                    ptrUnit->y + UnitShadowOffsetTable[id - FIRST_BUILDING_ID].y  );
+
+    GfxDrawSprite(&UnitWalkingShadowSprTable[id]);
+}
+
+void UnitDraw(TYPE_UNIT *ptrUnit, TYPE_CAMERA* ptrCamera, bool bHighlighted)
 {
 	uint8_t id = ptrUnit->id;
 	TYPE_SPRITE* ptrSpr;
@@ -213,14 +225,6 @@ void UnitDraw(TYPE_UNIT* ptrUnit, TYPE_CAMERA* ptrCamera, bool bHighlighted)
         // *******************
         //      Buildings
         // *******************
-
-        CameraApplyCoordinatesToSprite( ptrCamera,
-                                        &UnitWalkingShadowSprTable[id],
-                                        ptrUnit->x + UnitShadowOffsetTable[id - FIRST_BUILDING_ID].x,
-                                        ptrUnit->y + UnitShadowOffsetTable[id - FIRST_BUILDING_ID].y  );
-
-        GfxDrawSprite(&UnitWalkingShadowSprTable[id]);
-
         ptrSpr = &UnitSprTable[id];
     }
 
@@ -269,23 +273,23 @@ TYPE_RESOURCES UnitNeededResourcesFromID(TYPE_UNIT_ID id)
     return UnitResourcesTable[id];
 }
 
-void UnitMoveTo(TYPE_UNIT* ptrUnit, uint16_t x, uint16_t y)
+void UnitMoveTo(TYPE_UNIT *ptrUnit, uint16_t x, uint16_t y)
 {
 	ptrUnit->target_x = x;
 	ptrUnit->target_y = y;
 	ptrUnit->walking = true;
 }
 
-void UnitAttackAccepted(TYPE_UNIT* ptrUnit)
+void UnitAttackAccepted(TYPE_UNIT *ptrUnit)
 {
     ptrUnit->selecting_attack = true;
 }
 
-bool UnitCheckCollisionAgainstOtherUnits(TYPE_COLLISION_BLOCK* cb, TYPE_UNIT* ptrUnitArray, TYPE_UNIT* ptrCurrentUnit)
+bool UnitCheckCollisionAgainstOtherUnits(TYPE_COLLISION_BLOCK* cb, TYPE_UNIT *ptrUnitArray, TYPE_UNIT* ptrCurrentUnit)
 {
     for (uint8_t i = 0; i < PLAYER_MAX_UNITS_BUILDINGS; i++)
     {
-        TYPE_UNIT* ptrOtherUnit = &ptrUnitArray[i];
+        TYPE_UNIT *ptrOtherUnit = &ptrUnitArray[i];
         TYPE_COLLISION_BLOCK ocb = {.x = ptrOtherUnit->x,
                                     .y = ptrOtherUnit->y,
                                     .w = UnitGetWidthFromID(ptrOtherUnit->id),
@@ -317,46 +321,84 @@ void UnitHandler(TYPE_UNIT* unitArray, size_t sz)
 
     for (i = 0; i < sz; i++)
     {
-        TYPE_UNIT* ptrUnit = &unitArray[i];
+        TYPE_UNIT *ptrUnit = &unitArray[i];
 
         if (ptrUnit->alive == false)
         {
             continue;
         }
 
-
         bool bMoving = true;
 
         if (ptrUnit->walking != false)
         {
+            int16_t x_dist = ptrUnit->target_x - (ptrUnit->x + (UnitGetWidthFromID(ptrUnit->id) >> 1));
+            int16_t y_dist = ptrUnit->target_y - (ptrUnit->y + (UnitGetHeightFromID(ptrUnit->id) >> 1));
+            uint8_t unit_speed = UnitSpeedTable[ptrUnit->id];
+
             int8_t x_d = 0;
             int8_t y_d = 0;
 
-            if ( (ptrUnit->x - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_x)
-            {
-                ptrUnit->dir = DIRECTION_LEFT;
-                x_d = (int8_t)-UnitSpeedTable[ptrUnit->id];
-            }
-            else if ( (ptrUnit->x + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_x)
-            {
-                ptrUnit->dir = DIRECTION_RIGHT;
-                x_d = (int8_t)UnitSpeedTable[ptrUnit->id];
-            }
-            else if ( (ptrUnit->y - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_y)
-            {
-                ptrUnit->dir = DIRECTION_UP;
-                y_d = (int8_t)-UnitSpeedTable[ptrUnit->id];
-            }
-            else if ( (ptrUnit->y + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_y)
+            if ( (uint16_t)abs(x_dist) > (uint16_t)(abs(y_dist) << 2) ) /* Add some hysteresis so unit does not change constantly its direction */
             {
-                ptrUnit->dir = DIRECTION_DOWN;
-                y_d = (int8_t)UnitSpeedTable[ptrUnit->id];
+                if (x_dist >= (int16_t)unit_speed)
+                {
+                    x_d = unit_speed;
+                    ptrUnit->dir = DIRECTION_RIGHT;
+                }
+                else if (x_dist <= (int16_t)-unit_speed)
+                {
+                    x_d = (int8_t)-unit_speed;
+                    ptrUnit->dir = DIRECTION_LEFT;
+                }
+                else
+                {
+                    bMoving = false;
+                }
             }
             else
             {
-                bMoving = false;
+                if (y_dist >= (int16_t)unit_speed)
+                {
+                    y_d = unit_speed;
+                    ptrUnit->dir = DIRECTION_DOWN;
+                }
+                else if (y_dist <= (int16_t)-unit_speed)
+                {
+                    y_d = (int8_t)-unit_speed;
+                    ptrUnit->dir = DIRECTION_UP;
+                }
+                else
+                {
+                    bMoving = false;
+                }
             }
 
+            //~ if ( (ptrUnit->x - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_x)
+            //~ {
+                //~ ptrUnit->dir = DIRECTION_LEFT;
+                //~ x_d = (int8_t)-UnitSpeedTable[ptrUnit->id];
+            //~ }
+            //~ else if ( (ptrUnit->x + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_x)
+            //~ {
+                //~ ptrUnit->dir = DIRECTION_RIGHT;
+                //~ x_d = (int8_t)UnitSpeedTable[ptrUnit->id];
+            //~ }
+            //~ else if ( (ptrUnit->y - UnitSpeedTable[ptrUnit->id]) > ptrUnit->target_y)
+            //~ {
+                //~ ptrUnit->dir = DIRECTION_UP;
+                //~ y_d = (int8_t)-UnitSpeedTable[ptrUnit->id];
+            //~ }
+            //~ else if ( (ptrUnit->y + UnitSpeedTable[ptrUnit->id]) < ptrUnit->target_y)
+            //~ {
+                //~ ptrUnit->dir = DIRECTION_DOWN;
+                //~ y_d = (int8_t)UnitSpeedTable[ptrUnit->id];
+            //~ }
+            //~ else
+            //~ {
+                //~ bMoving = false;
+            //~ }
+
             if (ptrUnit->walking != false)
             {
                 TYPE_COLLISION_BLOCK cu = { .x = ptrUnit->x + x_d,
@@ -366,33 +408,22 @@ void UnitHandler(TYPE_UNIT* unitArray, size_t sz)
 
                 if (UnitCheckCollisionAgainstOtherUnits(&cu, unitArray, ptrUnit) == true)
                 {
-                    uint32_t dist = 0;
-                    uint32_t dist2 = 0;
-
                     switch (ptrUnit->dir)
                     {
                         case DIRECTION_LEFT:
                             // Fall through
                         case DIRECTION_RIGHT:
-                            dist = SystemGetHyp(abs(ptrUnit->x - ptrUnit->target_x), abs((ptrUnit->y + y_d) - ptrUnit->target_y));
-                            dist2 = SystemGetHyp(abs(ptrUnit->x - ptrUnit->target_x), abs((ptrUnit->y - y_d) - ptrUnit->target_y));
-
-                            y_d = dist < dist2? x_d: -x_d;
-
-                            ptrUnit->dir = y_d? DIRECTION_DOWN: DIRECTION_UP;
-
+                            y_d = -x_d;
                             x_d = 0;
+                            ptrUnit->dir = y_d > 0? DIRECTION_DOWN: DIRECTION_UP;
                         break;
 
                         case DIRECTION_UP:
                             // Fall through
                         case DIRECTION_DOWN:
-                            dist = SystemGetHyp(abs((ptrUnit->x - x_d) - ptrUnit->target_x), abs(ptrUnit->y - ptrUnit->target_y));
-                            dist2 = SystemGetHyp(abs((ptrUnit->x + x_d) - ptrUnit->target_x), abs(ptrUnit->y - ptrUnit->target_y));
-
-                            x_d = dist < dist2? -y_d: -x_d;
-                            ptrUnit->dir = x_d? DIRECTION_RIGHT: DIRECTION_LEFT;
+                            x_d = y_d;
                             y_d = 0;
+                            ptrUnit->dir = x_d > 0? DIRECTION_RIGHT: DIRECTION_LEFT;
                         break;
                     }
                 }
@@ -410,7 +441,7 @@ void UnitHandler(TYPE_UNIT* unitArray, size_t sz)
     }
 }
 
-uint8_t UnitGetAvailableActions(TYPE_UNIT* ptrUnit)
+uint8_t UnitGetAvailableActions(TYPE_UNIT *ptrUnit)
 {
     return UnitActionsTable[ptrUnit->id];
 }