Updated the supplier behavior to also use storage and implemented tower.

compile_commands.json

@@ -1 +1 @@
-/home/douwe/Projects/screeps/build/compile_commands.json
+/mnt/douwe/hdd/Projects/Screeps/build/compile_commands.json

douwco_hivemind/include/Constants.hpp

@@ -0,0 +1,9 @@
+#ifndef DOUWCO_HIVEMIND_CONSTANTS_HPP
+#define DOUWCO_HIVEMIND_CONSTANTS_HPP
+
+namespace DouwcoHivemind
+{
+    enum CreepRole { UNEMPLOYED, SUPPLIER, UPGRADER, BUILDER, MAINTAINER, MINER };
+}
+
+#endif // DOUWCO_HIVEMIND_CONSTANTS_HPP

douwco_hivemind/include/Creeps/CreepBase.hpp

@@ -2,48 +2,36 @@
 #define DOUWCO_HIVEMIND_CREEPBASE_HPP
 
 #include <Screeps/Creep.hpp>
+#include "Constants.hpp"
 
-namespace Screeps{
-    class RoomPosition;
-    class RoomObject;
-    class PathStep;
-}
+namespace Screeps {
+class RoomPosition;
+class RoomObject;
+class PathStep;
+} // namespace Screeps
 
-namespace DouwcoHivemind
-{
-    enum CreepRole
-    {
-        UNEMPLOYED,
-        SUPPLIER,
-        UPGRADER,
-        BUILDER,
-        MAINTAINER
-    };
+namespace DouwcoHivemind {
 
-    class CreepBase
-    {
-    public:
-        CreepRole role;
-        std::string target_id;
+class CreepBase {
+public:
+  CreepRole role;
+  std::string target_id;
 
-    protected:
-        Screeps::Creep creep;
-        JSON memory;
+protected:
+  Screeps::Creep creep;
+  JSON memory;
 
-    public:
-        CreepBase(Screeps::Creep crp);
-        virtual ~CreepBase();
-        virtual void loop() {}
+public:
+  CreepBase(Screeps::Creep crp);
+  virtual ~CreepBase();
+  virtual void loop() {}
 
+  bool isNearTo(const Screeps::RoomPosition &pos, int dist);
 
-
-        bool isNearTo(const Screeps::RoomPosition &pos, int dist);
-
-        
-    protected:
-        void moveToTarget(int dist = 1);
-        std::unique_ptr<Screeps::RoomObject> getRoomObjectTarget();
-    };
-}
+protected:
+  void moveToTarget(int dist = 1);
+  std::unique_ptr<Screeps::RoomObject> getRoomObjectTarget();
+};
+} // namespace DouwcoHivemind
 
 #endif // DOUWCO_HIVEMIND_CREEPBASE_HPP

douwco_hivemind/include/Creeps/Miner.hpp

