Fixed Rule::findTarget() not finding good or even valid targets

src/Rule.cpp

@@ -66,19 +66,26 @@ pro_maat::GridPos Rule::findTarget()
     // Get the smallest, non-occupied, inside the map square
     auto bestTarget = [this](const pro_maat::GridPos& leftHandSide, const pro_maat::GridPos& rightHandSide){
         // If the left hand side operand is not in the map or occupied, it is not valid
-        if(!pro_maat::isInMap(leftHandSide,mapSize) ||
+        if(!pro_maat::isInMap(leftHandSide,mapSize))
-           std::find(occupiedSquares.begin(),occupiedSquares.end(),leftHandSide) != occupiedSquares.end())
         {
             return(false);
         }
-        else if(!pro_maat::isInMap(rightHandSide,mapSize) ||
+        else if(std::find(occupiedSquares.begin(),occupiedSquares.end(),leftHandSide) != occupiedSquares.end())
-                std::find(occupiedSquares.begin(),occupiedSquares.end(),rightHandSide) != occupiedSquares.end())
+        {
+            return(false);
+        }
+        else if(!pro_maat::isInMap(rightHandSide,mapSize))
+        {
+            return(true);
+        }
+        else if(std::find(occupiedSquares.begin(),occupiedSquares.end(),rightHandSide) != occupiedSquares.end())
         {
             return(true);
         }
         else
         {
-            return(leftHandSide < rightHandSide);
+            return(pro_maat::manhattanDistance(entity->getPosition(),leftHandSide) <
+                   pro_maat::manhattanDistance(entity->getPosition(),rightHandSide));
         }};
 
 
@@ -96,23 +103,23 @@ pro_maat::GridPos Rule::findTarget()
 
         potentialTargets.reserve((entityWidth+2)*2+entityHeight*2);
 
-        // Computes the top left corner of the entity
+        // Computes the top left corner just outside of the entity
         pro_maat::GridPos topLeftCorner = processingEntity->getPosition();
-        topLeftCorner.first -= entityWidth*0.5 - 1;
+        topLeftCorner.first -= std::floor(entityWidth*0.5) + 1;
-        topLeftCorner.second -= entityHeight*0.5 - 1;
+        topLeftCorner.second -= std::floor(entityHeight*0.5) + 1;
 
 
         // Get all the top and bottom adjacent squares
         for(int i = 0;i<entityWidth+2;i++)
         {
             potentialTargets.emplace_back(topLeftCorner.first+i,topLeftCorner.second);
-            potentialTargets.emplace_back(topLeftCorner.first+i,topLeftCorner.second+entityHeight+2);
+            potentialTargets.emplace_back(topLeftCorner.first+i,topLeftCorner.second+entityHeight+1);
         }
         // Get the missing adjacent squares from the sides
         for(int i = 1;i<=entityHeight;i++)
         {
             potentialTargets.emplace_back(topLeftCorner.first,topLeftCorner.second+i);
-            potentialTargets.emplace_back(topLeftCorner.first+entityWidth+2,topLeftCorner.second+i);
+            potentialTargets.emplace_back(topLeftCorner.first+entityWidth+1,topLeftCorner.second+i);
         }
 
 
@@ -121,6 +128,7 @@ pro_maat::GridPos Rule::findTarget()
 
         if(target != potentialTargets.end())
         {
+            std::cout << "Target : (" << (*target).first << ","<< (*target).second << ")" << std::endl;
             return (*target);
         }
     }

src/Rule.h

@@ -7,6 +7,8 @@
 
 #include <vector>
 #include <algorithm>
+#include <math.h>
+#include <iostream>
 
 #include "Entity.h"
 

src/Utils.cpp

@@ -39,8 +39,8 @@ namespace pro_maat
 
     bool isInMap(const GridPos& square, const GridPos& gridSize)
     {
-        return (square.first < 0 || square.second < 0 ||
+        return !(square.first < 0 || square.second < 0 ||
-                square.first >= gridSize.first || square.second >= gridSize.second);
+                square.first > gridSize.first || square.second > gridSize.second);
     }
 
     float manhattanDistance(const GridPos& leftHandSide, const GridPos& rightHandSide)