修复bug

builder.js

@@ -1,13 +1,13 @@
 const utils = require('utils')
 module.exports = {
     run(creep) {
+        creep.say('builder')
         if (creep.working_target_id) {
             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 found = creep.room.lookForAt(LOOK_ENERGY, working_target_pos);
                 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
@@ -18,8 +18,7 @@ module.exports = {
                         //TODO:需要适应不同的建筑
                         let Re_code = creep.upgradeController(working_target)
                         if (OK == Re_code) {
-                            // console.log(`${creep.name} upgrade room controller`)
+                        } else if(Re_code!=ERR_NOT_ENOUGH_RESOURCES && Re_code!=ERR_NOT_IN_RANGE){
-                        } else {
                             console.log(`${creep.name} failed to upgrade room controller:err ${Re_code}`)
                         }
                     }

harvester.js

@@ -1,19 +1,63 @@
-const path=require('path')
+const path = require('path')
 module.exports = {
     run(creep) {
+        let status = change_status()
+        switch (status) {
+            case 'harvester':
+                creep.say('harvester')
+                harvester_job(creep)
+                break
+            case 'picker':
+                creep.say('picker')
+                picker_job(creep)
+                break
+        }
+    }
+}
+
+
+function harvester_job(creep) {
     //分配source
     if (creep.carry.energy < creep.carryCapacity) {
-            let sources = creep.room.find(FIND_SOURCES);
+        let working_target_id = creep.working_target_id;
-            //TODO:只去一个地方
+        let working_target = Game.getObjectById(working_target_id);
-            if (creep.harvest(sources[0]) == ERR_NOT_IN_RANGE) {
+        if (creep.harvest(working_target) == ERR_NOT_IN_RANGE) {
-                creep.moveTo(sources[0]);
+            creep.moveTo(working_target);
-                path.visualPath(creep.pos,sources[0].pos);
+            path.visualPath(creep.pos, working_target.pos);
         }
     } else {
         if (creep.transfer(Game.spawns['Spawn1'], RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
             creep.moveTo(Game.spawns['Spawn1']);
-                path.visualPath(creep.pos,Game.spawns['Spawn1'].pos);
+            path.visualPath(creep.pos, Game.spawns['Spawn1'].pos);
-            }
         }
     }
 }
+
+function picker_job(creep) {
+    if (Game.spawns['Spawn1'].store.getFreeCapacity(RESOURCE_ENERGY) == 0) {
+        creep.say('Standby.')
+        return
+    }
+    let working_target_id = creep.working_target_id;
+    if (!working_target_id) {
+        creep.say('Standby.')
+    }
+    let working_target = Game.getObjectById(working_target_id);
+    let Re_code = creep.harvest(working_target);
+    if (Re_code == ERR_NOT_IN_RANGE) {
+        creep.moveTo(working_target);
+    } else {
+        if (OK == Re_code) {
+            creep.harvest(working_target);
+            creep.drop(RESOURCE_ENERGY);
+        }
+    }
+}
+
+function change_status() {
+    if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() > 0) {
+        return 'picker'
+    } else {
+        return 'harvester'
+    }
+}

init.js

@@ -2,13 +2,6 @@
 
 module.exports = {
     init() {
-        // if (!Memory.Source) {
-        //     Memory.Source = new Object();
-        //     Memory.Source.Energy = [];
-        // }
-        // if (!Memory.Controller) {
-        //     Memory.Controller = [];
-        // }
         if (!Memory.Task) {
             Memory.Task = {}
         };
@@ -16,7 +9,7 @@ module.exports = {
         Memory.Task.LowPorioty = [];
         //WorkingTarget是被跟踪物，可以是一个structure、energy、constructionSite，也可以是一个creep
         if (!Memory.WorkingTarget) {
-            Memory.WorkingTarget = []
+            Memory.WorkingTarget = {}
         };
     }
 }

main.js

@@ -2,40 +2,40 @@ const init = require('init')
 const util = require('utils');
 const mount = require('mount')
 module.exports.loop = function () {
-    //clean creeps
     init.init();
     mount.mount()
     cleanCreeps()
-    cleanUnusedMemoryItem()
+    cleanInvalidMemoryCreep()
     cleanTargetMemory()
-    assign_harvester_picker_to_enery_source();
+    assign_harvester_to_enery_source();
     assign_transfer_to_picker()
     assign_builder_to_controller();
     assign_transfer_to_builder();
     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();
-    let picker_number = _(Game.creeps).filter({ memory: { role: 'picker' } }).size();
     if (!Game.spawns['Spawn1'].spawning) {
-        if ((harvester_number + picker_number) < energy_source_number) {
+        if (harvester_number < energy_source_number) {
             isSpawning = true
             createHarvestCreep();
         }
-        if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() < 2 && !isSpawning) {
+        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 == 0 && !isSpawning) {
+            isSpawning = true
             createBuilderCreep();
         }
         //判断是否需要再增加1个transfer
         let transfer_number = _.filter(Game.creeps, { memory: { role: 'transfer' } }).length
-        if ((builder_number + harvester_number + picker_number) > transfer_number && !isSpawning) {
+        if ((builder_number + harvester_number) > transfer_number && !isSpawning) {
+            isSpawning = true
             createTransferCreep();
         }
     }
-    chanage_role();
     assign_task();
 
 }
@@ -44,31 +44,33 @@ module.exports.loop = function () {
 function cleanCreeps() {
     for (let i in Memory.creeps) {
         if (!Game.creeps[i]) {
+            console.log(`${i} is invalid, removed from Memory.creeps`)
             delete Memory.creeps[i];
         }
     }
 }
 
-function cleanTargetMemory(){
+function cleanTargetMemory() {
-    _.each(Memory.WorkingTarget,target=>_.remove(target.working_creep_names,name=>!Game.creeps[name]))
+    for (let i of Object.keys(Memory.WorkingTarget)) {
+        let target = Memory.WorkingTarget[i]
+        if (!Game.getObjectById(target.id)) {
+            console.log(`target ${target.id} is invalid, removed from Memory.WorkingTarget`)
+            delete Memory.WorkingTarget[i];
+        }
+    }
 }
 
 
 function assign_transfer_to_picker() {
     //判断有多少个picker的transfer为0
-    let all_picker = _.filter(Game.creeps, { memory: { role: 'picker' } })
+    let all_picker = _.filter(Game.creeps, { memory: { role: 'harvester' } })
     let picker_has_no_creep = _.filter(all_picker, function (picker) {
         return !_.find(Memory.WorkingTarget, target => target.id == picker.id)//Memory.WorkingTarget中没有这个picker目标
     })
     _.each(picker_has_no_creep, function (picker) {
-        Memory.WorkingTarget.push({ id: picker.id, working_creep_names: [], cate: 'picker' })//在Memory.WorkingTarget加入需要creep的Picker
+        Memory.WorkingTarget[picker.name] = { id: picker.id, working_creep_names: [], cate: 'harvester' }//在Memory.WorkingTarget加入需要creep的Picker
     })
-    //先移除已经失效的creep
+    let picker_memories = _.filter(Memory.WorkingTarget, memory => memory.working_creep_names.length == 0 && memory.cate=='harvester')
-    // let picker_mem=_.filter(Memory.WorkingTarget,{cate:'picker'})
-    // _.each(picker_mem, function (m) {
-    //     _.remove(m.working_creep_names, creep_name => !Game.creeps[creep_name])//如果一个creep已经不存在了，就从列表中移除
-    // })
-    let picker_memories = _.filter(Memory.WorkingTarget, picker_memory => picker_memory.working_creep_names.length == 0)
     if (picker_memories.length > 0) {
         let available_transfer = _.filter(Game.creeps, creep => !creep.working_target_id && (creep.memory.role == 'transfer'))
         if (available_transfer.length > 0) {//一次只安排一个creep
@@ -96,14 +98,9 @@ function assign_transfer_to_builder() {
         return !_.find(Memory.WorkingTarget, target => target.id == builder.id)//Memory.WorkingTarget中没有这个builder目标
     })
     _.each(builder_has_no_creep, function (builder) {
-        Memory.WorkingTarget.push({ id: builder.id, working_creep_names: [], cate: 'builder' })//在Memory.WorkingTarget加入需要creep的builder
+        Memory.WorkingTarget[builder.name] = { id: builder.id, working_creep_names: [], cate: 'builder' }//在Memory.WorkingTarget加入需要creep的builder
     })
-    // //先移除已经失效的creep
+    let builder_memories = _.filter(Memory.WorkingTarget, memory => memory.working_creep_names.length == 0 && memory.cate=='builder')
-    // let bulder_mem=_.filter(Memory.WorkingTarget,{cate:'builder'})
-    // _.each(bulder_mem, function (m) {
-    //     _.remove(m.working_creep_names, creep_name => !Game.creeps[creep_name])//如果一个creep已经不存在了，就从列表中移除
-    // })
-    let builder_memories = _.filter(Memory.WorkingTarget, builder_memory => builder_memory.working_creep_names.length == 0)
     if (builder_memories.length > 0) {
         let available_transfer = _.filter(Game.creeps, creep => !creep.working_target_id && (creep.memory.role == 'transfer'))
         if (available_transfer.length > 0) {//一次只安排一个creep
@@ -116,29 +113,36 @@ function assign_transfer_to_builder() {
     }
 }
 
-function cleanUnusedMemoryItem() {
+function cleanInvalidMemoryCreep() {
-    //清理Memory中已经不存在的工作对象
+    //清理Memory中已经不存在的creep
-    _.remove(Memory.WorkingTarget, function (r) {
+    _.each(Memory.WorkingTarget, function (target) {
-        if (Game.getObjectById(r.id) === undefined || Game.getObjectById(r.id) === null)
+        _.remove(target.working_creep_names,function(creep_name){
+            if(!Game.creeps[creep_name]){
+                console.log(`${creep_name} is invalid, removed from working_creep_names`)
                 return true
-        else {
-            return false
             }
+            return false
+
+        })
     })
 }
 
 function assign_creeps(opt) {
     let memory = opt.memory
     let creep_name_to_assgin_array = opt.creep_name_to_assgin_array//需要分配工作的creeps
-    //清理Memory中已经不存在的工作对象
-    // removeUnusedMemoryItem(memory)
     //清理Memroy中已经不存在的creep
     _.each(memory, function (m) {
-        _.remove(m.working_creep_names, name => Game.creeps[name] === undefined || Game.creeps[name] === null)
+        _.remove(m.working_creep_names, function (name) {
+            if (Game.creeps[name] === undefined || Game.creeps[name] === null) {
+                console.log(`remove ${name} from ${m.id} working_creep_names`)
+                return true
+            }
+            return false
+        })
     })
     _.each(creep_name_to_assgin_array, function (creep_name) {
         //先计算每一个target目前有多少个creeps了
-        let working_creeps_of_target_array = []
+        let working_creeps_of_target_array = []//记录每个target已有的creep数量
         _.each(memory, m => working_creeps_of_target_array.push(m.working_creep_names.length))
         let 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) {
@@ -150,28 +154,23 @@ function assign_creeps(opt) {
 
 }
 
-function assign_harvester_picker_to_enery_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 (_(all_memory).findIndex(f => f['id'] == id) == -1) {
+        if (!_.find(all_memory,f => f['id'] == id)) {
-            all_memory.push({ 'id': id, 'working_creep_names': [], "cate": 'ENERGY_SOURCE' });
+            // console.log(`add id ${id}`)
+            all_memory[`Energy_${id}`] = { 'id': id, 'working_creep_names': [], "cate": 'ENERGY_SOURCE' };
         }
     }//向Memory.WorkingTarget里添加所有的Energy Source
-    // removeUnusedMemoryItem(all_memory)//移除已经不存在的target
     //寻找Energy Source的Memory
     let energy_memory = _.filter(all_memory, { cate: 'ENERGY_SOURCE' })
-    //检查一下是否每一个energy至少有一个creep
-    //先移除已经失效的creep
-    _.each(energy_memory, function (m) {
-        _.remove(m.working_creep_names, creep_name => !Game.creeps[creep_name])//如果一个creep已经不存在了，就从列表中移除
-    })
     //寻找creep为0的energy source
     let 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' || creep.memory.role == 'picker'))
+        let available_creep_array = _.filter(Game.creeps, creep => !creep.working_target_id && creep.memory.role == 'harvester')
         if (available_creep_array.length > 0) {//每次只安排一个
             let opt = {
                 memory: energy_memory,
@@ -187,7 +186,7 @@ function assign_harvester_picker_to_enery_source() {
 function assign_builder_to_controller() {
     //判断room controller 是否有creep,没有则添加
     if (!_.find(Memory.WorkingTarget, target => target.id == Game.spawns['Spawn1'].room.controller.id)) {
-        Memory.WorkingTarget.push({ id: Game.spawns['Spawn1'].room.controller.id, working_creep_names: [], cate: 'ROOM_CONTROLLER' })
+        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' })
     //先移除已经失效的creep
@@ -195,7 +194,7 @@ function assign_builder_to_controller() {
         _.remove(m.working_creep_names, creep_name => !Game.creeps[creep_name])//如果一个creep已经不存在了，就从列表中移除
     })
     //寻找creep为0的room controller
-    let room_controller_need_creep_array = _.filter(room_controller_mem, m => m.working_creep_names.length == 0)
+    let 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')
         if (builder_creep.length > 0) {
@@ -211,21 +210,7 @@ function assign_builder_to_controller() {
 
 
 
-function chanage_role() {
+
-    if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() > 0) {
-        let harvester_array = _(Game.creeps).filter({ memory: { role: 'harvester' } }).value();
-        // console.log(harvester_array[0].memory.role);
-        for (let harvester_creep of harvester_array) {
-            harvester_creep.memory.role = 'picker';
-        }
-    } else {
-        let picker_array = _(Game.creeps).filter({ memory: { role: 'picker' } }).value();
-        // console.log(harvester_array[0].memory.role);
-        for (let picker_creep of picker_array) {
-            picker_creep.memory.role = 'harvester';
-        }
-    }
-}
 
 function createHarvestCreep() {
     //create new creep
@@ -234,7 +219,7 @@ function createHarvestCreep() {
     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 = 'harvester';
-        console.log('Create new creep name ' + new_creep_name);
+        console.log('Create new creep ' + new_creep_name);
     } else {
         // console.log(`failed to create harvester with code ${Re_code}`);
     }
@@ -247,7 +232,7 @@ function createTransferCreep() {
     Re_code = Game.spawns['Spawn1'].createCreep([MOVE, CARRY, CARRY], new_creep_name);
     if (new_creep_name == Re_code) {
         Game.creeps[new_creep_name].memory.role = 'transfer';
-        console.log('Create new creep name ' + new_creep_name);
+        console.log('Create new creep ' + new_creep_name);
     } else {
         // console.log(`failed to create transfer with code ${Re_code}`);
     }
@@ -260,7 +245,7 @@ function createBuilderCreep() {
     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 name ' + new_creep_name);
+        console.log('Create new creep ' + new_creep_name);
     } else {
         // console.log(`failed to create builder with code ${Re_code}`);
     }

mount.js

@@ -1,5 +1,4 @@
 const harvester = require('harvester');
-const picker = require('picker');
 const transfer = require('transfer');
 const builder = require('builder');
 module.exports = {
@@ -27,9 +26,6 @@ function action() {
         case "harvester":
             harvester.run(this)
             break;
-        case "picker":
-            picker.run(this)
-            break;
         case "transfer":
             transfer.run(this)
             break;

transfer.js

@@ -5,7 +5,12 @@ const path = require('path')
 
 module.exports = {
     run(creep) {
+        creep.say('transfer')
         let working_target_id = creep.working_target_id
+        if(!working_target_id){
+            creep.say('Standby')
+            return
+        }
         let working_target = Game.getObjectById(working_target_id)
         //TODO:处理transfer的对象消失的情况
         if(!working_target){
@@ -14,7 +19,11 @@ module.exports = {
         }
         let working_target_pos = working_target.pos
         let my_pos = creep.pos;
-        if (working_target.memory.role == 'picker') {
+        if(!working_target.memory){
+            console.log(`check ${creep.name} working target`)
+            return
+        }
+        if (working_target.memory.role == 'harvester') {
             if (creep.store.energy < creep.store.getCapacity()) {
 
                 if (!working_target) {
@@ -58,3 +67,6 @@ module.exports = {
 
     }
 }
+
+
+