Added ide folder to gitignore

Main

See merge request douwe-ravers/screeps!2

.gitignore

@@ -0,0 +1,7 @@
+# IDE
+.cache/
+.idea/
+
+# Build files
+build/*
+dist/*

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "emsdk"]
+	path = emsdk
+	url = git@github.com:emscripten-core/emsdk.git
+[submodule "screepsxx"]
+	path = screepsxx
+	url = git@github.com:DouweRavers/screepsxx.git

.sync

@@ -1,2 +0,0 @@
-1650024834746
-5ce5d401e947ee7ab16cc8db

.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-	"files.exclude": {
-		".*": true,
-		"LICENSE": true,
-		"*.md": true
-	}
-}

CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(douwco_hivemind CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
+
+# set(COMPILE_FLAGS --cache ${CMAKE_BINARY_DIR}/cache)
+set(LINK_FLAGS -sASSERTIONS=0 -sMALLOC=emmalloc)
+add_compile_options(${COMPILE_FLAGS})
+add_link_options(${COMPILE_FLAGS} ${LINK_FLAGS})
+
+add_subdirectory(screepsxx)
+
+
+# If you change TARGET_NAME, please, make corresponding changes in main.js.
+set(TARGET_NAME douwco_hivemind)
+
+include_directories(${CMAKE_SOURCE_DIR}/douwco_hivemind/include)
+
+file(GLOB SRC_FILES ${CMAKE_SOURCE_DIR}/douwco_hivemind/src/*.cpp)
+add_executable(${TARGET_NAME} ${SRC_FILES})
+target_link_libraries(${TARGET_NAME} screepsxx)
+target_link_options(${TARGET_NAME} PUBLIC -sMODULARIZE=1 --no-entry --bind -sEXPORT_ES6=0)
+
+# Collect all artifacts in 'dist' directory
+# WASM-module and corresponding JS-module must have different base names in order to use them in Screeps, so we add suffixes.
+add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/${TARGET_NAME}.wasm ${CMAKE_SOURCE_DIR}/dist/${TARGET_NAME}_module.wasm)
+add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/${TARGET_NAME}.js ${CMAKE_SOURCE_DIR}/dist/${TARGET_NAME}_loader.js)
+add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/js/main.js ${CMAKE_SOURCE_DIR}/dist/main.js)
+add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/js/wasm_loader.js ${CMAKE_SOURCE_DIR}/dist/wasm_loader.js)
+
+# Following post-build step will automatically upload artifacts to
+# official Screeps server. If you want to use it, please,
+# set SCREEPS_TOKEN environment variable to your Screeps API token
+# (https://docs.screeps.com/auth-tokens.html).
+# If you don't want to use this script, please, remove following lines.
+#find_package(Python COMPONENTS Interpreter REQUIRED)
+#add_custom_command(TARGET ${TARGET_NAME} POST_BUILD COMMAND ${Python_EXECUTABLE} ${screepsxx_SOURCE_DIR}/tools/upload.py ${CMAKE_SOURCE_DIR}/dist $ENV{SCREEPS_TOKEN})

GLOBAL_VARIABLES.js

@@ -1,15 +0,0 @@
-module.exports = {
-    
-    // JOBS
-
-    JOB_HARVESTER: 0,
-    JOB_MINER: 1,
-    JOB_SUPPLIER: 2,
-    JOB_BUILDER:3,
-    JOB_UPGRADER: 4,
-    JOB_DEFENDER: 5,
-    JOB_RESERVER: 6,
-    JOB_RESERVED_HARVESTER: 7
-    
-    // OTHER
-};

README.md

@@ -1,5 +1,33 @@
-# screeps
+# Douwco Hivemind
-My source code for the MMO-programming game: Screeps.
+This is the sourcecode of my hivemind implementation for the MMO-programming game Screeps. This is mainly designed to learn programming with C++. This is possible throught the work done in the screepxx project, which I will and try to expand as well. 
 
-# Status
+# Running the project
-To those interested in this code. I wrote the main body of the source code when just learning programming so its kind of a mess. I'm now slowly rewriting the code base to a more SOLID version. :)
+All commands are run starting from the root directory.
+
+## Emsdk setup
+Screeps only supports ES5 js syntax which can only be guaranteed by using emsdk 2.0.0.
+
+```
+cd emsdk && \
+./emsdk install 2.0.0 && \
+./emsdk activate 2.0.0 && \
+source ./emsdk_env.sh && \
+cd ..
+```
+
+## Cmake setup
+Create the makefiles using cmake. For more info look at the readme in screepsxx.
+
+```
+mkdir build
+cd build
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=emsdk/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake ..
+```
+
+# Build
+To build the project run the following. In the dist folder the "screeps ready" project is copied.
+
+```
+cd build
+cmake --build .
+```

ai_main.js

@@ -1,65 +0,0 @@
-
-/*  ###########################
-    # Cross room managment AI #
-    ########################### */
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-module.exports = {
-    run_front: function()
-    {
-        if(Memory.AImain == null) Memory.AImain = {};
-        if(Memory.AImain.MainHub == null) Memory.AImain.MainHub = "insert name"
-        for(var n_flag in Game.flags){
-            var flag = Game.flags[n_flag];
-            if(flag.color == COLOR_YELLOW){
-                if(flag.room != undefined && flag.room.find(FIND_MY_CREEPS).length != flag.room.find(FIND_CREEPS).length){
-                    Game.spawns[Memory.AImain.MainHub].spawnCreep([TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, TOUGH, ATTACK, ATTACK, ATTACK, MOVE], 
-                    "Defender", { memory: { role:GLOBAL.JOB_DEFENDER , flag: flag.name }});
-                    break;
-                }
-                if(flag.room == undefined ||  flag.room.controller.reservation == undefined || (
-                    flag.room.controller.reservation.username == "DouweRavers" && flag.room.controller.reservation.ticksToEnd < 3500))
-                {
-                    if(Memory.AImain.MainHub != "insert name") Game.spawns[Memory.AImain.MainHub].spawnCreep([MOVE, CLAIM, CLAIM], "columbus", { memory: { role:GLOBAL.JOB_RESERVER, target: flag.name, home: Memory.AImain.MainHub}});
-                }
-                if(flag.room != undefined && flag.room.controller.reservation != undefined && flag.room.controller.reservation.username == "DouweRavers")
-                {
-                    var containers = flag.room.find(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER )});
-                    if(containers.length > 0){
-                        var has_miner = false;
-                        console.log("test");
-                        var creeps = flag.room.find(FIND_CREEPS);
-                        for(var cp in creeps){
-                            console.log(creeps[cp]);
-                            var creep = creeps[cp];
-                            if(creep.memory.role == GLOBAL.JOB_MINER){
-                                has_miner = true;
-                            }
-                        }
-                        if(!has_miner) {
-                            console.log("needs new miner")
-                            Game.spawns[Memory.AImain.MainHub].spawnCreep([ WORK, WORK, WORK, WORK, WORK, MOVE ], "ForeignMiner", { memory: { role:GLOBAL.JOB_MINER, container_id: containers[0].id}});
-                        }
-                    }
-                    var harvs = flag.room.find(FIND_MY_CREEPS).length;
-                    var source_id = flag.room.find(FIND_SOURCES)[0].id;
-                    if(harvs < 4){
-                        var spawn = Game.spawns[Memory.AImain.MainHub];
-                        var body = [];
-                        for(let i=0;i<Math.floor(spawn.room.energyAvailable/200);i++){
-                            body.push(WORK);
-                            body.push(CARRY);
-                            body.push(MOVE);
-                        }
-                        var name = "ForeignHarvy"+spawn.memory.creep_iterate;
-                        spawn.spawnCreep( body, name, { memory: 
-                                {role: GLOBAL.JOB_RESERVED_HARVESTER, source_id: source_id}});    
-                        
-                    }
-                }
-            }
-        }
-    },
-    run_back: function(){}
-};

