修复bug

.eslintrc.json

@@ -0,0 +1,23 @@
+{
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true
+    },
+    "extends": [
+        "airbnb-base",
+        "prettier"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 12
+    },
+    "rules": {
+        "prettier/prettier": ["error",{
+            "endOfLine":"auto",
+            "tabWidth":4
+        }]
+    },
+    "plugins": [
+        "prettier"
+    ]
+}

.gitignore

@@ -0,0 +1 @@
+node_modules

builder.js

@@ -1,82 +1,105 @@
-const utils = require('utils');
+/* eslint-disable no-console */
+/* eslint-disable func-names */
+/* eslint-disable no-undef */
+/* eslint-disable camelcase */
+const utils = require("./utils");
+
+function upgradeController_job(creep) {
+    const { working_target_id } = creep;
+    const working_target = Game.getObjectById(working_target_id);
+    if (utils.distance(creep.pos, working_target.pos) > 1.5) {
+        creep.moveTo(working_target);
+    } else {
+        const all_dropped_resource = creep.room.find(FIND_DROPPED_RESOURCES);
+        const nearest_dropped_enengy = _.filter(all_dropped_resource, function (
+            energy
+        ) {
+            return (
+                energy.resourceType === RESOURCE_ENERGY &&
+                utils.distance(energy.pos, creep.pos) < 1.5
+            );
+        });
+        if (nearest_dropped_enengy.length > 0) {
+            const Re_code_pickup = creep.pickup(nearest_dropped_enengy[0]);
+            if (OK === Re_code_pickup || ERR_FULL === Re_code_pickup) {
+                // TODO:需要适应不同的建筑
+                const Re_code = creep.upgradeController(working_target);
+                // eslint-disable-next-line no-empty
+                if (OK === Re_code) {
+                } else if (
+                    Re_code !== ERR_NOT_ENOUGH_RESOURCES &&
+                    Re_code !== ERR_NOT_IN_RANGE
+                ) {
+                    console.log(
+                        `${creep.name} failed to upgrade room controller:err ${Re_code}`
+                    );
+                }
+            } else {
+                console.log(
+                    `${creep.name} failed to pickup: err ${Re_code_pickup}`
+                );
+            }
+        }
+    }
+}
+
+function build_construction(creep) {
+    const { working_target_id } = creep;
+    const working_target = Game.getObjectById(working_target_id);
+    if (utils.distance(creep.pos, working_target.pos) > 1.5) {
+        creep.moveTo(working_target);
+    } else {
+        const all_dropped_resource = creep.room.find(FIND_DROPPED_RESOURCES);
+        const nearest_dropped_enengy = _.filter(all_dropped_resource, function (
+            energy
+        ) {
+            return (
+                energy.resourceType === RESOURCE_ENERGY &&
+                utils.distance(energy.pos, creep.pos) < 1.5
+            );
+        });
+        if (nearest_dropped_enengy.length > 0) {
+            const Re_code_pickup = creep.pickup(nearest_dropped_enengy[0]);
+            if (OK === Re_code_pickup || ERR_FULL === Re_code_pickup) {
+                // TODO:需要适应不同的建筑
+                const Re_code = creep.build(working_target);
+                // eslint-disable-next-line no-empty
+                if (OK === Re_code) {
+                } else if (
+                    Re_code !== ERR_NOT_ENOUGH_RESOURCES &&
+                    Re_code !== ERR_NOT_IN_RANGE
+                ) {
+                    console.log(`${creep.name} failed to build:err ${Re_code}`);
+                }
+            } else {
+                console.log(
+                    `${creep.name} failed to pickup: err ${Re_code_pickup}`
+                );
+            }
+        }
+    }
+}
+
 module.exports = {
     run(creep) {
         if (creep.working_target_id) {
-            let working_target_id = creep.working_target_id;
+            const { working_target_id } = creep;
-            let working_target = Game.getObjectById(working_target_id);
+            const working_target = Game.getObjectById(working_target_id);
             if (!working_target) {
                 // creep.working_target_id=undefined//目标已经完成，转为空闲状态
                 // _.each(Memery.WorkingTarget[creep.name].working_creep_names,creep_name=>Game.creeps[creep_name].working_target_id=undefined)
                 // delete Memery.WorkingTarget[creep.name]
-                return
+                return;
             }
-            if (working_target.structureType == STRUCTURE_CONTROLLER) {
+            if (working_target.structureType === STRUCTURE_CONTROLLER) {
-                creep.say('ug')
+                creep.say("ug");
-                upgradeController_job(creep)
+                upgradeController_job(creep);
-                return
+                return;
             }
-            creep.say('bd')
+            creep.say("bd");
-            build_construction(creep)
+            build_construction(creep);
         } else {
-            creep.say('SB')
+            creep.say("SB");
-        }
-    }
-}
-
-
-function upgradeController_job(creep) {
-    let working_target_id = creep.working_target_id;
-    let working_target = Game.getObjectById(working_target_id);
-    if (utils.distance(creep.pos, working_target.pos) > 1.5) {
-        creep.moveTo(working_target);
-    } else {
-        let all_dropped_resource = creep.room.find(FIND_DROPPED_RESOURCES)
-        let nearest_dropped_enengy = _.filter(all_dropped_resource, function (energy) {
-            return energy.resourceType == RESOURCE_ENERGY & utils.distance(energy.pos, creep.pos) < 1.5
-        })
-        if (nearest_dropped_enengy.length > 0) {
-            let Re_code_pickup = creep.pickup(nearest_dropped_enengy[0]);
-            if (OK == Re_code_pickup || ERR_FULL == Re_code_pickup) {
-                //TODO:需要适应不同的建筑
-                let Re_code = creep.upgradeController(working_target)
-                if (OK == Re_code) {
-
-                } else if (Re_code != ERR_NOT_ENOUGH_RESOURCES && Re_code != ERR_NOT_IN_RANGE) {
-                    console.log(`${creep.name} failed to upgrade room controller:err ${Re_code}`)
-                }
-            } else {
-                console.log(`${creep.name} failed to pickup: err ${Re_code_pickup}`)
-            }
-        }
-
-    }
-}
-
-
-function build_construction(creep) {
-    let working_target_id = creep.working_target_id;
-    let working_target = Game.getObjectById(working_target_id);
-    if (utils.distance(creep.pos, working_target.pos) > 1.5) {
-        creep.moveTo(working_target);
-    } else {
-        let all_dropped_resource = creep.room.find(FIND_DROPPED_RESOURCES)
-        let nearest_dropped_enengy = _.filter(all_dropped_resource, function (energy) {
-            return energy.resourceType == RESOURCE_ENERGY & utils.distance(energy.pos, creep.pos) < 1.5
-        })
-        if (nearest_dropped_enengy.length > 0) {
-            let Re_code_pickup = creep.pickup(nearest_dropped_enengy[0]);
-            if (OK == Re_code_pickup || ERR_FULL == Re_code_pickup) {
-                //TODO:需要适应不同的建筑
-                let Re_code = creep.build(working_target)
-                if (OK == Re_code) {
-
-                } else if (Re_code != ERR_NOT_ENOUGH_RESOURCES && Re_code != ERR_NOT_IN_RANGE) {
-                    console.log(`${creep.name} failed to build:err ${Re_code}`)
-                }
-            } else {
-                console.log(`${creep.name} failed to pickup: err ${Re_code_pickup}`)
-            }
-        }
-
-    }
         }
+    },
+};