@@ -0,0 +1,21 @@
+#ifndef DOUWCO_HIVEMIND_MINER_HPP
+#define DOUWCO_HIVEMIND_MINER_HPP
+
+#include "Creeps/CreepBase.hpp"
+#include <string>
+
+namespace DouwcoHivemind
+{
+    class Miner : public CreepBase
+    {
+    private:
+        bool arrivedAtContainer;
+
+    public:
+        Miner(Screeps::Creep crp);
+        ~Miner() override;
+        void loop() override;
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_MINER_HPP

douwco_hivemind/include/Creeps/Worker.hpp

@@ -2,6 +2,7 @@
 #define DOUWCO_HIVEMIND_HARVESTER_HPP
 
 #include "Creeps/CreepBase.hpp"
+#include "Screeps/StructureContainer.hpp"
 
 namespace DouwcoHivemind
 {
@@ -9,6 +10,7 @@ namespace DouwcoHivemind
     {
     private:
         bool harvesting;
+        bool foundContainer;
 
     public:
         Worker(Screeps::Creep crp);
@@ -20,9 +22,13 @@ namespace DouwcoHivemind
         virtual void depositEnergy(){}
     
     private:
+        void getEnergy();
         void harvestSource();
+        void collectEnergyFromContainers();
         std::unique_ptr<Screeps::Source> getSourceTarget();
+        std::unique_ptr<Screeps::StructureContainer> getContainerTarget();
         void searchSource();
+        void searchContainer();
     };
 }
 

douwco_hivemind/include/Engine.hpp

@@ -4,7 +4,7 @@
 #include <vector>
 
 #include "Creeps/CreepBase.hpp"
-#include "Room.hpp"
+#include "Entity/Room.hpp"
 #include "Structures/StructureBase.hpp"
 
 namespace DouwcoHivemind {

douwco_hivemind/include/Entity/Room.hpp

@@ -19,7 +19,7 @@ public:
   void loop();
 
 protected:
-  bool placeContainers();
+  void placeContainers();
 };
 } // namespace DouwcoHivemind
 

douwco_hivemind/include/Structures/Tower.hpp

@@ -0,0 +1,24 @@
+#ifndef DOUWCO_HIVEMIND_TOWER_HPP
+#define DOUWCO_HIVEMIND_TOWER_HPP
+
+#include <Screeps/StructureTower.hpp>
+
+#include "Structures/StructureBase.hpp"
+
+namespace DouwcoHivemind
+{
+    class Tower : public StructureBase
+    {
+    private:
+        Screeps::StructureTower tower;
+
+    public:
+        Tower(Screeps::StructureTower twr) : tower(twr),
+                                              StructureBase() {}
+        ~Tower() {}
+
+        void loop() override;
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_TOWER_HPP

douwco_hivemind/src/Creeps/CreepBase.cpp

@@ -4,144 +4,142 @@
 #include <Screeps/Room.hpp>
 #include <Screeps/RoomPosition.hpp>
 #include <cstddef>
+#include <cstdlib>
 
 #include "Creeps/CreepBase.hpp"
 
 #include "Tools/JsonTool.hpp"
-#include "Tools/PathTool.hpp"
 #include "Tools/MeasureTool.hpp"
+#include "Tools/PathTool.hpp"
 
-DouwcoHivemind::CreepBase::CreepBase(Screeps::Creep crp) : creep(crp),
-                                                   memory(crp.memory())
-{
-    role = memory.contains("role") ? static_cast<CreepRole>(memory["role"]) : CreepRole::UNEMPLOYED;
-    target_id = memory.contains("target_id") ? static_cast<std::string>(memory["target_id"]) : std::string();
+DouwcoHivemind::CreepBase::CreepBase(Screeps::Creep crp)
+    : creep(crp), memory(crp.memory()) {
+  role = memory.contains("role") ? static_cast<CreepRole>(memory["role"])
+                                 : CreepRole::UNEMPLOYED;
+  target_id = memory.contains("target_id")
+                  ? static_cast<std::string>(memory["target_id"])
+                  : std::string();
 }
 
-DouwcoHivemind::CreepBase::~CreepBase()
-{
-    memory["role"] = role;
-    memory["target_id"] = target_id;
-    creep.setMemory(memory);
+DouwcoHivemind::CreepBase::~CreepBase() {
+  memory["role"] = role;
+  memory["target_id"] = target_id;
+  creep.setMemory(memory);
 }
 
-void DouwcoHivemind::CreepBase::moveToTarget(int dist)
-{
-    // Is move required?
-    auto target = getRoomObjectTarget();  
-    if (isNearTo(target->pos(), dist))
-    {
-        memory.erase("path");
-        return;
+void DouwcoHivemind::CreepBase::moveToTarget(int dist) {
+  // Is move required?
+  auto target = getRoomObjectTarget();
+  if (isNearTo(target->pos(), dist)) {
+    memory.erase("path");
+    return;
+  }
+
+  // Is wating?
+  if (memory.contains("wait") && memory["wait"] > 0) {
+    memory["wait"] = memory["wait"].get<int>() - 1;
+    creep.say("Waiting..");
+    return;
+  }
+
+  // Is there a path to walk?
+  if (!memory.contains("path") || memory["path"].empty()) {
+    creep.say("Searching route!");
+    auto target_pos = target->pos();
+    auto path = creep.room().findPath(creep.pos(), target_pos);
+    auto last = path.back();
+    if (dist == 0) {
+      Screeps::Room::PathStep step;
+      step.x = target_pos.x();
+      step.y = target_pos.y();
+      step.dx = step.x - last.x;
+      step.dy = step.y - last.y;
+      path.push_back(step);
     }
-
-    // Is wating?
-    if (memory.contains("wait") && memory["wait"] > 0)
-    {
-        memory["wait"] = memory["wait"].get<int>() - 1;
-        creep.say("Waiting..");
-        return;
+    if (abs(last.x - target_pos.x()) > dist ||
+        abs(last.y - target_pos.y()) > dist) {
+      creep.say("No possible path");
+      memory["wait"] = rand() % 20;
+      return;
     }
+    memory["path"] = vectorToJson(flattenPathSteps(path));
+  }
 
-    // Is there a path to walk?
-    if (!memory.contains("path") || memory["path"].empty())
-    {
-        creep.say("Searching route!");
-        auto target_pos = target->pos();
-        auto path = creep.room().findPath(creep.pos(), target_pos);
-        auto last = path.back();
-        if (last.x - target_pos.x() > dist || last.y - target_pos.y() > dist)
-        {
-            creep.say("No possible path");
-            memory["wait"] = rand() % 20;
-            return;
-        }
-        memory["path"] = vectorToJson(flattenPathSteps(path));
+  // JS::console.log(std::string("creep pos: [") +
+  //                 std::to_string(creep.pos().x()) +
+  //                 std::string(",") +
+  //                 std::to_string(creep.pos().y()) +
+  //                 std::string("]"));
+
+  // Get step from memory
+  int pathStepData[5] = {0};
+  if (memory["path"].size() > 5) {
+    for (int i = 0; i < 5; i++) {
+      pathStepData[i] = memory["path"][i];
     }
+  } else {
+    memory.erase("path");
+    return;
+  }
 
-    // JS::console.log(std::string("creep pos: [") +
-    //                 std::to_string(creep.pos().x()) +
-    //                 std::string(",") +
-    //                 std::to_string(creep.pos().y()) +
-    //                 std::string("]"));
+  // Is the move of last tick executed?
+  int x = creep.pos().x();
+  int y = creep.pos().y();
 
-    // Get step from memory   
-    int pathStepData[5] = {0};
-    if (memory["path"].size() > 5)
-    {
-        for (int i = 0; i < 5; i++)
-        {
-            pathStepData[i] = memory["path"][i];
-        }
+  Screeps::Room::PathStep step;
+  step.x = pathStepData[0];
+  step.y = pathStepData[1];
+  step.dx = pathStepData[2];
+  step.dy = pathStepData[3];
+  step.direction = pathStepData[4];
+
+  if (memory.contains("last_pos")) {
+    int last_x = memory["last_pos"]["x"];
+    int last_y = memory["last_pos"]["y"];
+    memory.erase("last_pos");
+    if (x == last_x && y == last_y) {
+      creep.say("I'm stuck!");
+      memory["wait"] = rand() % 5;
+      return;
     }
-    else
-    {
-        memory.erase("path");
-        return;
-    }
-
-    // Is the move of last tick executed?
-    int x = creep.pos().x();
-    int y = creep.pos().y();
-    
-    Screeps::Room::PathStep step;
-    step.x = pathStepData[0];
-    step.y = pathStepData[1];
-    step.dx = pathStepData[2];
-    step.dy = pathStepData[3];
-    step.direction = pathStepData[4];
-
-    if (memory.contains("last_pos"))
-    {
-        int last_x = memory["last_pos"]["x"];
-        int last_y = memory["last_pos"]["y"];
-        memory.erase("last_pos");
-        if (x == last_x && y == last_y)
-        {
-            creep.say("I'm stuck!");
-            memory["wait"] = rand() % 5;
-            return;
-        }
-    }
-
-    // Is the creep on the place intended by the path?
-    if (!(x == step.x - step.dx && y == step.y - step.dy))
-    {
-        creep.say("I'm lost!");
-        memory["wait"] = rand() % 5;
-        memory.erase("path");
-        return;
-    }
-
-    // Lets move forward
-    int resp = creep.move(step.direction);
-    if (resp == Screeps::OK)
-    {
-        memory["last_pos"]["x"] = x;
-        memory["last_pos"]["y"] = y;
-
-        for (int i = 0; i < 5; i++)
-        {
-            memory["path"].erase(0);
-        }
+  }
+
+  // Is the creep on the place intended by the path?
+  if (!(x == step.x - step.dx && y == step.y - step.dy)) {
+    creep.say("I'm lost!");
+    memory["wait"] = rand() % 5;
+    memory.erase("path");
+    return;
+  }
+
+  // Lets move forward
+  int resp = creep.move(step.direction);
+  if (resp == Screeps::OK) {
+    memory["last_pos"]["x"] = x;
+    memory["last_pos"]["y"] = y;
+
+    for (int i = 0; i < 5; i++) {
+      memory["path"].erase(0);
     }
+  }
 }
 
-std::unique_ptr<Screeps::RoomObject> DouwcoHivemind::CreepBase::getRoomObjectTarget()
-{
-    // Check if any target is present
-    if(target_id.empty()) return nullptr;
-    // Check if game can find target
-    auto roomObj = Screeps::Game.getObjectById(target_id);
-    if (!roomObj)
-    {
-        JS::console.log(creep.name() + ": Game can\'t find target id: " + target_id);
-        return nullptr;
-    }
-    return std::move(roomObj);
+std::unique_ptr<Screeps::RoomObject>
+DouwcoHivemind::CreepBase::getRoomObjectTarget() {
+  // Check if any target is present
+  if (target_id.empty())
+    return nullptr;
+  // Check if game can find target
+  auto roomObj = Screeps::Game.getObjectById(target_id);
+  if (!roomObj) {
+    JS::console.log(creep.name() +
+                    ": Game can\'t find target id: " + target_id);
+    return nullptr;
+  }
+  return std::move(roomObj);
 }
 
-bool DouwcoHivemind::CreepBase::isNearTo(const Screeps::RoomPosition &pos, int dist)
-{
-    return DouwcoHivemind::isNearTo(creep.pos(), pos, dist);
+bool DouwcoHivemind::CreepBase::isNearTo(const Screeps::RoomPosition &pos,
+                                         int dist) {
+  return DouwcoHivemind::isNearTo(creep.pos(), pos, dist);
 }

douwco_hivemind/src/Creeps/Maintainer.cpp

@@ -17,6 +17,7 @@
 
 #include "Creeps/Maintainer.hpp"
 #include "Creeps/CreepBase.hpp"
+#include "Screeps/Constants.hpp"
 
 void DouwcoHivemind::Maintainer::depositEnergy()
 {
@@ -61,22 +62,24 @@ std::unique_ptr<Screeps::Structure> DouwcoHivemind::Maintainer::getDamagedStruct
 
 void DouwcoHivemind::Maintainer::searchDamagedStructure()
 {
-    int lowestMaintaince = INT16_MAX;
+    int highestDamage = 0;
     Screeps::Structure *selectedStructure;
     auto structures = creep.room().find(Screeps::FIND_STRUCTURES);
     for (auto &structureObject : structures)
     {
-        auto structure = dynamic_cast<Screeps::Structure *>(structureObject.get());
+        auto structure = dynamic_cast<Screeps::Structure *>(structureObject.release());
         if (!structure)
             continue;
 
-        int maintance = structure->hits();
+        int damage = structure->hitsMax() - structure->hits();
         auto structureType = structure->structureType();
         if (structureType == Screeps::STRUCTURE_CONTROLLER)
             continue;
-        if (maintance < lowestMaintaince)
+        if(structureType == Screeps::STRUCTURE_WALL || structureType == Screeps::STRUCTURE_RAMPART)
+            continue; // todo cover this situation as well.
+        if (highestDamage < damage)
         {
-            lowestMaintaince = maintance;
+            highestDamage = damage;
             selectedStructure = structure;
         }
     }

douwco_hivemind/src/Creeps/Miner.cpp

@@ -0,0 +1,40 @@
+#include "Creeps/Miner.hpp"
+#include "Creeps/CreepBase.hpp"
+#include "Screeps/Constants.hpp"
+#include "Screeps/Creep.hpp"
+#include "Screeps/Room.hpp"
+#include "Screeps/RoomPosition.hpp"
+#include "Screeps/Source.hpp"
+#include <string>
+
+DouwcoHivemind::Miner::Miner(Screeps::Creep crp) : CreepBase(crp) {
+  arrivedAtContainer = memory.contains("arrivedAtContainer")
+                           ? static_cast<bool>(memory["arrivedAtContainer"])
+                           : false;
+}
+
+DouwcoHivemind::Miner::~Miner() {
+  memory["arrivedAtContainer"] = arrivedAtContainer;
+}
+
+void DouwcoHivemind::Miner::loop() {
+  if (arrivedAtContainer) {
+    auto source =
+        static_cast<Screeps::Source *>(getRoomObjectTarget().release());
+    creep.harvest(*source);
+  } else {
+    auto container = getRoomObjectTarget();
+    if (!container)
+      return;
+    if (isNearTo(container->pos(), 0)) {
+      arrivedAtContainer = true;
+      int x = creep.pos().x();
+      int y = creep.pos().y();
+      auto roomObjs = creep.pos().findClosestByRange(Screeps::FIND_SOURCES, 2);
+      auto source = static_cast<Screeps::Source *>(roomObjs.release());
+      target_id = source->id();
+    } else {
+      moveToTarget(0);
+    }
+  }
+}

douwco_hivemind/src/Creeps/Supplier.cpp

@@ -1,120 +1,122 @@
-#include <vector>
-#include <optional>
 #include <emscripten.h>
+#include <optional>
+#include <string>
+#include <vector>
 
-#include <Screeps/Game.hpp>
 #include <Screeps/Creep.hpp>
-#include <Screeps/Source.hpp>
+#include <Screeps/Game.hpp>
 #include <Screeps/Room.hpp>
-#include <Screeps/RoomPosition.hpp>
 #include <Screeps/RoomObject.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Store.hpp>
 #include <Screeps/Structure.hpp>
 #include <Screeps/StructureController.hpp>
-#include <Screeps/StructureSpawn.hpp>
 #include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureStorage.hpp>
 #include <Screeps/StructureTower.hpp>
-#include <Screeps/Store.hpp>
 
 #include "Creeps/Supplier.hpp"
+#include "Screeps/Constants.hpp"
 
-void DouwcoHivemind::Supplier::depositEnergy()
-{
-    auto structure = getEnergyStructureTarget();
-    if (!structure) return;
+void DouwcoHivemind::Supplier::depositEnergy() {
+  auto structure = getEnergyStructureTarget();
+  if (!structure)
+    return;
 
-    if (isNearTo(structure->pos(), 1))
-    {
-        int resp = creep.transfer(*structure, Screeps::RESOURCE_ENERGY);
-    }
-    else
-    {
-        moveToTarget();
-    }
+  if (isNearTo(structure->pos(), 1)) {
+    int resp = creep.transfer(*structure, Screeps::RESOURCE_ENERGY);
+  } else {
+    moveToTarget();
+  }
 }
 
-std::unique_ptr<Screeps::Structure> DouwcoHivemind::Supplier::getEnergyStructureTarget()
-{
-    auto roomObj = getRoomObjectTarget();
-    if (!roomObj)
-    {
-        searchEnergyStructure();
-        return nullptr;
-    }
+std::unique_ptr<Screeps::Structure>
+DouwcoHivemind::Supplier::getEnergyStructureTarget() {
+  auto roomObj = getRoomObjectTarget();
+  if (!roomObj) {
+    searchEnergyStructure();
+    return nullptr;
+  }
 
-    auto structure = std::unique_ptr<Screeps::Structure>(dynamic_cast<Screeps::Structure *>(roomObj.release()));
+  auto structure = std::unique_ptr<Screeps::Structure>(
+      dynamic_cast<Screeps::Structure *>(roomObj.release()));
+  if (!structure) {
+    searchEnergyStructure();
+    return nullptr;
+  }
+
+  // Check if the structure can receive energy to harvest
+  int energyCapacity;
+  auto structureType = structure->structureType();
+  if (structureType == Screeps::STRUCTURE_TOWER) {
+    auto tower = dynamic_cast<Screeps::StructureTower *>(structure.get());
+    energyCapacity =
+        tower->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+  } else if (structureType == Screeps::STRUCTURE_SPAWN) {
+    auto spawn = dynamic_cast<Screeps::StructureSpawn *>(structure.get());
+    energyCapacity =
+        spawn->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+  } else if (structureType == Screeps::STRUCTURE_EXTENSION) {
+    auto extension =
+        dynamic_cast<Screeps::StructureExtension *>(structure.get());
+    energyCapacity =
+        extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+  } else if (structureType == Screeps::STRUCTURE_STORAGE) {
+    auto storage = dynamic_cast<Screeps::StructureStorage *>(structure.get());
+    energyCapacity =
+        storage->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+  }
+
+  if (energyCapacity == 0) {
+    searchEnergyStructure();
+    return nullptr;
+  }
+
+  return std::move(structure);
+}
+
+void DouwcoHivemind::Supplier::searchEnergyStructure() {
+  int mostEnergyNeeded = 0;
+  std::string selectedStructureId;
+  std::string storageStructureId;
+  auto structures = creep.room().find(Screeps::FIND_MY_STRUCTURES);
+  for (auto &structureObject : structures) {
+    auto structure = dynamic_cast<Screeps::Structure *>(structureObject.get());
     if (!structure)
-    {
-        searchEnergyStructure();
-        return nullptr;
-    }
+      continue;
+
+    int energyRequired = 0;
 
-    // Check if the structure can receive energy to harvest
-    int energyCapacity;
     auto structureType = structure->structureType();
-    if (structureType == Screeps::STRUCTURE_SPAWN)
-    {
-        auto spawn = dynamic_cast<Screeps::StructureSpawn *>(structure.get());
-        energyCapacity = spawn->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
-    }
-    else if (structureType == Screeps::STRUCTURE_EXTENSION)
-    {
-        auto extension = dynamic_cast<Screeps::StructureExtension *>(structure.get());
-        energyCapacity = extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
-    }
-    else if (structureType == Screeps::STRUCTURE_TOWER)
-    {
-        auto extension = dynamic_cast<Screeps::StructureTower *>(structure.get());
-        energyCapacity = extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+    if (structureType == Screeps::STRUCTURE_TOWER) {
+      auto tower = dynamic_cast<Screeps::StructureTower *>(structure);
+      energyRequired =
+          tower->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+    } else if (structureType == Screeps::STRUCTURE_SPAWN) {
+      auto spawn = dynamic_cast<Screeps::StructureSpawn *>(structure);
+      energyRequired =
+          spawn->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+    } else if (structureType == Screeps::STRUCTURE_EXTENSION) {
+      auto extension = dynamic_cast<Screeps::StructureExtension *>(structure);
+      energyRequired =
+          extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
+    } else if (structureType == Screeps::STRUCTURE_STORAGE) {
+      storageStructureId = structure->id();
     }
 
-    if (energyCapacity == 0)
-    {
-        searchEnergyStructure();
-        return nullptr;
+    if (energyRequired > mostEnergyNeeded) {
+      mostEnergyNeeded = energyRequired;
+      selectedStructureId = structure->id();
     }
+  }
 
-    return std::move(structure);
-}
-
-void DouwcoHivemind::Supplier::searchEnergyStructure()
-{
-    int mostEnergyNeeded = 0;
-    Screeps::Structure *selectedStructure;
-    auto structures = creep.room().find(Screeps::FIND_MY_STRUCTURES);
-    for (auto &structureObject : structures)
-    {
-        auto structure = dynamic_cast<Screeps::Structure *>(structureObject.get());
-        if (!structure)
-            continue;
-
-        int energyRequired;
-
-        auto structureType = structure->structureType();
-        if (structureType == Screeps::STRUCTURE_SPAWN)
-        {
-            auto spawn = dynamic_cast<Screeps::StructureSpawn *>(structure);
-            energyRequired = spawn->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
-        }
-        else if (structureType == Screeps::STRUCTURE_EXTENSION)
-        {
-            auto extension = dynamic_cast<Screeps::StructureExtension *>(structure);
-            energyRequired = extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
-        }
-        else if (structureType == Screeps::STRUCTURE_TOWER)
-        {
-            auto extension = dynamic_cast<Screeps::StructureTower *>(structure);
-            energyRequired = extension->store().getFreeCapacity(Screeps::RESOURCE_ENERGY).value();
-        }
-
-        if (energyRequired > mostEnergyNeeded)
-        {
-            mostEnergyNeeded = energyRequired;
-            selectedStructure = structure;
-        }
-    }
-
-    if (selectedStructure)
-        target_id = selectedStructure->id();
-    else
-        target_id.clear();
+  if (mostEnergyNeeded == 0)
+    selectedStructureId = storageStructureId;
+
+  if (selectedStructureId.empty())
+    target_id.clear();
+  else
+    target_id = selectedStructureId;
 }

douwco_hivemind/src/Creeps/Worker.cpp

@@ -1,123 +1,175 @@
-#include <vector>
-#include <optional>
 #include <emscripten.h>
+#include <optional>
+#include <string>
+#include <vector>
 
-#include <Screeps/Game.hpp>
+#include <Screeps/Constants.hpp>
 #include <Screeps/Creep.hpp>
-#include <Screeps/Source.hpp>
+#include <Screeps/Game.hpp>
 #include <Screeps/Room.hpp>
-#include <Screeps/RoomPosition.hpp>
 #include <Screeps/RoomObject.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Store.hpp>
 #include <Screeps/Structure.hpp>
 #include <Screeps/StructureController.hpp>
-#include <Screeps/StructureSpawn.hpp>
 #include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureSpawn.hpp>
 #include <Screeps/StructureTower.hpp>
-#include <Screeps/Constants.hpp>
-#include <Screeps/Store.hpp>
 
 #include "Creeps/Worker.hpp"
+#include "Screeps/StructureContainer.hpp"
 
-DouwcoHivemind::Worker::Worker(Screeps::Creep crp) : CreepBase(crp)
-{
-    harvesting = memory.contains("harvesting") ? static_cast<bool>(memory["harvesting"]) : false;
+DouwcoHivemind::Worker::Worker(Screeps::Creep crp) : CreepBase(crp) {
+  harvesting = memory.contains("harvesting")
+                   ? static_cast<bool>(memory["harvesting"])
+                   : false;
+  foundContainer = memory.contains("foundContainer")
+                       ? static_cast<bool>(memory["foundContainer"])
+                       : false;
 }
 
-DouwcoHivemind::Worker::~Worker()
-{
-    memory["harvesting"] = harvesting;
+DouwcoHivemind::Worker::~Worker() {
+  memory["harvesting"] = harvesting;
+  memory["foundContainer"] = foundContainer;
 }
 
-void DouwcoHivemind::Worker::loop()
-{
-    if (harvesting)
-    {
-        if (creep.store().getFreeCapacity(Screeps::RESOURCE_ENERGY) == 0)
-        {
-            harvesting = false;
-            target_id.clear();
-        }
-        harvestSource();
+void DouwcoHivemind::Worker::loop() {
+  if (harvesting) {
+    if (creep.store().getFreeCapacity(Screeps::RESOURCE_ENERGY) == 0) {
+      harvesting = false;
+      target_id.clear();
     }
-    else
-    {
-        if (creep.store().getUsedCapacity(Screeps::RESOURCE_ENERGY) == 0)
-        {
-            harvesting = true;
-            target_id.clear();
-        }
-        depositEnergy();
+    getEnergy();
+  } else {
+    if (creep.store().getUsedCapacity(Screeps::RESOURCE_ENERGY) == 0) {
+      harvesting = true;
+      target_id.clear();
     }
+    depositEnergy();
+  }
 }
 
-void DouwcoHivemind::Worker::harvestSource()
-{
-    auto source = getSourceTarget();
-    if (!source)
-        return;
-
-    if (isNearTo(source->pos(), 1))
-    {
-        int resp = creep.harvest(*source);
-    }
-    else
-    {
-        moveToTarget();
-    }
+void DouwcoHivemind::Worker::getEnergy() {
+  if (foundContainer || Screeps::Game.time()%100==0) collectEnergyFromContainers();
+  else harvestSource();
 }
 
-std::unique_ptr<Screeps::Source> DouwcoHivemind::Worker::getSourceTarget()
-{
-    auto roomObj = getRoomObjectTarget();
-    if (!roomObj)
-    {
-        searchSource();
-        return nullptr;
-    }
+void DouwcoHivemind::Worker::collectEnergyFromContainers() {
+  auto container = getContainerTarget();
+  if (!container)
+    return;
 
-    // Check if found roomobject is an actual source
-    auto source = std::unique_ptr<Screeps::Source>(dynamic_cast<Screeps::Source *>(roomObj.release()));
-    if (!source)
-    {
-        // EM_ASM({console.log($0 + ': Can\'t cast target to Source')}, creep.name().c_str());
-        searchSource();
-        return nullptr;
-    }
-
-    // Check if the source still has energy to harvest
-    if (source->energy() == 0)
-    {
-        searchSource();
-        return nullptr;
-    }
-
-    return std::move(source);
+  if (isNearTo(container->pos(), 1)) {
+    int resp = creep.withdraw(*container, Screeps::RESOURCE_ENERGY);
+  } else {
+    moveToTarget();
+  }
 }
 
-void DouwcoHivemind::Worker::searchSource()
-{
-    target_id.clear();
+void DouwcoHivemind::Worker::harvestSource() {
+  auto source = getSourceTarget();
+  if (!source)
+    return;
 
-    auto sources = creep.room().find(Screeps::FIND_SOURCES_ACTIVE);
-    if (sources.size() == 0)
-        return;
-
-    int x = creep.pos().x();
-    int y = creep.pos().y();
-
-    int closestDistance = INT16_MAX;
-    Screeps::Source *selectedSource;
-    for(auto &sourceObject : sources){
-        auto source =dynamic_cast<Screeps::Source *>(sourceObject.get());
-        if(source->energy()==0) continue;
-        int dx = source->pos().x() - x;
-        int dy = source->pos().y() - y;
-        int distance = dx*dx + dy*dy;
-        if(distance < closestDistance){
-            closestDistance = distance;
-            selectedSource = source;
-        }
-    }
-    if(!selectedSource) return;
-    target_id = selectedSource->id();
+  if (isNearTo(source->pos(), 1)) {
+    int resp = creep.harvest(*source);
+  } else {
+    moveToTarget();
+  }
 }
+
+std::unique_ptr<Screeps::StructureContainer>
+DouwcoHivemind::Worker::getContainerTarget() {
+  auto roomObj = getRoomObjectTarget();
+  if (!roomObj) {
+    searchContainer();
+    return nullptr;
+  }
+
+  // Check if found roomobject is an actual source
+  auto container = std::unique_ptr<Screeps::StructureContainer>(
+      dynamic_cast<Screeps::StructureContainer *>(roomObj.release()));
+  if (!container) {
+    // EM_ASM({console.log($0 + ': Can\'t cast target to Source')},
+    // creep.name().c_str());
+    searchContainer();
+    return nullptr;
+  }
+
+  // Check if the source still has energy to harvest
+  if (container->store().getUsedCapacity(Screeps::RESOURCE_ENERGY) == 0) {
+    searchContainer();
+    return nullptr;
+  }
+
+  return std::move(container);
+}
+
+std::unique_ptr<Screeps::Source> DouwcoHivemind::Worker::getSourceTarget() {
+  auto roomObj = getRoomObjectTarget();
+  if (!roomObj) {
+    searchSource();
+    return nullptr;
+  }
+
+  // Check if found roomobject is an actual source
+  auto source = std::unique_ptr<Screeps::Source>(
+      dynamic_cast<Screeps::Source *>(roomObj.release()));
+  if (!source) {
+    // EM_ASM({console.log($0 + ': Can\'t cast target to Source')},
+    // creep.name().c_str());
+    searchSource();
+    return nullptr;
+  }
+
+  // Check if the source still has energy to harvest
+  if (source->energy() == 0) {
+    searchSource();
+    return nullptr;
+  }
+
+  return std::move(source);
+}
+
+void DouwcoHivemind::Worker::searchSource() {
+  target_id.clear();
+  auto sourceObject = creep.pos().findClosestByRange(Screeps::FIND_SOURCES);
+  if (!sourceObject)
+    return;
+  auto source = dynamic_cast<Screeps::Source *>(sourceObject.release());
+  target_id = source->id();
+}
+
+void DouwcoHivemind::Worker::searchContainer() {
+  target_id.clear();
+
+  auto structureObjects = creep.room().find(Screeps::FIND_STRUCTURES);
+  if (structureObjects.size() == 0)
+    return;
+
+  int fullestContents = 0;
+  Screeps::StructureContainer *selectedContainer;
+  for (auto &structureObject : structureObjects) {
+    auto structure =
+        dynamic_cast<Screeps::Structure *>(structureObject.release());
+    if (structure->structureType() != Screeps::STRUCTURE_CONTAINER)
+      continue;
+    auto container = dynamic_cast<Screeps::StructureContainer *>(structure);
+    int availableEnergy =
+        container->store().getUsedCapacity(Screeps::RESOURCE_ENERGY).value();
+    if (availableEnergy == 0)
+      continue;
+    if (fullestContents < availableEnergy) {
+      fullestContents = availableEnergy;
+      selectedContainer = container;
+    }
+  }
+
+  if (!selectedContainer) {
+    foundContainer = false;
+  } else {
+    foundContainer = true;
+    target_id = selectedContainer->id();
+  }
+}

douwco_hivemind/src/Engine.cpp

@@ -1,15 +1,21 @@
 #include <Screeps/Game.hpp>
 #include <Screeps/Memory.hpp>
 #include <Screeps/StructureController.hpp>
+#include <memory>
 
 #include "Engine.hpp"
 
 #include "Creeps/Builder.hpp"
 #include "Creeps/Maintainer.hpp"
+#include "Creeps/Miner.hpp"
 #include "Creeps/Supplier.hpp"
 #include "Creeps/Upgrader.hpp"
+#include "Creeps/Miner.hpp"
 
+#include "Screeps/Constants.hpp"
+#include "Screeps/StructureSpawn.hpp"
 #include "Structures/Spawn.hpp"
+#include "Structures/Tower.hpp"
 
 DouwcoHivemind::Engine::Engine() {
   ReadOutRooms();
@@ -57,14 +63,22 @@ void DouwcoHivemind::Engine::ReadOutCreeps() {
       creeps.push_back(std::make_unique<Builder>(creep.second));
     else if (role == CreepRole::MAINTAINER)
       creeps.push_back(std::make_unique<Maintainer>(creep.second));
+    else if (role == CreepRole::MINER)
+      creeps.push_back(std::make_unique<Miner>(creep.second));
   }
 }
 
 void DouwcoHivemind::Engine::ReadOutStructures() {
   JS::console.log(std::string("Reading out structures"));
-  auto spawns = Screeps::Game.spawns();
-  for (auto &spawn : spawns) {
-    structures.push_back(std::make_unique<Spawn>(spawn.second));
+  auto structures_src  =Screeps::Game.structures();
+  for (auto &structure : structures_src) {
+    std::string structureType = structure.second.structureType();
+    if(structureType == Screeps::STRUCTURE_TOWER){
+      structures.push_back(std::make_unique<Tower>(static_cast<Screeps::StructureTower>(structure.second)));
+    }
+    else if(structureType == Screeps::STRUCTURE_SPAWN){
+      structures.push_back(std::make_unique<Spawn>(static_cast<Screeps::StructureSpawn>(structure.second)));
+    }
   }
 }
 

douwco_hivemind/src/Entity/Room.cpp

@@ -1,6 +1,7 @@
-#include "Room.hpp"
+#include "Entity/Room.hpp"
 
 #include "Screeps/Constants.hpp"
+#include "Screeps/Game.hpp"
 #include "Screeps/Room.hpp"
 #include "Screeps/RoomObject.hpp"
 #include "Screeps/RoomPosition.hpp"
@@ -8,13 +9,8 @@
 #include "Screeps/Structure.hpp"
 #include "Screeps/StructureContainer.hpp"
 #include "Screeps/StructureController.hpp"
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
+
+#include "Constants.hpp"
 
 DouwcoHivemind::Room::Room(Screeps::Room rm) : room(rm), memory(rm.memory()) {
   if (memory.contains("sourceContainers"))
@@ -27,16 +23,17 @@ DouwcoHivemind::Room::~Room() {
   room.setMemory(memory);
 }
 
-void DouwcoHivemind::Room::loop() {
-  if (placeContainers())
-    return;
+void DouwcoHivemind::Room::loop() {  
+  // Check on building setup
+  if(Screeps::Game.time()%1000!=0) return;
+  placeContainers();
 }
 
-bool DouwcoHivemind::Room::placeContainers() {
+void DouwcoHivemind::Room::placeContainers() {
   auto sources = room.find(Screeps::FIND_SOURCES);
 
   // No containers planned or build, planning now
-  if (sourceContainers.size() == 0) {
+  if (sourceContainers.size() < sources.size()) {
     int controller_x = room.controller().value().pos().x();
     int controller_y = room.controller().value().pos().y();
 
@@ -67,7 +64,7 @@ bool DouwcoHivemind::Room::placeContainers() {
       room.createConstructionSite(best_x, best_y, Screeps::STRUCTURE_CONTAINER);
       sourceContainers.push_back("under_construction");
     }
-    return true;
+    return;
   }
   // Check if construction container is done.
   for (auto entry : sourceContainers) {
@@ -82,7 +79,11 @@ bool DouwcoHivemind::Room::placeContainers() {
         index++;
       }
     }
-    return true;
+    return;
   }
-  return false;
-}
+  // Check if containers still exist
+  for(int i = 0; i < sourceContainers.size(); i++){
+    auto roomObj = Screeps::Game.getObjectById(sourceContainers[i]);
+    if(!roomObj) sourceContainers.erase(sourceContainers.begin() + i);
+  }
+}

douwco_hivemind/src/Structures/Spawn.cpp

@@ -4,70 +4,102 @@
 #include "Creeps/CreepBase.hpp"
 #include "Structures/Spawn.hpp"
 
-void DouwcoHivemind::Spawn::loop()
-{
-    // Only run every 50 ticks
-    if (Screeps::Game.time() % 50 != 0)
-        return;
+void DouwcoHivemind::Spawn::loop() {
+  // Only run every 500 ticks
+  if (Screeps::Game.time() % 100 != 0)
+    return;
 
-    int energyAvailable = spawn.room().energyAvailable();
-    int energyCapacityAvailable = spawn.room().energyCapacityAvailable();
-    
-    int required_upgraders = 1;
-    int required_suppliers = 1;
-    int required_maintainers = spawn.room().find(Screeps::FIND_STRUCTURES).size() <= 2 ? 0 : 1;;
-    int required_builders = spawn.room().find(Screeps::FIND_MY_CONSTRUCTION_SITES).size() == 0 ? 0 : 1;
-    for (auto &creep : Screeps::Game.creeps())
-    {
-        CreepRole role = creep.second.memory()["role"];
+  // Get energy data
+  int energyAvailable = spawn.room().energyAvailable();
+  int energyCapacityAvailable = spawn.room().energyCapacityAvailable();
 
-        if (role == CreepRole::SUPPLIER)
-            required_suppliers--;
-        else if (role == CreepRole::UPGRADER)
-            required_upgraders--;
-        else if (role == CreepRole::MAINTAINER)
-            required_maintainers--;
-        else if (role == CreepRole::BUILDER)
-            required_builders--;
-    }
+  // Calculate needed creep roles
+  int required_upgraders = 1;
+  int required_suppliers = 2;
+  int required_maintainers =
+      spawn.room().find(Screeps::FIND_STRUCTURES).size() <= 2 ? 0 : 1;
+  ;
+  int required_builders =
+      spawn.room().find(Screeps::FIND_MY_CONSTRUCTION_SITES).size() == 0 ? 0
+                                                                         : 1;
+  int required_miners = 1; // spawn.room().memory()["sourceContainers"].size();
 
-    // if (energyAvailable < energyCapacityAvailable && 3 < Screeps::Game.creeps().size())
-    //     return;
-    std::string name;
-    JSON opts;
-    if (required_suppliers > 0)
-    {
-        opts["memory"]["role"] = CreepRole::SUPPLIER;
-        name = "Supplier: ";
-    }
-    else if (required_upgraders > 0)
-    {
-        opts["memory"]["role"] = CreepRole::UPGRADER;
-        name = "Upgrader: ";
-    }
-    else if (required_builders > 0)
-    {
-        opts["memory"]["role"] = CreepRole::BUILDER;
-        name = "Builder: ";
-    }
-    else if (required_maintainers > 0)
-    {
-        opts["memory"]["role"] = CreepRole::MAINTAINER;
-        name = "Maintainer: ";
-    }
-    else
-        return;
+  // Count existing roles
+  int existing_upgraders = 0;
+  int existing_suppliers = 0;
+  int existing_maintainers = 0;
+  int existing_builders = 0;
+  int existing_miners = 0;
 
-    std::vector<std::string> body;
-    for (int i = 0; i < energyAvailable / 200; i++)
-    {
-        body.push_back("work");
-        body.push_back("carry");
-        body.push_back("move");
-    }
+  for (auto &creep : Screeps::Game.creeps()) {
+    CreepRole role = creep.second.memory()["role"];
 
-    spawn.spawnCreep(
-        body,
-        name + std::to_string(Screeps::Game.time()),
-        opts);
+    if (role == CreepRole::SUPPLIER)
+      existing_suppliers++;
+    else if (role == CreepRole::UPGRADER)
+      existing_upgraders++;
+    else if (role == CreepRole::MAINTAINER)
+      existing_maintainers++;
+    else if (role == CreepRole::BUILDER)
+      existing_builders++;
+    else if (role == CreepRole::MINER)
+      existing_miners++;
+  }
+
+  // Check if max energy used
+  if (energyAvailable < energyCapacityAvailable && 0 < existing_suppliers)
+    return;
+
+  // Set creep properties
+  std::string name;
+  JSON opts;
+  CreepRole role = CreepRole::UNEMPLOYED;
+  if (required_miners > existing_miners) {
+    role = CreepRole::MINER;
+    opts["memory"]["target_id"] =
+        spawn.room().memory()["sourceContainers"][0]; // make logic for more
+    name = "Miner: ";
+  } else if (required_suppliers > existing_suppliers) {
+    role = CreepRole::SUPPLIER;
+    name = "Supplier: ";
+  } else if (required_upgraders > existing_upgraders) {
+    role = CreepRole::UPGRADER;
+    name = "Upgrader: ";
+  } else if (required_builders > existing_builders) {
+    role = CreepRole::BUILDER;
+    name = "Builder: ";
+  } else if (required_maintainers > existing_maintainers) {
+    role = CreepRole::MAINTAINER;
+    name = "Maintainer: ";
+  } else
+    return;
+
+  opts["memory"]["role"] = role;
+
+  // Build creep body
+  std::vector<std::string> body;
+  if (role == CreepRole::MINER) {
+    body.push_back("move");
+    body.push_back("work");
+    for (int i = 0; i < (energyAvailable - 150) / 100 && i < 5; i++) {
+      body.push_back("work");
+    }
+  } else if (role == SUPPLIER) {
+    body.push_back("move");
+    body.push_back("work");
+    body.push_back("carry");
+    for (int i = 0; i < (energyAvailable - 200) / 100 && i * 50 < energyCapacityAvailable; i++) {
+      body.push_back("move");
+      body.push_back("carry");
+    }
+  } else {
+    for (int i = 0; i < energyAvailable / 200; i++) {
+      body.push_back("work");
+      body.push_back("carry");
+      body.push_back("move");
+    }
+  }
+
+  // Create creep
+  spawn.spawnCreep(body, name + std::to_string(Screeps::Game.time()), opts);
 }

douwco_hivemind/src/Structures/Tower.cpp

@@ -0,0 +1,23 @@
+#include <Screeps/Game.hpp>
+#include <Screeps/Room.hpp>
+#include <cstdint>
+
+#include "Creeps/CreepBase.hpp"
+#include "Screeps/Constants.hpp"
+#include "Screeps/Creep.hpp"
+#include "Structures/Tower.hpp"
+
+void DouwcoHivemind::Tower::loop() {
+    int minHits = INT16_MAX;
+    Screeps::Creep *target;
+    auto hostile_creeps = tower.room().find(Screeps::FIND_HOSTILE_CREEPS);
+    for (auto &creepRoomObj : hostile_creeps) {
+        Screeps::Creep* creep = static_cast<Screeps::Creep*>(creepRoomObj.get());
+        int health = creep->hits();
+        if(health<minHits){
+            minHits=health;
+            target = creep;
+        }
+    }
+    tower.attack(*target);
+}