controller_creeps.js

@@ -1,41 +0,0 @@
-
-/*  #######################################
-    # Controls the jobs of all the creeps #
-    #######################################*/
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-var job_harvester = require("job_harvester");
-var job_miner = require("job_miner");
-var job_supplier = require("job_supplier");
-var job_builder = require("job_builder");
-var job_upgrader = require("job_upgrader");
-var job_defender = require("job_defender");
-var job_reserver = require("job_reserver");
-var job_reserved_harvester = require("job_reserved_harvester");
-
-module.exports = {
-    run: function(){
-        for(var cr in Game.creeps){
-            cr = Game.creeps[cr];
-            switch(cr.memory.role){
-                case GLOBAL.JOB_HARVESTER: job_harvester.do(cr);
-                    break;
-                case GLOBAL.JOB_MINER: job_miner.do(cr);
-                    break;
-                case GLOBAL.JOB_SUPPLIER: job_supplier.do(cr);
-                    break;
-                case GLOBAL.JOB_BUILDER: job_builder.do(cr);
-                    break;
-                case GLOBAL.JOB_UPGRADER: job_upgrader.do(cr);
-                    break;
-                case GLOBAL.JOB_DEFENDER: job_defender.do(cr);
-                    break;
-                case GLOBAL.JOB_RESERVER: job_reserver.do(cr);
-                    break;
-                case GLOBAL.JOB_RESERVED_HARVESTER: job_reserved_harvester.do(cr);
-                    break;
-            }
-        }
-    }
-};

controller_spawns.js

@@ -1,171 +0,0 @@
-
-/*  #####################################
-    # Controls the way creeps are spawn #
-    #####################################*/
-
-var GLOBAL = require("GLOBAL_VARIABLES");
-
-module.exports = {
-    run: function(){
-        for(var sp in Game.spawns){
-            sp = Game.spawns[sp]
-            // values
-            var creep_count = 0
-            for(var cr in Game.creeps){
-                if(Game.creeps[cr].room.name == sp.room.name) creep_count += 1;
-            }
-            var source_count = 0;
-            if(sp.memory.sources_ids != undefined) source_count = sp.memory.sources_ids.length;
-
-            
-            // Memory setup
-            if(sp.memory.creep_iterate == undefined) sp.memory.creep_iterate = 0;
-
-            if(sp.memory.sources_ids == undefined){
-                sp.memory.sources_ids = [];
-                var sources = sp.room.find(FIND_SOURCES);
-                for(var source in sources){
-                    source = sources[source];
-                    sp.memory.sources_ids.push(source.id);
-                }
-                source_count = sp.memory.sources_ids.length;
-            }
-
-            if(sp.memory.containers_ids == undefined || sp.memory.containers_ids.length != source_count){
-                sp.memory.containers_ids = [];
-                var containers = sp.room.find(FIND_STRUCTURES, { filter:{ structureType: STRUCTURE_CONTAINER }});
-                if(containers.length > 0){
-                    for(let i=0;i<containers.length;i+=1){
-                        sp.memory.containers_ids.push(containers[i].id);
-                    }
-                }
-            }
-
-            // Different spawning configurations
-           
-            // Add improved versions at top of if-else statement
-            if(sp.memory.containers_ids.length >= source_count && sp.room.energyCapacityAvailable >= 550 && creep_count > source_count ){ // Miner method: Miners fille containers rest picks up from them
-                // Check current creep_jobs
-                var jobs = { miner: 0, supplier: 0, builder: 0, upgrader: 0, defender: 0};
-                var container_id = sp.memory.containers_ids[0];
-                for(var creep in Game.creeps){
-                    var creep = Game.creeps[creep];
-                    if(creep.room.name != sp.room.name) continue;
-                    switch (creep.memory.role) {
-                        case GLOBAL.JOB_MINER:
-                            jobs.miner += 1;    
-                            for(let i=0;i<sp.memory.containers_ids.length;i++){
-                                if(creep.memory.container_id != sp.memory.containers_ids[i]) container_id = sp.memory.containers_ids[i]; 
-                            }
-                            break;
-                        case GLOBAL.JOB_SUPPLIER:
-                            jobs.supplier += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_BUILDER:
-                            jobs.builder += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_UPGRADER:
-                            jobs.upgrader += creep.body.length;
-                            break;
-                        case GLOBAL.JOB_DEFENDER:
-                            jobs.defender += 1;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-                if(jobs.miner < source_count){
-                    if(sp.room.energyAvailable >= 550) create_miner(sp, container_id);
-                }
-                else if(jobs.supplier < source_count * 15 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_supplier(sp);
-                else if(jobs.builder < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_builder(sp);
-                else if(jobs.upgrader < source_count * 5 && sp.room.energyAvailable >= 300 && jobs.miner > 0) create_upgrader(sp);
-                else if(jobs.defender < 0 && sp.room.energyAvailable >= sp.room.energyCapacityAvailable*0.8 && jobs.miner > 0) create_defender(sp);
-            } else { // Harvesting method: everybody mines own sources
-                if (sp.room.find(FIND_MY_CREEPS).length < source_count * 5 && sp.room.energyAvailable >= 300){
-                    var source_id = sp.memory.sources_ids[sp.memory.creep_iterate % source_count];
-                    create_harvester(sp, source_id);
-                }
-            }
-        }
-    }
-};
-
-
-function create_harvester(sp, source_id){
-    var body = [];
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){
-        body.push(WORK);
-        body.push(CARRY);
-        body.push(MOVE);
-    }
-    var name = "Harvy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-            {role: GLOBAL.JOB_HARVESTER, source_id: source_id}});
-    sp.memory.creep_iterate += 1;
-}
-
-function create_miner(sp, container_id){
-    var body = [ WORK, WORK, WORK, WORK, WORK, MOVE ]; // (creep)5*work(2energy/tick)=10energy/tick -> (source)3000energy/300tick=10energy/tick
-    var name = "Mindy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_MINER, container_id: container_id}});
-    sp.memory.creep_iterate += 1;
-}
-
-function create_supplier(sp){
-    var body = [WORK];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/100)-1 && i < 8;i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-    }
-    var name = "Suppry"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_SUPPLIER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_builder(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/200);i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-        body.push(WORK);
-    }
-    var name = "Bobby"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_BUILDER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_upgrader(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/300);i++){ // as big as possible
-        body.push(CARRY);
-        body.push(MOVE);
-        body.push(WORK);
-        body.push(WORK);
-    }
-    var name = "Undy"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_UPGRADER}});
-    sp.memory.creep_iterate += 1; 
-}
-
-function create_defender(sp){
-    var body = [];
-
-    for(let i=0;i<Math.floor(sp.room.energyAvailable/150);i++){ // as big as possible
-        body.push(TOUGH);
-        body.push(TOUGH);
-        body.push(ATTACK);
-        body.push(MOVE);
-    }
-    var name = "Destroyer CODE"+sp.memory.creep_iterate;
-    sp.spawnCreep( body, name, { memory: 
-        {role: GLOBAL.JOB_DEFENDER}});
-    sp.memory.creep_iterate += 1; 
-}