controller_contributer.js

@@ -1,9 +1,15 @@
+/* eslint-disable no-undef */
 module.exports = {
     run(creep) {
-        if (Game.spawns.Spawn1.store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
+        if (Game.spawns.Spawn1.store.getFreeCapacity(RESOURCE_ENERGY) === 0) {
-            if (creep.transfer(Game.spawns.Spawn1.room.controller, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+            if (
+                creep.transfer(
+                    Game.spawns.Spawn1.room.controller,
+                    RESOURCE_ENERGY
+                ) === ERR_NOT_IN_RANGE
+            ) {
                 creep.moveTo(Game.spawns.Spawn1.room.controller.pos);
             }
         }
-    }
+    },
-}
+};

harvester.js

@@ -1,62 +1,67 @@
-const path = require('path')
+/* eslint-disable no-undef */
-module.exports = {
+/* eslint-disable camelcase */
-    run(creep) {
+const path = require("path");
-        let status = change_status()
-        switch (status) {
-            case 'harvester':
-                creep.say('hv')
-                harvester_job(creep)
-                break
-            case 'picker':
-                creep.say('pc')
-                picker_job(creep)
-                break
-        }
-    }
-}
-
 
 function harvester_job(creep) {
     if (creep.carry.energy < creep.carryCapacity) {
-        let working_target_id = creep.working_target_id;
+        const { working_target_id } = creep;
-        let working_target = Game.getObjectById(working_target_id);
+        const working_target = Game.getObjectById(working_target_id);
-        if (creep.harvest(working_target) == ERR_NOT_IN_RANGE) {
+        if (creep.harvest(working_target) === ERR_NOT_IN_RANGE) {
             creep.moveTo(working_target);
             path.visualPath(creep.pos, working_target.pos);
         }
-    } else {
+    } else if (
-        if (creep.transfer(Game.spawns['Spawn1'], RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+        creep.transfer(Game.spawns.Spawn1, RESOURCE_ENERGY) === ERR_NOT_IN_RANGE
-            creep.moveTo(Game.spawns['Spawn1']);
+    ) {
-            path.visualPath(creep.pos, Game.spawns['Spawn1'].pos);
+        creep.moveTo(Game.spawns.Spawn1);
-        }
+        path.visualPath(creep.pos, Game.spawns.Spawn1.pos);
     }
 }
 
 function picker_job(creep) {
-    if (Game.spawns['Spawn1'].store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
+    if (Game.spawns.Spawn1.store.getFreeCapacity(RESOURCE_ENERGY) === 0) {
-        creep.say('SB')
+        creep.say("SB");
-        return
+        return;
     }
-    let working_target_id = creep.working_target_id;
+    const { working_target_id } = creep;
     if (!working_target_id) {
-        creep.say('SB')
+        creep.say("SB");
     }
-    let working_target = Game.getObjectById(working_target_id);
+    const working_target = Game.getObjectById(working_target_id);
-    let Re_code = creep.harvest(working_target);
+    const Re_code = creep.harvest(working_target);
-    if (Re_code == ERR_NOT_IN_RANGE) {
+    if (Re_code === ERR_NOT_IN_RANGE) {
         creep.moveTo(working_target);
-    } else {
+    } else if (OK === Re_code) {
-        if (OK == Re_code) {
         creep.harvest(working_target);
         creep.drop(RESOURCE_ENERGY);
     }
 }
-}
 
 function change_status() {
-    if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() > 0) {
+    if (
-        return 'picker'
+        _(Game.creeps)
-    } else {
+            .filter({ memory: { role: "transfer" } })
-        return 'harvester'
+            .size() > 0
+    ) {
+        return "picker";
     }
+    return "harvester";
 }
+
+module.exports = {
+    run(creep) {
+        const status = change_status();
+        switch (status) {
+            case "harvester":
+                creep.say("hv");
+                harvester_job(creep);
+                break;
+            case "picker":
+                creep.say("pc");
+                picker_job(creep);
+                break;
+            default:
+                break;
+        }
+    },
+};

init.js

@@ -1,16 +1,14 @@
-
+/* eslint-disable no-undef */
-
 module.exports = {
     init() {
         if (!Memory.Task) {
-            Memory.Task = {}
+            Memory.Task = {};
-        };
+        }
         Memory.Task.HighPorioty = [];
         Memory.Task.LowPorioty = [];
         // WorkingTarget是被跟踪物，可以是一个structure、energy、constructionSite，也可以是一个creep
         if (!Memory.WorkingTarget) {
-            Memory.WorkingTarget = {}
+            Memory.WorkingTarget = {};
+        }
+    },
 };
-    }
-}
-

main.js

@@ -1,54 +1,10 @@
-const init = require('init')
+/* eslint-disable no-console */
-const util = require('utils');
+/* eslint-disable no-undef */
-const mount = require('mount')
+/* eslint-disable func-names */
-module.exports.loop = function () {
+/* eslint-disable camelcase */
-    extra()
+const mount = require("./mount");
-    init.init();
+const init = require("./init");
-    mount.mount()
+const util = require("./utils");
-    cleanCreeps()
-    cleanInvalidMemoryCreep()
-    cleanTargetMemory()
-    assign_harvester_to_enery_source();
-    assign_transfer_to_harvester()
-    assign_builder_to_controller();
-    assign_transfer_to_builder();
-    let construction_site_array = Game.spawns['Spawn1'].room.find(FIND_MY_CONSTRUCTION_SITES)
-    _.each(construction_site_array, function (found_construction_site) {
-        let constuction_key = `CONSTRUCTION_${found_construction_site.id}`
-        if (Memory.WorkingTarget[constuction_key] && Memory.WorkingTarget[constuction_key].working_creep_names.length == 0) {
-            assign_builder_to_construction(found_construction_site.id)
-        }
-
-    })
-    let isSpawning = false
-    let energy_source_number = _.filter(Game.spawns['Spawn1'].room.find(FIND_SOURCES_ACTIVE)).length;
-    let harvester_number = _(Game.creeps).filter({ memory: { role: 'harvester' } }).size();
-    if (!Game.spawns['Spawn1'].spawning) {
-        if (harvester_number < energy_source_number) {
-            isSpawning = true
-            createHarvestCreep();
-        }
-        if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() < energy_source_number && !isSpawning) {
-            isSpawning = true
-            createTransferCreep();
-        }
-        let builder_number = _.filter(Game.creeps, { memory: { role: 'builder' } }).length
-        //创造一个builder升级room controller
-        if (Game.spawns['Spawn1'].room.controller && builder_number < (1 + construction_site_array.length) && !isSpawning) {
-            isSpawning = true
-            createBuilderCreep();
-        }
-        //判断是否需要再增加1个transfer
-        let transfer_number = _.filter(Game.creeps, { memory: { role: 'transfer' } }).length
-        if ((builder_number + harvester_number) > transfer_number && !isSpawning) {
-            isSpawning = true
-            createTransferCreep();
-        }
-    }
-    assign_task();
-
-}
-
 
 function extra() {
     // Game.map.visual.circle(Game.getObjectById('5bbcaaeb9099fc012e6326f1').pos)
@@ -57,12 +13,12 @@ function extra() {
 }
 
 function cleanCreeps() {
-    for (let i in Memory.creeps) {
+    _.each(Object.keys(Memory.creeps), function (key) {
-        if (!Game.creeps[i]) {
+        if (!Game.creeps[key]) {
-            console.log(`${i} is invalid, removed from Memory.creeps`)
+            console.log(`${key} is invalid, removed from Memory.creeps`);
-            delete Memory.creeps[i];
+            delete Memory.creeps[key];
-        }
         }
+    });
 }
 
 function cleanInvalidMemoryCreep() {
@@ -70,201 +26,302 @@ function cleanInvalidMemoryCreep() {
     _.each(Memory.WorkingTarget, function (target) {
         _.remove(target.working_creep_names, function (creep_name) {
             if (!Game.creeps[creep_name]) {
-                console.log(`${creep_name} is invalid, removed from working_creep_names`)
+                console.log(
-                return true
+                    `${creep_name} is invalid, removed from working_creep_names`
+                );
+                return true;
             }
-            return false
+            return false;
-
+        });
-        })
+    });
-    })
 }
 
 function cleanTargetMemory() {
-    for (let i of Object.keys(Memory.WorkingTarget)) {
+    _.each(Object.keys(Memory.WorkingTarget), function (target_key) {
-        let target = Memory.WorkingTarget[i]
+        const target = Memory.WorkingTarget[target_key];
         if (!Game.getObjectById(target.id)) {
-            console.log(`target ${target.id} is invalid, removed from Memory.WorkingTarget.Set their creep to idle`)
+            console.log(
-            _.each(Memory.WorkingTarget[i].working_creep_names, creep_name => creep_name.working_target_id = undefined)
+                `target ${target.id} is invalid, removed from Memory.WorkingTarget.Set their creep to idle`
-            delete Memory.WorkingTarget[i];
+            );
-        }
+            _.each(target.working_creep_names, (creep_name) => {
+                Game.creeps[creep_name].working_target_id = undefined;
+            });
+            delete Memory.WorkingTarget[target_key];
         }
+    });
 }
 
