Rules are not template anymore (it was dumb)

Entities are now managed with unique_ptr to allow polymorphism (and good memory management)
Rules can be added via the Level object
Fixed Rule::findTarget not caring about targetType

TODO : Find why pathfinding (unlikely) or findTarget (most likely) is broken

src/Rule.cpp

@@ -3,3 +3,170 @@
 //
 
 #include "Rule.h"
+
+
+Rule::Rule(Entity* entity, State targetState, EntityType targetType,
+           std::vector<std::unique_ptr<Entity>>& entities,
+           const std::vector<pro_maat::GridPos>& occupiedSquares, const pro_maat::GridPos& mapSize)
+        : entity(entity),
+          targetState(targetState),
+          targetType(targetType),
+          entities(entities),
+          occupiedSquares(occupiedSquares),
+          mapSize(mapSize)
+{}
+
+void Rule::update()
+{
+    if (targetState == State::Moving || targetState == State::Fleeing)
+    {
+        entity->nextTarget = findTarget();
+        if(entity->nextTarget == entity->getPosition())
+        {
+            entity->nextState = State::Idle;
+        }
+        else
+        {
+            entity->nextState = targetState;
+        }
+        entity->update();
+    }
+    else if (targetState == State::Waiting)
+    {
+        entity->nextTarget = entity->getPosition();
+        entity->nextState = State::Waiting;
+        entity->update();
+    }
+    else
+    {
+        entity->nextTarget = entity->getPosition();
+        entity->nextState = State::Idle;
+        entity->update();
+    }
+}
+
+pro_maat::GridPos Rule::findTarget()
+{
+    // TODO : Sorting in place, consider using shared_ptr ?
+//    std::vector<Entity> sortedEntities{};
+//    sortedEntities.insert(sortedEntities.end(),entities.begin(),entities.end());
+
+    // Compares entities via their distance to the current entity
+    auto distanceSortEntities = [this](const std::unique_ptr<Entity>& leftHandSide, const std::unique_ptr<Entity>& rightHandSide){
+        return (pro_maat::manhattanDistance(entity->getPosition(),leftHandSide->getPosition()) <
+                pro_maat::manhattanDistance(entity->getPosition(),rightHandSide->getPosition()));
+    };
+
+    // Same but with grid coordinates
+    auto distanceSortSquares = [this](const pro_maat::GridPos& leftHandSide, const pro_maat::GridPos& rightHandSide){
+        return (pro_maat::manhattanDistance(entity->getPosition(),leftHandSide) <
+                pro_maat::manhattanDistance(entity->getPosition(),rightHandSide));
+    };
+
+    // 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) ||
+           std::find(occupiedSquares.begin(),occupiedSquares.end(),leftHandSide) != occupiedSquares.end())
+        {
+            return(false);
+        }
+        else if(!pro_maat::isInMap(rightHandSide,mapSize) ||
+                std::find(occupiedSquares.begin(),occupiedSquares.end(),rightHandSide) != occupiedSquares.end())
+        {
+            return(true);
+        }
+        else
+        {
+            return(leftHandSide < rightHandSide);
+        }};
+
+
+    // Sort in order to minimize entities to process
+    std::sort(entities.begin(),entities.end(),distanceSortEntities);
+
+    for(const auto& processingEntity : entities)
+    {
+        if(processingEntity->getType() != targetType) continue;
+
+        std::vector<pro_maat::GridPos> potentialTargets{};
+
+        pro_maat::GridUnit entityWidth = processingEntity->shape.getSize().x/pro_maat::pixelsPerUnit;
+        pro_maat::GridUnit entityHeight = processingEntity->shape.getSize().y/pro_maat::pixelsPerUnit;
+
+        potentialTargets.reserve((entityWidth+2)*2+entityHeight*2);
+
+        // Computes the top left corner of the entity
+        pro_maat::GridPos topLeftCorner = processingEntity->getPosition();
+        topLeftCorner.first -= entityWidth*0.5 - 1;
+        topLeftCorner.second -= 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);
+        }
+        // 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);
+        }
+
+
+        std::sort(potentialTargets.begin(),potentialTargets.end(),distanceSortSquares);
+        auto target = std::min_element(potentialTargets.begin(),potentialTargets.end(),bestTarget);
+
+        if(target != potentialTargets.end())
+        {
+            return (*target);
+        }
+    }
+
+    return (entity->getPosition());
+}
+
+
+////////////////////////
+//                    //
+// Delegate overrides //
+//                    //
+////////////////////////
+
+
+void Rule::move(Orientation orientation)
+{
+    entity->move(orientation);
+}
+
+State Rule::getState() const
+{
+    return entity->getState();
+}
+
+EntityType Rule::getType() const
+{
+    return entity->getType();
+}
+
+const sf::RectangleShape& Rule::getShape() const
+{
+    return entity->getShape();
+}
+
+pro_maat::GridPos Rule::getTarget() const
+{
+    return entity->getTarget();
+}
+
+const pro_maat::GridPos Rule::getPosition() const
+{
+    return entity->getPosition();
+}
+
+const std::vector<pro_maat::GridPos> Rule::getOccupiedSquares() const
+{
+    return entity->getOccupiedSquares();
+}