controller_towers.js

@@ -1,37 +0,0 @@
-module.exports = {
-    
-    run: function(){
-        for(var spawn in Game.spawns){
-            var room = Game.spawns[spawn].room;
-            var towers = room.find(FIND_MY_STRUCTURES,
-                {filter: (s)=>(s.structureType == STRUCTURE_TOWER)});
-            for(var tower in towers){
-                tower = towers[tower];
-                var enemy = tower.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
-                if(enemy != null) tower.attack(enemy);
-                else {
-                    var healt_creep = false;
-                    for(var creep in Game.creeps){
-                        creep = Game.creeps[creep];
-                        if(creep.hits < creep.hitsMax) {
-                            tower.heal(creep);
-                            healt_creep = true;
-                        }
-                    }
-                    if(!healt_creep && 500 < tower.energy){
-                         var structure = tower.pos.findClosestByPath(FIND_STRUCTURES, 
-                           {filter: (s)=>( (s.structureType != STRUCTURE_RAMPART && s.structureType != STRUCTURE_WALL && s.hits < s.hitsMax )
-                                || ( s.structureType == STRUCTURE_RAMPART && s.hits < 10000 ))});
-                        if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES, 
-                           {filter: (s)=>((s.structureType == STRUCTURE_RAMPART) && s.hits < 1000)});
-                        if(structure == null) structure = tower.pos.findClosestByRange(FIND_STRUCTURES, 
-                           {filter: (s)=>((s.structureType == STRUCTURE_WALL) && s.hits < 1000)});
-                        tower.repair(structure);
-                    }
-                   
-                }
-            }
-        }
-    }
-
-};

douwco_hivemind/include/Creeps/Builder.hpp