+function assign_creeps(opt) {
+    const { memory } = opt;
+    const { creep_name_to_assign_array } = opt; // 需要分配工作的creeps
+    _.each(creep_name_to_assign_array, function (creep_name) {
+        // 先计算每一个target目前有多少个creeps了
+        const working_creeps_of_target_array = []; // 记录每个target已有的creep数量
+        _.each(memory, (m) =>
+            working_creeps_of_target_array.push(m.working_creep_names.length)
+        );
+        const target_to_add_creep = _.filter(
+            memory,
+            (m) =>
+                m.working_creep_names.length ===
+                _.min(working_creeps_of_target_array)
+        ); // 选择目前已有creep最少的，对其添加creep
+        if (target_to_add_creep.length > 0) {
+            target_to_add_creep[0].working_creep_names.push(creep_name); // target记录自己安排的creep
+            Game.creeps[creep_name].working_target_id =
+                target_to_add_creep[0].id; // 将target安排给creep
+        }
+    });
+}
 
 function assign_transfer(target_memory) {
-    const NO_IDLE_TRANSFER = -1
+    const NO_IDLE_TRANSFER = -1;
-    const OK_TRANSFER = 0
+    const OK_TRANSFER = 0;
+    const MEMORY_EMPTY = -2;
     if (target_memory.length > 0) {
-        let idle_transfer = _.filter(Game.creeps, creep => !creep.working_target_id && (creep.memory.role == 'transfer'))
+        const idle_transfer = _.filter(
-        if (idle_transfer.length > 0) {//一次只安排一个creep
+            Game.creeps,
-            let opt = {
+            (creep) =>
+                !creep.working_target_id && creep.memory.role === "transfer"
+        );
+        if (idle_transfer.length > 0) {
+            // 一次只安排一个creep
+            const opt = {
                 memory: target_memory,
-                creep_name_to_assign_array: [idle_transfer[0].name]
+                creep_name_to_assign_array: [idle_transfer[0].name],
-            }
+            };
-            assign_creeps(opt)
+            assign_creeps(opt);
-            return OK_TRANSFER
+            return OK_TRANSFER;
-        } else {
-            return NO_IDLE_TRANSFER
-
         }
+        return NO_IDLE_TRANSFER;
     }
+    return MEMORY_EMPTY;
 }
 // TODO:应该和assign_transfer_to_builder合并
 function assign_transfer_to_harvester() {
     // 判断有多少个picker的transfer为0
-    let harvester_without_creep = _.filter(Game.creeps, function (creep) {
+    const harvester_without_creep = _.filter(Game.creeps, function (creep) {
-        return !Memory.WorkingTarget[creep.name] && creep.memory.role == 'harvester'//Memory.WorkingTarget中没有这个harvester目标
+        return (
-    })
+            !Memory.WorkingTarget[creep.name] &&
+            creep.memory.role === "harvester"
+        ); // Memory.WorkingTarget中没有这个harvester目标
+    });
     _.each(harvester_without_creep, function (harvester_creep) {
-        Memory.WorkingTarget[harvester_creep.name] = { id: harvester_creep.id, working_creep_names: [], cate: 'harvester' }//在Memory.WorkingTarget加入需要creep的Picker
+        Memory.WorkingTarget[harvester_creep.name] = {
-    })
+            id: harvester_creep.id,
-    let harvester_needs_creep_memory = _.filter(Memory.WorkingTarget, memory => memory.working_creep_names.length == 0 && memory.cate == 'harvester')//需要安排creep的harvester
+            working_creep_names: [],
-    assign_transfer(harvester_needs_creep_memory)
+            cate: "harvester",
+        }; // 在Memory.WorkingTarget加入需要creep的Picker
+    });
+    const harvester_needs_creep_memory = _.filter(
+        Memory.WorkingTarget,
+        (memory) =>
+            memory.working_creep_names.length === 0 &&
+            memory.cate === "harvester"
+    ); // 需要安排creep的harvester
+    assign_transfer(harvester_needs_creep_memory);
 }
 
 function assign_task() {
-    for (const creep_id in Game.creeps) {
+    _.each(Object.keys(Game.creeps), (creep_name) => {
-        let creep = Game.creeps[creep_id];
+        const creep = Game.creeps[creep_name];
         creep.action();
+    });
 }
 
+function createBuilderCreep() {
+    // create new creep
+    const new_creep_name = `AUTO_CREATE_Builder_${util.uuid()}`;
+    const Re_code = Game.spawns.Spawn1.createCreep(
+        [MOVE, CARRY, WORK],
+        new_creep_name
+    );
+    if (Re_code === new_creep_name) {
+        Game.creeps[new_creep_name].memory.role = "builder";
+        console.log(`Create new creep ${new_creep_name}`);
+    } else {
+        // console.log(`failed to create builder with code ${Re_code}`);
+    }
 }
-
 
 function assign_transfer_to_builder() {
     // 判断有多少个builder的transfer为0
-    let builder_without_creep = _.filter(Game.creeps, function (creep) {
+    const builder_without_creep = _.filter(Game.creeps, function (creep) {
-        return !Memory.WorkingTarget[creep.name] && creep.memory.role == 'builder'//Memory.WorkingTarget中没有这个builder目标
+        return (
-    })
+            !Memory.WorkingTarget[creep.name] && creep.memory.role === "builder"
+        ); // Memory.WorkingTarget中没有这个builder目标
+    });
     _.each(builder_without_creep, function (builder) {
-        Memory.WorkingTarget[builder.name] = { id: builder.id, working_creep_names: [], cate: 'builder' }//在Memory.WorkingTarget加入需要creep的builder
+        Memory.WorkingTarget[builder.name] = {
-    })
+            id: builder.id,
-    let builder_needs_creep_memory = _.filter(Memory.WorkingTarget, memory => memory.working_creep_names.length == 0 && memory.cate == 'builder')//需要安排creep的builder
+            working_creep_names: [],
-    if (assign_transfer(builder_needs_creep_memory) == -1) {
+            cate: "builder",
-        console.log(`no enough transfer to builder. Try to create a new one autmatically`)
+        }; // 在Memory.WorkingTarget加入需要creep的builder
-        createBuilderCreep()
+    });
+    const builder_needs_creep_memory = _.filter(
+        Memory.WorkingTarget,
+        (memory) =>
+            memory.working_creep_names.length === 0 && memory.cate === "builder"
+    ); // 需要安排creep的builder
+    if (builder_needs_creep_memory.length > 0) {
+        if (assign_transfer(builder_needs_creep_memory) === -1) {
+            console.log(
+                `no enough transfer to builder. Try to create a new one autmatically`
+            );
+            createBuilderCreep();
+        }
     }
 }
 
 function assign_builder_to_construction(construction_id) {
     // 检查construction是否已经是target
-    let constuction_key = `CONSTRUCTION_${construction_id}`
+    const constuction_key = `CONSTRUCTION_${construction_id}`;
-    if (!_.find(Memory.WorkingTarget, target => target.id == construction_id)) {
+    if (
-        Memory.WorkingTarget[constuction_key] = { id: construction_id, working_creep_names: [], cate: 'constuction_site' }
+        !_.find(Memory.WorkingTarget, (target) => target.id === construction_id)
+    ) {
+        Memory.WorkingTarget[constuction_key] = {
+            id: construction_id,
+            working_creep_names: [],
+            cate: "constuction_site",
+        };
     }
     // 安排一个builder过去
-    let builder = _.filter(Game.creeps, creep => creep.memory.role == 'builder' && !creep.working_target_id)
+    const builder = _.filter(
+        Game.creeps,
+        (creep) => creep.memory.role === "builder" && !creep.working_target_id
+    );
     if (builder.length > 0) {
-
+        const opt = {
-        let opt = {
+            memory: _.filter(
-            memory: _.filter(Memory.WorkingTarget, _memory => _memory.working_creep_names.length == 0 && _memory.cate == 'constuction_site'),
+                Memory.WorkingTarget,
-            creep_name_to_assgin_array: [builder[0].name]
+                (_memory) =>
-        }
+                    _memory.working_creep_names.length === 0 &&
-        assign_creeps(opt)
+                    _memory.cate === "constuction_site"
+            ),
+            creep_name_to_assgin_array: [builder[0].name],
+        };
+        assign_creeps(opt);
     } else {
-        console.log(`no enough builder to constuction_site ${construction_id}. Try to create a new one autmatically`)
+        console.log(
-        createBuilderCreep()
+            `no enough builder to constuction_site ${construction_id}. Try to create a new one autmatically`
+        );
+        createBuilderCreep();
     }
-    // //开始给建造constrction的每个creep安排transfer
-    // _.each(Memory.WorkingTarget[constuction_key].working_creep_names,function(builder_creep_name){
-    //     if(!Memory.WorkingTarget[builder_creep_name]){
-    //         Memory.WorkingTarget[builder_creep_name]={id:Game.creeps[builder_creep_name].id,working_creep_names: [], cate: 'builder'}
-    //     }
-    // })
 }
 
-
+function assign_harvester_to_energy_source() {
-function assign_creeps(opt) {
+    const sources = Game.spawns.Spawn1.room.find(FIND_SOURCES_ACTIVE);
-    let memory = opt.memory
+    _.each(Object.keys(sources), function (source_key) {
-    let creep_name_to_assign_array = opt.creep_name_to_assign_array//需要分配工作的creeps
+        const { id } = sources[source_key];
-    _.each(creep_name_to_assign_array, function (creep_name) {
+        const key = `Energy_${id}`;
-        //先计算每一个target目前有多少个creeps了
+        if (!_.find(Memory.WorkingTarget, (target) => target.id === id)) {
-        let working_creeps_of_target_array = []//记录每个target已有的creep数量
+            Memory.WorkingTarget[key] = {
-        _.each(memory, m => working_creeps_of_target_array.push(m.working_creep_names.length))
+                id,
-        let target_to_add_creep = _.filter(memory, m => m.working_creep_names.length == _.min(working_creeps_of_target_array))//选择目前已有creep最少的，对其添加creep
+                working_creep_names: [],
-        console.log(target_to_add_creep.length)
+                cate: "ENERGY_SOURCE",
-        if (target_to_add_creep.length > 0) {
+            };
-            target_to_add_creep[0].working_creep_names.push(creep_name)//target记录自己安排的creep
-            Game.creeps[creep_name].working_target_id = target_to_add_creep[0].id//将target安排给creep
         }
-    })
+    });
-
+    // 向Memory.WorkingTarget里添加所有的Energy Source
-
-}
-
-function assign_harvester_to_enery_source() {
-    let sources = Game.spawns['Spawn1'].room.find(FIND_SOURCES_ACTIVE);
-    let all_memory = Memory.WorkingTarget
-    for (let source of sources) {
-        let id = source.id
-        if (!_.find(all_memory, f => f['id'] == id)) {
-            all_memory[`Energy_${id}`] = { 'id': id, 'working_creep_names': [], "cate": 'ENERGY_SOURCE' };
-        }
-    }//向Memory.WorkingTarget里添加所有的Energy Source
     // 寻找Energy Source的Memory
-    let energy_memory = _.filter(all_memory, { cate: 'ENERGY_SOURCE' })
+    const energy_memory = _.filter(Memory.WorkingTarget, {
+        cate: "ENERGY_SOURCE",
+    });
     // 寻找creep为0的energy source
-    let energy_source_need_creep_array = _.filter(energy_memory, m => m.working_creep_names.length == 0)
+    const energy_source_need_creep_array = _.filter(
+        energy_memory,
+        (m) => m.working_creep_names.length === 0
+    );
     if (energy_source_need_creep_array.length > 0) {
         // 找到一个空闲的creep
-        let available_creep_array = _.filter(Game.creeps, creep => !creep.working_target_id && creep.memory.role == 'harvester')
+        const available_creep_array = _.filter(
-        if (available_creep_array.length > 0) {//每次只安排一个
+            Game.creeps,
-            let opt = {
+            (creep) =>
+                !creep.working_target_id && creep.memory.role === "harvester"
+        );
+        if (available_creep_array.length > 0) {
+            // 每次只安排一个
+            const opt = {
                 memory: energy_memory,
-                creep_name_to_assign_array: [available_creep_array[0].name]
+                creep_name_to_assign_array: [available_creep_array[0].name],
-            }
+            };
-            assign_creeps(opt)
+            assign_creeps(opt);
         }
     }
-
-
 }
 
 function assign_builder_to_controller() {
     // 如果存在正在建造的construction，且没有多余的builder，就暂停upgrade controller
-    if (Game.spawns['Spawn1'].room.find(FIND_MY_CONSTRUCTION_SITES).length > 0) {
+    if (Game.spawns.Spawn1.room.find(FIND_MY_CONSTRUCTION_SITES).length > 0) {
-        let working_builder = _.filter(Game.creeps, creep => creep.memory.role == 'builder' && !creep.working_target_id)
+        const working_builder = _.filter(
-        if (working_builder.length == 0) {//没有可以用的builder了
+            Game.creeps,
-            let controller_id = Game.spawns['Spawn1'].room.controller.id
+            (creep) =>
-            let controller_memory = Memory.WorkingTarget[`RoomController_${controller_id}`]
+                creep.memory.role === "builder" && !creep.working_target_id
+        );
+        if (working_builder.length === 0) {
+            // 没有可以用的builder了
+            const controller_id = Game.spawns.Spawn1.room.controller.id;
+            const controller_memory =
+                Memory.WorkingTarget[`RoomController_${controller_id}`];
             if (controller_memory) {
-                _.each(controller_memory.working_creep_names, creep_name => Game.creeps[creep_name].working_target_id = 0)
+                _.each(controller_memory.working_creep_names, (creep_name) => {
-                memory.working_creep_names = []
+                    Game.creeps[creep_name].working_target_id = 0;
-                return
+                });
+                memory.working_creep_names = [];
+                return;
             }
         }
     }
     // 判断room controller 是否有creep,没有则添加
-    if (!_.find(Memory.WorkingTarget, target => target.id == Game.spawns['Spawn1'].room.controller.id)) {
+    if (
-        Memory.WorkingTarget[`RoomController_${Game.spawns['Spawn1'].room.controller.id}`] = { id: Game.spawns['Spawn1'].room.controller.id, working_creep_names: [], cate: 'ROOM_CONTROLLER' }
+        !_.find(
+            Memory.WorkingTarget,
+            (target) => target.id === Game.spawns.Spawn1.room.controller.id
+        )
+    ) {
+        Memory.WorkingTarget[
+            `RoomController_${Game.spawns.Spawn1.room.controller.id}`
+        ] = {
+            id: Game.spawns.Spawn1.room.controller.id,
+            working_creep_names: [],
+            cate: "ROOM_CONTROLLER",
+        };
     }
-    let room_controller_mem = _.filter(Memory.WorkingTarget, { cate: 'ROOM_CONTROLLER' })
+    const room_controller_mem = _.filter(Memory.WorkingTarget, {
+        cate: "ROOM_CONTROLLER",
+    });
     // 寻找creep为0的room controller
-    let room_controller_need_creep_array = _.filter(room_controller_mem, m => m.working_creep_names.length == 0 && m.cate == 'ROOM_CONTROLLER')
+    const room_controller_need_creep_array = _.filter(
+        room_controller_mem,
+        (m) =>
+            m.working_creep_names.length === 0 && m.cate === "ROOM_CONTROLLER"
+    );
     if (room_controller_need_creep_array.length > 0) {
-        let builder_creep = _.filter(Game.creeps, creep => !creep.working_target_id && creep.memory.role == 'builder')
+        const builder_creep = _.filter(
+            Game.creeps,
+            (creep) =>
+                !creep.working_target_id && creep.memory.role === "builder"
+        );
         if (builder_creep.length > 0) {
-            let opt = {
+            const opt = {
                 memory: room_controller_mem,
-                creep_name_to_assign_array: [builder_creep[0].name]
+                creep_name_to_assign_array: [builder_creep[0].name],
-            }
+            };
-            assign_creeps(opt)
+            assign_creeps(opt);
         }
     }
 }
 
-
-
-
-
 function createHarvestCreep() {
     // create new creep
-    let new_creep_name = "AUTO_CREATE_Harvester_" + util.uuid();
+    const new_creep_name = `AUTO_CREATE_Harvester_${util.uuid()}`;
-    let Re_code;
+    const Re_code = Game.spawns.Spawn1.createCreep(
-    Re_code = Game.spawns['Spawn1'].createCreep([MOVE, CARRY, WORK], new_creep_name)
+        [MOVE, CARRY, WORK],
-    if (Re_code == new_creep_name) {
+        new_creep_name
-        Game.creeps[new_creep_name].memory.role = 'harvester';
+    );
-        console.log('Create new creep ' + new_creep_name);
+    if (Re_code === new_creep_name) {
+        Game.creeps[new_creep_name].memory.role = "harvester";
+        console.log(`Create new creep ${new_creep_name}`);
     } else {
         // console.log(`failed to create harvester with code ${Re_code}`);
     }
@@ -272,27 +329,87 @@ function createHarvestCreep() {
 
 function createTransferCreep() {
     // create new creep
-    let new_creep_name = "AUTO_CREATE_Transfer_" + util.uuid();
+    const new_creep_name = `AUTO_CREATE_Transfer_${util.uuid()}`;
-    let Re_code;
+    const Re_code = Game.spawns.Spawn1.createCreep(
-    Re_code = Game.spawns['Spawn1'].createCreep([MOVE, CARRY, CARRY], new_creep_name);
+        [MOVE, CARRY, CARRY],
-    if (new_creep_name == Re_code) {
+        new_creep_name
-        Game.creeps[new_creep_name].memory.role = 'transfer';
+    );
-        console.log('Create new creep ' + new_creep_name);
+    if (new_creep_name === Re_code) {
+        Game.creeps[new_creep_name].memory.role = "transfer";
+        console.log(`Create new creep ${new_creep_name}`);
     } else {
         // console.log(`failed to create transfer with code ${Re_code}`);
     }
 }
 
-function createBuilderCreep() {
+module.exports.loop = function () {
-    //create new creep
+    extra();
-    let new_creep_name = "AUTO_CREATE_Builder_" + util.uuid();
+    init.init();
-    let Re_code;
+    mount.mount();
-    Re_code = Game.spawns['Spawn1'].createCreep([MOVE, CARRY, WORK], new_creep_name)
+    cleanCreeps();
-    if (Re_code == new_creep_name) {
+    cleanInvalidMemoryCreep();
-        Game.creeps[new_creep_name].memory.role = 'builder';
+    cleanTargetMemory();
-        console.log('Create new creep ' + new_creep_name);
+    assign_harvester_to_energy_source();
-    } else {
+    assign_transfer_to_harvester();
-        // console.log(`failed to create builder with code ${Re_code}`);
+    assign_builder_to_controller();
+    assign_transfer_to_builder();
+    const construction_site_array = Game.spawns.Spawn1.room.find(
+        FIND_MY_CONSTRUCTION_SITES
+    );
+    _.each(construction_site_array, function (found_construction_site) {
+        const constuction_key = `CONSTRUCTION_${found_construction_site.id}`;
+        if (
+            Memory.WorkingTarget[constuction_key] &&
+            Memory.WorkingTarget[constuction_key].working_creep_names.length ===
+                0
+        ) {
+            assign_builder_to_construction(found_construction_site.id);
+        }
+    });
+    let isSpawning = false;
+    const energy_source_number = _.filter(
+        Game.spawns.Spawn1.room.find(FIND_SOURCES_ACTIVE)
+    ).length;
+    const harvester_number = _(Game.creeps)
+        .filter({ memory: { role: "harvester" } })
+        .size();
+    if (!Game.spawns.Spawn1.spawning) {
+        if (harvester_number < energy_source_number) {
+            isSpawning = true;
+            createHarvestCreep();
+        }
+        if (
+            _(Game.creeps)
+                .filter({ memory: { role: "transfer" } })
+                .size() < energy_source_number &&
+            !isSpawning
+        ) {
+            isSpawning = true;
+            createTransferCreep();
+        }
+        const builder_number = _.filter(Game.creeps, {
+            memory: { role: "builder" },
+        }).length;
+        // 创造一个builder升级room controller
+        if (
+            Game.spawns.Spawn1.room.controller &&
+            builder_number < 1 + construction_site_array.length &&
+            !isSpawning
+        ) {
+            isSpawning = true;
+            createBuilderCreep();
+        }
+        // 判断是否需要再增加1个transfer
+        const transfer_number = _.filter(Game.creeps, {
+            memory: { role: "transfer" },
+        }).length;
+        if (
+            builder_number + harvester_number > transfer_number &&
+            !isSpawning
+        ) {
+            isSpawning = true;
+            createTransferCreep();
         }
     }
-
+    assign_task();
+};

mount.js

@@ -1,42 +1,47 @@
-const harvester = require('harvester');
+/* eslint-disable func-names */
-const transfer = require('transfer');
+/* eslint-disable no-console */
-const builder = require('builder');
+/* eslint-disable camelcase */
-module.exports = {
+/* eslint-disable no-undef */
-    mount() {
+const harvester = require("./harvester");
-        Creep.prototype.action = action;
+const transfer = require("./transfer");
-        if (!(Creep.prototype.hasOwnProperty('working_target_id'))) {
+const builder = require("./builder");
-            Object.defineProperty(Creep.prototype, 'working_target_id', {
-                get: function () {
-                    return this.memory.working_target_id
-                },
-                set: function (id) {
-                    this.memory.working_target_id = id
-                }
-            }
-            )
-        }
-        Game.cwt = function (creep_name) {
-            Game.creeps[creep_name].working_target_id = undefined
-        }
-        Game.pos=function(id){
-            console.log(Game.getObjectById(id))
-        }
-    }
-}
-
 
 function action() {
-    let role = this.memory.role;
+    const { role } = this.memory;
     // this.say(`${role}`);
     switch (role) {
         case "harvester":
-            harvester.run(this)
+            harvester.run(this);
             break;
         case "transfer":
-            transfer.run(this)
+            transfer.run(this);
             break;
         case "builder":
-            builder.run(this)
+            builder.run(this);
+            break;
+        default:
             break;
     }
 }
+
+module.exports = {
+    mount() {
+        Creep.prototype.action = action;
+        if (!Creep.prototype.hasOwnProperty("working_target_id")) {
+            Object.defineProperty(Creep.prototype, "working_target_id", {
+                get() {
+                    return this.memory.working_target_id;
+                },
+                set(id) {
+                    this.memory.working_target_id = id;
+                },
+            });
+        }
+        Game.cwt = function (creep_name) {
+            Game.creeps[creep_name].working_target_id = undefined;
+        };
+        Game.pos = function (id) {
+            console.log(Game.getObjectById(id));
+        };
+    },
+};

package.json

@@ -0,0 +1,19 @@
+{
+  "name": "screeps-script",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "eslint": "^7.12.0",
+    "eslint-config-airbnb-base": "^14.2.0",
+    "eslint-config-prettier": "^6.14.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.1.4",
+    "prettier": "^2.1.2"
+  }
+}

path.js

@@ -1,8 +1,3 @@
 module.exports = {
-    visualPath(my_pos, target_pos) {
+    visualPath(my_pos, target_pos) {},
-        // visualize the path
+};
-        // let path = PathFinder.search(my_pos, target_pos).path;
-        // console.log(path)
-        // Game.map.visual.poly(path, { stroke: '#ffffff', strokeWidth: 8, opacity: .2, lineStyle: 'dashed' });
-    }
-}

task.js

@@ -1,9 +1,5 @@
-const { memory } = require("console")
+const { memory } = require("console");
 
 module.exports = {
-    upgradeController(){
+    upgradeController() {},
-        
+};
-    }
-}
-
-

test.js

@@ -1,3 +1,3 @@
-a= undefined || {a:'a'}
+a = undefined || { a: "a" };
 
-console.log(a)
+console.log(a);

transfer.js

@@ -1,73 +1,84 @@
-const utils = require('utils')
+/* eslint-disable no-undef */
-const path = require('path')
+/* eslint-disable no-console */
+/* eslint-disable camelcase */
+const utils = require("./utils");
+const path = require("./path");
 
 // const harvester = require("./harvester");
 
 module.exports = {
     run(creep) {
-        creep.say('tf')
+        creep.say("tf");
-        let working_target_id = creep.working_target_id
+        const { working_target_id } = creep;
         if (!working_target_id) {
-            creep.say('SB')
+            creep.say("SB");
-            return
+            return;
         }
-        let working_target = Game.getObjectById(working_target_id)
+        const working_target = Game.getObjectById(working_target_id);
         // TODO:处理transfer的对象消失的情况
         if (!working_target) {
-                // _.each(Memery.WorkingTarget[creep.name].working_creep_names,creep_name=>Game.creeps[creep_name].working_target_id=undefined)
+            Game.creeps[creep.name].working_target_id = undefined;
-                // delete Memery.WorkingTarget[creep.name]
+            return;
-            return
         }
-        let working_target_pos = working_target.pos
+        const working_target_pos = working_target.pos;
-        let my_pos = creep.pos;
+        const my_pos = creep.pos;
         if (!working_target.memory) {
-            console.log(`check ${creep.name}, working target memory ${JSON.stringify(working_target)}`)
+            console.log(
-            return
+                `check ${creep.name}, working target memory ${JSON.stringify(
+                    working_target
+                )}`
+            );
+            return;
         }
-        if (working_target.memory.role == 'harvester') {
+        if (working_target.memory.role === "harvester") {
             if (creep.store.energy < creep.store.getCapacity()) {
-
+                if (utils.distance(working_target_pos, my_pos) > 1.5) {
-                if (!working_target) {
+                    // 在附近就是1或者1.414
-                    // console.log(`${creep.name} working target vanished. Turn to unassigned.`)
+                    creep.moveTo(working_target_pos, {
-                    return
+                        visualizePathStyle: { stroke: "#ffffff" },
-                }
+                    });
-                if (utils.distance(working_target_pos, my_pos) > 1.5) {//在附近就是1或者1.414
-                    creep.moveTo(working_target_pos,{visualizePathStyle: {stroke: '#ffffff'}});
                     path.visualPath(creep.pos, working_target_pos);
                 } else {
                     // find dropped source
-                    let found = creep.room.lookForAt(LOOK_ENERGY, working_target_pos);
+
+                    const found = creep.room.lookForAt(
+                        LOOK_ENERGY,
+                        working_target_pos
+                    );
                     if (found.length > 0) {
-                        creep.pickup(found[0])
+                        creep.pickup(found[0]);
-                    }
-
-                }
-
-            } else {
-                if (creep.transfer(Game.spawns['Spawn1'], RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
-                    creep.moveTo(Game.spawns['Spawn1'],{visualizePathStyle: {stroke: '#ffffff'}});
-                    path.visualPath(creep.pos, Game.spawns['Spawn1'].pos);
                     }
                 }
+            } else if (
+                creep.transfer(Game.spawns.Spawn1, RESOURCE_ENERGY) ===
+                ERR_NOT_IN_RANGE
+            ) {
+                creep.moveTo(Game.spawns.Spawn1, {
+                    visualizePathStyle: { stroke: "#ffffff" },
+                });
+                path.visualPath(creep.pos, Game.spawns.Spawn1.pos);
             }
-        if (working_target.memory.role == 'builder') {
+        }
+        if (working_target.memory.role === "builder") {
             if (creep.store.energy > 0) {
-                if (utils.distance(working_target_pos, my_pos) > 1.5) {//在附近就是1或者1.414
+                if (utils.distance(working_target_pos, my_pos) > 1.5) {
-                    creep.moveTo(working_target_pos,{visualizePathStyle: {stroke: '#ffffff'}});
+                    // 在附近就是1或者1.414
+                    creep.moveTo(working_target_pos, {
+                        visualizePathStyle: { stroke: "#ffffff" },
+                    });
                     path.visualPath(creep.pos, working_target_pos);
                 } else {
-                    creep.drop(RESOURCE_ENERGY)
+                    creep.drop(RESOURCE_ENERGY);
                 }
-            } else {
+            } else if (
-                if (creep.withdraw(Game.spawns['Spawn1'], RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
+                creep.withdraw(Game.spawns.Spawn1, RESOURCE_ENERGY) ===
-                    creep.moveTo(Game.spawns['Spawn1'],{visualizePathStyle: {stroke: '#ffffff'}});
+                ERR_NOT_IN_RANGE
-                    path.visualPath(creep.pos, Game.spawns['Spawn1'].pos);
+            ) {
+                creep.moveTo(Game.spawns.Spawn1, {
+                    visualizePathStyle: { stroke: "#ffffff" },
+                });
+                path.visualPath(creep.pos, Game.spawns.Spawn1.pos);
             }
         }
-        }
+    },
-
+};
-    }
-}
-
-
-

utils.js

@@ -1,22 +1,23 @@
 module.exports = {
     uuid() {
         // 6位
-        let _uuid = "";
+        let uuid = "";
-        for (let i = 0; i < 6; i++) {
+        for (let i = 0; i < 6; i += 1) {
             if (Math.random() > 0.5) {
                 // 大于0.5就是数字，小于则是字母
-                _uuid = _uuid + (Math.round((Math.random() * 100)) % 10 );
+                uuid += Math.round(Math.random() * 100) % 10;
             } else {
-                _uuid = _uuid + String.fromCharCode(97 + (Math.round(Math.random() * 100)) % 26);
+                uuid += String.fromCharCode(
+                    97 + (Math.round(Math.random() * 100) % 26)
+                );
             }
         }
-        return _uuid;
+        return uuid;
     },
     distance(pos1, pos2) {
-        if(pos1.roomName==pos2.roomName){
+        if (pos1.roomName === pos2.roomName) {
-            return Math.sqrt(Math.pow((pos1.x-pos2.x),2)+Math.pow((pos1.y-pos2.y),2));
+            return Math.sqrt((pos1.x - pos2.x) ** 2 + (pos1.y - pos2.y) ** 2);
         }
         return -1; // 如果不在一个房间内，就返回负数。
-    }
+    },
-
+};
-}