使用全局Memory存放所有建筑ID及分配的Creep, Creep内存存放工作建筑

src/index.d.ts

@@ -1,8 +1,21 @@
 interface CreepMemory {
     role: string,
-    working?: boolean | null,
+    working?: boolean,
+    source?:string,
+    workTarget?: Id<Structure>,
     [property: string]: any,
 }
 
+interface MemoryStructure{
+    id: Id<Structure>,
+    structureType: string,
+    roomName: string
+    creep?: Id<Creep>,
+}
+
+interface Memory{
+    structures?: MemoryStructure[]
+}
+
 
 declare type Part = WORK | MOVE | CARRY | HEAL | ATTACK | RANGED_ATTACK | TOUGH | CLAIM;

src/main.ts

@@ -1,26 +1,25 @@
 import { errorMapper } from "./modules/errorMapping";
-import { Harvest } from "./modules/harvester";
+import { BigHarvest, Harvest } from "./modules/harvester";
 import { Build } from "./modules/builder";
 import { Upgrade } from "./modules/upgrader";
 import { SpawnCreep } from "./modules/spawnCreep";
+import { RoleToString, UpdateGlobalMemory } from "./modules/creepApi";
+import { Role } from "./modules/setting";
 export const loop = errorMapper(() => {
     let mainSpawn = Game.spawns["Spawn1"];
     SpawnCreep(mainSpawn);
-    for (var name in Memory.creeps) {
+    UpdateGlobalMemory();
-        if (!Game.creeps[name]) {
-            delete Memory.creeps[name];
-            console.log("clearing non-existing creep memory:", name);
-        }
-    }
 
     for (var name in Game.creeps) {
         let creep = Game.creeps[name];
-        if (creep.memory.role == "Harvester") {
+        if (creep.memory.role == RoleToString(Role.Harvester)) {
             Harvest(creep);
-        } else if (creep.memory.role == "Upgrader") {
+        } else if (creep.memory.role == RoleToString(Role.Upgrader)) {
             Upgrade(creep);
-        } else if (creep.memory.role == "Builder") {
+        } else if (creep.memory.role == RoleToString(Role.Builder)) {
             Build(creep);
+        }else if(creep.memory.role == RoleToString(Role.BigHarvester)){
+            BigHarvest(creep);
         }
     }
 })

src/modules/creepApi.ts

@@ -1,9 +1,9 @@
-import {Role} from "@/modules/setting";
+import { Role } from "@/modules/setting";
 
-export function SetRole(creep: Creep, role: Role){
+export function SetRole(creep: Creep, role: Role) {
-    switch(role){
+    switch (role) {
         case Role.Harvester:
-            creep.memory.role ="Harvester";
+            creep.memory.role = "Harvester";
         case Role.BigHarvester:
             creep.memory.role = "BigHarvester";
         case Role.Builder:
@@ -14,24 +14,24 @@ export function SetRole(creep: Creep, role: Role){
             creep.memory.role = "Repairer";
     }
 }
-export function RoleToString(role: Role) : string{
+export function RoleToString(role: Role): string {
-    switch(role){
+    switch (role) {
         case Role.Harvester:
             return "Harvester";
         case Role.BigHarvester:
-            return  "BigHarvester";
+            return "BigHarvester";
         case Role.Builder:
-            return  "Builder";
+            return "Builder";
         case Role.Upgrader:
-            return  "Upgrader";
+            return "Upgrader";
         case Role.Repairer:
-            return  "Repairer";
+            return "Repairer";
     }
 }
 
-export function SpawnCreep(spawn: StructureSpawn, body: Part[], role?:Role) : number{
+export function SpawnCreep(spawn: StructureSpawn, body: Part[], opt?: SpawnOptions): number {
     const name = "Creep" + Game.time;
-    return spawn.spawnCreep(body, name, {memory: {role : RoleToString(role)}});
+    return spawn.spawnCreep(body, name, opt);//{ memory: { role: RoleToString(role) } });
 }
 
 export function FindCapacity(creep: Creep): AnyStructure[] {
@@ -40,7 +40,7 @@ export function FindCapacity(creep: Creep): AnyStructure[] {
             let type = structure.structureType;
             return (
                 (type == STRUCTURE_EXTENSION ||
-                    type == STRUCTURE_SPAWN||
+                    type == STRUCTURE_SPAWN ||
                     type == STRUCTURE_CONTAINER) &&
                 structure.store.getFreeCapacity(RESOURCE_ENERGY) as number > 0
             )
@@ -61,25 +61,57 @@ export function GetConstructureSet(creep: Creep, structureType: string | null =
     })
 }
 
-export function GetConstructure(creep: Creep, structureType: string, ){
+export function GetConstructure(creep: Creep | Structure, structureType: string,) {
-    return creep.room.find(FIND_STRUCTURES, {filter:(structure: AnyStructure)=>{
+    return creep.room.find(FIND_STRUCTURES, {
-        return structure.structureType == structureType;
+        filter: (structure: AnyStructure) => {
-    }})
+            return structure.structureType == structureType;
+        }
+    })
 }
 
-export function GetContainer(creep: Creep): StructureContainer[]{
+export function GetContainer(creep: Creep | Structure): StructureContainer[] {
     let target = GetConstructure(creep, STRUCTURE_CONTAINER) as StructureContainer[];
-    return target
+    return target;
 }
 
-export function GetCreeps() : Map<string, number>{
+export function GetCreeps(): Map<string, number> {
     let resp: Map<string, number> = new Map();
-    for (var name in Game.creeps){
+    for (var name in Game.creeps) {
         var creep = Game.creeps[name];
-        if(resp.has(creep.memory.role))
+        if (resp.has(creep.memory.role))
-            resp.set(creep.memory.role, resp.get(creep.memory.role)+1)
+            resp.set(creep.memory.role, resp.get(creep.memory.role) + 1)
         else
             resp.set(creep.memory.role, 1);
     }
     return resp;
 }
+
+export function ClearMemory(){
+    for(var name in Memory.creeps){
+        if(!Game.creeps[name]){
+            delete Memory.creeps[name];
+            for(var structureMemory of Memory.structures){
+                if(structureMemory.creep == Game.creeps[name].id){
+                    //Creep死亡后, 应为各建筑重新分配Creep
+                    structureMemory.creep = null;
+                }
+            }
+            console.log("clearing non-existing creepmemory:", name);
+        }
+    }
+}
+
+export function UpdateStructureMemory(){
+    for(var roomName in Game.rooms){
+        const room = Game.rooms[roomName];
+        var structures = room.find(FIND_STRUCTURES);
+        for(var structure of structures){
+            Memory.structures.push({"id": structure.id, structureType: structure.structureType, roomName: room.name})
+        }
+    }
+}
+
+export function UpdateGlobalMemory(){
+    ClearMemory();
+    UpdateStructureMemory();
+}

src/modules/harvester.ts

@@ -2,10 +2,7 @@ import { FindCapacity, GetContainer, GetSource } from "./creepApi"
 import { MAIN_SOURCE_ID } from "./setting";
 
 export function Harvest(creep: Creep) {
-    if (creep.store.getFreeCapacity() == null) {
+    if (creep.store.getFreeCapacity() > 0) {
-        BigHarvest(creep);
-    }
-    else if (creep.store.getFreeCapacity() > 0) {
         let source: Source = GetSource(MAIN_SOURCE_ID);
         if (creep.harvest(source) == ERR_NOT_IN_RANGE) {
             creep.moveTo(source, { visualizePathStyle: { stroke: "#ffaa00" } });
@@ -22,9 +19,11 @@ export function Harvest(creep: Creep) {
 
 export function BigHarvest(creep: Creep) {
     let source: Source = GetSource(MAIN_SOURCE_ID);
-    let container = GetContainer(creep);
+    let target = Game.getObjectById(creep.memory.workTarget) as StructureContainer;
-    if (container[0].store.getFreeCapacity(RESOURCE_ENERGY) == 0) { }
+    if (target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) { 
+        console.log("container is full, wait for next tick, container id is:", target.id);
+    }
     else if (creep.harvest(source) == ERR_NOT_IN_RANGE) {
-        creep.moveTo(container[0], { visualizePathStyle: { stroke: "#ffaa00" } });
+        creep.moveTo(target, { visualizePathStyle: { stroke: "#ffaa00" } });
     }
 }

src/modules/spawnCreep.ts

@@ -2,39 +2,49 @@ import * as setting from "./setting";
 import * as creepApi from "./creepApi"
 
 const createDefaultHarvester = (spawn: StructureSpawn) => {
-    return creepApi.SpawnCreep(spawn, setting.mk1Body, setting.Role.Harvester);
+    return creepApi.SpawnCreep(spawn, setting.mk1Body, { memory: { role: creepApi.RoleToString(setting.Role.Harvester) } });
 }
 const createDefaultBuilder = (spawn: StructureSpawn) => {
-    return creepApi.SpawnCreep(spawn, setting.mk1Body, setting.Role.Builder);
+    return creepApi.SpawnCreep(spawn, setting.mk1Body, { memory: { role: creepApi.RoleToString(setting.Role.Builder) } });
 };
 
 const createDefaultUpgrader = (spawn: StructureSpawn) => {
-    return creepApi.SpawnCreep(spawn, setting.mk1Body, setting.Role.Upgrader);
+    return creepApi.SpawnCreep(spawn, setting.mk1Body, { memory: { role: creepApi.RoleToString(setting.Role.Upgrader) } });
 };
 
-const createMk2Harvester = (spawn: StructureSpawn) => {
+const createMk2Harvester = (spawn: StructureSpawn, container: StructureContainer) => {
-    return creepApi.SpawnCreep(spawn, setting.Mk2harvesterBody, setting.Role.BigHarvester);
+    return creepApi.SpawnCreep(spawn, setting.Mk2harvesterBody, { memory: { role: creepApi.RoleToString(setting.Role.BigHarvester), workTarget: container.id } });
 }
 
 export function SpawnCreep(spawn: StructureSpawn) {
     if (spawn.spawning) return;
 
     let currentCreeps = creepApi.GetCreeps();
-    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Harvester)) > setting.HARVESTER_COUNT) {
+    let currentContainer = creepApi.GetContainer(spawn);
+    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Harvester)) < setting.HARVESTER_COUNT) {
         if (createDefaultHarvester(spawn) == 0) {
             console.log("Spawn Harvester")
         }
     }
-    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Upgrader)) > setting.UPGRADER_COUNT) {
+    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Upgrader)) < setting.UPGRADER_COUNT) {
         if (createDefaultUpgrader(spawn) == 0) {
             console.log("Spawn Upgrader")
         }
     }
-    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Builder)) > setting.BUILDER_COUNT) {
+    if (currentCreeps.get(creepApi.RoleToString(setting.Role.Builder)) < setting.BUILDER_COUNT) {
         if (createDefaultBuilder(spawn) == 0) {
             console.log("Spawn Builder")
         }
     }
+    if (currentCreeps.get(creepApi.RoleToString(setting.Role.BigHarvester)) < currentContainer.length) {
+        for (var structure of Memory.structures) {
+            if (structure.structureType == STRUCTURE_CONTAINER && structure.creep == null)
+                if (createMk2Harvester(spawn, Game.getObjectById(structure.id) as StructureContainer) == 0) {
+                    structure.creep = Game.creeps[spawn.spawning.name].id;
+                    console.log("Spawn Mk2Harvester, Set Work Target:", structure.id);
+                }
+        }
+    }
     if (spawn.spawning) {
         var spawningCreep = Game.creeps[spawn.spawning.name];
         spawn.room.visual.text(