@@ -0,0 +1,22 @@
+#ifndef DOUWCO_HIVEMIND_BUILDER_HPP
+#define DOUWCO_HIVEMIND_BUILDER_HPP
+
+#include "Creeps/Worker.hpp"
+
+namespace DouwcoHivemind
+{
+    class Builder : public Worker
+    {
+    public:
+        Builder(Screeps::Creep creep) : Worker(creep) {}
+
+    protected:
+        void depositEnergy() override;
+        
+    private:
+        std::unique_ptr<Screeps::ConstructionSite> getConstructionSiteTarget();
+        void searchConstructionSite();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_BUILDER_HPP

douwco_hivemind/include/Creeps/CreepBase.hpp

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

douwco_hivemind/include/Creeps/Maintainer.hpp

@@ -0,0 +1,22 @@
+#ifndef DOUWCO_HIVEMIND_MAINTAINER_HPP
+#define DOUWCO_HIVEMIND_MAINTAINER_HPP
+
+#include "Creeps/Worker.hpp"
+
+namespace DouwcoHivemind
+{
+    class Maintainer : public Worker
+    {
+    public:
+        Maintainer(Screeps::Creep creep) : Worker(creep) {}
+
+    protected:
+        void depositEnergy() override;
+        
+    private:
+        std::unique_ptr<Screeps::Structure> getDamagedStructureTarget();
+        void searchDamagedStructure();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_MAINTAINER_HPP

douwco_hivemind/include/Creeps/Miner.hpp

@@ -0,0 +1,23 @@
+#ifndef DOUWCO_HIVEMIND_MINER_HPP
+#define DOUWCO_HIVEMIND_MINER_HPP
+
+#include <Creeps/CreepBase.hpp>
+
+namespace DouwcoHivemind
+{
+    class Miner : public CreepBase
+    {
+    private:
+          bool requestedContainer = false;
+    public:
+        Miner(Screeps::Creep crp);
+        ~Miner() override;
+        void loop() override;
+
+    private:
+        bool mineSource();
+        std::unique_ptr<Screeps::Source> getSourceTarget();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_MINER_HPP

douwco_hivemind/include/Creeps/Supplier.hpp

@@ -0,0 +1,22 @@
+#ifndef DOUWCO_HIVEMIND_SUPPLIER_HPP
+#define DOUWCO_HIVEMIND_SUPPLIER_HPP
+
+#include "Creeps/Worker.hpp"
+
+namespace DouwcoHivemind
+{
+    class Supplier : public Worker
+    {
+    public:
+        Supplier(Screeps::Creep creep) : Worker(creep) {}
+
+    protected:
+        void depositEnergy() override;
+        
+    private:
+        std::unique_ptr<Screeps::Structure> getEnergyStructureTarget();
+        void searchEnergyStructure();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_SUPPLIER_HPP

douwco_hivemind/include/Creeps/Upgrader.hpp

@@ -0,0 +1,18 @@
+#ifndef DOUWCO_HIVEMIND_HARVESTER_UPGRADER_HPP
+#define DOUWCO_HIVEMIND_HARVESTER_UPGRADER_HPP
+
+#include "Creeps/Worker.hpp"
+
+namespace DouwcoHivemind
+{
+    class Upgrader : public Worker
+    {
+    public:
+        Upgrader(Screeps::Creep creep) : Worker(creep) {}
+        
+    protected:
+        void depositEnergy() override;
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_HARVESTER_UPGRADER_HPP

douwco_hivemind/include/Creeps/Worker.hpp

@@ -0,0 +1,29 @@
+#ifndef DOUWCO_HIVEMIND_WORKER_HPP
+#define DOUWCO_HIVEMIND_WORKER_HPP
+
+#include "Creeps/CreepBase.hpp"
+
+namespace DouwcoHivemind
+{
+    class Worker : public CreepBase
+    {
+    private:
+        bool harvesting;
+
+    public:
+        Worker(Screeps::Creep crp);
+        ~Worker() override;
+
+        void loop() override;
+
+    protected:
+        virtual void depositEnergy(){}
+    
+    private:
+        void harvestSource();
+        std::unique_ptr<Screeps::Source> getSourceTarget();
+        void searchSource();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_WORKER_HPP

douwco_hivemind/include/Engine.hpp

@@ -0,0 +1,28 @@
+#ifndef DOUWCO_HIVEMIND_ENGINE_HPP
+#define DOUWCO_HIVEMIND_ENGINE_HPP
+
+#include <vector>
+
+#include "Creeps/CreepBase.hpp"
+#include "Structures/StructureBase.hpp"
+
+namespace DouwcoHivemind
+{   
+    class Engine
+    {
+    private:
+        std::vector<std::unique_ptr<CreepBase>> creeps;
+        std::vector<std::unique_ptr<StructureBase>> structures;
+
+    public:
+        Engine();
+        void loop();
+
+    private:
+        void ReadOutCreeps();
+        void ReadOutStructures();
+        void clearDeadCreepMemory();
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_ENGINE_HPP

douwco_hivemind/include/Structures/Spawn.hpp

@@ -0,0 +1,24 @@
+#ifndef DOUWCO_HIVEMIND_SPAWN_HPP
+#define DOUWCO_HIVEMIND_SPAWN_HPP
+
+#include <Screeps/StructureSpawn.hpp>
+
+#include "Structures/StructureBase.hpp"
+
+namespace DouwcoHivemind
+{
+    class Spawn : public StructureBase
+    {
+    private:
+        Screeps::StructureSpawn spawn;
+
+    public:
+        Spawn(Screeps::StructureSpawn spwn) : spawn(spwn),
+                                              StructureBase() {}
+        ~Spawn() {}
+
+        void loop() override;
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_SPAWN_HPP

douwco_hivemind/include/Structures/StructureBase.hpp

@@ -0,0 +1,15 @@
+#ifndef DOUWCO_HIVEMIND_STRUCTURE_HPP
+#define DOUWCO_HIVEMIND_STRUCTURE_HPP
+
+#include <Screeps/Structure.hpp>
+
+namespace DouwcoHivemind
+{
+    class StructureBase
+    {
+    public:
+        virtual void loop(){}
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_STRUCTURE_HPP

douwco_hivemind/include/Tools/JsonTool.hpp

@@ -0,0 +1,33 @@
+#ifndef DOUWCO_HIVEMIND_JSON_TOOLS_HPP
+#define DOUWCO_HIVEMIND_JSON_TOOLS_HPP
+
+#include <nlohmann/json.hpp>
+#include <vector>
+
+namespace DouwcoHivemind
+{
+
+    template <typename T>
+    std::vector<T> jsonToVector(const nlohmann::json &json)
+    {
+        std::vector<T> vector;
+        for (const auto &item : json)
+        {
+            vector.emplace_back(item.get<T>());
+        }
+        return vector;
+    };
+
+    template <typename T>
+    nlohmann::json vectorToJson(const std::vector<T> &vector)
+    {
+        nlohmann::json json;
+        for (const auto &item : vector)
+        {
+            json.emplace_back(item);
+        }
+        return json;
+    };
+}
+
+#endif // DOUWCO_HIVEMIND_JSON_TOOLS_HPP

douwco_hivemind/include/Tools/MeasureTool.hpp

@@ -0,0 +1,19 @@
+#ifndef DOUWCO_HIVEMIND_MEASURE_TOOL_HPP
+#define DOUWCO_HIVEMIND_MEASURE_TOOL_HPP
+
+#include <Screeps/RoomPosition.hpp>
+
+namespace DouwcoHivemind
+{
+    static bool isNearTo(const Screeps::RoomPosition &pos1, const Screeps::RoomPosition &pos2, int dist)
+    {
+        int dx = pos1.x() - pos2.x();
+        int dy = pos1.y() - pos2.y();
+        int dist2 = dist * dist;
+        return dx * dx <= dist2 &&
+            dy * dy <= dist2 &&
+            pos1.roomName() == pos2.roomName();
+    }
+} // namespace Screeps
+
+#endif // DOUWCO_HIVEMIND_MEASURE_TOOL_HPP

douwco_hivemind/include/Tools/PathTool.hpp

@@ -0,0 +1,40 @@
+#ifndef DOUWCO_HIVEMIND_PATH_TOOL_HPP
+#define DOUWCO_HIVEMIND_PATH_TOOL_HPP
+
+#include <vector>
+#include <Screeps/Room.hpp>
+
+namespace DouwcoHivemind
+{
+    static std::vector<int> flattenPathSteps(const std::vector<Screeps::Room::PathStep> &pathSteps)
+    {
+        std::vector<int> flattened;
+        for (const auto &step : pathSteps)
+        {
+            flattened.push_back(step.x);
+            flattened.push_back(step.y);
+            flattened.push_back(step.dx);
+            flattened.push_back(step.dy);
+            flattened.push_back(step.direction);
+        }
+        return flattened;
+    }
+
+    static std::vector<Screeps::Room::PathStep> unflattenPathSteps(const std::vector<int> &flattened)
+    {
+        std::vector<Screeps::Room::PathStep> pathSteps;
+        for (size_t i = 0; i < flattened.size(); i += 5)
+        {
+            Screeps::Room::PathStep step;
+            step.x = flattened[i];
+            step.y = flattened[i+1];
+            step.dx = flattened[i+2];
+            step.dy = flattened[i+3];
+            step.direction = flattened[i+4];
+            pathSteps.emplace_back(step);
+        }
+        return pathSteps;
+    }
+} // namespace Screeps
+
+#endif // DOUWCO_HIVEMIND_PATH_TOOL_HPP

douwco_hivemind/src/Builder.cpp

@@ -0,0 +1,83 @@
+#include <vector>
+#include <optional>
+#include <emscripten.h>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Structure.hpp>
+#include <Screeps/StructureController.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureTower.hpp>
+#include <Screeps/Constants.hpp>
+#include <Screeps/Store.hpp>
+
+#include <Screeps/ConstructionSite.hpp>
+
+#include "Creeps/Builder.hpp"
+
+void DouwcoHivemind::Builder::depositEnergy()
+{
+    auto constructionSite = getConstructionSiteTarget();
+    if (!constructionSite)
+        return;
+
+    if (isNearTo(constructionSite->pos(), 1))
+    {
+        int resp = creep.build(*constructionSite);
+    }
+    else
+    {
+        moveToTarget();
+    }
+}
+
+std::unique_ptr<Screeps::ConstructionSite> DouwcoHivemind::Builder::getConstructionSiteTarget()
+{
+    auto roomObj = getRoomObjectTarget();
+    if (!roomObj)
+    {
+        searchConstructionSite();
+        return nullptr;
+    }
+
+    auto constructionSite = std::unique_ptr<Screeps::ConstructionSite>(dynamic_cast<Screeps::ConstructionSite *>(roomObj.release()));
+    if (!constructionSite)
+    {
+        searchConstructionSite();
+        return nullptr;
+    }
+
+    return std::move(constructionSite);
+}
+
+void DouwcoHivemind::Builder::searchConstructionSite()
+{
+    int leastProgressLeft = INT16_MAX;
+    Screeps::ConstructionSite *selectedConstructionSite;
+    auto constructionSites = creep.room().find(Screeps::FIND_MY_CONSTRUCTION_SITES);
+    for (auto &constructionSiteObject : constructionSites)
+    {
+        auto constructionSite = dynamic_cast<Screeps::ConstructionSite *>(constructionSiteObject.get());
+        if (!constructionSite)
+            continue;
+
+        int progressLeft = constructionSite->progressTotal() - constructionSite->progress();
+        
+        if(constructionSite->structureType() == Screeps::STRUCTURE_ROAD) progressLeft *= 100;
+        if (progressLeft < leastProgressLeft)
+        {
+            leastProgressLeft = progressLeft;
+            selectedConstructionSite = constructionSite;
+        }
+    }
+
+    if (selectedConstructionSite)
+        target_id = selectedConstructionSite->id();
+    else
+        target_id.clear();
+}

douwco_hivemind/src/CreepBase.cpp

@@ -0,0 +1,143 @@
+#include <algorithm>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+
+#include "Creeps/CreepBase.hpp"
+
+#include "Tools/JsonTool.hpp"
+#include "Tools/PathTool.hpp"
+#include "Tools/MeasureTool.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()
+{
+    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;
+    }
+
+    // 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 (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;
+    }
+
+    // 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);
+        }
+    }
+}
+
+std::unique_ptr<Screeps::RoomObject> DouwcoHivemind::CreepBase::getRoomObjectTarget()
+{
+    // 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");
+        return nullptr;
+    }
+    return std::move(roomObj);
+}
+
+bool DouwcoHivemind::CreepBase::isNearTo(const Screeps::RoomPosition &pos, int dist)
+{
+    return DouwcoHivemind::isNearTo(creep.pos(), pos, dist);
+}

douwco_hivemind/src/Engine.cpp

@@ -0,0 +1,88 @@
+#include <Screeps/Game.hpp>
+#include <Screeps/Memory.hpp>
+
+#include "Engine.hpp"
+
+#include "Creeps/Supplier.hpp"
+#include "Creeps/Upgrader.hpp"
+#include "Creeps/Builder.hpp"
+#include "Creeps/Maintainer.hpp"
+
+#include "Structures/Spawn.hpp"
+
+DouwcoHivemind::Engine::Engine()
+{
+    ReadOutCreeps();
+    ReadOutStructures();
+}
+
+void DouwcoHivemind::Engine::loop()
+{
+    JS::console.log(std::string("Iterating over creeps"));
+    for (auto &creep : creeps)
+        creep->loop();
+
+    JS::console.log(std::string("Iterating over structures"));
+    for (auto &structure : structures)
+        structure->loop();
+
+    if (Screeps::Game.time() % 1000 == 0)
+    {
+        clearDeadCreepMemory();
+    }
+}
+
+void DouwcoHivemind::Engine::ReadOutCreeps()
+{
+    JS::console.log(std::string("Reading out creeps"));
+    auto src_creeps = Screeps::Game.creeps();
+    for (auto &creep : src_creeps)
+    {
+        CreepRole role = creep.second.memory()["role"];
+        if (role == CreepRole::SUPPLIER)
+            creeps.push_back(std::make_unique<Supplier>(creep.second));
+        else if (role == CreepRole::UPGRADER)
+            creeps.push_back(std::make_unique<Upgrader>(creep.second));
+        else if (role == CreepRole::BUILDER)
+            creeps.push_back(std::make_unique<Builder>(creep.second));
+        else if (role == CreepRole::MAINTAINER)
+            creeps.push_back(std::make_unique<Maintainer>(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));
+    }
+}
+
+void DouwcoHivemind::Engine::clearDeadCreepMemory()
+{
+    auto creepMemory = Screeps::Memory["creeps"];
+    auto creepsMap = Screeps::Game.creeps();
+    int iterator = 0;
+    for (auto [name, creep] : creepMemory.items())
+    {
+        // avoid cpu overload
+        iterator++;
+        if (iterator == 100)
+            break;
+
+        bool containsname = false;
+        for (auto creepObject : creepsMap)
+        {
+            if (creepObject.first == name)
+            {
+                containsname = true;
+                break;
+            }
+        }
+        if (!containsname)
+            creepMemory.erase(name);
+    }
+    Screeps::Memory.set("creeps", creepMemory);
+}

douwco_hivemind/src/Loop.cpp

@@ -0,0 +1,32 @@
+#include <Screeps/Context.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/StructureSpawn.hpp>
+
+#include <emscripten.h>
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include "Engine.hpp"
+#include "Structures/Spawn.hpp"
+
+EMSCRIPTEN_KEEPALIVE
+extern "C" void loop()
+{
+	Screeps::Context::update();
+
+	JS::console.log(std::string("\n\n\n\n\n\n\n\n\n"));
+	JS::console.log(std::string("Processing tick:\t") + std::to_string(Screeps::Game.time()));
+
+	{
+		DouwcoHivemind::Engine engine;
+		engine.loop();
+	}
+
+	JS::console.log("Used CPU:\t" + std::to_string(Screeps::Game.cpuGetUsed()));
+	JS::console.log("Bucket:\t" + std::to_string(static_cast<int>(Screeps::Game.cpu()["bucket"])));
+}
+
+EMSCRIPTEN_BINDINGS(loop)
+{
+	emscripten::function("loop", &loop);
+}

douwco_hivemind/src/Maintainer.cpp

@@ -0,0 +1,89 @@
+#include <vector>
+#include <optional>
+#include <emscripten.h>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Structure.hpp>
+#include <Screeps/StructureController.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureTower.hpp>
+#include <Screeps/Store.hpp>
+
+#include "Creeps/Maintainer.hpp"
+
+void DouwcoHivemind::Maintainer::depositEnergy()
+{
+    auto structure = getDamagedStructureTarget();
+    if (!structure)
+        return;
+
+    if (isNearTo(structure->pos(), 1))
+    {
+        int resp = creep.repair(*structure);
+    }
+    else
+    {
+        moveToTarget();
+    }
+}
+
+std::unique_ptr<Screeps::Structure> DouwcoHivemind::Maintainer::getDamagedStructureTarget()
+{
+    auto roomObj = getRoomObjectTarget();
+    if (!roomObj)
+    {
+        searchDamagedStructure();
+        return nullptr;
+    }
+
+    auto structure = std::unique_ptr<Screeps::Structure>(dynamic_cast<Screeps::Structure *>(roomObj.release()));
+    if (!structure)
+    {
+        searchDamagedStructure();
+        return nullptr;
+    }
+
+    // Check if the structure is still broken
+    int damage = structure->hitsMax() - structure->hits();
+    if (damage == 0)
+    {
+        searchDamagedStructure();
+        return nullptr;
+    }
+
+    return std::move(structure);
+}
+
+void DouwcoHivemind::Maintainer::searchDamagedStructure()
+{
+    int lowestMaintaince = INT16_MAX;
+    Screeps::Structure *selectedStructure;
+    auto structures = creep.room().find(Screeps::FIND_STRUCTURES);
+    for (auto &structureObject : structures)
+    {
+        auto structure = dynamic_cast<Screeps::Structure *>(structureObject.get());
+        if (!structure)
+            continue;
+
+        int maintance = structure->hits();
+        auto structureType = structure->structureType();
+        if (structureType == Screeps::STRUCTURE_CONTROLLER)
+            continue;
+        if (maintance < lowestMaintaince)
+        {
+            lowestMaintaince = maintance;
+            selectedStructure = structure;
+        }
+    }
+
+    if (selectedStructure)
+        target_id = selectedStructure->id();
+    else
+        target_id.clear();
+}

douwco_hivemind/src/Miner.cpp

@@ -0,0 +1,67 @@
+#include <emscripten.h>
+#include <Screeps/Constants.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+
+#include "Creeps/Miner.hpp"
+
+DouwcoHivemind::Miner::Miner(Screeps::Creep crp) : CreepBase(crp)
+{
+    requestedContainer = memory.contains("requestedContainer") ? static_cast<bool>(memory["requestedContainer"]) : false;
+}
+
+DouwcoHivemind::Miner::~Miner()
+{
+    memory["requestedContainer"] = requestedContainer;
+}
+
+void DouwcoHivemind::Miner::loop()
+{
+    if (mineSource() && !requestedContainer)
+    {
+        creep.room().createConstructionSite(creep.pos(), Screeps::STRUCTURE_CONTAINER);
+        requestedContainer = true;
+    }
+}
+
+bool DouwcoHivemind::Miner::mineSource()
+{
+    auto source = getSourceTarget();
+    if (!source){
+        EM_ASM({console.log($0 + ': Miner doesn\'t have valid source target')}, creep.name().c_str());
+        return false;
+    }
+
+    if (isNearTo(source->pos(), 1))
+    {
+        int resp = creep.harvest(*source);
+        return true;
+    }
+    else
+    {
+        moveToTarget();
+        return false;
+    }
+}
+
+std::unique_ptr<Screeps::Source> DouwcoHivemind::Miner::getSourceTarget()
+{
+    auto roomObj = getRoomObjectTarget();
+    if (!roomObj)
+    {
+        // todo: request source from room
+        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());
+        // todo: request source from room
+        return nullptr;
+    }
+
+    return std::move(source);
+}

douwco_hivemind/src/Spawn.cpp

@@ -0,0 +1,91 @@
+#include <algorithm>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Constants.hpp>
+#include <Screeps/Structure.hpp>
+
+#include "Creeps/CreepBase.hpp"
+#include "Structures/Spawn.hpp"
+
+void DouwcoHivemind::Spawn::loop()
+{
+    // Only run every 50 ticks
+    if (Screeps::Game.time() % 50 != 0)
+        return;
+
+    auto room = spawn.room();
+    int energyAvailable = room.energyAvailable();
+    int energyCapacityAvailable = room.energyCapacityAvailable();
+    int constructionSiteCount = room.find(Screeps::FIND_MY_CONSTRUCTION_SITES).size();
+    auto structures = room.find(Screeps::FIND_STRUCTURES);
+    int repairableStructureCount, extensionCount;
+    for (auto& roomObj : structures)
+    {
+        auto structure = dynamic_cast<Screeps::Structure*>(roomObj.get());
+        std::string type = structure->structureType();
+        if (type == Screeps::STRUCTURE_CONTROLLER || type == Screeps::STRUCTURE_SPAWN) continue;
+        repairableStructureCount++;
+        if (type == Screeps::STRUCTURE_EXTENSION) extensionCount++;
+    }
+
+    int required_suppliers = std::clamp(extensionCount/5, 1, 2);
+    int required_maintainers = std::clamp(repairableStructureCount, 0, 1);
+    int required_builders = std::clamp(constructionSiteCount, 0, 5);
+    int required_upgraders = std::clamp(5-required_builders-required_maintainers-required_suppliers, 1, 3);
+
+    for (auto &creep : Screeps::Game.creeps())
+    {
+        CreepRole role = creep.second.memory()["role"];
+
+        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--;
+    }
+
+    if (energyAvailable < energyCapacityAvailable && required_suppliers == 0)
+        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;
+
+    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");
+    }
+
+    spawn.spawnCreep(
+        body,
+        name + std::to_string(Screeps::Game.time()),
+        opts);
+}

douwco_hivemind/src/Supplier.cpp

@@ -0,0 +1,121 @@
+#include <vector>
+#include <optional>
+#include <emscripten.h>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Structure.hpp>
+#include <Screeps/StructureController.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureTower.hpp>
+#include <Screeps/Store.hpp>
+
+#include "Creeps/Supplier.hpp"
+
+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();
+    }
+}
+
+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()));
+    if (!structure)
+    {
+        searchEnergyStructure();
+        return nullptr;
+    }
+
+    // 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 (energyCapacity == 0)
+    {
+        searchEnergyStructure();
+        return nullptr;
+    }
+
+    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();
+}

douwco_hivemind/src/Upgrader.cpp

@@ -0,0 +1,33 @@
+#include <vector>
+#include <optional>
+#include <emscripten.h>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Structure.hpp>
+#include <Screeps/StructureController.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureTower.hpp>
+#include <Screeps/Constants.hpp>
+#include <Screeps/Store.hpp>
+
+#include "Creeps/Upgrader.hpp"
+
+void DouwcoHivemind::Upgrader::depositEnergy()
+{
+    auto controller = creep.room().controller().value();
+    target_id = controller.id();
+    if (isNearTo(controller.pos(), 3))
+    {
+        int resp = creep.upgradeController(controller);
+    }
+    else
+    {
+        moveToTarget();
+    }
+}

douwco_hivemind/src/Worker.cpp

@@ -0,0 +1,123 @@
+#include <vector>
+#include <optional>
+#include <emscripten.h>
+
+#include <Screeps/Game.hpp>
+#include <Screeps/Creep.hpp>
+#include <Screeps/Source.hpp>
+#include <Screeps/Room.hpp>
+#include <Screeps/RoomPosition.hpp>
+#include <Screeps/RoomObject.hpp>
+#include <Screeps/Structure.hpp>
+#include <Screeps/StructureController.hpp>
+#include <Screeps/StructureSpawn.hpp>
+#include <Screeps/StructureExtension.hpp>
+#include <Screeps/StructureTower.hpp>
+#include <Screeps/Constants.hpp>
+#include <Screeps/Store.hpp>
+
+#include "Creeps/Worker.hpp"
+
+DouwcoHivemind::Worker::Worker(Screeps::Creep crp) : CreepBase(crp)
+{
+    harvesting = memory.contains("harvesting") ? static_cast<bool>(memory["harvesting"]) : false;
+}
+
+DouwcoHivemind::Worker::~Worker()
+{
+    memory["harvesting"] = harvesting;
+}
+
+void DouwcoHivemind::Worker::loop()
+{
+    if (harvesting)
+    {
+        if (creep.store().getFreeCapacity(Screeps::RESOURCE_ENERGY) == 0)
+        {
+            harvesting = false;
+            target_id.clear();
+        }
+        harvestSource();
+    }
+    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();
+    }
+}
+
+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 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();
+}

job_builder.js

@@ -1,57 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        //creep.memory.target = null;
-
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){
-                if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
-                else {
-                    var container = creep.pos.findClosestByPath(FIND_STRUCTURES, 
-                        {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
-                    if(container != null) creep.memory.target = container.id;
-                }
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                // constuction
-                var structure = creep.pos.findClosestByRange(FIND_MY_CONSTRUCTION_SITES);
-                
-                // ramparts
-                if(structure == null){
-                    var ramparts = creep.room.find(FIND_STRUCTURES, 
-                        {filter: (s)=>((s.structureType == STRUCTURE_RAMPART || s.structureType == STRUCTURE_WALL) && s.hits < s.hitsMax)});
-                    for(var ramp in ramparts){
-                        ramp = ramparts[ramp];
-                        if(structure == null || structure.hits > ramp.hits) structure = ramp;
-                    }
-                }
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(target == null || target.hits == target.hitsMax) creep.memory.target = null;
-            if(creep.build(target) == ERR_NOT_IN_RANGE || creep.repair(target) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

job_defender.js

@@ -1,22 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        if(creep.memory.flag != undefined && Game.flags[creep.memory.flag].room.name != creep.room.name) creep.moveTo(Game.flags[creep.memory.flag]); 
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        if(creep.memory.target == null){
-            var enemy = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS);
-            if(enemy != null) creep.memory.target = enemy.id;
-        }
-        var enemy = Game.getObjectById(creep.memory.target);
-        if(enemy != null){
-            creep.say("ATTACK");
-            if(creep.attack(enemy) == ERR_NOT_IN_RANGE) creep.moveTo(enemy);
-        } else {
-            creep.memory.target = null;
-        }
-    }
-};

job_harvester.js

@@ -1,92 +0,0 @@
-
-/*  ###########################################
-    # Mine energy and do all fundamental jobs #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        //memory setup
-        if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
-        if(creep.memory.counter == undefined) creep.memory.counter = 0;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-
-        if (creep.memory.harvesting){
-            var source = Game.getObjectById(creep.memory.source_id);
-            var result = creep.harvest(source);
-            if (result == ERR_NOT_IN_RANGE){
-                creep.moveTo(source);    
-            }
-            if (result == ERR_NOT_ENOUGH_RESOURCES || creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){
-                switch(creep.memory.counter%10){
-                    case 0: // upgrading
-                        creep.memory.target = creep.room.controller.id;
-                        break;
-                    case 1: // suppling
-                    case 2:
-                    case 3:
-                    case 4:
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
-                            filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 5:
-                    case 6:
-                    case 7:
-                    case 8:
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 9: // repairing (no walls or ramparts)
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
-                            filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                }
-            }
-            
-            var target = Game.getObjectById(creep.memory.target);
-            var response = OK;
-            switch(creep.memory.counter%10){
-                case 0:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    break;
-                case 1:
-                case 2:
-                case 3:
-                case 4:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-                    break;
-                case 5:
-                case 6:
-                case 7:
-                case 8:
-                    response = creep.build(target);
-                    if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
-                    break;
-                case 9:
-                    response = creep.repair(target);
-                    if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
-                    break;
-            }
-            if(response == ERR_NOT_IN_RANGE){
-                creep.moveTo(target);
-            } else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
-                creep.memory.target = null;
-            }
-            if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = true;
-                creep.memory.target = null;
-                creep.memory.counter += 1;
-            }
-        }
-    }
-};

job_miner.js

@@ -1,16 +0,0 @@
-
-/*  ########################################
-    # Mine energy and drop it in container #
-    ########################################*/
-
-module.exports = {
-    do: function(creep){
-        var container = Game.getObjectById(creep.memory.container_id);
-        if(container != null && creep.pos.isEqualTo(container.pos)){
-            if(creep.memory.source_id == undefined) creep.memory.source_id = creep.pos.findClosestByPath(FIND_SOURCES).id;
-            creep.harvest(Game.getObjectById(creep.memory.source_id));
-        } else {
-            creep.moveTo(Game.getObjectById(creep.memory.container_id));
-        }
-    }
-};

job_reserved_harvester.js

@@ -1,93 +0,0 @@
-
-/*  ###########################################
-    # Mine energy and do all fundamental jobs #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        creep.memory.home = "Central"
-        //memory setup
-        if(creep.memory.harvesting == undefined) creep.memory.harvesting = true;
-        if(creep.memory.counter == undefined) creep.memory.counter = 0;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-
-        if (creep.memory.harvesting){
-            var source = Game.getObjectById(creep.memory.source_id);
-            if(source != undefined && creep.room.name == source.room.name){
-                var container = creep.pos.findClosestByPath(FIND_STRUCTURES, { filter:(s) => ( s.structureType == STRUCTURE_CONTAINER && s.store.getUsedCapacity(RESOURCE_ENERGY) > creep.store.getFreeCapacity(RESOURCE_ENERGY))});
-                if(container == null) {
-                    var source = Game.getObjectById(creep.memory.source_id);
-                    result = creep.harvest(source);
-                    if (result == ERR_NOT_IN_RANGE){
-                        creep.moveTo(source);    
-                    }
-                } else {
-                    var result = creep.withdraw(container, RESOURCE_ENERGY);
-                    if (result == ERR_NOT_IN_RANGE){
-                        creep.moveTo(container);
-                    }
-                }
-                if (creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                    creep.memory.harvesting = false;
-                    creep.memory.target = null;
-                }
-            } else {
-                creep.moveTo(source);
-            }
-        } else {
-            if(creep.memory.target == null){
-                switch(creep.memory.counter%3){
-                    case 0: // building
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 1: // repairing (no walls or ramparts)
-                        creep.memory.target = creep.pos.findClosestByRange(FIND_STRUCTURES,{
-                            filter:(s) => ( s.structureType != STRUCTURE_WALL && s.structureType != STRUCTURE_RAMPART) && s.hits < s.hitsMax-creep.store.getUsedCapacity(RESOURCE_ENERGY)*3/4});
-                        if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                        else creep.memory.counter += 1;
-                        break;
-                    case 2:
-                        var home = Game.spawns[creep.memory.home];
-                        if(creep.room.name == home.room.name){
-                            creep.memory.target = creep.pos.findClosestByRange(FIND_MY_STRUCTURES,{
-                            filter:(s) => ( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION || s.structureType == STRUCTURE_STORAGE ) && s.store.getFreeCapacity(RESOURCE_ENERGY) > 0});
-                            if(creep.memory.target != null) creep.memory.target = creep.memory.target.id;
-                            else creep.memory.counter += 1;
-                        } else {
-                            creep.moveTo(home);
-                        }
-                        break;
-                }
-            }
-            
-            var target = Game.getObjectById(creep.memory.target);
-            var response = OK;
-            switch(creep.memory.counter%3){
-                case 0: // building
-                    response = creep.build(target);
-                    if(target != null && target.progress == target.progressTotal) creep.memory.target = null;
-                    break;
-                case 1:
-                    response = creep.repair(target);
-                    if(target != null && target.hits == target.hitsMax) creep.memory.target = null;
-                    break;
-                case 2:
-                    response = creep.transfer(target, RESOURCE_ENERGY);
-                    if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-                    break;
-            }
-            if(response == ERR_NOT_IN_RANGE){
-                creep.moveTo(target);
-            } else if(response == ERR_FULL || response == ERR_INVALID_TARGET){
-                creep.memory.target = null;
-            }
-            if (creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.harvesting = true;
-                creep.memory.target = null;
-                creep.memory.counter += 1;
-            }
-        }
-    }
-};

job_reserver.js

@@ -1,16 +0,0 @@
-
-/*  ###########################################
-    # Go to a controller and reserve the room #
-    ###########################################*/
-
-module.exports = {
-    do: function(creep){
-        if(Game.flags[creep.memory.target].room != undefined && Game.flags[creep.memory.target].room == creep.room){
-            if(creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE){
-                creep.moveTo(creep.room.controller);
-            }
-        } else {
-            creep.moveTo(Game.flags[creep.memory.target]);
-        }
-    }
-};

job_supplier.js

@@ -1,54 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){ // aquire target
-                var containers = creep.room.find(FIND_STRUCTURES, 
-                    {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && s.store.getUsedCapacity(RESOURCE_ENERGY) >= creep.store.getFreeCapacity(RESOURCE_ENERGY)/2)});
-                var container = containers[0];
-                for(var c in containers){
-                    c = containers[c];
-                    if(c.store.getUsedCapacity(RESOURCE_ENERGY) > container.store.getUsedCapacity(RESOURCE_ENERGY)) container = c;
-                }
-                if(container != null) creep.memory.target = container.id;
-                else creep.memory.target = creep.room.storage.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                var structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(s.structureType == STRUCTURE_TOWER && s.store.getUsedCapacity(RESOURCE_ENERGY) < 900)});
-                if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(( s.structureType == STRUCTURE_SPAWN || s.structureType == STRUCTURE_EXTENSION) 
-                        && s.store.getFreeCapacity(RESOURCE_ENERGY) > s.store.getCapacity(RESOURCE_ENERGY)*0.1)});
-                if(structure == null) structure = creep.pos.findClosestByPath(FIND_MY_STRUCTURES, 
-                    {filter: (s)=>(( s.id == "5f3e44e1014017c66fc5df10") && s.store.getFreeCapacity() > 100)});
-                if(structure == null) structure = creep.room.storage;
-                if(structure == null) return;
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) creep.memory.target = null;
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

