screep/main.js

const init = require('init')
const util = require('utils');
const mount = require('mount')
module.exports.loop = function () {
    //clean creeps
    init.init();
    mount.mount()
    cleanCreeps()
    cleanUnusedMemoryItem()
    cleanTargetMemory()
    assign_harvester_picker_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) {
            isSpawning = true
            createHarvestCreep();
        }
        if (_(Game.creeps).filter({ memory: { role: 'transfer' } }).size() < 2 && !isSpawning) {
            createTransferCreep();
        }
        let builder_number = _.filter(Game.creeps, { memory: { role: 'builder' } }).length
        //创造一个builder升级room controller
        if (Game.spawns['Spawn1'].room.controller && builder_number == 0 && !isSpawning) {
            createBuilderCreep();
        }
        //判断是否需要再增加1个transfer
        let transfer_number = _.filter(Game.creeps, { memory: { role: 'transfer' } }).length
        if ((builder_number + harvester_number + picker_number) > transfer_number && !isSpawning) {
            createTransferCreep();
        }
    }
    chanage_role();
    assign_task();

}


function cleanCreeps() {
    for (let i in Memory.creeps) {
        if (!Game.creeps[i]) {
            delete Memory.creeps[i];
        }
    }
}

function cleanTargetMemory(){
    _.each(Memory.WorkingTarget,target=>_.remove(target.working_creep_names,name=>!Game.creeps[name]))
}


function assign_transfer_to_picker() {
    //判断有多少个picker的transfer为0
    let all_picker = _.filter(Game.creeps, { memory: { role: 'picker' } })
    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
    })
    //先移除已经失效的creep
    // 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
            let opt = {
                memory: picker_memories,
                creep_name_to_assgin_array: [available_transfer[0].name]
            }
            assign_creeps(opt)
        }
    }
}

function assign_task() {
    for (const creep_id in Game.creeps) {
        let creep = Game.creeps[creep_id];
        creep.action();
    }

}

function assign_transfer_to_builder() {
    //判断有多少个picker的transfer为0
    let all_builder = _.filter(Game.creeps, { memory: { role: 'builder' } })
    let builder_has_no_creep = _.filter(all_builder, function (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
    })
    // //先移除已经失效的creep
    // 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
            let opt = {
                memory: builder_memories,
                creep_name_to_assgin_array: [available_transfer[0].name]
            }
            assign_creeps(opt)
        }
    }
}

function cleanUnusedMemoryItem() {
    //清理Memory中已经不存在的工作对象
    _.remove(Memory.WorkingTarget, function (r) {
        if (Game.getObjectById(r.id) === undefined || Game.getObjectById(r.id) === null)
            return true
        else {
            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)
    })
    _.each(creep_name_to_assgin_array, function (creep_name) {
        //先计算每一个target目前有多少个creeps了
        let working_creeps_of_target_array = []
        _.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) {
            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_harvester_picker_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) {
            all_memory.push({ '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'))
        if (available_creep_array.length > 0) {//每次只安排一个
            let opt = {
                memory: energy_memory,
                creep_name_to_assgin_array: [available_creep_array[0].name]
            }
            assign_creeps(opt)
        }
    }


}

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' })
    }
    let room_controller_mem = _.filter(Memory.WorkingTarget, { cate: 'ROOM_CONTROLLER' })
    //先移除已经失效的creep
    _.each(room_controller_mem, function (m) {
        _.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)
    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) {

            let opt = {
                memory: room_controller_mem,
                creep_name_to_assgin_array: [builder_creep[0].name]
            }
            assign_creeps(opt)
        }
    }
}



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
    let new_creep_name = "AUTO_CREATE_Harvester_" + util.uuid();
    let Re_code;
    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);
    } else {
        // console.log(`failed to create harvester with code ${Re_code}`);
    }
}

function createTransferCreep() {
    //create new creep
    let new_creep_name = "AUTO_CREATE_Transfer_" + util.uuid();
    let Re_code;
    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);
    } else {
        // console.log(`failed to create transfer with code ${Re_code}`);
    }
}

function createBuilderCreep() {
    //create new creep
    let new_creep_name = "AUTO_CREATE_Builder_" + util.uuid();
    let Re_code;
    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);
    } else {
        // console.log(`failed to create builder with code ${Re_code}`);
    }
}