job_upgrader.js

@@ -1,43 +0,0 @@
-
-/*  #######################################################
-    # Deliver energy to spawns, controller and extencions #
-    ####################################################### */
-
-module.exports = {
-    do: function(creep){
-        // Memory creation
-        if(creep.memory.restock == undefined) creep.memory.restock = true;
-        if(creep.memory.target == undefined) creep.memory.target = null;
-        
-        // Job implementation
-        if(creep.memory.restock){
-            if(creep.memory.target == null){
-                if(creep.room.storage != null && 1000 < creep.room.storage.store.getUsedCapacity(RESOURCE_ENERGY)) creep.memory.target = creep.room.storage.id;
-                else {
-                    var container = creep.pos.findClosestByPath(FIND_STRUCTURES, 
-                        {filter: (s)=>(s.structureType == STRUCTURE_CONTAINER
-                        && 0 < s.store.getUsedCapacity(RESOURCE_ENERGY))});
-                    if(container != null) creep.memory.target = container.id;
-                }
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.withdraw(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(target != null && target.store.getUsedCapacity(RESOURCE_ENERGY) < creep.store.getFreeCapacity(RESOURCE_ENERGY)*0.4) creep.memory.target = null;
-            if(creep.store.getFreeCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = false;
-                creep.memory.target = null;
-            }
-        } else {
-            if(creep.memory.target == null){ // aquire target
-                var structure = structure = creep.room.controller;
-                creep.memory.target = structure.id;
-            }
-            var target = Game.getObjectById(creep.memory.target);
-            if(creep.transfer(target, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) creep.moveTo(target);
-            if(creep.store.getUsedCapacity(RESOURCE_ENERGY) == 0){
-                creep.memory.restock = true;
-                creep.memory.target = null;
-            }
-        }
-    }
-};

js/main.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const wasm_loader = require('wasm_loader')
+
+var mod;
+wasm_loader('douwco_hivemind_loader', 'douwco_hivemind_module').then((instance) => {
+    console.log("WASM module loaded.");
+    mod = instance;
+});
+
+module.exports.loop = function () {
+    if (mod !== undefined)
+        mod.loop();
+}

js/wasm_loader.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = ((mod_js, mod_wasm, opts) => {
+
+    const mod_file = require(mod_js);
+    const bin_file = require(mod_wasm);
+
+    opts = opts || {};
+
+    opts.wasmBinary = bin_file;
+    opts.print = opts.print || ((text) => console.log(text));
+    opts.printErr = opts.printErr || ((text) => console.log(`error: ${text}`));
+    opts.onAbort = opts.onAbort || (() => console.log('WASM aborted!!!'));
+
+    // == don't call main()
+    if (typeof opts.noInitialRun === "undefined")
+        opts.noInitialRun = true;
+
+    // == don't terminate after returning from main()
+    if (typeof opts.noExitRuntime === "undefined")
+        opts.noExitRuntime = true;
+
+    return mod_file(opts);
+});

main.js

@@ -1,26 +0,0 @@
-
-var controller_spawns = require("controller_spawns");
-var controller_creeps = require("controller_creeps");
-var controller_towers = require("controller_towers");
-var ai_main = require("ai_main");
-
-module.exports.loop = function () {
-    ai_main.run_front();
-    controller_creeps.run();
-    controller_towers.run();
-    controller_spawns.run();
-    if (Game.time % 60 == 30) clear_dead_creeps_from_memory();
-    ai_main.run_back();
-}
-
-/*
-    GLOBAL FUNCTIONS
-*/
-
-function clear_dead_creeps_from_memory() {
-    for (var cr in Memory.creeps) {
-        if (Game.creeps[cr] == null) {
-            delete (Memory.creeps[cr]);
-        }
-    }
-}