├── main.js ├── README.md ├── .vscode ├── extensions.json └── settings.json ├── .devcontainer ├── Dockerfile └── devcontainer.json ├── book.json ├── .prettierrc ├── test ├── mocha.opts ├── unit │ ├── mock.ts │ └── main.test.ts ├── setup-mocha.js └── integration │ ├── integration.test.ts │ └── helper.ts ├── src ├── Operations │ └── clear_claimed_rooms.ts ├── Managers │ ├── MemoryManager.ts │ ├── RunPowerCreepManager.ts │ ├── RunCreepManager.ts │ ├── RunAllCreepsManager.ts │ ├── QuadSquadRunManager.ts │ ├── CPUmanager.ts │ ├── ExecuteCommandsInNTicks.ts │ └── PowerCreepManager.ts ├── Roles │ ├── Party │ │ └── CCKparty.ts │ ├── Sign.ts │ ├── clearer.ts │ ├── mosquito.ts │ ├── Dismantler.ts │ ├── PowerMelee.ts │ ├── rampartUpgrader.ts │ ├── healer.ts │ ├── DrainTower.ts │ ├── Priest.ts │ ├── reserve.ts │ ├── PowerHeal.ts │ ├── SafeModer.ts │ ├── mineralMiner.ts │ ├── claimer.ts │ ├── scout.ts │ ├── Convoy.ts │ ├── FakeFiller.ts │ ├── SpecialCarry.ts │ ├── WallClearer.ts │ ├── ContinuousControllerKiller.ts │ ├── remoteDismantler.ts │ ├── annoy.ts │ ├── upgrader.ts │ ├── RoomLocker.ts │ ├── maintainer.ts │ ├── RampartErector.ts │ ├── ControllerLinkFiller.ts │ ├── CreepKiller.ts │ ├── defender.ts │ ├── RangedRampartDefender.ts │ ├── attacker.ts │ ├── RampartDefender.ts │ ├── DismantleControllerWalls.ts │ ├── signifer.ts │ ├── PowerCreeps │ │ └── efficient.ts │ ├── RangedAttacker.ts │ ├── builder.ts │ ├── Escort.ts │ ├── sweeper.ts │ └── filler.ts ├── utils │ ├── Types.ts │ ├── MemHack.ts │ ├── ErrorExporter.ts │ ├── TerrainDataExporter.ts │ ├── ErrorMapper.ts │ └── Global.ts ├── Misc │ ├── find_exposed_creeps.ts │ ├── find_exposed_structs.ts │ ├── decrementTempBadRooms.ts │ └── mosquito_manager.ts ├── Rooms │ ├── rooms.data.ts │ ├── rooms.remotes.ts │ ├── rooms.powerSpawning.ts │ ├── rooms.factory.ts │ └── rooms.supportOtherRooms.ts ├── Random_Stuff │ └── urgent_buy.ts ├── Functions │ └── roomPositionFunctions.ts └── main.ts ├── .editorconfig ├── screeps.example.json ├── .gitattributes ├── tsconfig.json ├── rollup.config.js ├── TODO.txt ├── LICENSE ├── .gitignore └── package.json /main.js: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/waxeye7/Pacifist-Bot/HEAD/README.md -------------------------------------------------------------------------------- /.vscode/extensions.json: -------------------------------------------------------------------------------- 1 | { 2 | "recommendations": [ 3 | "ms-vscode-remote.vscode-remote-extensionpack" 4 | ] 5 | } 6 | -------------------------------------------------------------------------------- /.devcontainer/Dockerfile: -------------------------------------------------------------------------------- 1 | FROM node:12-alpine 2 | 3 | RUN apk add --update --no-cache git ca-certificates openssl openssh 4 | RUN npm install -g rollup 5 | -------------------------------------------------------------------------------- /book.json: -------------------------------------------------------------------------------- 1 | { 2 | "title": "Screeps Typescript Starter", 3 | "description": "Starter kit for TypeScript-based Screeps AI codes.", 4 | "root": "./docs" 5 | } 6 | -------------------------------------------------------------------------------- /.prettierrc: -------------------------------------------------------------------------------- 1 | { 2 | "semi": true, 3 | "tabWidth": 2, 4 | "printWidth": 120, 5 | "singleQuote": false, 6 | "trailingComma": "none", 7 | "arrowParens": "avoid", 8 | "endOfLine": "auto" 9 | } 10 | -------------------------------------------------------------------------------- /test/mocha.opts: -------------------------------------------------------------------------------- 1 | --require test/setup-mocha.js 2 | --require ts-node/register 3 | --require tsconfig-paths/register 4 | --ui bdd 5 | 6 | --reporter spec 7 | --bail 8 | --full-trace 9 | --watch-extensions tsx,ts 10 | --colors 11 | 12 | --recursive 13 | --timeout 5000 14 | --exit 15 | -------------------------------------------------------------------------------- /src/Operations/clear_claimed_rooms.ts: -------------------------------------------------------------------------------- 1 | function clear_claimed_rooms() { 2 | if(!Memory.Operations) { 3 | Memory.Operations = {clear_claimed_rooms:{}}; 4 | } 5 | 6 | for(let roomName in Memory.Operations.clear_claimed_rooms) { 7 | 8 | } 9 | 10 | } 11 | 12 | export default clear_claimed_rooms; 13 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | # editorconfig.org 2 | 3 | root = true 4 | 5 | [*] 6 | indent_style = space 7 | indent_size = 2 8 | charset = utf-8 9 | trim_trailing_whitespace = true 10 | insert_final_newline = true 11 | 12 | [*.py] 13 | indent_style = space 14 | indent_size = 4 15 | 16 | [*.rb] 17 | indent_style = space 18 | indent_size = 4 19 | -------------------------------------------------------------------------------- /test/unit/mock.ts: -------------------------------------------------------------------------------- 1 | export const Game: { 2 | creeps: { [name: string]: any }; 3 | rooms: any; 4 | spawns: any; 5 | time: any; 6 | } = { 7 | creeps: {}, 8 | rooms: [], 9 | spawns: {}, 10 | time: 12345 11 | }; 12 | 13 | export const Memory: { 14 | creeps: { [name: string]: any }; 15 | } = { 16 | creeps: {} 17 | }; 18 | -------------------------------------------------------------------------------- /src/Managers/MemoryManager.ts: -------------------------------------------------------------------------------- 1 | function MemoryManager() { 2 | 3 | if(!Memory.targetRampRoom) { 4 | Memory.targetRampRoom = { 5 | room:false, 6 | urgent:false 7 | } 8 | } 9 | 10 | if(!Memory.keepAfloat) { 11 | Memory.keepAfloat = []; 12 | } 13 | 14 | 15 | } 16 | 17 | export default MemoryManager; 18 | -------------------------------------------------------------------------------- /src/Managers/RunPowerCreepManager.ts: -------------------------------------------------------------------------------- 1 | function RunPowerCreepManager() { 2 | 3 | for(let name in Game.powerCreeps) { 4 | if(name.startsWith("efficient")) { 5 | let creep = Game.powerCreeps[name]; 6 | if(creep && creep.ticksToLive) { 7 | global.ROLES["efficient"].run(creep); 8 | } 9 | } 10 | } 11 | 12 | } 13 | 14 | export default RunPowerCreepManager; 15 | -------------------------------------------------------------------------------- /test/setup-mocha.js: -------------------------------------------------------------------------------- 1 | //inject mocha globally to allow custom interface refer without direct import - bypass bundle issue 2 | global._ = require('lodash'); 3 | global.mocha = require('mocha'); 4 | global.chai = require('chai'); 5 | global.sinon = require('sinon'); 6 | global.chai.use(require('sinon-chai')); 7 | 8 | // Override ts-node compiler options 9 | process.env.TS_NODE_PROJECT = 'tsconfig.test.json' 10 | -------------------------------------------------------------------------------- /screeps.example.json: -------------------------------------------------------------------------------- 1 | { 2 | "main": { 3 | "token": "YOUR_TOKEN", 4 | "protocol": "https", 5 | "hostname": "screeps.com", 6 | "port": 443, 7 | "path": "/", 8 | "branch": "main" 9 | }, 10 | "pserver": { 11 | "email": "username", 12 | "password": "Password", 13 | "protocol": "http", 14 | "hostname": "1.2.3.4", 15 | "port": 21025, 16 | "path": "/", 17 | "branch": "main" 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Roles/Party/CCKparty.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 9 | let result = creep.Boost(); 10 | if(!result) { 11 | return; 12 | } 13 | } 14 | 15 | } 16 | 17 | 18 | const roleCCKparty = { 19 | run, 20 | //run: run, 21 | //function2, 22 | //function3 23 | }; 24 | export default roleCCKparty; 25 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | 4 | # Custom for Visual Studio 5 | *.cs diff=csharp 6 | *.sln merge=union 7 | *.csproj merge=union 8 | *.vbproj merge=union 9 | *.fsproj merge=union 10 | *.dbproj merge=union 11 | 12 | # Standard to msysgit 13 | *.doc diff=astextplain 14 | *.DOC diff=astextplain 15 | *.docx diff=astextplain 16 | *.DOCX diff=astextplain 17 | *.dot diff=astextplain 18 | *.DOT diff=astextplain 19 | *.pdf diff=astextplain 20 | *.PDF diff=astextplain 21 | *.rtf diff=astextplain 22 | *.RTF diff=astextplain 23 | -------------------------------------------------------------------------------- /src/utils/Types.ts: -------------------------------------------------------------------------------- 1 | // export interface Creep { 2 | // findSource: () => object; 3 | // findSpawn:any; 4 | // findStorage:any; 5 | // findClosestLink:any; 6 | // withdrawStorage:any; 7 | // moveToRoom:any; 8 | // harvestEnergy:any; 9 | // acquireEnergyWithContainersAndOrDroppedEnergy:any; 10 | // roadCheck:any; 11 | // roadlessLocation:any; 12 | // } 13 | 14 | // export interface Room { 15 | // findStorage:any; 16 | // findExtractor:any; 17 | // findSpawn:any; 18 | // findStorageContainer:any; 19 | // findContainers:any; 20 | // findMineral:any; 21 | // } 22 | 23 | -------------------------------------------------------------------------------- /src/Misc/find_exposed_creeps.ts: -------------------------------------------------------------------------------- 1 | function find_exposed_creeps(pos: RoomPosition, hostileCreeps: Array): Array { 2 | let exposedHostiles: Array = []; 3 | hostileCreeps.forEach(Hostile => { 4 | let range = pos.getRangeTo(Hostile); 5 | if (range > 3) return; 6 | let structures = Hostile.pos.lookFor(LOOK_STRUCTURES); 7 | let ramparts = structures.filter(s => s.structureType === STRUCTURE_RAMPART); 8 | if (ramparts.length && ramparts[0].hits > 1000) return; 9 | exposedHostiles.push(Hostile); 10 | }); 11 | return exposedHostiles; 12 | } 13 | 14 | export default find_exposed_creeps; 15 | -------------------------------------------------------------------------------- /src/Misc/find_exposed_structs.ts: -------------------------------------------------------------------------------- 1 | function find_exposed_structs(pos: RoomPosition, structures: Array): Array { 2 | let exposedStructs: Array = []; 3 | structures.forEach(struct => { 4 | let range = pos.getRangeTo(struct); 5 | if (range > 3) return; 6 | let structures = struct.pos.lookFor(LOOK_STRUCTURES); 7 | let ramparts = structures.filter(s => s.structureType === STRUCTURE_RAMPART); 8 | if (ramparts.length && ramparts[0].hits > 1000) return; 9 | exposedStructs.push(struct); 10 | }); 11 | return exposedStructs; 12 | } 13 | 14 | export default find_exposed_structs; 15 | -------------------------------------------------------------------------------- /src/utils/MemHack.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Ripped from https://github.com/AlinaNova21/ZeSwarm/ 3 | * Organized by Carson Burke and xTwisteDx 4 | * 5 | * Usage: 6 | * Before the loop, import memHack 7 | * At start of loop(), run memHack.run() 8 | */ 9 | 10 | class MemHack { 11 | memory: Memory | undefined 12 | 13 | constructor() { 14 | this.memory = Memory 15 | this.memory = RawMemory._parsed 16 | } 17 | 18 | run() { 19 | delete global.Memory 20 | global.Memory = this.memory 21 | RawMemory._parsed = this.memory 22 | } 23 | } 24 | 25 | export const memHack = new MemHack() 26 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "module": "esnext", 4 | "lib": [ 5 | "es2018" 6 | ], 7 | "target": "es2018", 8 | "moduleResolution": "Node", 9 | "outDir": "dist", 10 | "baseUrl": "src/", 11 | "sourceMap": true, 12 | "strict": false, // Disable strict mode 13 | "experimentalDecorators": true, 14 | "noImplicitReturns": true, 15 | "allowSyntheticDefaultImports": true, 16 | "allowUnreachableCode": false, 17 | "forceConsistentCasingInFileNames": false // Disable forceConsistentCasingInFileNames 18 | }, 19 | "exclude": [ 20 | "node_modules" 21 | ] 22 | } 23 | -------------------------------------------------------------------------------- /test/integration/integration.test.ts: -------------------------------------------------------------------------------- 1 | import {assert} from "chai"; 2 | import {helper} from "./helper"; 3 | 4 | describe("main", () => { 5 | it("runs a server and matches the game tick", async function () { 6 | for (let i = 1; i < 10; i += 1) { 7 | assert.equal(await helper.server.world.gameTime, i); 8 | await helper.server.tick(); 9 | } 10 | }); 11 | 12 | it("writes and reads to memory", async function () { 13 | await helper.player.console(`Memory.foo = 'bar'`); 14 | await helper.server.tick(); 15 | const memory = JSON.parse(await helper.player.memory); 16 | assert.equal(memory.foo, 'bar'); 17 | }); 18 | }); 19 | -------------------------------------------------------------------------------- /src/Misc/decrementTempBadRooms.ts: -------------------------------------------------------------------------------- 1 | function decrementTempBadRooms() { 2 | if (!Memory.AvoidRoomsTemp) { 3 | Memory.AvoidRoomsTemp = {}; 4 | return; 5 | } 6 | 7 | for (const roomName in Memory.AvoidRoomsTemp) { 8 | const roomValue = Memory.AvoidRoomsTemp[roomName]; 9 | if (typeof roomValue === 'number') { 10 | if (roomValue > 0) { 11 | Memory.AvoidRoomsTemp[roomName]--; 12 | } else if(roomValue < 0){ 13 | Memory.AvoidRoomsTemp[roomName] = 0; 14 | } else if(roomValue === 0) { 15 | delete Memory.AvoidRoomsTemp[roomName]; 16 | } 17 | } 18 | } 19 | } 20 | 21 | export default decrementTempBadRooms; 22 | -------------------------------------------------------------------------------- /src/Rooms/rooms.data.ts: -------------------------------------------------------------------------------- 1 | function data(room) { 2 | if(!room.memory.data) { 3 | room.memory.data = {}; 4 | } 5 | if(!room.memory.data.DOB) { 6 | room.memory.data.DOB = 0; 7 | } 8 | if(!room.memory.data.DOBug) { 9 | room.memory.data.DOBug = 0; 10 | } 11 | if(room.controller.progress <= 200) { 12 | room.memory.data.DOBug = 0; 13 | } 14 | if(!room.memory.data.c_spawned) { 15 | room.memory.data.c_spawned = 0; 16 | } 17 | 18 | 19 | let data = room.memory.data; 20 | data.DOB += 1; 21 | data.DOBug += 1; 22 | room.memory.data = data; 23 | 24 | } 25 | 26 | export default data; 27 | // module.exports = market; 28 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "[javascript]": { 3 | "editor.formatOnSave": false 4 | }, 5 | "[json]": { 6 | "editor.formatOnSave": true 7 | }, 8 | "[typescript]": { 9 | "editor.formatOnSave": false 10 | }, 11 | "editor.codeActionsOnSave": { 12 | "source.fixAll.eslint": "explicit" 13 | }, 14 | "editor.formatOnSave": true, 15 | "editor.renderWhitespace": "boundary", 16 | "files.encoding": "utf8", 17 | "files.insertFinalNewline": true, 18 | "files.trimTrailingWhitespace": true, 19 | "search.exclude": { 20 | "_book/**": true, 21 | ".rpt2_cache/**": true, 22 | "dist/**": true, 23 | "node_modules/**": true, 24 | "typings/**": true 25 | }, 26 | "typescript.tsdk": "./node_modules/typescript/lib" 27 | } 28 | -------------------------------------------------------------------------------- /src/Roles/Sign.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | 7 | if(creep.memory.suicide) { 8 | creep.recycle(); 9 | return; 10 | } 11 | 12 | if(creep.room.controller && creep.room.controller.my && (!creep.room.controller.sign || creep.room.controller.sign.text !== "check out my YT channel - marlyman123")) { 13 | if(creep.pos.isNearTo(creep.room.controller)) { 14 | creep.signController(creep.room.controller, "check out my YT channel - marlyman123") 15 | } 16 | else { 17 | creep.MoveCostMatrixIgnoreRoads(creep.room.controller, 1); 18 | } 19 | } 20 | else { 21 | creep.memory.suicide = true; 22 | } 23 | } 24 | 25 | 26 | const roleSign = { 27 | run, 28 | //run: run, 29 | //function2, 30 | //function3 31 | }; 32 | export default roleSign; 33 | -------------------------------------------------------------------------------- /rollup.config.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | 3 | import clear from 'rollup-plugin-clear'; 4 | import resolve from '@rollup/plugin-node-resolve'; 5 | import commonjs from '@rollup/plugin-commonjs'; 6 | import typescript from 'rollup-plugin-typescript2'; 7 | import screeps from 'rollup-plugin-screeps'; 8 | 9 | let cfg; 10 | const dest = process.env.DEST; 11 | if (!dest) { 12 | console.log("No destination specified - code will be compiled but not uploaded"); 13 | } else if ((cfg = require("./screeps.json")[dest]) == null) { 14 | throw new Error("Invalid upload destination"); 15 | } 16 | 17 | export default { 18 | input: "src/main.ts", 19 | output: { 20 | file: "dist/main.js", 21 | format: "cjs", 22 | sourcemap: true 23 | }, 24 | 25 | plugins: [ 26 | clear({ targets: ["dist"] }), 27 | resolve({ rootDir: "src" }), 28 | commonjs(), 29 | typescript({tsconfig: "./tsconfig.json"}), 30 | screeps({config: cfg, dryRun: cfg == null}) 31 | ] 32 | } 33 | -------------------------------------------------------------------------------- /src/Roles/clearer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep: Creep) { 6 | 7 | creep.memory.moving = false; 8 | 9 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 10 | let result = creep.Boost(); 11 | if(!result) { 12 | return; 13 | } 14 | } 15 | 16 | 17 | const hostile = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS); 18 | if (hostile) { 19 | let result = creep.attack(hostile); 20 | 21 | if(result === 0 && (Game.time % 25 === 0 || hostile.hits !== hostile.hitsMax)) { 22 | creep.room.roomTowersAttackEnemy(hostile); 23 | } 24 | creep.moveTo(hostile); 25 | 26 | } 27 | else if(creep.ticksToLive < 100 || !creep.room.memory.danger && creep.room.memory.danger_timer === 0) { 28 | creep.recycle(); 29 | } 30 | 31 | }; 32 | 33 | const roleClearer = { 34 | run 35 | //run: run, 36 | //function2, 37 | //function3 38 | }; 39 | export default roleClearer; 40 | -------------------------------------------------------------------------------- /src/Managers/RunCreepManager.ts: -------------------------------------------------------------------------------- 1 | function RunCreepManager(name) { 2 | try { 3 | let creep = Game.creeps[name]; 4 | if(!creep) { 5 | delete Memory.creeps[name]; 6 | return; 7 | } 8 | 9 | if(creep.memory.role == undefined) { 10 | console.log("i am undefined", name) 11 | creep.suicide(); 12 | return; 13 | } 14 | 15 | if (!global.ROLES[creep.memory.role]) { 16 | console.log(`Unknown role: ${creep.memory.role} for creep ${name}`); 17 | return; 18 | } 19 | 20 | let creepUsed = Game.cpu.getUsed(); 21 | global.ROLES[creep.memory.role].run(creep); 22 | if(global.profiler) { 23 | console.log(creep.memory.role, "used", (Game.cpu.getUsed() - creepUsed).toFixed(2)) 24 | } 25 | } catch (error) { 26 | console.log(`Error running creep ${name}:`, error); 27 | } 28 | } 29 | 30 | export default RunCreepManager; 31 | -------------------------------------------------------------------------------- /TODO.txt: -------------------------------------------------------------------------------- 1 | 4 corner room mineral miner 2 | make spawn more carry based on if the carry function made the full amount of parts 3 | 4 | 5 | --SQUAD QUAD-- 6 | cache quad squad movement inside target room if position is unchanged or after x ticks 7 | add same quad inter room pathing trick when turning corner of room to make more efficient movement 8 | make quads bounce if too much damage 9 | quads smarter and kill structs in range 2 of enemy ramparts potentially. 10 | 11 | :thinking: make a kind of raider role that walks around different rooms triggering a costly response but only committing as long as the response is not there 12 | make ram smarter by retreating on lower hits and or tower damage too high - wait to drain tower first. 13 | 14 | make roles like the priest request and use observer! 15 | 16 | clean up rooms.ts 17 | 18 | add remote rooms preference based on distance to sources 19 | 20 | min cut 21 | 22 | 23 | add carrier energy request system 24 | 25 | 26 | PREHEAL quad on contact with attack enemy creep 27 | -------------------------------------------------------------------------------- /src/Random_Stuff/urgent_buy.ts: -------------------------------------------------------------------------------- 1 | function urgent_buy(terminal: StructureTerminal, resource: ResourceConstant, amount: number) { 2 | if (!terminal.cooldown) { 3 | let orderPrice = 2000; 4 | let orders = Game.market.getAllOrders({ type: ORDER_SELL, resourceType: resource }); 5 | orders = _.filter(orders, order => order.price <= orderPrice); 6 | console.log(orders); 7 | if (orders.length > 0) { 8 | orders.sort((a, b) => a.price - b.price); 9 | amount = Math.min(orders[0].amount, amount); 10 | let orderID = orders[0].id; 11 | let result = Game.market.deal(orderID, amount, terminal.room.name); 12 | if (result === 0) { 13 | console.log( 14 | orders[0].amount, 15 | resource, 16 | "Bought at Price:", 17 | orders[0].price, 18 | "=", 19 | orders[0].amount * orders[0].price 20 | ); 21 | return; 22 | } else { 23 | console.log("failed to buy", resource, "becuase", result); 24 | } 25 | } 26 | } 27 | } 28 | 29 | export default urgent_buy; 30 | -------------------------------------------------------------------------------- /src/Managers/RunAllCreepsManager.ts: -------------------------------------------------------------------------------- 1 | import QuadSquadRunManager from "./QuadSquadRunManager"; 2 | import RunCreepManager from "./RunCreepManager"; 3 | import RunPowerCreepManager from "./RunPowerCreepManager"; 4 | 5 | function RunAllCreepsManager() { 6 | 7 | const start = Game.cpu.getUsed() 8 | 9 | 10 | RunPowerCreepManager(); 11 | 12 | 13 | let executeCreepScriptsLaterList = []; 14 | const creepNames = Object.keys(Memory.creeps); 15 | for(let name of creepNames) { 16 | if(!Game.creeps[name]) { 17 | delete Memory.creeps[name]; 18 | continue; 19 | } 20 | if(name.startsWith("SquadCreepA") || name.startsWith("SquadCreepB") || name.startsWith("SquadCreepY") || name.startsWith("SquadCreepZ")) { 21 | executeCreepScriptsLaterList.push(name); 22 | } 23 | else { 24 | RunCreepManager(name); 25 | } 26 | } 27 | 28 | QuadSquadRunManager(executeCreepScriptsLaterList); 29 | console.log('Creeps Ran in', Game.cpu.getUsed() - start, 'ms'); 30 | 31 | } 32 | 33 | export default RunAllCreepsManager; 34 | -------------------------------------------------------------------------------- /src/utils/ErrorExporter.ts: -------------------------------------------------------------------------------- 1 | const errorSegment = 10 2 | RawMemory.setActiveSegments([errorSegment]) 3 | 4 | interface ErrorData { 5 | errors: string[]; 6 | version?: number 7 | } 8 | 9 | export default class ErrorExporter { 10 | public static getSegmentData(): ErrorData { 11 | const segment = RawMemory.segments[errorSegment] 12 | if (segment === undefined || segment.length === 0) return { errors: [] } 13 | else return JSON.parse(RawMemory.segments[errorSegment]) 14 | } 15 | 16 | public static setSegmentData(data: ErrorData): void { 17 | RawMemory.segments[errorSegment] = JSON.stringify(data) 18 | } 19 | 20 | public static addErrorToSegment(stack: string, version?: number): void { 21 | const data = this.getSegmentData() 22 | if (JSON.stringify(data).length > 90000) { 23 | Game.notify(`Error segment (${errorSegment}) is full`) 24 | return 25 | } 26 | 27 | data.errors.push(stack) 28 | if (version) data.version = version; 29 | this.setSegmentData(data) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /test/unit/main.test.ts: -------------------------------------------------------------------------------- 1 | import {assert} from "chai"; 2 | import {loop} from "../../src/main"; 3 | import {Game, Memory} from "./mock" 4 | 5 | describe("main", () => { 6 | before(() => { 7 | // runs before all test in this block 8 | }); 9 | 10 | beforeEach(() => { 11 | // runs before each test in this block 12 | // @ts-ignore : allow adding Game to global 13 | global.Game = _.clone(Game); 14 | // @ts-ignore : allow adding Memory to global 15 | global.Memory = _.clone(Memory); 16 | }); 17 | 18 | it("should export a loop function", () => { 19 | assert.isTrue(typeof loop === "function"); 20 | }); 21 | 22 | it("should return void when called with no context", () => { 23 | assert.isUndefined(loop()); 24 | }); 25 | 26 | it("Automatically delete memory of missing creeps", () => { 27 | Memory.creeps.persistValue = "any value"; 28 | Memory.creeps.notPersistValue = "any value"; 29 | 30 | Game.creeps.persistValue = "any value"; 31 | 32 | loop(); 33 | 34 | assert.isDefined(Memory.creeps.persistValue); 35 | assert.isUndefined(Memory.creeps.notPersistValue); 36 | }); 37 | }); 38 | -------------------------------------------------------------------------------- /src/Roles/mosquito.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep: Creep) { 2 | creep.memory.moving = false; 3 | if (creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 4 | let result = creep.Boost(); 5 | if (!result) { 6 | return; 7 | } 8 | } 9 | 10 | if (creep.memory.targetRoom && creep.room.name !== creep.memory.targetRoom) { 11 | if (creep.hits !== creep.hitsMax) creep.heal(creep); 12 | let hostileCreepsInRange3 = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 3); 13 | if (hostileCreepsInRange3.length) { 14 | let closestEnemy = creep.pos.findClosestByRange(hostileCreepsInRange3); 15 | if (closestEnemy) { 16 | let range = creep.pos.getRangeTo(closestEnemy); 17 | if (range <= 3) { 18 | creep.heal(creep); 19 | if (range === 1) creep.rangedMassAttack(); 20 | else creep.rangedAttack(closestEnemy); 21 | } 22 | } 23 | } 24 | if (creep.memory.boostlabs?.length > 0) return; 25 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 26 | } 27 | }; 28 | 29 | const mosquito = { 30 | run 31 | }; 32 | 33 | export default mosquito; 34 | -------------------------------------------------------------------------------- /src/Managers/QuadSquadRunManager.ts: -------------------------------------------------------------------------------- 1 | function QuadSquadRunManager(QuadSquadNameList) { 2 | 3 | for(let name of QuadSquadNameList) { 4 | let creep = Game.creeps[name]; 5 | if(!creep) { 6 | delete Memory.creeps[name]; 7 | } 8 | else { 9 | if(creep.memory.role == undefined) { 10 | console.log("i am undefined", name) 11 | creep.suicide(); 12 | } 13 | if(creep.memory.role == "SquadCreepA") { 14 | global.ROLES[creep.memory.role].run(creep); 15 | } 16 | } 17 | } 18 | for(let name of QuadSquadNameList) { 19 | let creep = Game.creeps[name]; 20 | if(!creep) { 21 | delete Memory.creeps[name]; 22 | } 23 | else { 24 | if(creep.memory.role == undefined) { 25 | console.log("i am undefined", name) 26 | creep.suicide(); 27 | } 28 | if(creep.memory.role !== "SquadCreepA") { 29 | global.ROLES[creep.memory.role].run(creep); 30 | } 31 | } 32 | } 33 | } 34 | 35 | export default QuadSquadRunManager; 36 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /src/Roles/Dismantler.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | 7 | function findLocked(creep) { 8 | 9 | let buildingsToDismantle = creep.room.find(FIND_STRUCTURES, {filter: building => building.structureType == STRUCTURE_WALL}); 10 | 11 | if(buildingsToDismantle.length > 0) { 12 | return buildingsToDismantle[0].id; 13 | } 14 | } 15 | 16 | 17 | 18 | const run = function (creep) { 19 | ; 20 | 21 | if(creep.memory.locked && creep.memory.locked != false) { 22 | let dismantleTarget = Game.getObjectById(creep.memory.locked); 23 | if(dismantleTarget == undefined) { 24 | creep.memory.locked = false; 25 | } 26 | } 27 | 28 | if(!creep.memory.locked) { 29 | creep.memory.locked = findLocked(creep); 30 | } 31 | 32 | 33 | if(creep.memory.locked && creep.memory.locked != false) { 34 | let dismantleTarget = Game.getObjectById(creep.memory.locked); 35 | if(creep.dismantle(dismantleTarget) == ERR_NOT_IN_RANGE) { 36 | creep.moveTo(dismantleTarget, {reusePath:25}); 37 | } 38 | } 39 | } 40 | 41 | 42 | const roleDismantler = { 43 | run, 44 | //run: run, 45 | //function2, 46 | //function3 47 | }; 48 | export default roleDismantler; 49 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # yarn lock file 2 | /yarn.lock 3 | 4 | # npm lock file (v5.0.0+) 5 | /package-lock.json 6 | 7 | # Ignore basic folders 8 | /dist 9 | /.rpt2_cache 10 | /tsc-out 11 | /node_modules 12 | /_book 13 | /build/* 14 | 15 | # TypeScript definitions installed by Typings 16 | /typings 17 | 18 | # Screeps Config 19 | screeps.json 20 | 21 | # ScreepsServer data from integration tests 22 | /server 23 | 24 | # Numerous always-ignore extensions 25 | *.diff 26 | *.err 27 | *.orig 28 | *.log 29 | *.rej 30 | *.swo 31 | *.swp 32 | *.zip 33 | *.vi 34 | *~ 35 | 36 | # Editor folders 37 | .cache 38 | .project 39 | .settings 40 | .tmproj 41 | *.esproj 42 | nbproject 43 | *.sublime-project 44 | *.sublime-workspace 45 | .idea 46 | 47 | # ========================= 48 | # Operating System Files 49 | # ========================= 50 | 51 | # OSX 52 | # ========================= 53 | 54 | .DS_Store 55 | .AppleDouble 56 | .LSOverride 57 | 58 | # Thumbnails 59 | ._* 60 | 61 | # Files that might appear on external disk 62 | .Spotlight-V100 63 | .Trashes 64 | 65 | # Directories potentially created on remote AFP share 66 | .AppleDB 67 | .AppleDesktop 68 | Network Trash Folder 69 | Temporary Items 70 | .apdisk 71 | 72 | # Windows 73 | # ========================= 74 | 75 | # Windows image file caches 76 | Thumbs.db 77 | ehthumbs.db 78 | 79 | # Folder config file 80 | Desktop.ini 81 | 82 | # Recycle Bin used on file shares 83 | $RECYCLE.BIN/ 84 | 85 | # Windows Installer files 86 | *.cab 87 | *.msi 88 | *.msm 89 | *.msp 90 | 91 | # Windows shortcuts 92 | *.lnk 93 | -------------------------------------------------------------------------------- /.devcontainer/devcontainer.json: -------------------------------------------------------------------------------- 1 | // For format details, see https://aka.ms/devcontainer.json. For config options, see the README at: 2 | // https://github.com/microsoft/vscode-dev-containers/tree/v0.166.0/containers/docker-existing-dockerfile 3 | { 4 | "name": "Screeps-TypeScript-Starter", 5 | 6 | // Update the 'dockerFile' property if you aren't using the standard 'Dockerfile' filename. 7 | "dockerFile": "Dockerfile", 8 | 9 | // Set *default* container specific settings.json values on container create. 10 | "settings": { 11 | "terminal.integrated.shell.linux": null 12 | }, 13 | 14 | // Add the IDs of extensions you want installed when the container is created. 15 | "extensions": [] 16 | 17 | // Use 'forwardPorts' to make a list of ports inside the container available locally. 18 | // "forwardPorts": [], 19 | 20 | // Uncomment the next line to run commands after the container is created - for example installing curl. 21 | // "postCreateCommand": "apt-get update && apt-get install -y curl", 22 | 23 | // Uncomment when using a ptrace-based debugger like C++, Go, and Rust 24 | // "runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ], 25 | 26 | // Uncomment to use the Docker CLI from inside the container. See https://aka.ms/vscode-remote/samples/docker-from-docker. 27 | // "mounts": [ "source=/var/run/docker.sock,target=/var/run/docker.sock,type=bind" ], 28 | 29 | // Uncomment to connect as a non-root user if you've added one. See https://aka.ms/vscode-remote/containers/non-root. 30 | // "remoteUser": "vscode" 31 | } 32 | -------------------------------------------------------------------------------- /src/Roles/PowerMelee.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.suicide) { 9 | creep.recycle(); 10 | return; 11 | } 12 | 13 | if(creep.room.name != creep.memory.targetRoom) { 14 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 15 | } 16 | 17 | 18 | if(!creep.memory.target) { 19 | let powerBanks = creep.room.find(FIND_STRUCTURES, {filter: s => s.structureType == STRUCTURE_POWER_BANK}); 20 | if(powerBanks.length > 0) { 21 | creep.memory.target = powerBanks[0].id; 22 | } 23 | 24 | else { 25 | creep.memory.suicide = true; 26 | } 27 | } 28 | 29 | if(creep.memory.target) { 30 | let target:any = Game.getObjectById(creep.memory.target); 31 | if(target) { 32 | 33 | if(target.hits <= 180000 && !creep.memory.spawnedGoblin) { 34 | global.SGB(creep.memory.homeRoom, creep.memory.targetRoom); 35 | creep.memory.spawnedGoblin = true; 36 | } 37 | 38 | if(creep.pos.isNearTo(target)) { 39 | creep.attack(target) 40 | 41 | } 42 | else { 43 | creep.MoveCostMatrixRoadPrio(target, 1); 44 | } 45 | 46 | } 47 | else { 48 | creep.memory.target = false; 49 | } 50 | } 51 | 52 | } 53 | 54 | 55 | const rolePowerMelee = { 56 | run, 57 | //run: run, 58 | //function2, 59 | //function3 60 | }; 61 | export default rolePowerMelee; 62 | -------------------------------------------------------------------------------- /src/Rooms/rooms.remotes.ts: -------------------------------------------------------------------------------- 1 | function remotes(room) { 2 | if (!room.memory.resources) { 3 | room.memory.resources = {}; 4 | } 5 | if (!room.memory.resources[room.name]) { 6 | room.memory.resources[room.name] = {}; 7 | } 8 | 9 | let neighbors = Object.values(Game.map.describeExits(room.name)); 10 | let newRooms = []; 11 | 12 | // Filter out existing rooms and current room 13 | neighbors = neighbors.filter(roomName => roomName !== room.name && !room.memory.resources[roomName]); 14 | 15 | for (let roomName of neighbors) { 16 | if (!Game.rooms[roomName] || (Game.rooms[roomName].controller && !Game.rooms[roomName].controller.my) || Game.map.getRoomStatus(roomName).status !== "normal") { 17 | room.memory.resources[roomName] = {}; 18 | newRooms.push(roomName); 19 | } 20 | } 21 | 22 | // Check each new room's neighbors 23 | for (let roomName of newRooms) { 24 | let secondaryNeighbors = Object.values(Game.map.describeExits(roomName)); 25 | 26 | // Filter out existing rooms and current room 27 | secondaryNeighbors = secondaryNeighbors.filter(secondaryRoomName => secondaryRoomName !== room.name && !room.memory.resources[secondaryRoomName]); 28 | 29 | for (let secondaryRoomName of secondaryNeighbors) { 30 | if (!Game.rooms[secondaryRoomName] || (Game.rooms[secondaryRoomName].controller && !Game.rooms[secondaryRoomName].controller.my) || Game.map.getRoomStatus(secondaryRoomName).status !== "normal") { 31 | room.memory.resources[secondaryRoomName] = {}; 32 | } 33 | } 34 | } 35 | } 36 | 37 | export default remotes; 38 | -------------------------------------------------------------------------------- /test/integration/helper.ts: -------------------------------------------------------------------------------- 1 | const { readFileSync } = require('fs'); 2 | const _ = require('lodash'); 3 | const { ScreepsServer, stdHooks } = require('screeps-server-mockup'); 4 | const DIST_MAIN_JS = 'dist/main.js'; 5 | 6 | /* 7 | * Helper class for creating a ScreepsServer and resetting it between tests. 8 | * See https://github.com/Hiryus/screeps-server-mockup for instructions on 9 | * manipulating the terrain and game state. 10 | */ 11 | class IntegrationTestHelper { 12 | private _server: any; 13 | private _player: any; 14 | 15 | get server() { 16 | return this._server; 17 | } 18 | 19 | get player() { 20 | return this._player; 21 | } 22 | 23 | async beforeEach() { 24 | this._server = new ScreepsServer(); 25 | 26 | // reset world but add invaders and source keepers bots 27 | await this._server.world.reset(); 28 | 29 | // create a stub world composed of 9 rooms with sources and controller 30 | await this._server.world.stubWorld(); 31 | 32 | // add a player with the built dist/main.js file 33 | const modules = { 34 | main: readFileSync(DIST_MAIN_JS).toString(), 35 | }; 36 | this._player = await this._server.world.addBot({ username: 'player', room: 'W0N1', x: 15, y: 15, modules }); 37 | 38 | // Start server 39 | await this._server.start(); 40 | } 41 | 42 | async afterEach() { 43 | await this._server.stop(); 44 | } 45 | } 46 | 47 | beforeEach(async () => { 48 | await helper.beforeEach(); 49 | }); 50 | 51 | afterEach(async () => { 52 | await helper.afterEach(); 53 | }); 54 | 55 | before(() => { 56 | stdHooks.hookWrite(); 57 | }); 58 | 59 | export const helper = new IntegrationTestHelper(); 60 | -------------------------------------------------------------------------------- /src/Misc/mosquito_manager.ts: -------------------------------------------------------------------------------- 1 | function mosquito_manager() { 2 | if (Game.cpu.bucket < 1500) return; 3 | if(!Memory.e) Memory.e = {mosquito: []}; 4 | 5 | for (let u of Memory.e.mosquito) { 6 | if (u.ts > 0) { 7 | function findClosestRooms(roomName: string) { 8 | const range = 5; 9 | let myRoomNames = ["E45N59","E49N59","E49N58","E51N54","E41N58","E42N59"]; 10 | myRoomNames = _.shuffle(myRoomNames); 11 | 12 | let myRooms: Array = []; 13 | for (const myRoomName of myRoomNames) { 14 | if (Game.map.getRoomLinearDistance(roomName, myRoomName) > range) { 15 | continue; 16 | } 17 | let room = Game.rooms[myRoomName]; 18 | let storage = room.storage; 19 | let terminal = room.terminal; 20 | if (room && storage && terminal && room.controller && room.controller.my && room.controller.level === 8) { 21 | if ( 22 | storage.store[RESOURCE_ENERGY] >= 10000 23 | ) 24 | myRooms.push(room); 25 | } 26 | } 27 | 28 | 29 | const closestRooms = myRooms.sort((a, b) => { 30 | const distanceA = Game.map.getRoomLinearDistance(roomName, a.name); 31 | const distanceB = Game.map.getRoomLinearDistance(roomName, b.name); 32 | return distanceA - distanceB; 33 | }); 34 | return closestRooms.slice(0, 3); 35 | } 36 | 37 | let closestRooms = findClosestRooms(u.n); 38 | for (let closestRoom of closestRooms) { 39 | if (u.ts > 0) { 40 | if (global.spawn_mosquito(closestRoom.name, u.n)) { 41 | u.ts--; 42 | continue; 43 | } 44 | } 45 | } 46 | } 47 | } 48 | } 49 | 50 | export default mosquito_manager 51 | -------------------------------------------------------------------------------- /src/Roles/rampartUpgrader.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | creep.memory.moving = false; 8 | 9 | if(creep.memory.homeRoom && creep.memory.homeRoom != creep.room.name) { 10 | return creep.moveTo(new RoomPosition(25, 25, creep.memory.homeRoom)); 11 | } 12 | 13 | if(creep.memory.repairing && creep.store[RESOURCE_ENERGY] == 0) { 14 | creep.memory.repairing = false; 15 | creep.memory.locked = false; 16 | } 17 | if(!creep.memory.repairing && creep.store.getFreeCapacity() == 0) { 18 | creep.memory.repairing = true; 19 | } 20 | if(!creep.memory.repairing) { 21 | creep.harvestEnergy(); 22 | } 23 | if(creep.memory.repairing) { 24 | if(!creep.memory.locked) { 25 | let rampartsInRoom = creep.room.find(FIND_MY_STRUCTURES, {filter: s => s.structureType == STRUCTURE_RAMPART}); 26 | if(rampartsInRoom.length > 0) { 27 | rampartsInRoom.sort((a,b) => a.hits - b.hits); 28 | creep.memory.locked = rampartsInRoom[0].id 29 | } 30 | } 31 | if(creep.memory.locked) { 32 | let target = Game.getObjectById(creep.memory.locked); 33 | if(target) { 34 | if(creep.pos.getRangeTo(target) <= 3) { 35 | creep.repair(target); 36 | } 37 | else { 38 | creep.MoveCostMatrixRoadPrio(target, 3); 39 | } 40 | } 41 | else { 42 | creep.memory.locked = false; 43 | } 44 | 45 | } 46 | 47 | } 48 | 49 | } 50 | 51 | const roleRampartUpgrader = { 52 | run, 53 | //run: run, 54 | //function2, 55 | //function3 56 | }; 57 | export default roleRampartUpgrader; 58 | -------------------------------------------------------------------------------- /src/Managers/CPUmanager.ts: -------------------------------------------------------------------------------- 1 | function CPUmanager(tickTotal) { 2 | 3 | 4 | if(!Memory.CPU) { 5 | Memory.CPU = {}; 6 | } 7 | if(!Memory.CPU.hundredTickAvg) { 8 | Memory.CPU.hundredTickAvg = {}; 9 | Memory.CPU.hundredTickAvg.data = []; 10 | Memory.CPU.hundredTickAvg.avg = 0; 11 | } 12 | if(!Memory.CPU.fiveHundredTickAvg) { 13 | Memory.CPU.fiveHundredTickAvg = {}; 14 | Memory.CPU.fiveHundredTickAvg.data = []; 15 | Memory.CPU.fiveHundredTickAvg.avg = 0; 16 | } 17 | 18 | Memory.CPU.hundredTickAvg.data.push(tickTotal) 19 | 20 | if(Game.time % 100 == 0) { 21 | let total = 0; 22 | let lengthOfHundredArray = Memory.CPU.hundredTickAvg.data.length; 23 | for(let num of Memory.CPU.hundredTickAvg.data) { 24 | total += Number(num); 25 | } 26 | let average = (total / lengthOfHundredArray).toFixed(2); 27 | 28 | Memory.CPU.hundredTickAvg.avg = average; 29 | console.log("hundred tick average is " + average) 30 | Memory.CPU.hundredTickAvg.data = []; 31 | 32 | 33 | Memory.CPU.fiveHundredTickAvg.data.push(average) 34 | if(Game.time % 500 == 0) { 35 | 36 | let total = 0; 37 | let lengthOfFiveHundredArray = Memory.CPU.fiveHundredTickAvg.data.length; 38 | for(let num of Memory.CPU.fiveHundredTickAvg.data) { 39 | total += Number(num); 40 | } 41 | let average = (total / lengthOfFiveHundredArray).toFixed(2); 42 | 43 | Memory.CPU.fiveHundredTickAvg.avg = average; 44 | console.log("five hundred tick average is " + average) 45 | Memory.CPU.fiveHundredTickAvg.data = []; 46 | 47 | } 48 | } 49 | 50 | 51 | if(Game.time % 5 == 0) { 52 | console.log("my bucket:", Game.cpu.bucket) 53 | } 54 | } 55 | 56 | export default CPUmanager; 57 | -------------------------------------------------------------------------------- /src/Roles/healer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | 8 | if(creep.hits < creep.hitsMax) { 9 | creep.heal(creep); 10 | } 11 | 12 | if(creep.memory.fleeing) { 13 | // find hostiles with attack or ranged attack 14 | let hostiles = creep.room.find(FIND_HOSTILE_CREEPS); 15 | let meleeHostiles = hostiles.filter(c => c.getActiveBodyparts(ATTACK) > 0 ); 16 | let rangedHostiles = hostiles.filter(c => c.getActiveBodyparts(RANGED_ATTACK) > 0 ); 17 | if(rangedHostiles.length) { 18 | let closestRangedHostile = creep.pos.findClosestByRange(rangedHostiles); 19 | if(creep.pos.getRangeTo(closestRangedHostile) <= 5) { 20 | return; 21 | } 22 | } 23 | else if(meleeHostiles.length) { 24 | let closestMeleeHostile = creep.pos.findClosestByRange(meleeHostiles); 25 | if(creep.pos.getRangeTo(closestMeleeHostile) <= 3) { 26 | return; 27 | } 28 | } 29 | } 30 | else if(!creep.memory.danger) { 31 | creep.memory.fleeing = false; 32 | } 33 | 34 | let damagedCreepsInRoom = _.filter(Game.creeps, (damagedCreep) => damagedCreep.hits < damagedCreep.hitsMax && damagedCreep.room.name == creep.room.name); 35 | 36 | if(damagedCreepsInRoom.length > 0) { 37 | if (creep.heal(damagedCreepsInRoom[0]) == 0) { 38 | creep.moveTo(damagedCreepsInRoom[0]); 39 | } 40 | if(creep.heal(damagedCreepsInRoom[0]) == ERR_NOT_IN_RANGE) { 41 | creep.moveTo(damagedCreepsInRoom[0]); 42 | creep.rangedHeal(damagedCreepsInRoom[0]); 43 | } 44 | } 45 | 46 | } 47 | 48 | 49 | const roleHealer = { 50 | run, 51 | //run: run, 52 | //function2, 53 | //function3 54 | }; 55 | export default roleHealer; 56 | -------------------------------------------------------------------------------- /src/Roles/DrainTower.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | ; 8 | 9 | if(creep.hits == creep.hitsMax) { 10 | creep.memory.draining = true; 11 | } 12 | if(creep.hits+750 < creep.hitsMax) { 13 | creep.memory.draining = false; 14 | } 15 | if(creep.memory.targetRoom && creep.memory.targetRoom !== creep.room.name) { 16 | if(creep.hits + 200 > creep.hitsMax) { 17 | creep.memory.draining = true; 18 | } 19 | } 20 | 21 | creep.heal(creep); 22 | 23 | if(creep.memory.draining) { 24 | if(creep.memory.targetRoom && creep.memory.targetRoom !== creep.room.name) { 25 | return creep.moveTo(new RoomPosition(25, 25, creep.memory.targetRoom)); 26 | } 27 | else { 28 | 29 | creep.rangedMassAttack(); 30 | 31 | if(Game.time % 5 == 0) { 32 | creep.say("vennskap?⛄", true); 33 | } 34 | if(creep.pos.x > 0 && creep.pos.y > 0 && creep.pos.y < 49 && creep.pos.x < 49) { 35 | return; 36 | } 37 | else { 38 | return creep.moveTo(new RoomPosition(25, 25, creep.memory.targetRoom)); 39 | } 40 | } 41 | } 42 | 43 | else { 44 | if(creep.memory.targetRoom && creep.memory.targetRoom == creep.room.name) { 45 | return creep.moveTo(new RoomPosition(25, 25, creep.memory.homeRoom)); 46 | } 47 | else { 48 | if(creep.pos.x > 0 && creep.pos.y > 0 && creep.pos.y < 49 && creep.pos.x < 49) { 49 | return; 50 | } 51 | else { 52 | return creep.moveTo(new RoomPosition(25, 25, creep.memory.homeRoom)); 53 | } 54 | } 55 | } 56 | } 57 | 58 | 59 | const roleDrainTower = { 60 | run, 61 | //run: run, 62 | //function2, 63 | //function3 64 | }; 65 | export default roleDrainTower; 66 | 67 | -------------------------------------------------------------------------------- /src/Roles/Priest.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.suicide) { 9 | creep.recycle(); 10 | return; 11 | } 12 | 13 | if(!creep.memory.RoomToPreach || creep.memory.RoomToPreach == creep.room.name) { 14 | 15 | let rooms = Object.values(Game.map.describeExits(creep.room.name)) 16 | 17 | let filtered_rooms = rooms.filter(function(roomname) {return !creep.memory.roomsVisited.includes(roomname) && Game.map.getRoomStatus(roomname).status == "normal";}); 18 | 19 | if(filtered_rooms.length > 0 ) { 20 | creep.memory.RoomToPreach = filtered_rooms[Math.floor(Math.random()*filtered_rooms.length)]; 21 | } 22 | else if(rooms.length > 0) { 23 | creep.memory.RoomToPreach = rooms[Math.floor(Math.random()*rooms.length)]; 24 | } 25 | else { 26 | creep.memory.suicide = true; 27 | } 28 | 29 | } 30 | 31 | if(creep.room.controller && (!creep.room.controller.sign || creep.room.controller.sign.text !== "check out my YT channel - marlyman123") && 32 | creep.room.controller.pos.getOpenPositionsIgnoreCreepsCheckStructs().length > 0) { 33 | if(creep.pos.isNearTo(creep.room.controller)) { 34 | creep.signController(creep.room.controller, "check out my YT channel - marlyman123") 35 | } 36 | else { 37 | creep.MoveCostMatrixSwampPrio(creep.room.controller, 1); 38 | } 39 | } 40 | else { 41 | if(!creep.memory.roomsVisited.includes(creep.room.name)) { 42 | creep.memory.roomsVisited.push(creep.room.name); 43 | } 44 | creep.moveTo(new RoomPosition(25,25,creep.memory.RoomToPreach), {range:23, reusePath:100, swampCost:1}) 45 | } 46 | } 47 | 48 | 49 | const rolePriest = { 50 | run, 51 | //run: run, 52 | //function2, 53 | //function3 54 | }; 55 | export default rolePriest; 56 | -------------------------------------------------------------------------------- /src/Rooms/rooms.powerSpawning.ts: -------------------------------------------------------------------------------- 1 | function powerSpawning(room) { 2 | if(room.controller.level == 8) { 3 | 4 | if(Game.time % 5000 == 0 && !Game.powerCreeps["efficient-" + room.name] && room.storage && room.terminal && room.memory.Structures.powerSpawn && Game.getObjectById(room.memory.Structures.powerSpawn) && room.find(FIND_MY_SPAWNS).length) { 5 | let allow = true; 6 | for(let name in Game.powerCreeps) { 7 | let roomName = name.split("-")[1]; 8 | if(!Game.rooms[roomName] || Game.rooms[roomName] && Game.rooms[roomName].controller && Game.rooms[roomName].controller.level !== 8) { 9 | Game.powerCreeps[name].rename("efficient-" + room.name); 10 | allow = false; 11 | } 12 | } 13 | if(allow) { 14 | PowerCreep.create("efficient-" + room.name, POWER_CLASS.OPERATOR); 15 | } 16 | } 17 | 18 | 19 | 20 | if(!room.memory.Structures.powerSpawn) { 21 | let powerSpawns = room.find(FIND_MY_STRUCTURES, {filter:s => s.structureType == STRUCTURE_POWER_SPAWN}); 22 | if(powerSpawns.length == 1) { 23 | room.memory.Structures.powerSpawn = powerSpawns[0].id; 24 | } 25 | } 26 | 27 | if(room.memory.Structures.powerSpawn) { 28 | let powerSpawn:any = Game.getObjectById(room.memory.Structures.powerSpawn); 29 | if(powerSpawn) { 30 | if(Game.cpu.bucket > 6000 && powerSpawn.store[RESOURCE_POWER] >= 1 && powerSpawn.store[RESOURCE_ENERGY] >= 50) { 31 | powerSpawn.processPower(); 32 | } 33 | 34 | if(Game.powerCreeps["efficient-" + room.name] && !Game.powerCreeps["efficient-" + room.name].ticksToLive) { 35 | Game.powerCreeps["efficient-" + room.name].spawn(powerSpawn); 36 | } 37 | 38 | } 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | else { 47 | room.memory.Structures.powerSpawn = false; 48 | } 49 | } 50 | 51 | } 52 | } 53 | 54 | export default powerSpawning; 55 | // module.exports = market; 56 | -------------------------------------------------------------------------------- /src/Roles/reserve.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep:Creep) { 6 | creep.memory.moving = false; 7 | 8 | 9 | 10 | // if(creep.room.name == creep.memory.homeRoom) { 11 | // if(creep.room.controller && creep.room.controller.my && creep.room.controller.sign.text !== "we come in peace") { 12 | // if(creep.pos.isNearTo(creep.room.controller)) { 13 | // creep.signController(creep.room.controller, "we come in peace") 14 | // } 15 | // else { 16 | // creep.moveTo(creep.room.controller); 17 | // } 18 | // return; 19 | // } 20 | // } 21 | 22 | if(creep.room.name != creep.memory.targetRoom) { 23 | return creep.moveToRoom(creep.memory.targetRoom); 24 | } 25 | 26 | if(creep.room.controller) { 27 | if(creep.memory.claim) { 28 | if(creep.room.controller.level == 0) { 29 | let claimOutcome = creep.claimController(creep.room.controller); 30 | if(claimOutcome === 0) { 31 | // creep.signController(creep.room.controller, "we come in peace") 32 | creep.suicide(); 33 | return; 34 | } 35 | if(claimOutcome === -7) { 36 | creep.attackController(creep.room.controller); 37 | return; 38 | } 39 | 40 | if(claimOutcome === ERR_NOT_IN_RANGE) { 41 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 1) 42 | return; 43 | } 44 | } 45 | } 46 | if(creep.pos.isNearTo(creep.room.controller)) { 47 | // creep.signController(creep.room.controller, "we come in peace") 48 | creep.reserveController(creep.room.controller); 49 | } 50 | else { 51 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 1) 52 | } 53 | 54 | if(creep.room.controller.reservation && creep.room.controller.reservation.ticksToEnd >= 4999) { 55 | creep.suicide(); 56 | } 57 | } 58 | } 59 | 60 | const roleReserve = { 61 | run, 62 | //run: run, 63 | //function2, 64 | //function3 65 | }; 66 | export default roleReserve; 67 | -------------------------------------------------------------------------------- /src/Roles/PowerHeal.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.suicide) { 9 | creep.recycle(); 10 | return; 11 | } 12 | 13 | if(creep.room.name != creep.memory.targetRoom) { 14 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 15 | } 16 | 17 | 18 | if(!creep.memory.targets || Game.time % 30 == 0) { 19 | creep.memory.targets = []; 20 | let powerMelees = creep.room.find(FIND_MY_CREEPS, {filter: c => c.memory.role == "PowerMelee"}); 21 | if(powerMelees.length > 0) { 22 | for(let pm of powerMelees) { 23 | creep.memory.targets.push(pm.id); 24 | } 25 | } 26 | 27 | else if(Game.time % 30 == 0) { 28 | creep.memory.suicide = true; 29 | } 30 | } 31 | 32 | if(creep.memory.targets && creep.memory.targets.length > 0) { 33 | let targets = []; 34 | for(let target of creep.memory.targets) { 35 | let targetObj = Game.getObjectById(target) 36 | if(targetObj) { 37 | targets.push(targetObj); 38 | } 39 | } 40 | if(targets.length > 0) { 41 | let range1Targets = creep.pos.findInRange(targets, 1); 42 | if(range1Targets.length > 0) { 43 | range1Targets.sort((a,b) => a.hits - b.hits); 44 | if(range1Targets[0].hits < range1Targets[0].hitsMax) { 45 | creep.heal(range1Targets[0]); 46 | return; 47 | } 48 | else { 49 | creep.heal(range1Targets[0]); 50 | } 51 | } 52 | 53 | targets.sort((a,b) => a.hits - b.hits); 54 | 55 | if(creep.pos.isNearTo(targets[0])) { 56 | creep.heal(targets[0]) 57 | } 58 | else { 59 | creep.MoveCostMatrixRoadPrio(targets[0], 1); 60 | } 61 | 62 | 63 | } 64 | else { 65 | creep.memory.target = false; 66 | } 67 | } 68 | 69 | } 70 | 71 | 72 | const rolePowerHeal = { 73 | run, 74 | //run: run, 75 | //function2, 76 | //function3 77 | }; 78 | export default rolePowerHeal; 79 | -------------------------------------------------------------------------------- /src/Rooms/rooms.factory.ts: -------------------------------------------------------------------------------- 1 | function factory(room) { 2 | if(room.controller && room.controller.my && room.controller.level >= 7 && Game.time % 10 == 0 && Game.cpu.bucket > 3500) { 3 | if(!room.memory.Structures.factory) { 4 | let factories = room.find(FIND_MY_STRUCTURES, {filter: building => building.structureType == STRUCTURE_FACTORY}); 5 | if(factories.length > 0) { 6 | room.memory.Structures.factory = factories[0].id; 7 | } 8 | } 9 | 10 | 11 | 12 | if(room.memory.Structures.factory) { 13 | let factory:any = Game.getObjectById(room.memory.Structures.factory); 14 | let storage:any = Game.getObjectById(room.memory.Structures.storage); 15 | if(factory && factory.cooldown == 0 && factory.store[RESOURCE_ENERGY] >= 600 && storage.store[RESOURCE_BATTERY] === 0 && storage && storage.store[RESOURCE_ENERGY] > 250000) { 16 | factory.produce(RESOURCE_BATTERY); 17 | } 18 | else if(factory && factory.cooldown == 0 && factory.store[RESOURCE_BATTERY] >= 50 && factory.store.getFreeCapacity() >= 450 && storage && (storage.store[RESOURCE_ENERGY] <= 420000 && storage.store[RESOURCE_BATTERY] > 200 && factory.store[RESOURCE_BATTERY] >= 30000 || Memory.targetRampRoom.urgent && storage.store[RESOURCE_ENERGY] < 130000)) { 19 | factory.produce(RESOURCE_ENERGY); 20 | } 21 | // if(factory.cooldown == 0) { 22 | // let storage = Game.getObjectById(room.memory.Structures.storage) || room.findStorage(); 23 | // if(factory.store[RESOURCE_KEANIUM_BAR] < 10000 && 24 | // factory.store[RESOURCE_ENERGY] >= 200 && 25 | // factory.store[RESOURCE_KEANIUM] >= 500 && 26 | // storage && storage.store[RESOURCE_ENERGY] > 475000) { 27 | // factory.produce(RESOURCE_KEANIUM_BAR); 28 | // } 29 | // else if(factory.store[RESOURCE_KEANIUM_BAR] >= 20 && 30 | // factory.store[RESOURCE_ENERGY] >= 40 && 31 | // factory.store[RESOURCE_MIST] >= 100) { 32 | // factory.produce(RESOURCE_CONDENSATE); 33 | // } 34 | // } 35 | } 36 | 37 | 38 | 39 | } 40 | } 41 | 42 | export default factory; 43 | // module.exports = market; 44 | -------------------------------------------------------------------------------- /src/Managers/ExecuteCommandsInNTicks.ts: -------------------------------------------------------------------------------- 1 | function ExecuteCommandsInNTicks() { 2 | 3 | if(!Memory.commandsToExecute) { 4 | Memory.commandsToExecute = []; 5 | } 6 | 7 | // Memory.commandsToExecute.push({delay:40, bucketNeeded:9500, formation:"Duo", homeRoom:"E33N59", Boosted:true, targetRoom:"E29N55"}) 8 | let commands = Memory.commandsToExecute; 9 | 10 | let index = 0; 11 | for(let command of commands) { 12 | if(command.delay > 0) { 13 | command.delay --; 14 | console.log(JSON.stringify(command)) 15 | } 16 | 17 | else if(command.delay == 0) { 18 | if(command.bucketNeeded && command.bucketNeeded <= Game.cpu.bucket) { 19 | if(command.formation == "Singleton") { 20 | global.SS(command.homeRoom,command.targetRoom); 21 | } 22 | else if(command.formation == "Duo") { 23 | global.SD(command.homeRoom,command.targetRoom,command.Boosted); 24 | } 25 | else if(command.formation == "ToughDuo") { 26 | global.SDB(command.homeRoom,command.targetRoom,command.Boosted); 27 | } 28 | else if(command.formation == "RangedQuad") { 29 | global.SQR(command.homeRoom,command.targetRoom,command.Boosted) 30 | } 31 | else if(command.formation == "MeleeQuad") { 32 | global.SQM(command.homeRoom,command.targetRoom,command.Boosted) 33 | } 34 | else if(command.formation == "DismantleQuad") { 35 | global.SQD(command.homeRoom,command.targetRoom,command.Boosted) 36 | } 37 | else if(command.formation == "CCK") { 38 | global.SCCK(command.homeRoom, command.targetRoom); 39 | } 40 | else if(command.formation == "CCKparty") { 41 | global.spawn_hunting_party(command.homeRoom, command.targetRoom, command.controllerFreePositions); 42 | } 43 | commands.splice(index, 1); 44 | } 45 | else if(!command.bucketNeeded || !command.formation) { 46 | commands.splice(index, 1); 47 | } 48 | 49 | } 50 | index ++; 51 | } 52 | 53 | Memory.commandsToExecute = commands; 54 | 55 | 56 | } 57 | 58 | export default ExecuteCommandsInNTicks; 59 | -------------------------------------------------------------------------------- /src/Roles/SafeModer.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep) { 2 | creep.memory.moving = false; 3 | 4 | if(!creep.memory.targetRoom) { 5 | let controller = creep.room.controller; 6 | if(controller && controller.safeModeAvailable <= 1) { 7 | let storage = creep.room.storage; 8 | if(storage) { 9 | if(creep.store.getUsedCapacity(RESOURCE_GHODIUM) < 1000 ) { 10 | if(storage.store[RESOURCE_GHODIUM] < 1000) { 11 | creep.recycle(); 12 | return; 13 | } 14 | // withdraw from storage 15 | if(creep.pos.isNearTo(storage)) { 16 | creep.withdraw(storage, RESOURCE_GHODIUM); 17 | } 18 | else { 19 | creep.MoveCostMatrixRoadPrio(storage, 1); 20 | } 21 | } 22 | else if(creep.store.getFreeCapacity() === 0) { 23 | if(creep.pos.isNearTo(controller)) { 24 | creep.generateSafeMode(controller); 25 | } 26 | else { 27 | creep.MoveCostMatrixRoadPrio(controller, 1); 28 | } 29 | } 30 | } 31 | return; 32 | } 33 | 34 | creep.recycle(); 35 | } 36 | else { 37 | 38 | if(creep.store.getUsedCapacity(RESOURCE_GHODIUM) < 1000 && creep.room.name !== creep.memory.targetRoom) { 39 | let storage = creep.room.storage; 40 | if(storage && storage.store[RESOURCE_GHODIUM] >= 1000) { 41 | if(creep.pos.isNearTo(storage)) { 42 | creep.withdraw(storage, RESOURCE_GHODIUM); 43 | } 44 | else { 45 | creep.MoveCostMatrixRoadPrio(storage, 1); 46 | } 47 | } 48 | else { 49 | creep.recycle(); 50 | } 51 | } 52 | else if(creep.store.getUsedCapacity(RESOURCE_GHODIUM) < 1000 && creep.room.name === creep.memory.targetRoom) { 53 | creep.recycle(); 54 | } 55 | else if(creep.store.getFreeCapacity() === 0) { 56 | if(creep.room.name !== creep.memory.targetRoom) { 57 | creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 58 | return; 59 | } 60 | 61 | let controller = creep.room.controller; 62 | if(controller) { 63 | if(creep.pos.isNearTo(controller)) { 64 | creep.generateSafeMode(controller); 65 | } 66 | else { 67 | creep.MoveCostMatrixRoadPrio(controller, 1); 68 | } 69 | } 70 | } 71 | } 72 | } 73 | 74 | 75 | const roleSafeModer = { 76 | run, 77 | }; 78 | export default roleSafeModer; 79 | -------------------------------------------------------------------------------- /src/Roles/mineralMiner.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | ; 7 | creep.memory.moving = false; 8 | 9 | 10 | 11 | if(!creep.memory.deposit) { 12 | let found_deposit = creep.room.find(FIND_MINERALS); 13 | creep.memory.deposit = found_deposit[0]; 14 | } 15 | 16 | let deposit:any = Game.getObjectById(creep.memory.deposit.id); 17 | if(deposit.mineralAmount == 0) { 18 | creep.memory.suicide = true; 19 | } 20 | 21 | 22 | if(!creep.memory.mining && creep.store[deposit.mineralType] == 0) { 23 | creep.memory.mining = true; 24 | } 25 | else if(creep.memory.mining && creep.store.getFreeCapacity() == 0) { 26 | creep.memory.mining = false; 27 | } 28 | 29 | if(creep.memory.mining) { 30 | if(creep.pos.isNearTo(deposit)) { 31 | creep.harvest(deposit); 32 | } 33 | else { 34 | creep.MoveCostMatrixRoadPrio(deposit, 1); 35 | } 36 | } 37 | else { 38 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 39 | 40 | if(storage && storage.store[deposit.mineralType] < 19500) { 41 | if(creep.pos.isNearTo(storage)) { 42 | creep.transfer(storage, deposit.mineralType); 43 | } 44 | else { 45 | creep.MoveCostMatrixRoadPrio(storage, 1); 46 | } 47 | return; 48 | } 49 | 50 | 51 | let terminal = creep.room.terminal; 52 | 53 | if(terminal && terminal.store[deposit.mineralType] < 5000) { 54 | if(creep.pos.isNearTo(terminal)) { 55 | creep.transfer(terminal, deposit.mineralType); 56 | } 57 | else { 58 | creep.MoveCostMatrixRoadPrio(terminal, 1); 59 | } 60 | return; 61 | } 62 | 63 | 64 | if(storage) { 65 | if(creep.pos.isNearTo(storage)) { 66 | creep.transfer(storage, deposit.mineralType); 67 | } 68 | else { 69 | creep.MoveCostMatrixRoadPrio(storage, 1); 70 | } 71 | return; 72 | } 73 | } 74 | 75 | if(creep.ticksToLive <= 60 && creep.memory.mining) { 76 | creep.memory.suicide = true; 77 | } 78 | if(creep.memory.suicide == true) { 79 | creep.recycle(); 80 | return; 81 | } 82 | 83 | } 84 | 85 | const roleMineralMiner = { 86 | run, 87 | //run: run, 88 | //function2, 89 | //function3 90 | }; 91 | export default roleMineralMiner; 92 | -------------------------------------------------------------------------------- /src/Functions/roomPositionFunctions.ts: -------------------------------------------------------------------------------- 1 | interface RoomPosition { 2 | getNearbyPositions:() => Array; 3 | getOpenPositions:() => Array; 4 | getOpenPositionsIgnoreCreeps:() => Array; 5 | getOpenPositionsIgnoreCreepsCheckStructs:() => Array; 6 | } 7 | 8 | RoomPosition.prototype.getNearbyPositions = function getNearbyPositions() { 9 | let positions = []; 10 | 11 | let startX = this.x - 1 || 1; 12 | let startY = this.y - 1 || 1; 13 | 14 | for(let x = startX; x <= this.x + 1 && x < 49; x++) { 15 | 16 | for(let y = startY; y <= this.y + 1 && y < 49; y++) { 17 | 18 | if (x !== this.x || y !== this.y) { 19 | positions.push(new RoomPosition(x, y, this.roomName)); 20 | } 21 | } 22 | } 23 | return positions; 24 | } 25 | 26 | 27 | RoomPosition.prototype.getOpenPositions = function getOpenPositions() { 28 | let nearbyPositions = this.getNearbyPositions(); 29 | 30 | let terrain = Game.map.getRoomTerrain(this.roomName); 31 | let walkablePositions = _.filter(nearbyPositions, function(pos:any) { 32 | return terrain.get(pos.x, pos.y) !== TERRAIN_MASK_WALL;}); 33 | 34 | let freePositions = _.filter(walkablePositions, function(pos) { 35 | return !pos.lookFor(LOOK_CREEPS).length;}); 36 | 37 | return freePositions; 38 | } 39 | 40 | RoomPosition.prototype.getOpenPositionsIgnoreCreeps = function getOpenPositionsIgnoreCreeps() { 41 | let nearbyPositions = this.getNearbyPositions(); 42 | 43 | let terrain = Game.map.getRoomTerrain(this.roomName); 44 | let walkablePositions = _.filter(nearbyPositions, function(pos:any) { 45 | return terrain.get(pos.x, pos.y) !== TERRAIN_MASK_WALL;}); 46 | 47 | return walkablePositions; 48 | } 49 | 50 | RoomPosition.prototype.getOpenPositionsIgnoreCreepsCheckStructs = function getOpenPositionsIgnoreCreepsCheckStructs() { 51 | let nearbyPositions = this.getNearbyPositions(); 52 | 53 | let terrain = Game.map.getRoomTerrain(this.roomName); 54 | let walkablePositions = _.filter(nearbyPositions, function(pos:any) { 55 | return terrain.get(pos.x, pos.y) !== TERRAIN_MASK_WALL && pos.x >= 1 && pos.x <= 48 && pos.y >= 1 && pos.y <= 48;}); 56 | 57 | let freePositions = _.filter(walkablePositions, function(pos) { 58 | let lookStructures = pos.lookFor(LOOK_STRUCTURES) 59 | return lookStructures.length == 0 || lookStructures.length == 1 && (lookStructures[0].structureType == STRUCTURE_ROAD || lookStructures[0].structureType == STRUCTURE_CONTAINER);}); 60 | 61 | return freePositions; 62 | } 63 | -------------------------------------------------------------------------------- /src/Roles/claimer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | import { getBody } from "Rooms/rooms.spawning"; 7 | 8 | const run = function (creep) { 9 | creep.memory.moving = false; 10 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 11 | let result = creep.Boost(); 12 | if(!result) { 13 | return; 14 | } 15 | } 16 | creep.heal(creep); 17 | 18 | if(creep.room.name != creep.memory.targetRoom && !creep.memory.line) { 19 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 20 | } 21 | else if(creep.room.name != creep.memory.targetRoom && creep.memory.line) { 22 | return; 23 | } 24 | 25 | if(creep.ticksToLive == 1 && creep.room.name == creep.memory.targetRoom && !creep.room.controller.upgradeBlocked && !creep.room.controller.reservation) { 26 | let newName = 'DismantleControllerWalls-' + creep.memory.homeRoom + "-" + creep.memory.targetRoom; 27 | Game.rooms[creep.memory.homeRoom].memory.spawn_list.push(getBody([MOVE,WORK], Game.rooms[creep.memory.homeRoom], 50), newName, {memory: {role: 'DismantleControllerWalls', homeRoom: creep.memory.homeRoom, targetRoom:creep.memory.targetRoom}}); 28 | console.log('Adding DismantleControllerWalls to Spawn List: ' + newName); 29 | } 30 | 31 | let controller = creep.room.controller; 32 | 33 | if(controller && controller.level == 0 && !controller.reservation) { 34 | 35 | if(creep.claimController(controller) == 0) { 36 | creep.suicide(); 37 | return; 38 | } 39 | if(creep.claimController(controller) == ERR_NOT_IN_RANGE) { 40 | creep.moveTo(controller); 41 | } 42 | 43 | } 44 | 45 | else if(controller && !controller.my && controller.level > 0 && !controller.reservation) { 46 | if(creep.pos.isNearTo(controller)) { 47 | let result = creep.attackController(controller); 48 | if(result == 0) { 49 | creep.suicide(); 50 | } 51 | } 52 | else { 53 | creep.moveTo(controller); 54 | } 55 | } 56 | 57 | else if(controller && controller.level == 0 && controller.reservation && controller.reservation.ticksToEnd > 0) { 58 | if(creep.pos.isNearTo(controller)) { 59 | creep.attackController(controller); 60 | } 61 | else { 62 | creep.moveTo(controller); 63 | } 64 | } 65 | 66 | } 67 | 68 | 69 | const roleClaimer = { 70 | run, 71 | //run: run, 72 | //function2, 73 | //function3 74 | }; 75 | export default roleClaimer; 76 | -------------------------------------------------------------------------------- /src/Roles/scout.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | if(creep.room.name !== creep.memory.targetRoom) { 8 | // if(creep.memory.route = -2) creep.suicide() 9 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 10 | } 11 | 12 | if(!Memory.rooms[creep.memory.homeRoom].resources[creep.room.name].energy) { 13 | Memory.rooms[creep.memory.homeRoom].resources[creep.room.name].energy = {}; 14 | } 15 | 16 | let sources = creep.room.find(FIND_SOURCES); 17 | 18 | // Function to check if a source is reachable 19 | const isSourceReachable = (source) => { 20 | const ret = PathFinder.search( 21 | creep.pos, 22 | { pos: source.pos, range: 1 }, 23 | { 24 | roomCallback: (roomName) => { 25 | let room = Game.rooms[roomName]; 26 | if (!room) return false; 27 | let costs = new PathFinder.CostMatrix; 28 | 29 | room.find(FIND_STRUCTURES).forEach(function(structure) { 30 | costs.set(structure.pos.x, structure.pos.y, 255); 31 | }); 32 | 33 | return costs; 34 | } 35 | } 36 | ); 37 | 38 | return !ret.incomplete && ret.path.length > 0; 39 | }; 40 | 41 | // Check if all sources are reachable 42 | let allSourcesReachable = sources.every(isSourceReachable); 43 | 44 | if(sources.length <= 2 && allSourcesReachable && creep.room.controller && creep.room.controller.level == 0 && !creep.room.controller.reservation) { 45 | for(let source of sources) { 46 | Memory.rooms[creep.memory.homeRoom].resources[creep.room.name].energy[source.id] = {}; 47 | Memory.rooms[creep.memory.homeRoom].resources[creep.room.name].active = true; 48 | } 49 | } 50 | else { 51 | if(creep.room.controller?.level<3 && !creep.room.controller.my && !creep.room.controller.safeMode) { 52 | let newName = 'Annoyer-' + Math.floor(Math.random() * Game.time) + "-" + creep.memory.homeRoom; 53 | Memory.rooms[creep.memory.homeRoom].spawn_list.push([ATTACK, MOVE], newName, {memory: {role: 'annoy', homeRoom:creep.memory.homeRoom, targetRoom:creep.room.name}}); 54 | } 55 | else { 56 | Memory.rooms[creep.memory.homeRoom].resources[creep.room.name].energy = {}; 57 | } 58 | } 59 | 60 | creep.suicide(); 61 | } 62 | 63 | const roleScout = { 64 | run, 65 | //run: run, 66 | //function2, 67 | //function3 68 | }; 69 | export default roleScout; 70 | -------------------------------------------------------------------------------- /src/Roles/Convoy.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 9 | creep.memory.full = true; 10 | } 11 | if(creep.memory.full && creep.store.getUsedCapacity() == 0) { 12 | creep.memory.full = false; 13 | } 14 | 15 | if(!creep.memory.full && creep.ticksToLive > 1480 && creep.room.memory.Structures && creep.room.memory.Structures.storage) { 16 | let storage = Game.getObjectById(creep.room.memory.Structures.storage); 17 | if(storage) { 18 | if(creep.pos.isNearTo(storage)) { 19 | if(creep.withdraw(storage, RESOURCE_ENERGY) == 0) { 20 | creep.memory.full = true; 21 | } 22 | } 23 | else { 24 | creep.MoveCostMatrixSwampPrio(storage, 1); 25 | } 26 | } 27 | return; 28 | } 29 | 30 | if(creep.memory.full && creep.room.name !== creep.memory.targetRoom) { 31 | if(creep.hits < creep.hitsMax / 1.5) { 32 | Memory.delayConvoy[creep.memory.homeRoom] = 8000; 33 | } 34 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 35 | } 36 | 37 | if(creep.room.name == creep.memory.targetRoom && (creep.room.memory.Structures && creep.room.memory.Structures.storage || creep.room.storage)) { 38 | let storage:any = Game.getObjectById(creep.room.memory.Structures.storage) || creep.room.storage; 39 | if(creep.memory.full && storage && storage.store.getFreeCapacity() > 100 && creep.store.getUsedCapacity() > 0) { 40 | if(creep.pos.isNearTo(storage)) { 41 | if(creep.transfer(storage, RESOURCE_ENERGY) === 0) { 42 | creep.memory.homeRoom = creep.memory.targetRoom; 43 | } 44 | } 45 | else { 46 | creep.MoveCostMatrixRoadPrio(storage, 1); 47 | } 48 | } 49 | else { 50 | creep.recycle(); 51 | } 52 | } 53 | else if(!creep.room.memory.Structures || !creep.room.memory.Structures.storage) { 54 | let spawn = creep.pos.findClosestByRange(FIND_MY_SPAWNS); 55 | if(spawn) { 56 | if(creep.pos.isNearTo(spawn)) { 57 | spawn.recycle(creep); 58 | } 59 | else { 60 | creep.MoveCostMatrixRoadPrio(spawn, 1); 61 | } 62 | } 63 | else { 64 | creep.suicide(); 65 | } 66 | } 67 | } 68 | 69 | 70 | const roleConvoy = { 71 | run, 72 | //run: run, 73 | //function2, 74 | //function3 75 | }; 76 | export default roleConvoy; 77 | -------------------------------------------------------------------------------- /src/Rooms/rooms.supportOtherRooms.ts: -------------------------------------------------------------------------------- 1 | function supportOtherRooms(room) { 2 | if(!Memory.delayConvoy) Memory.delayConvoy = {}; 3 | if(Memory.delayConvoy && Memory.delayConvoy[room.name] && Memory.delayConvoy[room.name] > 0) { 4 | Memory.delayConvoy[room.name] --; 5 | if(Memory.delayConvoy[room.name] > 5000) return; 6 | } 7 | 8 | let storage:any; 9 | if(room.memory.Structures) { 10 | if(room.memory.Structures.storage) { 11 | storage = Game.getObjectById(room.memory.Structures.storage); 12 | } 13 | } 14 | if( 15 | room.memory.data && 16 | room.memory.data.DOB && 17 | room.memory.data.DOB % 715 == 0 && 18 | Memory.target_colonise && 19 | Game.rooms[Memory.target_colonise.room] && 20 | Game.rooms[Memory.target_colonise.room].controller && 21 | Game.rooms[Memory.target_colonise.room].controller.my && 22 | 23 | storage && storage.store[RESOURCE_ENERGY] >= 310000 24 | 25 | && 26 | ( 27 | Game.rooms[Memory.target_colonise.room].memory.Structures.spawn && Game.getObjectById(Game.rooms[Memory.target_colonise.room].memory.Structures.spawn) && (Game.rooms[Memory.target_colonise.room].controller.level <= 6 && !Game.rooms[Memory.target_colonise.room].terminal && Game.rooms[Memory.target_colonise.room].controller.level >= 3 && (Game.cpu.bucket > 8000 || Game.cpu.bucket > 4000 && Game.rooms[Memory.target_colonise.room].storage && Game.rooms[Memory.target_colonise.room].storage.store[RESOURCE_ENERGY] <= 100000) || 28 | Game.rooms[Memory.target_colonise.room].controller.level == 2 && 29 | Game.rooms[Memory.target_colonise.room].memory.Structures && 30 | Game.rooms[Memory.target_colonise.room].memory.Structures.bin && 31 | Game.getObjectById(Game.rooms[Memory.target_colonise.room].memory.Structures.bin) && Game.cpu.bucket > 9000) 32 | ) 33 | && 34 | 35 | 36 | Game.rooms[Memory.target_colonise.room].controller.level <= 5 && 37 | room.controller.level == 8 && 38 | Game.map.getRoomLinearDistance(room.name, Memory.target_colonise.room) <= 6) { 39 | if(Game.rooms[Memory.target_colonise.room].controller.level < 4) { 40 | global.spawnConvoy(room.name, Memory.target_colonise.room); 41 | } 42 | else if(Game.rooms[Memory.target_colonise.room].controller.level >= 4) { 43 | global.spawnConvoy(room.name, Memory.target_colonise.room); 44 | } 45 | if(Game.rooms[Memory.target_colonise.room].controller.level <= 7 && Game.rooms[Memory.target_colonise.room].controller.safeModeAvailable === 0 && storage && storage.store[RESOURCE_GHODIUM] >= 1000) { 46 | global.spawnSafeModer(room.name, Memory.target_colonise.room); 47 | } 48 | } 49 | } 50 | 51 | 52 | 53 | export default supportOtherRooms; 54 | -------------------------------------------------------------------------------- /src/Roles/FakeFiller.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | function findLocked(creep) { 7 | 8 | if(creep.room.energyAvailable == creep.room.energyCapacityAvailable && creep.room.memory.Structures) { 9 | creep.memory.locked = creep.room.memory.Structures.storage; 10 | return; 11 | } 12 | else { 13 | let possibleDropOffLocations = []; 14 | 15 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 16 | if(storage && storage.store.getFreeCapacity() !== 0) { 17 | possibleDropOffLocations.push(storage); 18 | } 19 | 20 | let spawnAndExtensions = creep.room.find(FIND_MY_STRUCTURES, {filter: building => (building.structureType == STRUCTURE_SPAWN || building.structureType == STRUCTURE_EXTENSION) && building.store.getFreeCapacity(RESOURCE_ENERGY) !== 0}); 21 | if(spawnAndExtensions.length > 0) { 22 | possibleDropOffLocations.push(creep.pos.findClosestByRange(spawnAndExtensions)); 23 | } 24 | 25 | if(possibleDropOffLocations.length > 0) { 26 | let lock = creep.pos.findClosestByRange(possibleDropOffLocations); 27 | if(lock) { 28 | creep.memory.locked = lock.id; 29 | return lock 30 | } 31 | } 32 | } 33 | 34 | } 35 | 36 | 37 | 38 | const run = function (creep) { 39 | 40 | if(creep.memory.full && creep.store[RESOURCE_ENERGY] == 0) { 41 | creep.memory.full = false; 42 | creep.memory.role = "carry" 43 | creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 44 | return; 45 | } 46 | 47 | 48 | 49 | let lock:any = Game.getObjectById(creep.memory.locked) || findLocked(creep); 50 | if(lock) { 51 | if(lock.store.getFreeCapacity(RESOURCE_ENERGY) == 0) { 52 | lock = findLocked(creep); 53 | } 54 | 55 | if(lock) { 56 | if(creep.pos.isNearTo(lock)) { 57 | creep.transfer(lock, RESOURCE_ENERGY) 58 | 59 | } 60 | else { 61 | creep.MoveCostMatrixRoadPrio(lock, 1); 62 | } 63 | } 64 | 65 | } 66 | else { 67 | if(creep.room.memory.Structures && creep.room.memory.Structures.storage) { 68 | let storage:any = Game.getObjectById(creep.room.memory.Structures.storage); 69 | if(storage && storage.store.getFreeCapacity() == 0) { 70 | if(creep.pos.isNearTo(storage)) { 71 | creep.drop(RESOURCE_ENERGY); 72 | } 73 | else { 74 | creep.MoveCostMatrixRoadPrio(storage, 1) 75 | } 76 | } 77 | } 78 | } 79 | 80 | 81 | 82 | 83 | } 84 | 85 | const roleFakeFiller = { 86 | run, 87 | //run: run, 88 | //function2, 89 | //function3 90 | }; 91 | export default roleFakeFiller; 92 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "pacifist-bot", 3 | "version": "3.0.0", 4 | "description": "", 5 | "main": "index.js", 6 | "//": "If you add or change the names of destinations in screeps.json, make sure you update these scripts to reflect the changes", 7 | "scripts": { 8 | "lint": "eslint \"src/**/*.ts\"", 9 | "build": "rollup -c", 10 | "push-main": "rollup -c --environment DEST:main", 11 | "push-pserver": "rollup -c --environment DEST:pserver", 12 | "push-season": "rollup -c --environment DEST:season", 13 | "push-sim": "rollup -c --environment DEST:sim", 14 | "push-gohorse": "rollup -c --environment DEST:gohorse", 15 | "push-screepsplus": "rollup -c --environment DEST:screepsplus", 16 | "push-myserver": "rollup -c --environment DEST:myserver", 17 | "push-swc": "rollup -c --environment DEST:swc", 18 | "test": "npm run test-unit", 19 | "test-unit": "mocha test/unit/**/*.ts", 20 | "test-integration": "echo 'See docs/in-depth/testing.md for instructions on enabling integration tests'", 21 | "watch-main": "rollup -cw --environment DEST:main", 22 | "watch-pserver": "rollup -cw --environment DEST:pserver", 23 | "watch-season": "rollup -cw --environment DEST:season", 24 | "watch-sim": "rollup -cw --environment DEST:sim" 25 | }, 26 | "repository": { 27 | "type": "git", 28 | "url": "git+https://github.com/screepers/screeps-typescript-starter.git" 29 | }, 30 | "author": "", 31 | "license": "Unlicense", 32 | "bugs": { 33 | "url": "https://github.com/screepers/screeps-typescript-starter/issues" 34 | }, 35 | "homepage": "https://github.com/screepers/screeps-typescript-starter#readme", 36 | "engines": { 37 | "node": "10.x || 12.x" 38 | }, 39 | "devDependencies": { 40 | "@rollup/plugin-commonjs": "^20.0.0", 41 | "@rollup/plugin-node-resolve": "^13.0.4", 42 | "@types/chai": "^4.1.6", 43 | "@types/lodash": "3.10.2", 44 | "@types/mocha": "^5.2.5", 45 | "@types/node": "^13.13.1", 46 | "@types/screeps": "^3.2.3", 47 | "@types/sinon": "^5.0.5", 48 | "@types/sinon-chai": "^3.2.0", 49 | "@typescript-eslint/eslint-plugin": "^4.29.1", 50 | "@typescript-eslint/parser": "^4.29.1", 51 | "@typescript-eslint/typescript-estree": "^4.29.1", 52 | "chai": "^4.2.0", 53 | "eslint": "^7.32.0", 54 | "eslint-config-prettier": "^8.3.0", 55 | "eslint-import-resolver-typescript": "^2.4.0", 56 | "eslint-plugin-import": "^2.24.0", 57 | "eslint-plugin-prettier": "^3.4.0", 58 | "lodash": "^3.10.1", 59 | "mocha": "^5.2.0", 60 | "prettier": "^2.3.2", 61 | "rollup": "^2.56.2", 62 | "rollup-plugin-clear": "^2.0.7", 63 | "rollup-plugin-screeps": "^1.0.1", 64 | "rollup-plugin-typescript2": "^0.31.0", 65 | "sinon": "^6.3.5", 66 | "sinon-chai": "^3.2.0", 67 | "ts-node": "^10.2.0", 68 | "tsconfig-paths": "^3.10.1", 69 | "typescript": "^4.3.5" 70 | }, 71 | "dependencies": { 72 | "source-map": "~0.6.1" 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /src/utils/TerrainDataExporter.ts: -------------------------------------------------------------------------------- 1 | // terrainDataExporter.js 2 | 3 | const TerrainDataExporter = () => { 4 | // Check if terrain data has been initialized 5 | if (!Memory.terrainDataInitialized) { 6 | // If lastProcessedCoord is undefined, set it to start the iteration 7 | if (!Memory.lastProcessedCoord) { 8 | Memory.lastProcessedCoord = { x: 0, y: 0 }; 9 | } 10 | 11 | // Define how many rooms to process in each iteration 12 | const roomsPerIteration = 100; 13 | 14 | // Get the world size 15 | const worldSize = Game.map.getWorldSize(); 16 | 17 | // Define the maximum coordinates to iterate 18 | const maxX = Math.floor(worldSize / 2); 19 | const maxY = Math.floor(worldSize / 2); 20 | 21 | // Initialize roomStatuses array in Memory if not exists 22 | Memory.roomStatuses = Memory.roomStatuses || []; 23 | 24 | // Iterate through rooms based on the last processed coordinate 25 | for (let i = 0; i < roomsPerIteration; i++) { 26 | const x = Memory.lastProcessedCoord.x; 27 | const y = Memory.lastProcessedCoord.y; 28 | 29 | for (let horizontalDirection of ['E', 'W']) { 30 | for (let verticalDirection of ['N', 'S']) { 31 | const roomName = `${horizontalDirection}${x}${verticalDirection}${y}`; 32 | 33 | const roomStatus = Game.map.getRoomStatus(roomName); 34 | 35 | // Update existing or add new room status in Memory 36 | const existingStatus = Memory.roomStatuses.find(status => status.roomName === roomName); 37 | 38 | if (existingStatus) { 39 | // Merge new status with existing status 40 | existingStatus.status = roomStatus.status; 41 | } else { 42 | // Add new room status to the array 43 | Memory.roomStatuses.push({ 44 | roomName: roomName, 45 | status: roomStatus.status, 46 | }); 47 | } 48 | 49 | // Log room status for debugging 50 | console.log(`Room: ${roomName}, Status: ${roomStatus.status}`); 51 | } 52 | } 53 | 54 | // Update the last processed coordinate 55 | Memory.lastProcessedCoord.x++; 56 | 57 | // If x exceeds maxX, reset x, increment y 58 | if (Memory.lastProcessedCoord.x > maxX) { 59 | Memory.lastProcessedCoord.x = 0; 60 | Memory.lastProcessedCoord.y++; 61 | } 62 | 63 | // If y exceeds maxY, set a flag indicating that terrain data has been initialized 64 | if (Memory.lastProcessedCoord.y > maxY) { 65 | Memory.terrainDataInitialized = true; 66 | break; 67 | } 68 | } 69 | 70 | // Console log the progress 71 | console.log(`Processed ${Memory.lastProcessedCoord.x * (maxY + 1) + Memory.lastProcessedCoord.y + 1} rooms.`); 72 | } 73 | }; 74 | 75 | export default TerrainDataExporter; 76 | -------------------------------------------------------------------------------- /src/Roles/SpecialCarry.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | creep.memory.moving = false; 8 | 9 | 10 | if(creep.evacuate()) { 11 | return; 12 | } 13 | 14 | if(creep.memory.suicide) { 15 | creep.recycle(); 16 | return; 17 | } 18 | 19 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 20 | creep.memory.full = true; 21 | } 22 | if(creep.memory.full && creep.store[RESOURCE_ENERGY] == 0) { 23 | creep.memory.full = false; 24 | } 25 | 26 | 27 | if(creep.ticksToLive <= 22 && !creep.memory.full || creep.memory.full && creep.ticksToLive <= 12) { 28 | creep.memory.suicide = true; 29 | } 30 | 31 | 32 | let storage:any = Game.getObjectById(creep.room.memory.Structures.storage); 33 | 34 | 35 | 36 | if(!creep.memory.full) { 37 | if(storage) { 38 | 39 | if(creep.pos.isNearTo(storage)) { 40 | if(creep.withdraw(storage, RESOURCE_ENERGY) === 0) 41 | creep.memory.full = true; 42 | } 43 | else { 44 | creep.moveToSafePositionToRepairRampart(storage, 1); 45 | } 46 | 47 | } 48 | } 49 | 50 | if (creep.memory.full) { 51 | if (!creep.memory.creep_target) { 52 | let SpecialRepairers = creep.room.find(FIND_MY_CREEPS, { 53 | filter: c => { 54 | return c.memory.role == "SpecialRepair"; 55 | } 56 | }); 57 | if (SpecialRepairers.length > 0) { 58 | SpecialRepairers.sort((a, b) => b.ticksToLive - a.ticksToLive); 59 | creep.memory.creep_target = SpecialRepairers[0].id; 60 | } 61 | } 62 | 63 | if (creep.memory.creep_target) { 64 | let target: any = Game.getObjectById(creep.memory.creep_target); 65 | if (!target) { 66 | creep.memory.creep_target = false; 67 | return; 68 | } 69 | 70 | if (!creep.pos.isNearTo(target)) { 71 | creep.moveToSafePositionToRepairRampart(target, 1); 72 | } 73 | 74 | // let container:any = Game.getObjectById(creep.memory.container_target); 75 | 76 | if (target && creep.pos.isNearTo(target) && target.store[RESOURCE_ENERGY] < 72 && !target.room.find(FIND_DROPPED_RESOURCES, {filter: r => r.resourceType == RESOURCE_ENERGY && r.amount > 250 && target.pos.getRangeTo(r) <= 1}).length) { 77 | if ( 78 | creep.transfer(target, RESOURCE_ENERGY) == 0 && 79 | storage && 80 | creep.store[RESOURCE_ENERGY] <= (creep.pos.getRangeTo(storage) + 2) * 35 * 2 81 | ) { 82 | creep.drop(RESOURCE_ENERGY, creep.store[RESOURCE_ENERGY] - target.store.getFreeCapacity()); 83 | } 84 | } 85 | } 86 | } 87 | } 88 | 89 | const roleSpecialCarry = { 90 | run, 91 | //run: run, 92 | //function2, 93 | //function3 94 | }; 95 | export default roleSpecialCarry; 96 | -------------------------------------------------------------------------------- /src/Roles/WallClearer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | ; 7 | if(creep.memory.suicide) { 8 | creep.recycle(); 9 | return; 10 | } 11 | 12 | let controller = creep.room.controller; 13 | let openControllerPositions; 14 | if(controller) { 15 | openControllerPositions = controller.pos.getOpenPositionsIgnoreCreepsCheckStructs(); 16 | } 17 | 18 | let buildings = creep.room.find(FIND_STRUCTURES, {filter: s => s.structureType !== STRUCTURE_ROAD && s.structureType !== STRUCTURE_CONTAINER && s.structureType !== STRUCTURE_CONTROLLER && s.pos.x >= 1 && s.pos.x <= 48 && s.pos.y >= 1 && s.pos.y <= 48}); 19 | 20 | if(controller && controller.my && controller.level == 1 && controller.ticksToDowngrade > 19900) { 21 | if(buildings.length > 0) { 22 | for(let building of buildings) { 23 | building.destroy(); 24 | } 25 | } 26 | else if(buildings.length == 0) { 27 | controller.unclaim(); 28 | if(creep.room.name == creep.memory.targetRoom) { 29 | if(creep.ticksToLive <= 100) { 30 | creep.suicide(); 31 | } 32 | else { 33 | creep.memory.suicide = true; 34 | } 35 | } 36 | } 37 | 38 | } 39 | 40 | 41 | if(creep.room.name !== creep.memory.homeRoom && controller && controller.level == 0 && !controller.reservation && buildings.length > 0 && openControllerPositions.length > 0) { 42 | if(creep.pos.isNearTo(controller)) { 43 | creep.claimController(controller); 44 | creep.signController(creep.room.controller, "check out my YT channel - marlyman123") 45 | } 46 | else { 47 | creep.MoveCostMatrixRoadPrio(controller, 1) 48 | } 49 | return; 50 | } 51 | 52 | 53 | 54 | 55 | let route:any = Game.map.findRoute(creep.room.name, creep.memory.targetRoom, { 56 | routeCallback(roomName, fromRoomName) { 57 | if(Game.map.getRoomStatus(roomName).status !== "normal") { 58 | return Infinity; 59 | } 60 | if(_.includes(Memory.AvoidRooms, roomName, 0) && roomName !== creep.memory.targetRoom) { 61 | return 25; 62 | } 63 | 64 | 65 | 66 | if(roomName.length == 6) { 67 | if(parseInt(roomName[1] + roomName[2]) % 10 == 0) { 68 | return 4; 69 | } 70 | if(parseInt(roomName[4] + roomName[5]) % 10 == 0) { 71 | return 4; 72 | } 73 | } 74 | 75 | return 5; 76 | }}); 77 | 78 | if(route == 2) { 79 | creep.suicide(); 80 | } 81 | if(route != 2 && route.length > 0) { 82 | const exit = creep.pos.findClosestByRange(route[0].exit); 83 | creep.MoveCostMatrixRoadPrioAvoidEnemyCreepsMuch(exit, 0); 84 | return; 85 | } 86 | } 87 | 88 | 89 | const roleWallClearer = { 90 | run, 91 | //run: run, 92 | //function2, 93 | //function3 94 | }; 95 | export default roleWallClearer; 96 | -------------------------------------------------------------------------------- /src/Roles/ContinuousControllerKiller.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 9 | let result = creep.Boost(); 10 | if(!result) { 11 | return; 12 | } 13 | } 14 | 15 | if(creep.hits !== creep.hitsMax || creep.room.name === creep.memory.targetRoom) creep.heal(); 16 | 17 | if (creep.room.name !== creep.memory.targetRoom) { 18 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 19 | } 20 | 21 | if (!creep.memory.ticksToGetHere && creep.room.name == creep.memory.targetRoom) { 22 | creep.memory.ticksToGetHere = 600 - creep.ticksToLive; 23 | } 24 | 25 | if(creep.room.controller) { 26 | let controller = creep.room.controller; 27 | if(!creep.pos.isNearTo(controller)) { 28 | creep.MoveCostMatrixRoadPrio(controller, 1); 29 | let structuresInRangeOne = creep.pos.findInRange(FIND_STRUCTURES, 1); 30 | if(structuresInRangeOne.length > 0) { 31 | structuresInRangeOne.sort((a,b) => a.hits - b.hits); 32 | creep.attack(structuresInRangeOne[0]); 33 | } 34 | 35 | } 36 | else { 37 | if(!controller.upgradeBlocked && !controller.my && controller.level > 0) { 38 | let myControllerKillers = _.filter(Game.creeps, (c) => c.memory.role == "CCK" && c.memory.targetRoom == creep.room.name && Math.abs(c.ticksToLive - creep.ticksToLive) < 200); 39 | if(myControllerKillers.length > 1 && creep.ticksToLive > 1 && !creep.room.find(FIND_HOSTILE_CREEPS, { 40 | filter: c => (c.getActiveBodyparts(ATTACK) > 0 || c.getActiveBodyparts(RANGED_ATTACK) > 0) && c.pos.getRangeTo(c) <= 3 41 | }).length) { 42 | // wait 43 | } 44 | else { 45 | if(creep.attackController(controller) === 0) { 46 | creep.signController(controller, "too close to pacifist bot room, claim elsewhere."); 47 | 48 | Memory.commandsToExecute.push({ delay: 1015-(creep.memory.ticksToGetHere+creep.body.length*3 + 50), bucketNeeded: 3000, formation: "CCK", homeRoom: creep.memory.homeRoom, targetRoom: creep.memory.targetRoom }) 49 | 50 | 51 | creep.suicide(); 52 | return; 53 | } 54 | } 55 | 56 | } 57 | } 58 | 59 | if(creep.ticksToLive === 1 && creep.room.controller && !creep.room.controller.safeMode) { 60 | const index = Game.rooms[creep.memory.homeRoom].memory.observe.RoomsToSee.indexOf(creep.memory.targetRoom); 61 | if (index === 0) { 62 | Game.rooms[creep.memory.homeRoom].memory.observe.lastObserved = Game.rooms[creep.memory.homeRoom].memory.observe.RoomsToSee.length - 1 63 | } 64 | else { 65 | Game.rooms[creep.memory.homeRoom].memory.observe.lastObserved = index - 1; 66 | } 67 | } 68 | } 69 | 70 | 71 | } 72 | 73 | 74 | const roleContinuousControllerKiller = { 75 | run, 76 | //run: run, 77 | //function2, 78 | //function3 79 | }; 80 | export default roleContinuousControllerKiller; 81 | -------------------------------------------------------------------------------- /src/utils/ErrorMapper.ts: -------------------------------------------------------------------------------- 1 | import { SourceMapConsumer } from "source-map"; 2 | import ErrorExporter from "./ErrorExporter"; 3 | export class ErrorMapper { 4 | // Cache consumer 5 | private static _consumer?: SourceMapConsumer; 6 | 7 | public static get consumer(): SourceMapConsumer { 8 | if (this._consumer == null) { 9 | this._consumer = new SourceMapConsumer(require("main.js.map")); 10 | } 11 | 12 | return this._consumer; 13 | } 14 | 15 | // Cache previously mapped traces to improve performance 16 | public static cache: { [key: string]: string } = {}; 17 | 18 | /** 19 | * Generates a stack trace using a source map generate original symbol names. 20 | * 21 | * WARNING - EXTREMELY high CPU cost for first call after reset - >30 CPU! Use sparingly! 22 | * (Consecutive calls after a reset are more reasonable, ~0.1 CPU/ea) 23 | * 24 | * @param {Error | string} error The error or original stack trace 25 | * @returns {string} The source-mapped stack trace 26 | */ 27 | public static sourceMappedStackTrace(error: Error | string): string { 28 | const stack: string = error instanceof Error ? (error.stack as string) : error; 29 | if (Object.prototype.hasOwnProperty.call(this.cache, stack)) { 30 | return this.cache[stack]; 31 | } 32 | 33 | // eslint-disable-next-line no-useless-escape 34 | const re = /^\s+at\s+(.+?\s+)?\(?([0-z._\-\\\/]+):(\d+):(\d+)\)?$/gm; 35 | let match: RegExpExecArray | null; 36 | let outStack = error.toString(); 37 | 38 | while ((match = re.exec(stack))) { 39 | if (match[2] === "main") { 40 | const pos = this.consumer.originalPositionFor({ 41 | column: parseInt(match[4], 10), 42 | line: parseInt(match[3], 10) 43 | }); 44 | 45 | if (pos.line != null) { 46 | if (pos.name) { 47 | outStack += `\n at ${pos.name} (${pos.source}:${pos.line}:${pos.column})`; 48 | } else { 49 | if (match[1]) { 50 | // no original source file name known - use file name from given trace 51 | outStack += `\n at ${match[1]} (${pos.source}:${pos.line}:${pos.column})`; 52 | } else { 53 | // no original source file name known or in given trace - omit name 54 | outStack += `\n at ${pos.source}:${pos.line}:${pos.column}`; 55 | } 56 | } 57 | } else { 58 | // no known position 59 | break; 60 | } 61 | } else { 62 | // no more parseable lines 63 | break; 64 | } 65 | } 66 | 67 | this.cache[stack] = outStack; 68 | return outStack; 69 | } 70 | 71 | public static wrapLoop(loop: () => void): () => void { 72 | return () => { 73 | try { 74 | loop(); 75 | } catch (e) { 76 | if (e instanceof Error) { 77 | if ("sim" in Game.rooms) { 78 | const message = `Source maps don't work in the simulator - displaying original error`; 79 | console.log(`${message}
${_.escape(e.stack)}`); 80 | } else { 81 | const stack = _.escape(this.sourceMappedStackTrace(e)); 82 | 83 | console.log(`${stack}`); 84 | ErrorExporter.addErrorToSegment(stack); 85 | } 86 | } else { 87 | // can't handle it 88 | throw e; 89 | } 90 | } 91 | }; 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /src/Roles/remoteDismantler.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | function findLocked(creep) { 6 | 7 | let HostileStructures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 8 | filter: object => object.structureType != STRUCTURE_CONTROLLER}); 9 | 10 | let specialStructures = HostileStructures.filter(object => object.structureType == STRUCTURE_SPAWN || object.structureType == STRUCTURE_TOWER || object.structureType == STRUCTURE_POWER_SPAWN || object.structureType == STRUCTURE_LAB || object.structureType == STRUCTURE_STORAGE || object.structureType == STRUCTURE_TERMINAL || object.structureType == STRUCTURE_NUKER || object.structureType == STRUCTURE_OBSERVER || object.structureType == STRUCTURE_POWER_SPAWN || object.structureType == STRUCTURE_FACTORY); 11 | if(specialStructures.length > 0) { 12 | let closestspecialStructure = creep.pos.findClosestByRange(specialStructures); 13 | // HostileStructures.sort((a,b) => a.hits - b.hits); 14 | creep.say("🎯", true); 15 | return closestspecialStructure.id; 16 | } 17 | if(HostileStructures.length > 0) { 18 | let closestHostileStructure = creep.pos.findClosestByRange(HostileStructures); 19 | // HostileStructures.sort((a,b) => a.hits - b.hits); 20 | creep.say("🎯", true); 21 | return closestHostileStructure.id; 22 | } 23 | 24 | let Structures = creep.room.find(FIND_STRUCTURES, { 25 | filter: object => object.structureType != STRUCTURE_CONTROLLER && object.structureType != STRUCTURE_ROAD && object.structureType != STRUCTURE_CONTAINER}); 26 | 27 | if(Structures.length > 0) { 28 | let closestStructure = creep.pos.findClosestByRange(Structures); 29 | // Structures.sort((a,b) => a.hits - b.hits); 30 | creep.say("🎯", true); 31 | return closestStructure.id; 32 | } 33 | } 34 | 35 | const run = function (creep) { 36 | creep.memory.moving = false; 37 | 38 | if(creep.room.name != creep.memory.targetRoom) { 39 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 40 | } 41 | else { 42 | let dismantleTarget; 43 | if(creep.memory.locked && creep.memory.locked != false) { 44 | dismantleTarget = Game.getObjectById(creep.memory.locked); 45 | if(!dismantleTarget) { 46 | creep.memory.locked = false; 47 | } 48 | } 49 | 50 | if(!creep.memory.locked || Game.time % 240 == 0) { 51 | dismantleTarget = findLocked(creep); 52 | creep.memory.locked = dismantleTarget; 53 | } 54 | 55 | 56 | if(creep.memory.locked && creep.memory.locked != false) { 57 | dismantleTarget = Game.getObjectById(creep.memory.locked); 58 | if(creep.dismantle(dismantleTarget) == ERR_NOT_IN_RANGE) { 59 | creep.moveTo(dismantleTarget, {reusePath:8}); 60 | let structuresInRange1 = creep.pos.findInRange(FIND_HOSTILE_STRUCTURES, 1); 61 | if(structuresInRange1.length > 0) { 62 | creep.dismantle(structuresInRange1[0]) 63 | } 64 | } 65 | } 66 | } 67 | 68 | if(creep.ticksToLive === 1 && creep.memory.persistent && creep.memory.locked && creep.room.controller && !creep.room.controller.safeMode) { 69 | global.SRDP(creep.memory.homeRoom, creep.memory.targetRoom) 70 | } 71 | } 72 | 73 | 74 | const roleRemoteDismantler = { 75 | run, 76 | //run: run, 77 | //function2, 78 | //function3 79 | }; 80 | 81 | export default roleRemoteDismantler; 82 | // module.exports = roleRemoteDismantler; 83 | -------------------------------------------------------------------------------- /src/Roles/annoy.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep:Creep) { 6 | ; 7 | 8 | if(creep.room.controller && !creep.room.controller.my && creep.room.controller.safeMode > 0) { 9 | return creep.moveToRoom(creep.memory.targetRoom); 10 | } 11 | 12 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 13 | let Structures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 14 | filter: object => object.structureType != STRUCTURE_CONTROLLER && object.structureType != STRUCTURE_KEEPER_LAIR && object.structureType != STRUCTURE_STORAGE && object.structureType != STRUCTURE_TERMINAL}); 15 | let ConstructionSites = creep.room.find(FIND_HOSTILE_CONSTRUCTION_SITES, {filter: site => site.structureType != STRUCTURE_ROAD && site.progress != 0}); 16 | if(enemyCreeps.length > 0) { 17 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 18 | if(creep.pos.isNearTo(closestEnemyCreep)) { 19 | creep.attack(closestEnemyCreep); 20 | } 21 | else { 22 | if(closestEnemyCreep.pos.x != 0 && closestEnemyCreep.pos.x != 49 && closestEnemyCreep.pos.y != 0 && closestEnemyCreep.pos.y != 49) { 23 | creep.moveTo(closestEnemyCreep, {swampCost:2, reusePath:25, visualizePathStyle: {stroke: '#ffffff'}}); 24 | } 25 | } 26 | 27 | if(creep.attack(closestEnemyCreep) == 0) { 28 | if(closestEnemyCreep.pos.x != 0 && closestEnemyCreep.pos.x != 49 && closestEnemyCreep.pos.y != 0 && closestEnemyCreep.pos.y != 49) { 29 | creep.moveTo(closestEnemyCreep, {swampCost:2, reusePath:25, visualizePathStyle: {stroke: '#ffffff'}}); 30 | } 31 | return; 32 | } 33 | return; 34 | } 35 | 36 | else if(Structures.length > 0) { 37 | let closestStructure = creep.pos.findClosestByRange(Structures) 38 | if(creep.pos.isNearTo(closestStructure)) { 39 | creep.attack(closestStructure) 40 | } 41 | else { 42 | creep.moveTo(closestStructure, {swampCost:2, reusePath:25, visualizePathStyle: {stroke: '#ffffff'}}); 43 | } 44 | } 45 | 46 | else if(ConstructionSites.length > 0) { 47 | ConstructionSites.sort((a,b) => b.progress - a.progress); 48 | if(creep.pos.x != ConstructionSites[0].pos.x || creep.pos.y != ConstructionSites[0].pos.y) { 49 | creep.moveTo(ConstructionSites[0], {swampCost:2, reusePath:25, visualizePathStyle: {stroke: '#ffffff'}}); 50 | } 51 | // .pos.x, ConstructionSites[0].pos.y 52 | } 53 | 54 | 55 | 56 | else { 57 | let buildings = creep.room.find(FIND_STRUCTURES, {filter: building => building.structureType == STRUCTURE_WALL}); 58 | if(buildings.length > 0) { 59 | buildings.sort((a,b) => a.pos.getRangeTo(creep.room.controller) - b.pos.getRangeTo(creep.room.controller)); 60 | // let closestWall = creep.pos.findClosestByRange(buildings); 61 | if(creep.pos.isNearTo(buildings[0])) { 62 | creep.attack(buildings[0]); 63 | } 64 | else { 65 | creep.moveTo(buildings[0]); 66 | } 67 | } 68 | else { 69 | creep.moveTo(24,25); 70 | } 71 | } 72 | 73 | if(creep.room.name != creep.memory.targetRoom) { 74 | return creep.moveToRoom(creep.memory.targetRoom); 75 | } 76 | } 77 | 78 | 79 | const roleAnnoy = { 80 | run, 81 | //run: run, 82 | //function2, 83 | //function3 84 | }; 85 | export default roleAnnoy; 86 | -------------------------------------------------------------------------------- /src/Roles/upgrader.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep) { 2 | creep.memory.moving = false; 3 | if(creep.evacuate()) { 4 | return; 5 | } 6 | // const start = Game.cpu.getUsed() 7 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 8 | 9 | if(creep.room.controller && creep.room.controller.level == 4 && !storage && creep.room.find(FIND_MY_CREEPS).length < 9) { 10 | creep.memory.role = "builder"; 11 | creep.memory.locked = false; 12 | } 13 | if(creep.room.controller.level == 2 && creep.ticksToLive % 100 == 0 && creep.room.find(FIND_MY_CONSTRUCTION_SITES).length > 0) { 14 | creep.memory.role = "builder"; 15 | } 16 | 17 | // if(creep.fatigue > 0) { 18 | // console.log('hi') 19 | // creep.room.createConstructionSite(creep.pos, STRUCTURE_ROAD); 20 | // } 21 | 22 | let controllerLink:any = Game.getObjectById(creep.room.memory.Structures.controllerLink); 23 | 24 | if(creep.memory.upgrading && creep.store[RESOURCE_ENERGY] == 0) { 25 | creep.memory.upgrading = false; 26 | creep.MoveCostMatrixRoadPrio(controllerLink, 1); 27 | } 28 | if(!creep.memory.upgrading && creep.store[RESOURCE_ENERGY] > 0) { 29 | creep.memory.upgrading = true; 30 | } 31 | 32 | if(creep.memory.upgrading) { 33 | if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE && creep.room.memory.Structures.controllerLink && creep.pos.getRangeTo(creep.room.controller == 4)) { 34 | creep.roomCallbackRoadPrioUpgraderInPosition(creep.room.controller, 3); 35 | } 36 | else if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) { 37 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 3); 38 | } 39 | 40 | if(controllerLink && creep.pos.isNearTo(controllerLink) && creep.store[RESOURCE_ENERGY] <= creep.getActiveBodyparts(WORK) && creep.pos.isNearTo(controllerLink)) { 41 | creep.withdraw(controllerLink, RESOURCE_ENERGY); 42 | } 43 | 44 | } 45 | else { 46 | if(controllerLink && controllerLink.store[RESOURCE_ENERGY] > 0) { 47 | if(creep.pos.isNearTo(controllerLink)) { 48 | creep.withdraw(controllerLink, RESOURCE_ENERGY); 49 | if(creep.ticksToLive % 23 == 0) { 50 | let lookForRoadsOnCreepPos = creep.pos.lookFor(LOOK_STRUCTURES); 51 | if(lookForRoadsOnCreepPos.length > 0) { 52 | for(let building of lookForRoadsOnCreepPos) { 53 | if(building.structureType == STRUCTURE_ROAD) { 54 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 2); 55 | } 56 | } 57 | } 58 | } 59 | 60 | } 61 | else { 62 | creep.MoveCostMatrixRoadPrio(controllerLink, 1); 63 | } 64 | } 65 | else if(creep.room.controller.level < 7) { 66 | 67 | if(storage == undefined) { 68 | let result = creep.acquireEnergyWithContainersAndOrDroppedEnergy(); 69 | if(result == 0) { 70 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 3) 71 | } 72 | } 73 | else { 74 | let result = creep.withdrawStorage(storage); 75 | if(result == 0) { 76 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 3) 77 | } 78 | } 79 | 80 | } 81 | 82 | } 83 | 84 | 85 | 86 | 87 | 88 | 89 | if(controllerLink && creep.ticksToLive == 1) { 90 | creep.transfer(controllerLink, RESOURCE_ENERGY); 91 | } 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | // console.log('Upgrader Ran in', Game.cpu.getUsed() - start, 'ms') 102 | 103 | 104 | if(!controllerLink && creep.ticksToLive <= 50 && !creep.memory.upgrading) { 105 | creep.memory.suicide = true; 106 | } 107 | if(creep.memory.suicide == true) { 108 | creep.recycle(); 109 | return; 110 | } 111 | 112 | 113 | 114 | } 115 | 116 | 117 | 118 | 119 | const roleUpgrader = { 120 | run, 121 | //run: run, 122 | //function2, 123 | //function3 124 | }; 125 | export default roleUpgrader; 126 | -------------------------------------------------------------------------------- /src/Roles/RoomLocker.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep):CreepMoveReturnCode | -2 | -5 | -7 | void { 2 | 3 | creep.memory.moving = false; 4 | 5 | if(creep.store.getUsedCapacity() === 0 && creep.memory.full) { 6 | creep.memory.full = false; 7 | } 8 | if(creep.store.getFreeCapacity() === 0 && !creep.memory.full) { 9 | creep.memory.full = true; 10 | } 11 | 12 | if(!creep.memory.full && creep.room.name === creep.memory.homeRoom) { 13 | let storage = creep.room.storage; 14 | if(storage) { 15 | let result = creep.withdraw(storage, RESOURCE_ENERGY); 16 | if(result === ERR_NOT_IN_RANGE) { 17 | creep.MoveCostMatrixIgnoreRoads(storage, 1); 18 | } 19 | else if(result === OK) { 20 | creep.memory.full = true; 21 | } 22 | } 23 | } 24 | 25 | if(creep.room.name != creep.memory.targetRoom && creep.memory.full && !creep.memory.line) { 26 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 27 | } 28 | else if(creep.room.name != creep.memory.targetRoom && creep.memory.full && creep.memory.line) { 29 | return; 30 | } 31 | 32 | if(creep.room.name === creep.memory.targetRoom && !creep.memory.full) { 33 | creep.harvestEnergy(); 34 | } 35 | 36 | if(creep.room.name === creep.memory.targetRoom && creep.memory.full) { 37 | let controller = creep.room.controller; 38 | if(controller && controller.level === 0) { 39 | creep.MoveCostMatrixRoadPrio(controller, 1); 40 | } 41 | if(controller && (controller.level === 1 || controller.level === 2 && controller.ticksToDowngrade < 9990)) { 42 | creep.upgradeController(controller); 43 | if(controller.level === 1 || controller.ticksToDowngrade <= 9500) { 44 | creep.MoveCostMatrixRoadPrio(controller, 1) 45 | } 46 | } 47 | if(controller && controller.level === 2 && controller.ticksToDowngrade >= 9500) { 48 | if(!creep.memory.walled || Game.time % 100 === 0) { 49 | wallExits(creep.room); 50 | creep.memory.walled = true; 51 | } 52 | let constructionSites:Array = creep.room.find(FIND_CONSTRUCTION_SITES); 53 | // filter by structureWall 54 | constructionSites = constructionSites.filter((site) => site.structureType === STRUCTURE_WALL); 55 | if(constructionSites.length > 0) { 56 | let closestConstructionSite = creep.pos.findClosestByRange(constructionSites); 57 | if(creep.pos.getRangeTo(closestConstructionSite) <= 3) { 58 | creep.build(closestConstructionSite); 59 | } 60 | else { 61 | creep.moveTo(closestConstructionSite); 62 | } 63 | } 64 | else { 65 | // if no construction sites, upgrade controller 66 | if(creep.pos.getRangeTo(controller) > 3) { 67 | creep.moveTo(controller); 68 | } 69 | else { 70 | creep.upgradeController(controller); 71 | } 72 | } 73 | } 74 | } 75 | 76 | } 77 | 78 | function wallExits(room: Room) { 79 | const exits = room.find(FIND_EXIT); 80 | 81 | const offsetX = [-2, -2, -2, 0, 0, 2, 2, 2]; 82 | const offsetY = [-2, 0, 2, -2, 2, -2, 0, 2]; 83 | 84 | for (let i = 0; i < exits.length; i++) { 85 | const exitPos = exits[i]; 86 | 87 | for (let j = 0; j < 8; j++) { 88 | const wallX = exitPos.x + offsetX[j]; 89 | const wallY = exitPos.y + offsetY[j]; 90 | 91 | // Make sure the wall position is within the bounds of the room 92 | if (wallX >= 0 && wallX <= 49 && wallY >= 0 && wallY <= 49) { 93 | // Check if there's already a wall at this position 94 | const structuresAtPos = room.lookForAt(LOOK_STRUCTURES, wallX, wallY); 95 | const wallsAtPos = structuresAtPos.filter((structure) => structure.structureType === STRUCTURE_WALL); 96 | if (wallsAtPos.length === 0) { 97 | room.createConstructionSite(wallX, wallY, STRUCTURE_WALL); 98 | } 99 | } 100 | } 101 | } 102 | } 103 | 104 | const roleRoomLocker = { 105 | run, 106 | //run: run, 107 | //function2, 108 | //function3 109 | }; 110 | export default roleRoomLocker; 111 | -------------------------------------------------------------------------------- /src/Roles/maintainer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | ; 7 | creep.memory.moving = false; 8 | 9 | if(creep.memory.suicide) { 10 | creep.recycle(); 11 | return; 12 | } 13 | if(creep.evacuate()) { 14 | return; 15 | } 16 | if(creep.memory.targetRoom && creep.room.name !== creep.memory.targetRoom) { 17 | creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 18 | } 19 | 20 | if(creep.memory.repairing && creep.store[RESOURCE_ENERGY] == 0) { 21 | creep.memory.repairing = false; 22 | } 23 | if(!creep.memory.repairing && creep.store.getFreeCapacity() == 0) { 24 | creep.memory.repairing = true; 25 | } 26 | 27 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 28 | 29 | 30 | if(creep.memory.repairing) { 31 | let buildingsToRepair = []; 32 | creep.room.memory.keepTheseRoads.forEach(function(roadID) { 33 | let road:any = Game.getObjectById(roadID); 34 | if(road && road.hits <= road.hitsMax - 500) { 35 | buildingsToRepair.push(road); 36 | } 37 | }); 38 | let containers; 39 | if(creep.room.controller.level <= 6) { 40 | containers = creep.room.find(FIND_STRUCTURES, {filter: s => s.structureType == STRUCTURE_CONTAINER}); 41 | } 42 | else { 43 | containers = creep.room.find(FIND_STRUCTURES, {filter: s => s.structureType == STRUCTURE_CONTAINER && s.id == creep.room.memory.Structures.bin}); 44 | } 45 | 46 | if(containers.length > 0) { 47 | for(let container of containers) { 48 | if(container.hits <= container.hitsMax - 500) { 49 | buildingsToRepair.push(container); 50 | } 51 | } 52 | } 53 | 54 | if(!creep.memory.rampartsToRepair) { 55 | let rampartsInRoom = creep.room.find(FIND_MY_STRUCTURES, {filter: s => s.structureType == STRUCTURE_RAMPART && s.hits < 500000 && (!creep.room.storage || creep.room.storage.pos.getRangeTo(s) >= 9)}); 56 | let idsOfRamparts = []; 57 | for(let rampart of rampartsInRoom) { 58 | idsOfRamparts.push(rampart.id); 59 | } 60 | creep.memory.rampartsToRepair = idsOfRamparts; 61 | } 62 | 63 | let rampartsIDS = creep.memory.rampartsToRepair; 64 | if(rampartsIDS.length > 0) { 65 | for(let rampart of rampartsIDS) { 66 | let rampObj:any = Game.getObjectById(rampart); 67 | if(rampObj && rampObj.hits <= 50000) { 68 | buildingsToRepair.push(rampObj); 69 | } 70 | } 71 | } 72 | 73 | if(creep.room.memory.danger_timer > 0 && storage) { 74 | buildingsToRepair = buildingsToRepair.filter(function(b) {return storage.pos.getRangeTo(b) <= 10;}); 75 | } 76 | 77 | if(buildingsToRepair.length > 0) { 78 | let closeByBuildings = creep.pos.findInRange(buildingsToRepair, 3); 79 | if(closeByBuildings.length > 0) { 80 | creep.repair(closeByBuildings[closeByBuildings.length - 1]) 81 | if(closeByBuildings[closeByBuildings.length - 1].hits !== closeByBuildings[closeByBuildings.length - 1].hitsMax) { 82 | creep.MoveCostMatrixRoadPrio(closeByBuildings[closeByBuildings.length - 1], 1) 83 | } 84 | else { 85 | creep.MoveCostMatrixRoadPrio(closeByBuildings[0], 0) 86 | } 87 | } 88 | else { 89 | creep.MoveCostMatrixRoadPrio(creep.pos.findClosestByRange(buildingsToRepair), 3) 90 | } 91 | } 92 | else { 93 | creep.memory.suicide = true; 94 | } 95 | 96 | } 97 | else { 98 | if(creep.pos.isNearTo(storage)) { 99 | creep.withdraw(storage, RESOURCE_ENERGY); 100 | } 101 | else { 102 | creep.MoveCostMatrixRoadPrio(storage, 1) 103 | } 104 | } 105 | 106 | 107 | } 108 | 109 | const roleMaintainer = { 110 | run, 111 | //run: run, 112 | //function2, 113 | //function3 114 | }; 115 | export default roleMaintainer; 116 | -------------------------------------------------------------------------------- /src/Roles/RampartErector.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | creep.memory.moving = false; 7 | 8 | if(creep.memory.suicide) { 9 | creep.recycle(); 10 | return; 11 | } 12 | 13 | if(creep.memory.full && creep.store[RESOURCE_ENERGY] == 0) { 14 | creep.memory.full = false; 15 | creep.memory.locked_repair = false; 16 | creep.memory.locked = false; 17 | } 18 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 19 | creep.memory.full = true; 20 | } 21 | if(!creep.memory.full) { 22 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 23 | if(creep.pos.isNearTo(storage)) { 24 | creep.withdraw(storage, RESOURCE_ENERGY); 25 | } 26 | else { 27 | creep.MoveCostMatrixRoadPrio(storage, 1) 28 | } 29 | } 30 | if(creep.memory.full) { 31 | if(creep.memory.locked_repair) { 32 | let target:any = Game.getObjectById(creep.memory.locked_repair); 33 | if(target && target.hits < 500000) { 34 | if(creep.repair(target) == ERR_NOT_IN_RANGE) { 35 | creep.MoveCostMatrixRoadPrio(target, 3) 36 | } 37 | return; 38 | } 39 | else { 40 | creep.memory.locked_repair = false; 41 | creep.memory.locked = false; 42 | } 43 | } 44 | 45 | if(!creep.memory.locked) { 46 | if(creep.memory.rampartLocations.length > 0) { 47 | let nextTarget = creep.room.memory.construction.rampartLocations.pop(); 48 | if(nextTarget && nextTarget.length >= 2 && typeof nextTarget[0] === 'number' && typeof nextTarget[1] === 'number' && nextTarget[0] >= 0 && nextTarget[0] <= 49 && nextTarget[1] >= 0 && nextTarget[1] <= 49) { 49 | let position = new RoomPosition(nextTarget[0], nextTarget[1], creep.room.name) 50 | position.createConstructionSite(STRUCTURE_RAMPART); 51 | creep.memory.locked = position; 52 | return; 53 | } 54 | else { 55 | creep.memory.suicide = true; 56 | } 57 | } 58 | else { 59 | creep.memory.suicide = true; 60 | } 61 | } 62 | if(creep.memory.locked) { 63 | let position = creep.memory.locked 64 | if(position && position.x <= 47 && position.y <= 47 && position.x >= 2 && position.y >= 2) { 65 | let position2 = new RoomPosition(position.x, position.y, position.roomName) 66 | let lookForConstructionSites = position2.lookFor(LOOK_CONSTRUCTION_SITES); 67 | if(lookForConstructionSites.length > 0) { 68 | let target = lookForConstructionSites[0]; 69 | if(creep.pos.getRangeTo(target) <= 3) { 70 | creep.build(target) 71 | } 72 | else { 73 | creep.MoveCostMatrixRoadPrio(target, 3) 74 | } 75 | } 76 | else if(lookForConstructionSites.length == 0) { 77 | let lookForBuildings = position2.lookFor(LOOK_STRUCTURES); 78 | if(lookForBuildings.length > 0) { 79 | for(let building of lookForBuildings) { 80 | if(building.structureType == STRUCTURE_RAMPART) { 81 | creep.memory.locked_repair = building.id; 82 | creep.repair(building); 83 | } 84 | } 85 | } 86 | else { 87 | creep.memory.locked = false; 88 | } 89 | } 90 | else { 91 | creep.memory.locked = false; 92 | } 93 | } 94 | else { 95 | creep.memory.locked = false; 96 | } 97 | } 98 | } 99 | 100 | 101 | } 102 | 103 | const roleRampartErector = { 104 | run, 105 | //run: run, 106 | //function2, 107 | //function3 108 | }; 109 | export default roleRampartErector; 110 | -------------------------------------------------------------------------------- /src/Roles/ControllerLinkFiller.ts: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * A little description of this function 4 | * @param {Creep} creep 5 | **/ 6 | 7 | const run = function (creep) { 8 | creep.memory.moving = false; 9 | if(creep.ticksToLive == 1499) { 10 | creep.room.memory.reserveFill = []; 11 | } 12 | if(creep.evacuate()) { 13 | return; 14 | } 15 | if(creep.ticksToLive <= 14 && !creep.memory.full) { 16 | creep.memory.suicide = true; 17 | } 18 | if(creep.memory.suicide == true) { 19 | creep.recycle(); 20 | return; 21 | } 22 | if(!creep.memory.MaxStorage) { 23 | let carryPartsAmount = 0 24 | for(let part of creep.body) { 25 | if(part.type == CARRY) { 26 | carryPartsAmount += 1; 27 | } 28 | } 29 | creep.memory.MaxStorage = carryPartsAmount * 50; 30 | } 31 | 32 | let MaxStorage = creep.memory.MaxStorage; 33 | 34 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 35 | creep.memory.full = true; 36 | } 37 | if(creep.memory.full) { 38 | if(creep.room.controller && (creep.room.controller.level <= 6 && creep.store[RESOURCE_ENERGY] < 50 || creep.room.controller.level == 7 && creep.store[RESOURCE_ENERGY] < 100 || creep.room.controller.level == 8 && creep.store[RESOURCE_ENERGY] < 200)) { 39 | creep.memory.full = false; 40 | creep.memory.t = false; 41 | } 42 | } 43 | 44 | 45 | 46 | if(!creep.memory.full) { 47 | let bin; 48 | let storage; 49 | if(creep.room.memory.Structures) { 50 | bin = Game.getObjectById(creep.room.memory.Structures.bin) || creep.room.findBin(storage); 51 | storage = Game.getObjectById(creep.room.memory.Structures.storage) || creep.room.findStorage(); 52 | } 53 | if(bin && bin.store[RESOURCE_ENERGY] >= MaxStorage) { 54 | if(creep.pos.isNearTo(bin)) { 55 | let result = creep.withdraw(bin, RESOURCE_ENERGY); 56 | if(result == 0) { 57 | creep.memory.full = true; 58 | } 59 | } 60 | else { 61 | creep.MoveCostMatrixSwampPrio(bin, 1); 62 | } 63 | } 64 | else if(storage && storage.store[RESOURCE_ENERGY] > 0) { 65 | let result = creep.withdrawStorage(storage); 66 | if(result == 0) { 67 | creep.memory.full = true; 68 | } 69 | } 70 | else if(!creep.room.memory.danger) { 71 | creep.acquireEnergyWithContainersAndOrDroppedEnergy(); 72 | } 73 | } 74 | 75 | if(creep.memory.full) { 76 | let storage; 77 | if(creep.room.memory.Structures) { 78 | storage = Game.getObjectById(creep.room.memory.Structures.storage) || creep.room.findStorage(); 79 | } 80 | 81 | 82 | let target = Game.getObjectById(creep.memory.t) || creep.findFillerTarget(); 83 | if(target) { 84 | if(target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) { 85 | target = creep.findFillerTarget(); 86 | } 87 | if(target) { 88 | if(creep.pos.isNearTo(target)) { 89 | let result = creep.transfer(target, RESOURCE_ENERGY); 90 | if(result == 0) { 91 | let indexOfTargetId = creep.room.memory.reserveFill.indexOf(target.id); 92 | if(indexOfTargetId !== -1) { 93 | creep.room.memory.reserveFill = creep.room.memory.reserveFill.splice(indexOfTargetId, 1); 94 | } 95 | } 96 | if(creep.store[RESOURCE_ENERGY] > target.store.getFreeCapacity(RESOURCE_ENERGY)) { 97 | let newTarget = creep.findFillerTarget(); 98 | if(newTarget && creep.pos.getRangeTo(newTarget) > 1) { 99 | creep.MoveCostMatrixRoadPrio(newTarget, 1); 100 | } 101 | } 102 | else { 103 | creep.memory.full = false; 104 | if(storage) { 105 | creep.MoveCostMatrixRoadPrio(storage, 1); 106 | } 107 | } 108 | } 109 | else { 110 | creep.MoveCostMatrixRoadPrio(target, 1) 111 | } 112 | } 113 | } 114 | 115 | } 116 | } 117 | 118 | const roleControllerLinkFiller = { 119 | run, 120 | //run: run, 121 | //function2, 122 | //function3 123 | }; 124 | export default roleControllerLinkFiller; 125 | -------------------------------------------------------------------------------- /src/Roles/CreepKiller.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | ; 7 | creep.memory.moving = false; 8 | 9 | if(creep.room.name != creep.memory.targetRoom) { 10 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 11 | } 12 | 13 | if(!creep.memory.ticksToGetHere && creep.room.name == creep.memory.targetRoom) { 14 | creep.memory.ticksToGetHere = 1500 - creep.ticksToLive; 15 | } 16 | if(creep.memory.ticksToGetHere && creep.ticksToLive == creep.memory.ticksToGetHere + (creep.body.length * 3) && creep.room.controller && creep.room.controller.level > 0) { 17 | global.SCK(creep.memory.homeRoom, creep.memory.targetRoom); 18 | } 19 | 20 | let hostileCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 21 | if(hostileCreeps.length > 0) { 22 | let closestHostile = creep.pos.findClosestByRange(hostileCreeps); 23 | if(creep.pos.isNearTo(closestHostile)) { 24 | creep.attack(closestHostile); 25 | creep.MoveCostMatrixRoadPrio(closestHostile, 0); 26 | } 27 | else { 28 | creep.MoveCostMatrixRoadPrio(closestHostile, 0); 29 | } 30 | return; 31 | } 32 | 33 | if((!creep.memory.exposed_hostile_structs || creep.ticksToLive % 512 == 0)) { 34 | let listOfTargets = []; 35 | let hostileStructures = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: s => s.structureType !== STRUCTURE_CONTROLLER}); 36 | 37 | for(let s of hostileStructures) { 38 | let buildingsOnTheS = s.pos.lookFor(LOOK_STRUCTURES); 39 | buildingsOnTheS = buildingsOnTheS.filter(function(s) {return s.structureType !== STRUCTURE_ROAD && s.structureType !== STRUCTURE_CONTAINER;}); 40 | if(buildingsOnTheS.length == 1 && s.structureType !== STRUCTURE_RAMPART) { 41 | listOfTargets.push(s); 42 | } 43 | } 44 | 45 | let spawns = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: s => s.structureType == STRUCTURE_SPAWN}); 46 | if(spawns.length > 0) { 47 | listOfTargets.sort((a,b) => a.pos.getRangeTo(spawns[0]) - b.pos.getRangeTo(spawns[0])); 48 | } 49 | 50 | let listOfTargetsIds = []; 51 | for(let target of listOfTargets) { 52 | listOfTargetsIds.push(target.id); 53 | } 54 | 55 | if(listOfTargetsIds.length > 0) { 56 | creep.memory.exposed_hostile_structs = listOfTargetsIds; 57 | 58 | } 59 | else { 60 | creep.memory.exposed_hostile_structs = true; 61 | let sites = creep.room.find(FIND_HOSTILE_CONSTRUCTION_SITES, {filter: s => s.progress !== 0}); 62 | if(sites.length == 0) { 63 | creep.memory.sites = true; 64 | } 65 | else { 66 | let siteIDS = []; 67 | for(let site of sites) { 68 | siteIDS.push(site.id); 69 | } 70 | creep.memory.sites = siteIDS; 71 | } 72 | 73 | } 74 | 75 | } 76 | 77 | if(creep.memory.exposed_hostile_structs && typeof(creep.memory.exposed_hostile_structs) !== "boolean" && creep.memory.exposed_hostile_structs.length > 0) { 78 | let target = Game.getObjectById(creep.memory.exposed_hostile_structs[0]); 79 | if(target) { 80 | if(creep.pos.isNearTo(target)) { 81 | creep.attack(target); 82 | } 83 | else { 84 | creep.MoveCostMatrixRoadPrio(target, 1); 85 | } 86 | } 87 | else { 88 | creep.memory.exposed_hostile_structs.shift(); 89 | } 90 | } 91 | else if(creep.memory.sites && typeof(creep.memory.sites) !== "boolean" && creep.memory.sites.length > 0) { 92 | let site = Game.getObjectById(creep.memory.sites[0]); 93 | if(site) { 94 | creep.MoveCostMatrixRoadPrio(site, 0); 95 | } 96 | else { 97 | creep.memory.sites.shift(); 98 | } 99 | } 100 | else { 101 | let spawns = creep.room.find(FIND_HOSTILE_STRUCTURES, {filter: s => s.structureType == STRUCTURE_SPAWN}); 102 | if(spawns.length > 0) { 103 | let closestSpawn = creep.pos.findClosestByRange(spawns); 104 | if(!creep.pos.isNearTo(closestSpawn)) { 105 | creep.MoveCostMatrixRoadPrio(closestSpawn, 1); 106 | } 107 | } 108 | 109 | } 110 | 111 | 112 | } 113 | 114 | 115 | const roleCreepKiller = { 116 | run, 117 | //run: run, 118 | //function2, 119 | //function3 120 | }; 121 | export default roleCreepKiller; 122 | -------------------------------------------------------------------------------- /src/Roles/defender.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep) { 2 | ; 3 | if(creep.room.memory.danger) { 4 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 5 | 6 | if(enemyCreeps.length > 0) { 7 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 8 | let rampartToMan = creep.room.memory.rampartToMan; 9 | 10 | let rampart:any = Game.getObjectById(rampartToMan); 11 | 12 | if(creep.body.length <= 3 || creep.body.length % 3 == 0) { 13 | let rampartDefenders = creep.room.find(FIND_MY_CREEPS, {filter: creep => creep.memory.role == "RampartDefender"}); 14 | if(rampartDefenders.length >= 0) { 15 | if(creep.pos.findInRange(enemyCreeps, 2).length > 1 && Game.time % 20 >10 && Game.time % 20 <=20) { 16 | creep.rangedMassAttack(); 17 | } 18 | else if(creep.pos.findInRange(enemyCreeps, 1).length > 0 && Game.time % 20 <10 && Game.time % 20 > 0) { 19 | creep.rangedAttack(closestEnemyCreep); 20 | } 21 | else { 22 | creep.rangedAttack(closestEnemyCreep); 23 | } 24 | if(rampart) { 25 | if(creep.pos.lookFor(LOOK_STRUCTURES).length == 0 || creep.pos.lookFor(LOOK_STRUCTURES).length == 1 && creep.pos.lookFor(LOOK_STRUCTURES)[0].structureType == STRUCTURE_ROAD) { 26 | creep.moveTo(rampart); 27 | } 28 | else { 29 | let structuresHere = creep.pos.lookFor(LOOK_STRUCTURES); 30 | if(structuresHere.length == 0 || (structuresHere.length == 1 && structuresHere[0].structureType == STRUCTURE_ROAD) || (structuresHere.length == 1 && structuresHere[0].structureType == STRUCTURE_CONTAINER) || (rampart && creep.pos.isNearTo(rampart) && Game.time % 6 == 0)) { 31 | creep.moveTo(rampart); 32 | } 33 | } 34 | } 35 | } 36 | else { 37 | if(Game.time % 100 == 0) { 38 | creep.memory.suicide = true; 39 | } 40 | if(creep.memory.suicide) { 41 | creep.recycle(); 42 | return; 43 | } 44 | } 45 | return; 46 | } 47 | 48 | if(creep.pos.isNearTo(closestEnemyCreep)) { 49 | creep.rangedMassAttack(); 50 | if(rampart && creep.pos.isNearTo(rampart) || Game.time % 5 ==0) { 51 | creep.moveTo(creep.room.terminal); 52 | } 53 | return; 54 | } 55 | else if(creep.room.memory.attack_target) { 56 | let target = creep.room.memory.attack_target 57 | if(target && creep.rangedAttack(target) == ERR_NOT_IN_RANGE) { 58 | creep.moveTo(target); 59 | return; 60 | } 61 | else { 62 | creep.rangedAttack(closestEnemyCreep) 63 | } 64 | } 65 | 66 | if(rampart) { 67 | if(creep.pos.lookFor(LOOK_STRUCTURES).length == 0 || creep.pos.lookFor(LOOK_STRUCTURES).length == 1 && creep.pos.lookFor(LOOK_STRUCTURES)[0].structureType == STRUCTURE_ROAD) { 68 | creep.moveTo(rampart); 69 | return; 70 | } 71 | else if(creep.pos && creep.pos != rampart.pos && rampart.pos.lookFor(LOOK_CREEPS).length == 1 && enemyCreeps.length == 2 && creep.pos.getRangeTo(closestEnemyCreep) < rampart.pos.getRangeTo(closestEnemyCreep)) { 72 | creep.moveTo(closestEnemyCreep); 73 | } 74 | else { 75 | creep.moveTo(creep.room.terminal); 76 | } 77 | } 78 | 79 | } 80 | } 81 | 82 | else { 83 | if(creep.memory.suicide == true) { 84 | creep.recycle(); 85 | return; 86 | } 87 | if(Game.time % 100 == 0) { 88 | creep.memory.suicide = true; 89 | } 90 | } 91 | // else { 92 | // creep.memory.role = "RangedAttacker"; 93 | // } 94 | // else { 95 | // creep.memory.role = "RangedAttacker"; 96 | // creep.memory.targetRoom = "E12S39"; 97 | // } 98 | } 99 | 100 | const roleDefender = { 101 | run, 102 | //run: run, 103 | //function2, 104 | //function3 105 | }; 106 | export default roleDefender; 107 | -------------------------------------------------------------------------------- /src/Roles/RangedRampartDefender.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep:Creep) { 2 | 3 | creep.memory.moving = false; 4 | 5 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 6 | let result = creep.Boost(); 7 | console.log(result) 8 | if(!result) { 9 | return; 10 | } 11 | } 12 | 13 | 14 | if(creep.evacuate()) { 15 | return; 16 | } 17 | 18 | if(creep.room.memory.danger) { 19 | 20 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 21 | 22 | if(enemyCreeps.length > 0) { 23 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 24 | 25 | if(!creep.memory.myRampartToMan || creep.ticksToLive % 5 == 0) { 26 | let roomRampartTarget:any = Game.getObjectById(creep.room.memory.rampartToMan); 27 | 28 | let rangeFromCreepToCreep; 29 | let rangeFromRampartToCreep; 30 | let storage = creep.room.storage; 31 | if(roomRampartTarget) { 32 | let closestEnemyCreepToRoomRampart = roomRampartTarget.pos.findClosestByRange(enemyCreeps); 33 | if(closestEnemyCreepToRoomRampart) { 34 | rangeFromRampartToCreep = roomRampartTarget.pos.getRangeTo(closestEnemyCreepToRoomRampart); 35 | rangeFromCreepToCreep = creep.pos.getRangeTo(closestEnemyCreep); 36 | } 37 | } 38 | if(rangeFromCreepToCreep && rangeFromRampartToCreep) { 39 | if (rangeFromCreepToCreep > rangeFromRampartToCreep && storage && (closestEnemyCreep.pos.getRangeTo(storage) === 11 || rangeFromCreepToCreep > 4)) { 40 | creep.memory.myRampartToMan = creep.room.memory.rampartToMan; 41 | } 42 | 43 | } 44 | else { 45 | creep.memory.myRampartToMan = creep.room.memory.rampartToMan; 46 | } 47 | } 48 | 49 | 50 | if(creep.pos.isNearTo(closestEnemyCreep)) { 51 | creep.rangedMassAttack(); 52 | creep.room.roomTowersAttackEnemy(closestEnemyCreep); 53 | 54 | if(Game.time % 10 == 0) { 55 | creep.say("☮️", true); 56 | } 57 | else if(Game.time % 10 == 1) { 58 | creep.say("God", true); 59 | } 60 | else if(Game.time % 10 == 2) { 61 | creep.say("Save", true); 62 | } 63 | else if(Game.time % 10 == 3) { 64 | creep.say("Us", true); 65 | } 66 | else if(Game.time % 10 == 4) { 67 | creep.say("☮️", true); 68 | } 69 | } 70 | 71 | else if(creep.pos.getRangeTo(closestEnemyCreep) <= 3) { 72 | let enemyCreepsInRange = enemyCreeps.filter(function(eC) {return creep.pos.getRangeTo(eC) <= 3;}); 73 | 74 | if(enemyCreepsInRange.length > 1) { 75 | enemyCreepsInRange.sort((a,b) => a.hits - b.hits); 76 | if(enemyCreepsInRange[0].hits < enemyCreepsInRange[0].hitsMax) { 77 | creep.rangedAttack(closestEnemyCreep); 78 | creep.room.roomTowersAttackEnemy(closestEnemyCreep); 79 | } 80 | else { 81 | // could add more random targetting and random hitting from towers to get some creeps low hits to blast them down but this will do for now. 82 | // add more complexity as needed. 83 | let randomTarget = enemyCreepsInRange[Math.floor(Math.random() * enemyCreepsInRange.length)]; 84 | creep.rangedAttack(randomTarget); 85 | creep.room.roomTowersAttackEnemy(randomTarget); 86 | } 87 | } 88 | else { 89 | creep.rangedAttack(closestEnemyCreep); 90 | } 91 | } 92 | 93 | let rampart:any = Game.getObjectById(creep.memory.myRampartToMan); 94 | 95 | if(rampart) { 96 | if(!creep.pos.isEqualTo(rampart)) { 97 | creep.moveToSafePositionToRepairRampart(rampart, 0); 98 | } 99 | } 100 | } 101 | } 102 | else if(!creep.room.memory.danger && creep.ticksToLive < 50) { 103 | if(creep.memory.targetRoom) { 104 | creep.memory.homeRoom = creep.memory.targetRoom; 105 | } 106 | creep.recycle(); 107 | } 108 | } 109 | 110 | const roleRangedRampartDefender = { 111 | run, 112 | }; 113 | export default roleRangedRampartDefender; 114 | -------------------------------------------------------------------------------- /src/Roles/attacker.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | ; 7 | 8 | 9 | if(creep.memory.targetRoom && creep.memory.targetRoom !== creep.room.name) { 10 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 11 | 12 | if(enemyCreeps.length > 0) { 13 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 14 | 15 | if(creep.attack(closestEnemyCreep) == ERR_NOT_IN_RANGE) { 16 | creep.moveTo(closestEnemyCreep); 17 | return; 18 | } 19 | if(creep.attack(closestEnemyCreep) == 0) { 20 | creep.moveTo(closestEnemyCreep); 21 | return; 22 | } 23 | } 24 | return creep.moveToRoom(creep.memory.targetRoom); 25 | } 26 | else { 27 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 28 | let Structures; 29 | 30 | let lowHitWalls = creep.room.find(FIND_STRUCTURES, { 31 | filter: object => object.structureType == STRUCTURE_WALL && object.hits < 10000 32 | }); 33 | 34 | 35 | if(creep.room.controller && creep.room.controller.my) { 36 | Structures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 37 | filter: object => object.structureType != STRUCTURE_CONTROLLER});} 38 | else { 39 | Structures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 40 | filter: object => object.structureType != STRUCTURE_CONTROLLER && object.structureType != STRUCTURE_KEEPER_LAIR}); 41 | } 42 | 43 | if(lowHitWalls.length > 0) { 44 | let closestLowHitWall = creep.pos.findClosestByRange(lowHitWalls); 45 | if(creep.pos.isNearTo(closestLowHitWall)) { 46 | creep.attack(closestLowHitWall); 47 | } 48 | else{ 49 | creep.moveTo(closestLowHitWall); 50 | } 51 | return; 52 | } 53 | 54 | 55 | if(enemyCreeps.length > 0) { 56 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 57 | 58 | if(creep.attack(closestEnemyCreep) == ERR_NOT_IN_RANGE) { 59 | creep.moveTo(closestEnemyCreep); 60 | return; 61 | } 62 | if(creep.attack(closestEnemyCreep) == 0) { 63 | creep.moveTo(closestEnemyCreep); 64 | return; 65 | } 66 | } 67 | 68 | if(Structures.length > 0) { 69 | let closestStructure = creep.pos.findClosestByRange(Structures); 70 | if(creep.pos.isNearTo(closestStructure)) { 71 | creep.attack(closestStructure); 72 | } 73 | else{ 74 | creep.moveTo(closestStructure); 75 | } 76 | return; 77 | } 78 | 79 | if(enemyCreeps.length > 0) { 80 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 81 | if(creep.pos.isNearTo(closestEnemyCreep)) { 82 | creep.attack(closestEnemyCreep); 83 | } 84 | else { 85 | creep.moveTo(closestEnemyCreep); 86 | } 87 | 88 | if(creep.attack(closestEnemyCreep) == 0) { 89 | creep.moveTo(closestEnemyCreep); 90 | return; 91 | } 92 | return; 93 | } 94 | 95 | 96 | else { 97 | delete creep.memory.targetRoom; 98 | // if(Memory.tasks.wipeRooms.destroyStructures.length > 0) { 99 | // creep.memory.targetRoom = Memory.tasks.wipeRooms.destroyStructures[0]; 100 | // } 101 | // else { 102 | // if(Game.time % 20 == 0) { 103 | // let found_room = false; 104 | // _.forEach(Game.rooms, function(room) { 105 | // if(room.memory.danger == true) { 106 | // creep.memory.targetRoom = room.name; 107 | // found_room = true; 108 | // return; 109 | // } 110 | // }); 111 | // if(found_room == false) { 112 | // delete creep.memory.targetRoom; 113 | // } 114 | // } 115 | // } 116 | // } 117 | } 118 | } 119 | 120 | // if you are afraid of death, look away. 121 | if(Game.time % 55 == 0 && !creep.memory.targetRoom) { 122 | creep.memory.suicide = true; 123 | } 124 | 125 | if(creep.memory.suicide == true) { 126 | creep.recycle(); 127 | return; 128 | } 129 | // suicide section 130 | 131 | 132 | } 133 | 134 | 135 | const roleAttacker = { 136 | run, 137 | //run: run, 138 | //function2, 139 | //function3 140 | }; 141 | export default roleAttacker; 142 | -------------------------------------------------------------------------------- /src/utils/Global.ts: -------------------------------------------------------------------------------- 1 | declare global { 2 | /* 3 | Example types, expand on these or remove them and add your own. 4 | Note: Values, properties defined here do no fully *exist* by this type definiton alone. 5 | You must also give them an implemention if you would like to use them. (ex. actually setting a `role` property in a Creeps memory) 6 | 7 | Types added in this `global` block are in an ambient, global context. This is needed because `main.ts` is a module file (uses import or export). 8 | Interfaces matching on name from @types/screeps will be merged. This is how you can extend the 'built-in' interfaces from @types/screeps. 9 | */ 10 | interface Object { 11 | status:any; 12 | targetRoom:any; 13 | boosted:boolean; 14 | } 15 | interface Memory { 16 | CPU: any; 17 | AvoidRooms: any; 18 | AvoidRoomsTemp: { [key: string]: number }; 19 | billtong_rooms: any; 20 | CanClaimRemote: number; 21 | DistressSignals: any; 22 | tasks: any; 23 | uuid: number; 24 | log: any; 25 | targetRampRoom: any; 26 | // my_goods:Array>; 27 | my_goods: any; 28 | target_colonise: any; 29 | resource_requests: any; 30 | keepAfloat: any; 31 | commandsToExecute: any; 32 | delayConvoy: object; 33 | Operations: { clear_claimed_rooms: {} }; 34 | e: { mosquito: Array<{ n: string; ts: number; cp?: RoomPosition | null }> }; 35 | terrainDataInitialized: boolean; 36 | lastProcessedCoord: { x: number; y: number; }; 37 | roomStatuses: any; 38 | } 39 | 40 | interface billtong_rooms { 41 | billtong_rooms:Array; 42 | } 43 | 44 | interface RawMemory { 45 | _parsed:any; 46 | } 47 | 48 | interface AvoidRooms { 49 | RoomsToAvoid:Array; 50 | } 51 | interface CPU { 52 | lastCPU:number; 53 | } 54 | interface DistressSignals { 55 | reinforce_me?:string; 56 | } 57 | 58 | interface RoomMemory { 59 | safeGuard:number; 60 | spawn_list: Array | string | object>; 61 | roomData:any; 62 | has_hostile_structures: boolean; 63 | has_hostile_creeps: boolean; 64 | has_safe_creeps: boolean; 65 | has_attacker: boolean; 66 | danger: boolean; 67 | name: string; 68 | towers: Array; 69 | spawn: string; 70 | container: string; 71 | storage: string; 72 | keepTheseRoads: any; 73 | rampartToMan: any; 74 | danger_timer: number; 75 | first_offence: number; 76 | bin: any; 77 | in_position: boolean; 78 | labs: any; 79 | attack_target: any; 80 | request_unboost: boolean; 81 | AvoidRooms: Array; 82 | Energy_Spent_First: Array; 83 | spawning_squad: object; 84 | factory:any; 85 | NukeRepair:boolean; 86 | Structures:any; 87 | resources:any; 88 | controllerLink:any; 89 | observe:any; 90 | } 91 | interface CreepMemory { 92 | exposedStructures:any; 93 | backupTR:any; 94 | myRampartToMan:any; 95 | repairing: boolean; 96 | name: string; 97 | role: string; 98 | room: object; 99 | target: any; 100 | working: boolean; 101 | building: boolean; 102 | upgrading: boolean; 103 | full: boolean; 104 | claim: boolean; 105 | locked: any; 106 | homeRoom: string; 107 | targetRoom: string; 108 | suicide: boolean; 109 | storage: any; 110 | source: any; 111 | sourceId:any; 112 | myLink: any; 113 | deposit: any; 114 | MaxStorage: number; 115 | searchedRooms: Array; 116 | controllerLink:any; 117 | go:boolean; 118 | direction:number | false; 119 | moving:boolean; 120 | path:any; 121 | boostlabs:Array; 122 | line:number; 123 | } 124 | 125 | // Syntax for adding proprties to `global` (ex "global.log") 126 | namespace NodeJS { 127 | interface Global { 128 | showBoosts: any; 129 | spawnConvoy: any; 130 | spawnSafeModer: any; 131 | profiler: any; 132 | Memory: any; 133 | ROLES: any; 134 | SS: any; 135 | SQR: any; 136 | SRDP: any; 137 | SQM: any; 138 | SQD: any; 139 | SRD: any; 140 | SC: any; 141 | SD: any; 142 | SDB: any; 143 | SG: any; 144 | SGB: any; 145 | SCK: any; 146 | SGD: any; 147 | SPK: any; 148 | SDM: any; 149 | SCCK: any; 150 | SCCK2: any; 151 | SMDP: any; 152 | spawn_hunting_party: any; 153 | lock_room: any; 154 | spawn_mosquito: any; 155 | buildRemoteRoads: any; 156 | } 157 | } 158 | } 159 | 160 | export default global; 161 | -------------------------------------------------------------------------------- /src/Roles/RampartDefender.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep:any) { 2 | 3 | creep.memory.moving = false; 4 | 5 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0 && creep.room.memory.danger) { 6 | let result = creep.Boost(); 7 | if(!result) { 8 | return; 9 | } 10 | } 11 | 12 | if(creep.memory.again && !creep.memory.ttgh) { 13 | creep.memory.ttgh = 1500 - creep.ticksToLive; 14 | } 15 | if(creep.memory.again && creep.memory.ttgh && creep.ticksToLive === creep.memory.ttgh + 145) { 16 | global.SMDP(creep.memory.homeRoom, creep.memory.targetRoom); 17 | } 18 | 19 | if(creep.room.storage ) { 20 | if(creep.room.memory.danger && creep.pos.getRangeTo(creep.room.storage) > 12) { 21 | creep.MoveCostMatrixRoadPrioAvoidEnemyCreepsMuch(creep.room.storage, 10) 22 | } 23 | else if(creep.room.memory.danger && creep.pos.getRangeTo(creep.room.storage) > 10) { 24 | creep.MoveCostMatrixRoadPrio(creep.room.storage, 10); 25 | } 26 | else if(!creep.room.memory.danger && creep.pos.getRangeTo(creep.room.storage) > 8) { 27 | creep.MoveCostMatrixRoadPrio(creep.room.storage, 8); 28 | } 29 | } 30 | 31 | 32 | if(creep.evacuate()) { 33 | return; 34 | } 35 | 36 | if(creep.room.memory.danger) { 37 | 38 | let enemyCreeps:Array = creep.room.find(FIND_HOSTILE_CREEPS); 39 | // filter enemy creeps by creeps with ranged attack, work, or attack parts 40 | enemyCreeps = _.filter(enemyCreeps, (c) => c.getActiveBodyparts(ATTACK) > 0 || c.getActiveBodyparts(RANGED_ATTACK) > 0 || c.getActiveBodyparts(WORK) > 0); 41 | if(enemyCreeps.length > 0) { 42 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 43 | 44 | 45 | 46 | if(!creep.memory.myRampartToMan || (creep.ticksToLive % 3 == 0 && enemyCreeps.length == 1 || creep.ticksToLive % 20 == 0 && enemyCreeps.length > 1)) { 47 | 48 | let roomRampartTarget:any = Game.getObjectById(creep.room.memory.rampartToMan); 49 | 50 | let rangeFromCreepToCreep; 51 | let rangeFromRampartToCreep; 52 | let storage = creep.room.storage; 53 | if(roomRampartTarget) { 54 | let closestEnemyCreepToRoomRampart = roomRampartTarget.pos.findClosestByRange(enemyCreeps); 55 | if(closestEnemyCreepToRoomRampart) { 56 | rangeFromRampartToCreep = roomRampartTarget.pos.getRangeTo(closestEnemyCreepToRoomRampart); 57 | rangeFromCreepToCreep = creep.pos.getRangeTo(closestEnemyCreep); 58 | } 59 | } 60 | if(rangeFromCreepToCreep && rangeFromRampartToCreep) { 61 | if (rangeFromCreepToCreep > rangeFromRampartToCreep && storage && (closestEnemyCreep.pos.getRangeTo(storage) === 11 || rangeFromCreepToCreep > 4)) { 62 | creep.memory.myRampartToMan = creep.room.memory.rampartToMan; 63 | } 64 | 65 | } 66 | else { 67 | creep.memory.myRampartToMan = creep.room.memory.rampartToMan; 68 | } 69 | 70 | 71 | } 72 | 73 | 74 | if(creep.pos.isNearTo(closestEnemyCreep)) { 75 | 76 | let LookStructures = creep.pos.lookFor(LOOK_STRUCTURES); 77 | if(LookStructures.length > 0) { 78 | for(let building of LookStructures) { 79 | if(building.structureType == STRUCTURE_RAMPART) { 80 | 81 | let attackResult = creep.attack(closestEnemyCreep); 82 | if(attackResult == 0) { 83 | creep.room.roomTowersAttackEnemy(closestEnemyCreep); 84 | } 85 | 86 | if(Game.time % 10 == 0) { 87 | creep.say("☮️", true); 88 | } 89 | else if(Game.time % 10 == 1) { 90 | creep.say("God", true); 91 | } 92 | else if(Game.time % 10 == 2) { 93 | creep.say("Save", true); 94 | } 95 | else if(Game.time % 10 == 3) { 96 | creep.say("Us", true); 97 | } 98 | else if(Game.time % 10 == 4) { 99 | creep.say("☮️", true); 100 | } 101 | 102 | if(attackResult == 0) { 103 | return; 104 | } 105 | } 106 | } 107 | } 108 | } 109 | 110 | let rampart:any = Game.getObjectById(creep.memory.myRampartToMan); 111 | 112 | if(rampart) { 113 | 114 | if(!creep.pos.isEqualTo(rampart)) { 115 | creep.moveToSafePositionToRepairRampart(rampart, 0); 116 | } 117 | 118 | } 119 | } 120 | } 121 | else if(!creep.room.memory.danger && creep.ticksToLive < 50) { 122 | creep.recycle(); 123 | } 124 | } 125 | 126 | const roleRampartDefender = { 127 | run, 128 | //run: run, 129 | //function2, 130 | //function3 131 | }; 132 | export default roleRampartDefender; 133 | -------------------------------------------------------------------------------- /src/Roles/DismantleControllerWalls.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep) { 6 | 7 | if(creep.room.name != creep.memory.targetRoom) { 8 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 9 | } 10 | 11 | let controller = creep.room.controller 12 | if(!controller) { 13 | creep.memory.suicide = true; 14 | } 15 | 16 | if(!creep.pos.isNearTo(controller)) { 17 | GoToController(creep, controller.pos, 1); 18 | } 19 | else { 20 | creep.suicide(); 21 | } 22 | 23 | let buildings = creep.room.find(FIND_STRUCTURES, {filter: s => s.structureType !== STRUCTURE_CONTAINER && s.structureType !== STRUCTURE_ROAD && s.structureType !== STRUCTURE_CONTROLLER}); 24 | let buildingsInRange = creep.pos.findInRange(buildings, 1); 25 | if(buildingsInRange.length > 0) { 26 | buildingsInRange.sort(function (a, b):any { 27 | 28 | 29 | if (a.pos.getRangeTo(controller) > b.pos.getRangeTo(controller)) return 1; 30 | if (a.pos.getRangeTo(controller) < b.pos.getRangeTo(controller)) return -1; 31 | 32 | 33 | if (a.hits > b.hits) return 1; 34 | if (a.hits < b.hits) return -1; 35 | 36 | }); 37 | creep.dismantle(buildingsInRange[0]); 38 | } 39 | } 40 | 41 | 42 | 43 | function GoToController(creep, target, range) { 44 | if(target && creep.fatigue == 0 && creep.pos.getRangeTo(target) > range) { 45 | if(creep.memory.path && creep.memory.path.length > 0 && (Math.abs(creep.pos.x - creep.memory.path[0].x) > 1 || Math.abs(creep.pos.y - creep.memory.path[0].y) > 1)) { 46 | creep.memory.path = false; 47 | } 48 | if(!creep.memory.path || creep.memory.path.length == 0 || !creep.memory.MoveTargetId || creep.memory.MoveTargetId != target.id || target.roomName !== creep.room.name) { 49 | let costMatrix = GoToTheController; 50 | 51 | let path = PathFinder.search( 52 | creep.pos, {pos:target, range:range}, 53 | { 54 | maxOps: 1000, 55 | maxRooms: 1, 56 | roomCallback: (roomName) => costMatrix(roomName) 57 | } 58 | ); 59 | creep.memory.path = path.path; 60 | creep.memory.MoveTargetId = target.id; 61 | } 62 | 63 | 64 | let pos = creep.memory.path[0]; 65 | let direction = creep.pos.getDirectionTo(pos); 66 | creep.move(direction); 67 | creep.memory.moving = true; 68 | creep.memory.path.shift(); 69 | } 70 | } 71 | 72 | 73 | 74 | const GoToTheController = (roomName: string): boolean | CostMatrix => { 75 | let room = Game.rooms[roomName]; 76 | if (!room || room == undefined || room === undefined || room == null || room === null) { 77 | return false; 78 | } 79 | 80 | let costs = new PathFinder.CostMatrix; 81 | 82 | const terrain = new Room.Terrain(roomName); 83 | 84 | for(let y = 0; y <= 49; y++) { 85 | for(let x = 0; x <= 49; x++) { 86 | const tile = terrain.get(x, y); 87 | let weight; 88 | if(tile == TERRAIN_MASK_WALL) { 89 | weight = 255 90 | } 91 | else if(tile == TERRAIN_MASK_SWAMP) { 92 | weight = 10; 93 | } 94 | else if(tile == 0){ 95 | weight = 2; 96 | } 97 | costs.set(x, y, weight); 98 | } 99 | } 100 | 101 | let EnemyCreeps = room.find(FIND_HOSTILE_CREEPS); 102 | for(let eCreep of EnemyCreeps) { 103 | costs.set(eCreep.pos.x, eCreep.pos.y, 255); 104 | } 105 | 106 | room.find(FIND_MY_CONSTRUCTION_SITES).forEach(function(site) { 107 | if(site.structureType !== STRUCTURE_CONTAINER && site.structureType !== STRUCTURE_ROAD && site.structureType !== STRUCTURE_RAMPART) { 108 | costs.set(site.pos.x, site.pos.y, 255); 109 | } 110 | }); 111 | 112 | let myCreeps = room.find(FIND_MY_CREEPS); 113 | for(let myCreep of myCreeps) { 114 | if(myCreep.memory.role == "DismantleControllerWalls") { 115 | costs.set(myCreep.pos.x, myCreep.pos.y, 140); 116 | } 117 | } 118 | 119 | _.forEach(room.find(FIND_STRUCTURES), function(struct:any) { 120 | if(struct.structureType == STRUCTURE_ROAD) { 121 | costs.set(struct.pos.x, struct.pos.y, 1); 122 | } 123 | else if(struct.structureType == STRUCTURE_CONTAINER) { 124 | return; 125 | } 126 | else if(struct.structureType == STRUCTURE_RAMPART && struct.my) { 127 | return; 128 | } 129 | else { 130 | if(struct.hits >= 5000000) { 131 | costs.set(struct.pos.x, struct.pos.y, 175); 132 | } 133 | else if(struct.hits >= 2500000) { 134 | costs.set(struct.pos.x, struct.pos.y, 150); 135 | } 136 | else if(struct.hits >= 1000000) { 137 | costs.set(struct.pos.x, struct.pos.y, 100); 138 | } 139 | else if(struct.hits >= 500000) { 140 | costs.set(struct.pos.x, struct.pos.y, 75); 141 | } 142 | else { 143 | costs.set(struct.pos.x, struct.pos.y, 50); 144 | } 145 | 146 | } 147 | }); 148 | return costs; 149 | } 150 | 151 | 152 | const roleDismantleControllerWalls = { 153 | run, 154 | //run: run, 155 | //function2, 156 | //function3 157 | }; 158 | 159 | export default roleDismantleControllerWalls; 160 | // module.exports = roleRemoteDismantler; 161 | -------------------------------------------------------------------------------- /src/Managers/PowerCreepManager.ts: -------------------------------------------------------------------------------- 1 | function PowerCreepManager() { 2 | if(Game.time % 5000 == 1) { 3 | 4 | let myGpl = Game.gpl.level; 5 | let myLevels = 0; 6 | let PowerCreeps = []; 7 | for(let name in Game.powerCreeps) { 8 | PowerCreeps.push(Game.powerCreeps[name]); 9 | } 10 | 11 | for(let powerCreep of PowerCreeps) { 12 | myLevels += powerCreep.level + 1; 13 | } 14 | 15 | if(myGpl > myLevels) { 16 | if(PowerCreeps.length > 0) { 17 | PowerCreeps.sort((a,b) => a.level - b.level); 18 | let level = PowerCreeps[0].level; 19 | if(level == 0) { 20 | PowerCreeps[0].upgrade(PWR_GENERATE_OPS); 21 | console.log("adding power", "PWR_GENERATE_OPS", "to", PowerCreeps[0]); 22 | } 23 | else if(level == 1) { 24 | PowerCreeps[0].upgrade(PWR_OPERATE_EXTENSION); 25 | console.log("adding power", "PWR_OPERATE_EXTENSION", "to", PowerCreeps[0]); 26 | } 27 | else if(level == 2) { 28 | PowerCreeps[0].upgrade(PWR_GENERATE_OPS); 29 | console.log("adding power", "PWR_GENERATE_OPS", "to", PowerCreeps[0]); 30 | } 31 | else if(level == 3) { 32 | PowerCreeps[0].upgrade(PWR_OPERATE_EXTENSION); 33 | console.log("adding power", "PWR_OPERATE_EXTENSION", "to", PowerCreeps[0]); 34 | } 35 | else if(level == 4) { 36 | PowerCreeps[0].upgrade(PWR_OPERATE_TOWER); 37 | console.log("adding power", "PWR_OPERATE_TOWER", "to", PowerCreeps[0]); 38 | } 39 | else if(level == 5) { 40 | PowerCreeps[0].upgrade(PWR_OPERATE_TOWER); 41 | console.log("adding power", "PWR_OPERATE_TOWER", "to", PowerCreeps[0]); 42 | } 43 | else if(level == 6) { 44 | PowerCreeps[0].upgrade(PWR_OPERATE_SPAWN); 45 | console.log("adding power", "PWR_OPERATE_SPAWN", "to", PowerCreeps[0]); 46 | } 47 | else if(level == 7) { 48 | PowerCreeps[0].upgrade(PWR_GENERATE_OPS); 49 | console.log("adding power", "PWR_GENERATE_OPS", "to", PowerCreeps[0]); 50 | } 51 | else if(level == 8) { 52 | PowerCreeps[0].upgrade(PWR_OPERATE_EXTENSION); 53 | console.log("adding power", "PWR_OPERATE_EXTENSION", "to", PowerCreeps[0]); 54 | } 55 | else if(level == 9) { 56 | PowerCreeps[0].upgrade(PWR_OPERATE_TOWER); 57 | console.log("adding power", "PWR_OPERATE_TOWER", "to", PowerCreeps[0]); 58 | } 59 | else if(level == 10) { 60 | PowerCreeps[0].upgrade(PWR_OPERATE_SPAWN); 61 | console.log("adding power", "PWR_OPERATE_SPAWN", "to", PowerCreeps[0]); 62 | } 63 | else if(level == 11) { 64 | PowerCreeps[0].upgrade(PWR_OPERATE_SPAWN); 65 | console.log("adding power", "PWR_OPERATE_SPAWN", "to", PowerCreeps[0]); 66 | } 67 | else if(level == 12) { 68 | PowerCreeps[0].upgrade(PWR_OPERATE_LAB); 69 | console.log("adding power", "PWR_OPERATE_LAB", "to", PowerCreeps[0]); 70 | } 71 | else if(level == 13) { 72 | PowerCreeps[0].upgrade(PWR_OPERATE_LAB); 73 | console.log("adding power", "PWR_OPERATE_LAB", "to", PowerCreeps[0]); 74 | } 75 | else if(level == 14) { 76 | PowerCreeps[0].upgrade(PWR_GENERATE_OPS); 77 | console.log("adding power", "PWR_GENERATE_OPS", "to", PowerCreeps[0]); 78 | } 79 | else if(level == 15) { 80 | PowerCreeps[0].upgrade(PWR_OPERATE_EXTENSION); 81 | console.log("adding power", "PWR_OPERATE_EXTENSION", "to", PowerCreeps[0]); 82 | } 83 | else if(level == 16) { 84 | PowerCreeps[0].upgrade(PWR_OPERATE_TOWER); 85 | console.log("adding power", "PWR_OPERATE_TOWER", "to", PowerCreeps[0]); 86 | } 87 | else if(level == 17) { 88 | PowerCreeps[0].upgrade(PWR_OPERATE_SPAWN); 89 | console.log("adding power", "PWR_OPERATE_SPAWN", "to", PowerCreeps[0]); 90 | } 91 | else if(level == 18) { 92 | PowerCreeps[0].upgrade(PWR_OPERATE_LAB); 93 | console.log("adding power", "PWR_OPERATE_LAB", "to", PowerCreeps[0]); 94 | } 95 | else if(level == 19) { 96 | PowerCreeps[0].upgrade(PWR_OPERATE_LAB); 97 | console.log("adding power", "PWR_OPERATE_LAB", "to", PowerCreeps[0]); 98 | } 99 | else if(level == 20) { 100 | PowerCreeps[0].upgrade(PWR_FORTIFY); 101 | console.log("adding power", "PWR_FORTIFY", "to", PowerCreeps[0]); 102 | } 103 | else if(level == 21) { 104 | PowerCreeps[0].upgrade(PWR_FORTIFY); 105 | console.log("adding power", "PWR_FORTIFY", "to", PowerCreeps[0]); 106 | } 107 | else if(level == 22) { 108 | PowerCreeps[0].upgrade(PWR_GENERATE_OPS); 109 | console.log("adding power", "PWR_GENERATE_OPS", "to", PowerCreeps[0]); 110 | } 111 | else if(level == 23) { 112 | PowerCreeps[0].upgrade(PWR_OPERATE_TOWER); 113 | console.log("adding power", "PWR_OPERATE_TOWER", "to", PowerCreeps[0]); 114 | } 115 | else if(level == 24) { 116 | PowerCreeps[0].upgrade(PWR_OPERATE_SPAWN); 117 | console.log("adding power", "PWR_OPERATE_SPAWN", "to", PowerCreeps[0]); 118 | } 119 | } 120 | } 121 | 122 | }} 123 | 124 | export default PowerCreepManager; 125 | -------------------------------------------------------------------------------- /src/Roles/signifer.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | const run = function (creep:any) { 6 | creep.memory.moving = false; 7 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 8 | let result = creep.Boost(); 9 | if(!result) { 10 | return; 11 | } 12 | } 13 | 14 | if(Game.rooms[creep.memory.targetRoom] && Game.rooms[creep.memory.targetRoom].controller && Game.rooms[creep.memory.targetRoom].controller.safeMode && Game.rooms[creep.memory.targetRoom].controller.safeMode > 0) { 15 | creep.memory.suicide = true; 16 | } 17 | if(creep.memory.suicide) { 18 | creep.recycle(); 19 | return; 20 | } 21 | 22 | 23 | if(!creep.memory.healtarget) { 24 | let creepsInRoom = creep.room.find(FIND_MY_CREEPS, {filter: (c) => {return (c.memory.role == "ram");}}); 25 | if(creepsInRoom.length > 0) { 26 | creepsInRoom.sort((a,b) => b.ticksToLive - a.ticksToLive); 27 | creep.memory.healtarget = creepsInRoom[0].id; 28 | if(!creep.memory.healtarget)return; 29 | } 30 | } 31 | 32 | let hostileCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 33 | 34 | // Assuming "creep" is your reference point 35 | let hostilesInRangeFour = hostileCreeps.filter(hostileCreep => { 36 | // Calculate the distance between the hostileCreep and your "creep" 37 | let distance = creep.pos.getRangeTo(hostileCreep); 38 | 39 | // Keep the hostileCreep in the resulting array if it is within range 4 40 | return distance <= 4; 41 | }); 42 | 43 | let hostilesInRangeThree = hostilesInRangeFour.filter(hostileCreep => { 44 | // Calculate the distance between the hostileCreep and your "creep" 45 | let distance = creep.pos.getRangeTo(hostileCreep); 46 | 47 | // Keep the hostileCreep in the resulting array if it is within range 4 48 | return distance <= 3; 49 | }); 50 | 51 | if(creep.memory.healtarget) { 52 | 53 | 54 | let target:any = Game.getObjectById(creep.memory.healtarget); 55 | if(target) { 56 | creep.moveTo(target.pos); 57 | if(creep.pos.isNearTo(target) && creep.room.name == creep.memory.targetRoom) { 58 | if(creep.pos.x == 0) { 59 | if(Game.time % 3 == 0 && new RoomPosition(creep.pos.x + 1, creep.pos.y, creep.room.name).isNearTo(target)) { 60 | creep.move(RIGHT); 61 | } 62 | else if (Game.time % 3 == 1 && new RoomPosition(creep.pos.x + 1, creep.pos.y - 1, creep.room.name).isNearTo(target)) { 63 | creep.move(TOP_RIGHT); 64 | } 65 | else if (Game.time % 3 == 2 && new RoomPosition(creep.pos.x + 1, creep.pos.y + 1, creep.room.name).isNearTo(target)) { 66 | creep.move(BOTTOM_RIGHT); 67 | } 68 | } 69 | else if(creep.pos.x == 49) { 70 | if(Game.time % 3 == 0 && new RoomPosition(creep.pos.x - 1, creep.pos.y, creep.room.name).isNearTo(target)) { 71 | creep.move(LEFT); 72 | } 73 | else if (Game.time % 3 == 1 && new RoomPosition(creep.pos.x - 1, creep.pos.y - 1, creep.room.name).isNearTo(target)) { 74 | creep.move(TOP_LEFT); 75 | } 76 | else if (Game.time % 3 == 2 && new RoomPosition(creep.pos.x - 1, creep.pos.y + 1, creep.room.name).isNearTo(target)) { 77 | creep.move(BOTTOM_LEFT); 78 | } 79 | } 80 | else if(creep.pos.y == 0) { 81 | if(Game.time % 3 == 0 && new RoomPosition(creep.pos.x, creep.pos.y + 1, creep.room.name).isNearTo(target)) { 82 | creep.move(BOTTOM); 83 | } 84 | else if (Game.time % 3 == 1 && new RoomPosition(creep.pos.x - 1, creep.pos.y + 1, creep.room.name).isNearTo(target)) { 85 | creep.move(BOTTOM_LEFT); 86 | } 87 | else if (Game.time % 3 == 2 && new RoomPosition(creep.pos.x + 1, creep.pos.y + 1, creep.room.name).isNearTo(target)) { 88 | creep.move(BOTTOM_RIGHT); 89 | } 90 | } 91 | else if(creep.pos.y == 49) { 92 | if(Game.time % 3 == 0 && new RoomPosition(creep.pos.x, creep.pos.y - 1, creep.room.name).isNearTo(target)) { 93 | creep.move(TOP); 94 | } 95 | else if (Game.time % 3 == 1 && new RoomPosition(creep.pos.x - 1, creep.pos.y - 1, creep.room.name).isNearTo(target)) { 96 | creep.move(TOP_LEFT); 97 | } 98 | else if (Game.time % 3 == 2 && new RoomPosition(creep.pos.x + 1, creep.pos.y - 1, creep.room.name).isNearTo(target)) { 99 | creep.move(TOP_RIGHT); 100 | } 101 | } 102 | } 103 | 104 | if(creep.hits == creep.hitsMax && (creep.room.name === creep.memory.targetRoom || target.hits !== target.hitsMax && creep.hits < target.hits || hostilesInRangeFour.length)) { 105 | creep.heal(target); 106 | } 107 | else if(creep.room.name === creep.memory.targetRoom || creep.hits !== creep.hitsMax || hostilesInRangeThree.length) { 108 | creep.heal(creep); 109 | } 110 | } 111 | else { 112 | creep.heal(creep); 113 | } 114 | } 115 | else if(creep.hits !== creep.hitsMax || hostilesInRangeThree.length) { 116 | creep.heal(creep); 117 | } 118 | } 119 | 120 | 121 | const roleSignifer = { 122 | run, 123 | //run: run, 124 | //function2, 125 | //function3 126 | }; 127 | export default roleSignifer; 128 | -------------------------------------------------------------------------------- /src/Roles/PowerCreeps/efficient.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep) { 2 | creep.memory.moving = false; 3 | 4 | if(creep.room.memory.danger && creep.powers[PWR_GENERATE_OPS] && creep.powers[PWR_GENERATE_OPS].cooldown == 0 && creep.store.getFreeCapacity() > 0) creep.usePower(PWR_GENERATE_OPS); 5 | if(creep.room.controller && !creep.room.controller.isPowerEnabled) { 6 | if(creep.pos.isNearTo(creep.room.controller)) { 7 | creep.enableRoom(creep.room.controller); 8 | } 9 | else { 10 | creep.MoveCostMatrixRoadPrio(creep.room.controller, 1); 11 | } 12 | return; 13 | } 14 | if(creep.ticksToLive < 120) { 15 | let powerSpawn:any = Game.getObjectById(creep.room.memory.Structures.powerSpawn); 16 | if(powerSpawn) { 17 | if(creep.pos.isNearTo(powerSpawn)) { 18 | creep.renew(powerSpawn); 19 | } 20 | else { 21 | creep.MoveCostMatrixRoadPrio(powerSpawn, 1); 22 | } 23 | return; 24 | } 25 | } 26 | 27 | let storage:any = creep.room.storage; 28 | let terminal = creep.room.terminal; 29 | 30 | let danger = creep.room.memory.danger; 31 | 32 | 33 | 34 | if(creep.store.getFreeCapacity() === 0) { 35 | creep.memory.full = true; 36 | } 37 | if(creep.store.getUsedCapacity() === 0) { 38 | creep.memory.full = false; 39 | } 40 | 41 | 42 | if(creep.memory.full ) { 43 | if(storage) { 44 | if(creep.pos.isNearTo(storage)) { 45 | for(let resource in creep.store) { 46 | if(creep.transfer(storage, resource, creep.store[resource] - 50) === 0 && resource === RESOURCE_OPS) { 47 | creep.memory.full = false; 48 | } 49 | } 50 | } 51 | else { 52 | creep.MoveCostMatrixRoadPrio(storage, 1); 53 | } 54 | return; 55 | } 56 | } 57 | 58 | for(let power in creep.powers) { 59 | 60 | if(parseInt(power) == PWR_GENERATE_OPS) { 61 | 62 | if(creep.powers[power].cooldown == 0) { 63 | creep.usePower(power) 64 | return; 65 | } 66 | } 67 | else if(parseInt(power) == PWR_OPERATE_EXTENSION) { 68 | 69 | if(creep.powers[power].cooldown == 0 && storage && storage.store[RESOURCE_ENERGY] > 15000 && creep.store[RESOURCE_OPS] >= 3 && creep.room.energyAvailable !== creep.room.energyCapacityAvailable) { 70 | usePowerInRange(creep, power, 3, storage); 71 | return; 72 | } 73 | } 74 | 75 | else if(parseInt(power) == PWR_REGEN_SOURCE) { 76 | if(creep.powers[power].cooldown == 0 && !danger) { 77 | if(!creep.memory.sources) { 78 | creep.memory.sources = []; 79 | let sources = creep.room.find(FIND_SOURCES); 80 | if(sources.length > 0) { 81 | for(let source of sources) { 82 | creep.memory.sources.push({id:source.id, lastBuff:0}) 83 | } 84 | } 85 | } 86 | if(creep.memory.sources) { 87 | let index = 0; 88 | for(let source of creep.memory.sources) { 89 | if(Game.time - 300 > source.lastBuff) { 90 | let sourceObj:any = Game.getObjectById(source.id); 91 | if(sourceObj) { 92 | let result = usePowerInRange(creep, power, 3, sourceObj); 93 | if(result && result == "success") { 94 | creep.memory.sources[index].lastBuff = Game.time; 95 | } 96 | return; 97 | } 98 | } 99 | index ++; 100 | } 101 | } 102 | } 103 | } 104 | else if(parseInt(power) == PWR_OPERATE_OBSERVER) { 105 | if(creep.powers[power].cooldown == 0) { 106 | if(!creep.memory.observer) { 107 | let observer = creep.room.find(FIND_MY_STRUCTURES, {filter: { structureType : STRUCTURE_OBSERVER}}); 108 | if(observer.length > 0) { 109 | creep.memory.observer = {id:observer[0].id, lastBuff:0}; 110 | } 111 | } 112 | if(creep.memory.observer) { 113 | let lastBuffTimer = creep.powers[power].level * 200; 114 | if(Game.time - lastBuffTimer > creep.memory.observer.lastBuff) { 115 | let observer:any = Game.getObjectById(creep.memory.observer.id); 116 | if(observer) { 117 | let result = usePowerInRange(creep, power, 3, observer); 118 | if(result && result == "success") { 119 | creep.memory.observer.lastBuff = Game.time; 120 | } 121 | return; 122 | } 123 | } 124 | } 125 | } 126 | } 127 | } 128 | } 129 | 130 | 131 | 132 | 133 | function usePowerInRange(creep, power, range, target=false):any { 134 | if(creep.pos.getRangeTo(target) <= range) { 135 | if(creep.usePower(power, target) == 0) { 136 | return "success"; 137 | } 138 | 139 | } 140 | else { 141 | creep.MoveCostMatrixRoadPrio(target, range); 142 | } 143 | } 144 | 145 | 146 | 147 | const roleEfficient = { 148 | run, 149 | //run: run, 150 | //function2, 151 | //function3 152 | }; 153 | export default roleEfficient; 154 | -------------------------------------------------------------------------------- /src/Roles/RangedAttacker.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | // const run = function (creep) { 6 | // creep.harvestEnergy(); 7 | // } 8 | 9 | const run = function (creep) { 10 | ; 11 | 12 | creep.memory.moving = false; 13 | if(creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 14 | let result = creep.Boost(); 15 | if(!result) { 16 | return; 17 | } 18 | } 19 | let enemyCreeps = creep.room.find(FIND_HOSTILE_CREEPS); 20 | let Structures; 21 | 22 | if(creep.hits != creep.hitsMax || (enemyCreeps.length > 0 && creep.pos.getRangeTo(creep.pos.findClosestByRange(enemyCreeps)) <= 4)) { 23 | creep.heal(creep); 24 | } 25 | 26 | if(creep.notifyWhenAttacked == true) { 27 | creep.notifyWhenAttacked(false); 28 | } 29 | 30 | if(creep.memory.targetRoom && creep.memory.targetRoom !== creep.room.name) { 31 | if(!creep.memory.ignore) { 32 | if(enemyCreeps.length > 0) { 33 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 34 | 35 | let isMelee = false; 36 | for(let part of closestEnemyCreep.body) { 37 | if(part.type == ATTACK) { 38 | isMelee = true; 39 | } 40 | } 41 | 42 | if(creep.pos.getRangeTo(closestEnemyCreep) > 3) { 43 | creep.moveTo(closestEnemyCreep); 44 | return; 45 | } 46 | else if(creep.pos.isNearTo(closestEnemyCreep)) { 47 | creep.rangedMassAttack(); 48 | } 49 | else { 50 | creep.rangedAttack(closestEnemyCreep); 51 | creep.moveTo(closestEnemyCreep); 52 | } 53 | if(isMelee && creep.rangedAttack(closestEnemyCreep) == 0) { 54 | creep.RangedAttackFleeFromMelee(closestEnemyCreep); 55 | } 56 | else { 57 | creep.moveTo(closestEnemyCreep); 58 | } 59 | } 60 | } 61 | 62 | return creep.moveToRoomAvoidEnemyRooms(creep.memory.targetRoom); 63 | } 64 | else { 65 | 66 | 67 | if(enemyCreeps.length > 0) { 68 | let closestEnemyCreep = creep.pos.findClosestByRange(enemyCreeps); 69 | 70 | let isMelee = false; 71 | for(let part of closestEnemyCreep.body) { 72 | if(part.type == ATTACK) { 73 | isMelee = true; 74 | } 75 | } 76 | 77 | 78 | if(creep.pos.getRangeTo(closestEnemyCreep) == 1) { 79 | creep.rangedMassAttack() 80 | } 81 | else if(creep.pos.getRangeTo(closestEnemyCreep) == 2 || creep.pos.getRangeTo(closestEnemyCreep) == 3) { 82 | creep.rangedAttack(closestEnemyCreep) 83 | } 84 | 85 | if(isMelee && creep.pos.getRangeTo(closestEnemyCreep) <= 2) { 86 | if(closestEnemyCreep.fatigue == 0) { 87 | creep.RangedAttackFleeFromMelee(closestEnemyCreep); 88 | } 89 | else { 90 | creep.moveTo(creep); 91 | } 92 | } 93 | else if(isMelee && creep.pos.getRangeTo(closestEnemyCreep) == 3) { 94 | 95 | } 96 | else if(!isMelee) { 97 | creep.moveTo(closestEnemyCreep); 98 | } 99 | else { 100 | creep.moveTo(closestEnemyCreep); 101 | } 102 | 103 | if((creep.pos.x == 1 || creep.pos.x == 48 || creep.pos.y == 1 || creep.pos.y == 48) && !isMelee) { 104 | creep.moveTo(creep); 105 | } 106 | 107 | return; 108 | } 109 | 110 | if(creep.room.controller && creep.room.controller.my) { 111 | Structures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 112 | filter: object => object.structureType != STRUCTURE_CONTROLLER && object.structureType != STRUCTURE_ROAD && object.structureType != STRUCTURE_WALL && object.structureType != STRUCTURE_CONTAINER && !object.my 113 | }); 114 | } 115 | else { 116 | Structures = creep.room.find(FIND_HOSTILE_STRUCTURES, { 117 | filter: object => object.structureType != STRUCTURE_CONTROLLER && object.structureType != STRUCTURE_ROAD && object.structureType !== STRUCTURE_CONTAINER}); 118 | } 119 | 120 | 121 | if(Structures.length > 0) { 122 | let closestStructure = creep.pos.findClosestByRange(Structures); 123 | if(creep.pos.isNearTo(closestStructure)) { 124 | creep.rangedAttack(closestStructure); 125 | 126 | } 127 | else{ 128 | creep.MoveCostMatrixRoadPrio(closestStructure, 1); 129 | } 130 | return; 131 | } 132 | 133 | let myConstructionSites = creep.room.find(FIND_MY_CONSTRUCTION_SITES); 134 | if(myConstructionSites.length > 0) { 135 | if(myConstructionSites[0].structureType == STRUCTURE_CONTAINER || myConstructionSites[0].structureType == STRUCTURE_ROAD) { 136 | creep.MoveCostMatrixRoadPrio(myConstructionSites[0], 2); 137 | } 138 | else { 139 | creep.MoveCostMatrixRoadPrio(myConstructionSites[0], 3); 140 | } 141 | } 142 | 143 | 144 | if(enemyCreeps.length == 0 && Structures.length == 0 && creep.ticksToLive % 50 == 0 && creep.memory.sticky == false) { 145 | creep.memory.targetRoom = false; 146 | } 147 | } 148 | 149 | 150 | // if you are afraid of death, look away. 151 | if(Game.time % 35 == 0 && !creep.memory.targetRoom) { 152 | creep.memory.suicide = true; 153 | } 154 | 155 | if(creep.memory.suicide == true) { 156 | creep.recycle(); 157 | return; 158 | } 159 | // suicide section 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | } 169 | 170 | const roleRangedAttacker = { 171 | run, 172 | //run: run, 173 | //function2, 174 | //function3 175 | }; 176 | export default roleRangedAttacker; 177 | -------------------------------------------------------------------------------- /src/Roles/builder.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | function findLocked(creep) { 7 | let buildingsToBuild = creep.room.find(FIND_MY_CONSTRUCTION_SITES); 8 | 9 | if(buildingsToBuild.length > 0) { 10 | let buildings; 11 | if(creep.room.controller.level == 2 ) { 12 | let spawn = creep.room.find(FIND_MY_SPAWNS); 13 | buildings = buildingsToBuild.filter(function(building) {return building.structureType == STRUCTURE_LINK || building.structureType == STRUCTURE_STORAGE || building.pos.x == spawn[0].pos.x && building.pos.y == spawn[0].pos.y -2;}); 14 | } 15 | else { 16 | buildings = buildingsToBuild.filter(function(building) {return building.structureType == STRUCTURE_LINK || building.structureType == STRUCTURE_STORAGE;}); 17 | } 18 | 19 | if(buildings.length > 0) { 20 | creep.memory.suicide = false; 21 | creep.say("🎯", true); 22 | buildings.sort((a,b) => b.progressTotal - a.progressTotal); 23 | return buildings[0].id; 24 | } 25 | } 26 | 27 | if(buildingsToBuild.length > 0) { 28 | let buildings = buildingsToBuild.filter(function(building) {return building.structureType == STRUCTURE_EXTENSION;}); 29 | if(buildings.length > 0) { 30 | creep.memory.suicide = false; 31 | creep.say("🎯", true); 32 | buildings.sort((a,b) => b.progressTotal - a.progressTotal); 33 | return buildings[0].id; 34 | } 35 | } 36 | 37 | if(buildingsToBuild.length > 0) { 38 | let buildings = buildingsToBuild.filter(function(building) {return building.structureType == STRUCTURE_CONTAINER;}); 39 | if(buildings.length > 0) { 40 | creep.memory.suicide = false; 41 | creep.say("🎯", true); 42 | buildings.sort((a,b) => b.progressTotal - a.progressTotal); 43 | return buildings[0].id; 44 | } 45 | } 46 | 47 | if(buildingsToBuild.length > 0) { 48 | creep.memory.suicide = false; 49 | creep.say("🎯", true); 50 | let closestBuildingToBuild = creep.pos.findClosestByRange(buildingsToBuild); 51 | // buildingsToBuild.sort((a,b) => b.progressTotal - a.progressTotal); 52 | // return buildingsToBuild[0].id; 53 | return closestBuildingToBuild.id; 54 | // if building is link or storage build first. 55 | } 56 | creep.memory.suicide = true; 57 | } 58 | 59 | const run = function (creep) { 60 | creep.memory.moving = false; 61 | 62 | if(creep.evacuate()) { 63 | return; 64 | } 65 | 66 | 67 | if(creep.memory.fleeing) { 68 | // find hostiles with attack or ranged attack 69 | let hostiles = creep.room.find(FIND_HOSTILE_CREEPS); 70 | let meleeHostiles = hostiles.filter(c => c.getActiveBodyparts(ATTACK) > 0 ); 71 | let rangedHostiles = hostiles.filter(c => c.getActiveBodyparts(RANGED_ATTACK) > 0 ); 72 | if(rangedHostiles.length) { 73 | let closestRangedHostile = creep.pos.findClosestByRange(rangedHostiles); 74 | if(creep.pos.getRangeTo(closestRangedHostile) <= 8) { 75 | return; 76 | } 77 | } 78 | else if(meleeHostiles.length) { 79 | let closestMeleeHostile = creep.pos.findClosestByRange(meleeHostiles); 80 | if(creep.pos.getRangeTo(closestMeleeHostile) <= 6) { 81 | return; 82 | } 83 | } 84 | } 85 | else if(!creep.memory.danger) { 86 | creep.memory.fleeing = false; 87 | } 88 | 89 | // const start = Game.cpu.getUsed() 90 | 91 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 92 | 93 | if(storage && creep.pos.isNearTo(storage) && creep.getActiveBodyparts(WORK) * 5 >= creep.store[RESOURCE_ENERGY]) { 94 | creep.withdraw(storage, RESOURCE_ENERGY); 95 | } 96 | 97 | if(creep.memory.building && creep.store[RESOURCE_ENERGY] == 0) { 98 | creep.memory.building = false; 99 | } 100 | if(!creep.memory.building && creep.store.getFreeCapacity() == 0) { 101 | creep.memory.building = true; 102 | } 103 | 104 | if(creep.memory.building) { 105 | if(creep.memory.locked) { 106 | let buildTarget = Game.getObjectById(creep.memory.locked); 107 | if(!buildTarget) { 108 | creep.memory.locked = false; 109 | } 110 | } 111 | 112 | if(!creep.memory.locked) { 113 | creep.memory.locked = findLocked(creep); 114 | } 115 | 116 | 117 | 118 | if(creep.memory.locked) { 119 | let buildTarget = Game.getObjectById(creep.memory.locked); 120 | if(buildTarget && creep.build(buildTarget) == ERR_NOT_IN_RANGE) { 121 | creep.MoveCostMatrixRoadPrio(buildTarget, 3); 122 | } 123 | } 124 | } 125 | 126 | else if(!creep.memory.building && storage) { 127 | let result = creep.withdrawStorage(storage); 128 | if(result == 0) { 129 | if(!creep.memory.locked) { 130 | creep.memory.locked = findLocked(creep); 131 | } 132 | if(creep.memory.locked) { 133 | let buildTarget = Game.getObjectById(creep.memory.locked); 134 | creep.MoveCostMatrixRoadPrio(buildTarget, 3); 135 | } 136 | } 137 | } 138 | 139 | else { 140 | let result = creep.acquireEnergyWithContainersAndOrDroppedEnergy(); 141 | if(result == 0) { 142 | if(!creep.memory.locked) { 143 | creep.memory.locked = findLocked(creep); 144 | } 145 | if(creep.memory.locked) { 146 | let buildTarget = Game.getObjectById(creep.memory.locked); 147 | creep.MoveCostMatrixRoadPrio(buildTarget, 3); 148 | } 149 | } 150 | } 151 | if(creep.memory.suicide && creep.store[RESOURCE_ENERGY] == 0 && storage && storage.store[RESOURCE_ENERGY] >= 300) { 152 | creep.memory.suicide = false; 153 | } 154 | // if(creep.ticksToLive <= 30 && !creep.memory.building || storage && storage.store[RESOURCE_ENERGY] < 300 && Game.time % 21 == 0 && creep.store[RESOURCE_ENERGY] == 0) { 155 | // creep.memory.suicide = true; 156 | // } 157 | if(creep.memory.suicide == true) { 158 | let myRamparts = creep.room.find(FIND_MY_STRUCTURES, {filter: (s) => s.structureType == STRUCTURE_RAMPART && (s.hits < 450000 && creep.room.memory.danger || s.hits < 10000)}); 159 | if(myRamparts.length) { 160 | myRamparts.sort((a,b) => a.hits - b.hits); 161 | creep.room.roomTowersRepairTarget(myRamparts[0]); 162 | return; 163 | } 164 | creep.recycle(); 165 | return; 166 | } 167 | 168 | } 169 | 170 | const roleBuilder = { 171 | run, 172 | //run: run, 173 | //function2, 174 | //function3 175 | }; 176 | export default roleBuilder; 177 | -------------------------------------------------------------------------------- /src/Roles/Escort.ts: -------------------------------------------------------------------------------- 1 | const run = function (creep) { 2 | creep.memory.moving = false; 3 | if(creep.room.name === creep.memory.targetRoom) { 4 | if(creep.pos.x >= 2 || creep.pos.x <= 47 || creep.pos.y >= 2 || creep.pos.y <= 47) { 5 | creep.memory.role = "Solomon"; return; 6 | } 7 | else { 8 | creep.moveTo(25,25,{range:20}) 9 | } 10 | } 11 | if (creep.ticksToLive === 1499) { 12 | let room = creep.room; 13 | let newName = "Claimer-" + Math.floor(Math.random() * Game.time) + "-" + room.name; 14 | room.memory.spawn_list.push([TOUGH, MOVE, MOVE, MOVE, MOVE, CLAIM, HEAL, HEAL], newName, { 15 | memory: { 16 | role: "claimer", 17 | targetRoom: creep.memory.targetRoom, 18 | homeRoom: room.name, 19 | boostlabs: [room.memory.labs.outputLab5, room.memory.labs.outputLab7], 20 | line: 2 21 | } 22 | }); 23 | console.log("Adding Claimer to Spawn List: " + newName); 24 | 25 | if(room.memory.labs && room.memory.labs.status && !room.memory.labs.status.boost) { 26 | room.memory.labs.status.boost = {}; 27 | } 28 | if(room.memory.labs.status.boost) { 29 | if(room.memory.labs.status.boost.lab5) { 30 | room.memory.labs.status.boost.lab5.amount += 60; 31 | room.memory.labs.status.boost.lab5.use += 1; 32 | } 33 | else { 34 | room.memory.labs.status.boost.lab5 = {}; 35 | room.memory.labs.status.boost.lab5.amount = 60; 36 | room.memory.labs.status.boost.lab5.use = 1; 37 | } 38 | if(room.memory.labs.status.boost.lab7) { 39 | room.memory.labs.status.boost.lab7.amount += 30; 40 | room.memory.labs.status.boost.lab7.use += 1; 41 | } 42 | else { 43 | room.memory.labs.status.boost.lab7 = {}; 44 | room.memory.labs.status.boost.lab7.amount = 30; 45 | room.memory.labs.status.boost.lab7.use = 1; 46 | } 47 | } 48 | 49 | } 50 | if (creep.memory.boostlabs && creep.memory.boostlabs.length > 0) { 51 | let result = creep.Boost(); 52 | if (!result) { 53 | return; 54 | } 55 | } 56 | 57 | if (!creep.memory.party) { 58 | // filter by creeps with the memory.line property and with role claimer or role RoomLocker 59 | let party = creep.room.find(FIND_MY_CREEPS, {filter: c => (c.memory.role === "RoomLocker" || c.memory.role === "claimer" || c.memory.role === "Escort") && c.memory.line && (!c.memory.boostlabs || c.memory.boostlabs && !c.memory.boostlabs.length)}); 60 | 61 | if (party.length === 3) { 62 | party.sort((a, b) => a.memory.line - b.memory.line); 63 | let partyIDs = party.map(c => c.id); 64 | creep.memory.party = partyIDs; 65 | } 66 | } 67 | 68 | if (creep.memory.party) { 69 | let party = []; 70 | for (let id of creep.memory.party) { 71 | let partyMember = Game.getObjectById(id); 72 | if (partyMember) { 73 | party.push(partyMember); 74 | } 75 | } 76 | party.reverse(); 77 | let allGood = true; 78 | for (let partyMember of party) { 79 | if (partyMember.memory.line === 3 && partyMember.memory.full) { 80 | if (partyMember.room.name === party[1].room.name && !partyMember.pos.isNearTo(party[1])) { 81 | allGood = false; 82 | partyMember.MoveCostMatrixRoadPrio(party[1], 1); 83 | } else if (partyMember.room.name !== party[1].room.name || partyMember.pos.isNearTo(party[1])) { 84 | partyMember.moveTo(party[1]); 85 | } 86 | } else if (partyMember.memory.line === 2 && !partyMember.memory.boostlabs.length) { 87 | if (partyMember.room.name === party[2].room.name && !partyMember.pos.isNearTo(party[2])) { 88 | allGood = false; 89 | partyMember.MoveCostMatrixRoadPrio(party[2], 1); 90 | } else if (partyMember.room.name !== party[2].room.name || partyMember.pos.isNearTo(party[2])) { 91 | partyMember.moveTo(party[2]); 92 | } 93 | } else if (partyMember.memory.line === 1 && !partyMember.memory.boostlabs.length) { 94 | if (allGood) { 95 | partyMember.moveToRoomAvoidEnemyRooms(partyMember.memory.targetRoom); 96 | } 97 | let lowestHealthInParty = party.reduce((lowest, creep) => creep.hits < lowest.hits && creep.hits !== creep.hitsMax ? creep : lowest, party[party.length-1]); 98 | 99 | let hostileCreepsInRange3 = partyMember.pos.findInRange(FIND_HOSTILE_CREEPS, 3); 100 | if(hostileCreepsInRange3.length > 0) { 101 | let closestHostile = partyMember.pos.findClosestByRange(hostileCreepsInRange3); 102 | if(partyMember.pos.isNearTo(closestHostile)) { 103 | partyMember.rangedMassAttack(); 104 | } 105 | else { 106 | partyMember.rangedAttack(closestHostile); 107 | } 108 | } 109 | else if(partyMember.room.name !== partyMember.memory.homeRoom && (!partyMember.room.controller || !partyMember.room.controller.my && !partyMember.room.controller.reservation)) { 110 | // filter structures not mine and not container and not road and not controller and not power bank and not invader core lair and not invader core 111 | 112 | let structures = creep.room.find(FIND_STRUCTURES); 113 | structures = structures.filter(s => !s.my && s.structureType !== STRUCTURE_CONTAINER && s.structureType !== STRUCTURE_ROAD && s.structureType !== STRUCTURE_CONTROLLER && s.structureType !== STRUCTURE_POWER_BANK && s.structureType !== STRUCTURE_INVADER_CORE && s.structureType !== STRUCTURE_KEEPER_LAIR && s.structureType !== STRUCTURE_PORTAL && s.structureType !== STRUCTURE_CONTAINER); 114 | let closestStructure = partyMember.pos.findClosestByRange(structures); 115 | partyMember.rangedAttack(closestStructure); 116 | } 117 | 118 | if(partyMember.room.name === lowestHealthInParty.room.name && partyMember.pos.getRangeTo(lowestHealthInParty) <= 3) { 119 | if(partyMember.pos.getRangeTo(lowestHealthInParty) <= 1) { 120 | partyMember.heal(lowestHealthInParty); 121 | } 122 | else { 123 | partyMember.rangedHeal(lowestHealthInParty); 124 | } 125 | } 126 | else if(partyMember.hits !== partyMember.hitsMax && hostileCreepsInRange3.length || partyMember.room.name === partyMember.memory.targetRoom) { 127 | partyMember.heal(partyMember); 128 | } 129 | } 130 | } 131 | } 132 | }; 133 | 134 | const roleEscort = { 135 | run 136 | //run: run, 137 | //function2, 138 | //function3 139 | }; 140 | export default roleEscort; 141 | -------------------------------------------------------------------------------- /src/Roles/sweeper.ts: -------------------------------------------------------------------------------- 1 | function findLocked(creep) { 2 | let terminal = creep.room.terminal; 3 | if (terminal && terminal.store[RESOURCE_ENERGY] < 10000) { 4 | creep.memory.locked = terminal.id; 5 | return terminal; 6 | } 7 | 8 | if(creep.room.energyCapacityAvailable /1.5 < creep.room.energyAvailable) { 9 | let towers = creep.room.find(FIND_MY_STRUCTURES, {filter: building => (building.structureType == STRUCTURE_TOWER && building.store[RESOURCE_ENERGY] < 200)}); 10 | if(towers.length > 0) { 11 | let closestTower = creep.pos.findClosestByRange(towers); 12 | creep.memory.locked = closestTower.id; 13 | return closestTower; 14 | } 15 | } 16 | 17 | let spawnAndExtensions = creep.room.find(FIND_MY_STRUCTURES, {filter: building => (building.structureType == STRUCTURE_SPAWN || building.structureType == STRUCTURE_EXTENSION || building.structureType == STRUCTURE_TOWER) && building.store.getFreeCapacity(RESOURCE_ENERGY) > 0}); 18 | if(spawnAndExtensions.length > 0) { 19 | let closestDropOffLocation = creep.pos.findClosestByRange(spawnAndExtensions); 20 | creep.memory.locked = closestDropOffLocation.id; 21 | return closestDropOffLocation; 22 | } 23 | 24 | let towers2 = creep.room.find(FIND_MY_STRUCTURES, {filter: building => (building.structureType == STRUCTURE_TOWER && building.store[RESOURCE_ENERGY] >= 0)}); 25 | if(towers2.length > 0) { 26 | let closestTower = creep.pos.findClosestByRange(towers2); 27 | creep.memory.locked = closestTower.id; 28 | return closestTower; 29 | } 30 | } 31 | 32 | 33 | 34 | /** 35 | * A little description of this function 36 | * @param {Creep} creep 37 | **/ 38 | 39 | const run = function (creep) { 40 | creep.memory.moving = false; 41 | if(creep.evacuate()) { 42 | return; 43 | } 44 | if(creep.memory.suicide == true) { 45 | creep.recycle(); 46 | return; 47 | } 48 | if(!creep.memory.MaxStorage) { 49 | let carryPartsAmount = 0 50 | for(let part of creep.body) { 51 | if(part.type == CARRY) { 52 | carryPartsAmount += 1; 53 | } 54 | } 55 | creep.memory.MaxStorage = carryPartsAmount * 50; 56 | } 57 | let MaxStorage = creep.memory.MaxStorage; 58 | 59 | 60 | 61 | 62 | if(creep.memory.full && creep.store.getFreeCapacity() == MaxStorage) { 63 | creep.memory.full = false; 64 | creep.memory.lockedDropped = false; 65 | } 66 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 67 | creep.memory.full = true; 68 | } 69 | 70 | 71 | if(creep.memory.full) { 72 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 73 | if(storage) { 74 | if(creep.pos.isNearTo(storage)) { 75 | for(let resourceType in creep.store) { 76 | creep.transfer(storage, resourceType); 77 | } 78 | } 79 | else { 80 | creep.MoveCostMatrixRoadPrio(storage, 1); 81 | } 82 | } 83 | else { 84 | if(!creep.memory.locked) { 85 | let target = findLocked(creep); 86 | 87 | } 88 | 89 | if(creep.memory.locked) { 90 | 91 | let target:any = Game.getObjectById(creep.memory.locked); 92 | 93 | if(_.keys(target.store).length == 0) { 94 | target = findLocked(creep); 95 | } 96 | 97 | if(creep.pos.isNearTo(target)) { 98 | creep.transfer(target, RESOURCE_ENERGY); 99 | if(creep.store[RESOURCE_ENERGY] == 0) { 100 | creep.memory.full = false; 101 | } 102 | else { 103 | findLocked(creep); 104 | let target:any = Game.getObjectById(creep.memory.locked); 105 | if(!creep.pos.isNearTo(target)) { 106 | creep.MoveCostMatrixIgnoreRoads(target, 1); 107 | } 108 | } 109 | } 110 | else { 111 | creep.MoveCostMatrixIgnoreRoads(target, 1); 112 | } 113 | } 114 | } 115 | } 116 | 117 | else { 118 | 119 | let result = creep.Sweep(); 120 | 121 | if(result == "picked up" && creep.store.getFreeCapacity() == 0) { 122 | let storage = Game.getObjectById(creep.memory.storage) || creep.findStorage(); 123 | if(storage) { 124 | if(creep.pos.isNearTo(storage)) { 125 | if(creep.transfer(storage, RESOURCE_ENERGY) == 0) { 126 | creep.memory.full = false; 127 | } 128 | } 129 | else { 130 | creep.MoveCostMatrixRoadPrio(storage, 1); 131 | } 132 | } 133 | else { 134 | if(!creep.memory.locked) { 135 | let target = findLocked(creep); 136 | } 137 | 138 | if(creep.memory.locked) { 139 | let target = Game.getObjectById(creep.memory.locked); 140 | 141 | if(creep.pos.isNearTo(target)) { 142 | creep.transfer(target, RESOURCE_ENERGY); 143 | if(creep.store[RESOURCE_ENERGY] == 0) { 144 | creep.memory.full = false; 145 | } 146 | else { 147 | findLocked(creep); 148 | let target = Game.getObjectById(creep.memory.locked); 149 | if(!creep.pos.isNearTo(target)) { 150 | creep.MoveCostMatrixIgnoreRoads(target, 1) 151 | } 152 | } 153 | } 154 | else { 155 | creep.MoveCostMatrixIgnoreRoads(target, 1) 156 | } 157 | } 158 | } 159 | } 160 | // && _.keys(creep.store).length == 0 161 | if(result == "nothing to sweep" && creep.ticksToLive <= 1400) { 162 | creep.memory.suicide = true; 163 | } 164 | else if(creep.store.getFreeCapacity() == 0) { 165 | creep.memory.full = true; 166 | } 167 | else { 168 | creep.memory.full = false; 169 | } 170 | 171 | } 172 | creep.memory.moving = false; 173 | 174 | 175 | } 176 | 177 | const roleSweeper = { 178 | run, 179 | //run: run, 180 | //function2, 181 | //function3 182 | }; 183 | export default roleSweeper; 184 | -------------------------------------------------------------------------------- /src/main.ts: -------------------------------------------------------------------------------- 1 | import "./utils/Commands"; 2 | import { ErrorMapper } from "./utils/ErrorMapper"; 3 | import { memHack } from "utils/MemHack"; 4 | import global from "./utils/Global"; 5 | 6 | // import TerrainDataExporter from "./utils/TerrainDataExporter"; 7 | 8 | 9 | import CPUmanager from "Managers/CPUmanager"; 10 | import PowerCreepManager from "Managers/PowerCreepManager"; 11 | import MemoryManager from "Managers/MemoryManager"; 12 | import RunAllCreepsManager from "Managers/RunAllCreepsManager"; 13 | import ExecuteCommandsInNTicks from "Managers/ExecuteCommandsInNTicks"; 14 | import decrementTempBadRooms from "Misc/decrementTempBadRooms"; 15 | 16 | import rooms from "./Rooms/rooms"; 17 | 18 | import "./Functions/powerCreepFunctions" 19 | import "./Functions/creepFunctions"; 20 | import "./Functions/roomFunctions"; 21 | import "./Functions/roomPositionFunctions"; 22 | 23 | import roleMineralMiner from "./Roles/mineralMiner"; 24 | import roleEnergyMiner from "./Roles/energyMiner"; 25 | import roleCarry from "./Roles/carry"; 26 | import roleEnergyManager from "./Roles/energyManager"; 27 | import roleDismantler from "./Roles/Dismantler"; 28 | import roleRemoteRepair from "./Roles/remoteRepair"; 29 | import roleBuilder from "./Roles/builder"; 30 | import roleUpgrader from "./Roles/upgrader"; 31 | import roleRepair from "./Roles/repair"; 32 | import roleMaintainer from "Roles/maintainer"; 33 | import roleFiller from "./Roles/filler"; 34 | import roleFakeFiller from "Roles/FakeFiller"; 35 | import roleControllerLinkFiller from "Roles/ControllerLinkFiller"; 36 | import roleConvoy from "Roles/Convoy"; 37 | import roleDefender from "./Roles/defender"; 38 | import roleAttacker from "./Roles/attacker"; 39 | import roleRangedAttacker from "./Roles/RangedAttacker"; 40 | import roleDrainTower from "./Roles/DrainTower"; 41 | import roleHealer from "./Roles/healer"; 42 | import roleBuildContainer from "./Roles/buildcontainer"; 43 | import roleClaimer from "./Roles/claimer"; 44 | import roleRemoteDismantler from "./Roles/remoteDismantler"; 45 | import roleDismantleControllerWalls from "Roles/DismantleControllerWalls"; 46 | import roleScout from "./Roles/scout"; 47 | import roleSweeper from "Roles/sweeper"; 48 | import roleAnnoy from "Roles/annoy"; 49 | import roleCreepKiller from "Roles/CreepKiller"; 50 | import roleReserve from "Roles/reserve"; 51 | import roleRampartDefender from "Roles/RampartDefender"; 52 | import roleRangedRampartDefender from "Roles/RangedRampartDefender"; 53 | import roleRampartErector from "Roles/RampartErector"; 54 | import roleRam from "Roles/ram"; 55 | import roleSignifer from "Roles/signifer"; 56 | import roleBilltong from "./Roles/billtong" 57 | import roleGoblin from "Roles/goblin"; 58 | import roleSpecialRepair from "Roles/SpecialRepair"; 59 | import roleSpecialCarry from "Roles/SpecialCarry"; 60 | import roleWallClearer from "Roles/WallClearer"; 61 | import roleSquadCreepA from "Roles/Squad/SquadCreepA"; 62 | import roleSquadCreepB from "Roles/Squad/SquadCreepB"; 63 | import roleSquadCreepY from "Roles/Squad/SquadCreepY"; 64 | import roleSquadCreepZ from "Roles/Squad/SquadCreepZ"; 65 | import roleSign from "Roles/Sign"; 66 | import rolePriest from "Roles/Priest"; 67 | import roleGuard from "Roles/Guard"; 68 | import rolePowerMelee from "Roles/PowerMelee"; 69 | import rolePowerHeal from "Roles/PowerHeal"; 70 | import roleEfficient from "Roles/PowerCreeps/efficient"; 71 | import roleSneakyControllerUpgrader from "Roles/SneakyControllerUpgrader"; 72 | import roleSolomon from "Roles/Solomon"; 73 | import roleRampartUpgrader from "Roles/rampartUpgrader"; 74 | import roleContinuousControllerKiller from "Roles/ContinuousControllerKiller"; 75 | import roleClearer from "Roles/clearer"; 76 | import roleSafeModer from "Roles/SafeModer"; 77 | 78 | import roleCCKparty from "Roles/Party/CCKparty"; 79 | import roleFreedomFighter from "Roles/Party/FreedomFighter"; 80 | 81 | import roleRoomLocker from "Roles/RoomLocker"; 82 | import roleEscort from "Roles/Escort"; 83 | 84 | import mosquito from "Roles/mosquito"; 85 | 86 | import mosquito_attack from "Misc/mosquito_attack"; 87 | import mosquito_manager from "Misc/mosquito_manager"; 88 | import { Build_Remote_Roads } from "Rooms/rooms.construction"; 89 | 90 | global.ROLES = { 91 | Solomon: roleSolomon, 92 | RRD: roleRangedRampartDefender, 93 | PowerMelee: rolePowerMelee, 94 | PowerHeal: rolePowerHeal, 95 | MineralMiner: roleMineralMiner, 96 | EnergyMiner: roleEnergyMiner, 97 | carry: roleCarry, 98 | reserve: roleReserve, 99 | EnergyManager: roleEnergyManager, 100 | Dismantler: roleDismantler, 101 | RemoteRepair: roleRemoteRepair, 102 | builder: roleBuilder, 103 | upgrader: roleUpgrader, 104 | repair: roleRepair, 105 | maintainer: roleMaintainer, 106 | filler: roleFiller, 107 | FakeFiller: roleFakeFiller, 108 | ControllerLinkFiller: roleControllerLinkFiller, 109 | defender: roleDefender, 110 | attacker: roleAttacker, 111 | RangedAttacker: roleRangedAttacker, 112 | DrainTower: roleDrainTower, 113 | healer: roleHealer, 114 | buildcontainer: roleBuildContainer, 115 | claimer: roleClaimer, 116 | RemoteDismantler: roleRemoteDismantler, 117 | DismantleControllerWalls: roleDismantleControllerWalls, 118 | scout: roleScout, 119 | sweeper: roleSweeper, 120 | annoy: roleAnnoy, 121 | CreepKiller: roleCreepKiller, 122 | RampartDefender: roleRampartDefender, 123 | RampartErector: roleRampartErector, 124 | signifer: roleSignifer, 125 | ram: roleRam, 126 | billtong: roleBilltong, 127 | goblin: roleGoblin, 128 | SpecialRepair: roleSpecialRepair, 129 | SpecialCarry: roleSpecialCarry, 130 | WallClearer: roleWallClearer, 131 | SquadCreepA: roleSquadCreepA, 132 | SquadCreepB: roleSquadCreepB, 133 | SquadCreepY: roleSquadCreepY, 134 | SquadCreepZ: roleSquadCreepZ, 135 | Sign: roleSign, 136 | Priest: rolePriest, 137 | Guard: roleGuard, 138 | efficient: roleEfficient, 139 | SneakyControllerUpgrader: roleSneakyControllerUpgrader, 140 | Convoy: roleConvoy, 141 | RampartUpgrader: roleRampartUpgrader, 142 | CCK: roleContinuousControllerKiller, 143 | clearer: roleClearer, 144 | SafeModer: roleSafeModer, 145 | CCKparty: roleCCKparty, 146 | FreedomFighter: roleFreedomFighter, 147 | RoomLocker: roleRoomLocker, 148 | Escort: roleEscort, 149 | mosquito: mosquito, 150 | }; 151 | 152 | export const loop = ErrorMapper.wrapLoop(() => { 153 | 154 | 155 | const startTotal = Game.cpu.getUsed(); 156 | 157 | memHack.run() 158 | 159 | MemoryManager(); 160 | 161 | rooms(); 162 | 163 | PowerCreepManager(); 164 | 165 | 166 | 167 | RunAllCreepsManager(); 168 | 169 | mosquito_attack(); 170 | mosquito_manager(); 171 | 172 | ExecuteCommandsInNTicks(); 173 | 174 | decrementTempBadRooms(); 175 | 176 | // TerrainDataExporter(); 177 | // console.log(JSON.stringify(Memory.roomStatuses)) 178 | 179 | let tickTotal = (Game.cpu.getUsed() - startTotal).toFixed(2); 180 | console.log(tickTotal + "ms", "on this tick"); 181 | 182 | 183 | CPUmanager(tickTotal); 184 | global.buildRemoteRoads = function(roomName) { 185 | Build_Remote_Roads(Game.rooms[roomName]); 186 | }; 187 | }); 188 | -------------------------------------------------------------------------------- /src/Roles/filler.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * A little description of this function 3 | * @param {Creep} creep 4 | **/ 5 | 6 | const run = function (creep) { 7 | creep.memory.moving = false; 8 | if(creep.ticksToLive == 1499 || Game.time % 40 == 0) { 9 | creep.room.memory.reserveFill = []; 10 | } 11 | if(creep.evacuate()) { 12 | return; 13 | } 14 | if(creep.ticksToLive == 22 && creep.memory.storage && creep.room.find(FIND_MY_CREEPS, {filter: (c) => {return (c.memory.role == "filler")}}).length == 1) { 15 | let newName = 'filler-'+ Math.floor(Math.random() * Game.time) + "-" + creep.room.name; 16 | if(creep.room.controller.level <= 3 && creep.room.memory.spawn_list) { 17 | creep.room.memory.spawn_list.unshift([CARRY,MOVE], newName, {memory: {role: 'filler'}}); 18 | } 19 | else if(creep.room.controller.level >= 4 && creep.room.controller.level <= 6 && creep.room.memory.spawn_list) { 20 | creep.room.memory.spawn_list.unshift([CARRY,CARRY,CARRY,CARRY,MOVE,MOVE], newName, {memory: {role: 'filler'}}); 21 | } 22 | else if(creep.room.controller.level == 7 && creep.room.memory.spawn_list) { 23 | creep.room.memory.spawn_list.unshift([CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE], newName, {memory: {role: 'filler'}}); 24 | } 25 | else if(creep.room.controller.level == 8 && creep.room.memory.spawn_list) { 26 | creep.room.memory.spawn_list.unshift([CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,CARRY,MOVE,MOVE,MOVE,MOVE], newName, {memory: {role: 'filler'}}); 27 | } 28 | console.log("added filler to spawn queue", creep.room.name) 29 | } 30 | if(creep.ticksToLive <= 14 && !creep.memory.full) { 31 | creep.memory.suicide = true; 32 | } 33 | if(creep.memory.suicide == true) { 34 | creep.recycle(); 35 | return; 36 | } 37 | if(!creep.memory.MaxStorage) { 38 | let carryPartsAmount = 0 39 | for(let part of creep.body) { 40 | if(part.type == CARRY) { 41 | carryPartsAmount += 1; 42 | } 43 | } 44 | creep.memory.MaxStorage = carryPartsAmount * 50; 45 | } 46 | 47 | let MaxStorage = creep.memory.MaxStorage; 48 | 49 | 50 | if(creep.memory.fleeing) { 51 | // find hostiles with attack or ranged attack 52 | let hostiles = creep.room.find(FIND_HOSTILE_CREEPS); 53 | let meleeHostiles = hostiles.filter(c => c.getActiveBodyparts(ATTACK) > 0 ); 54 | let rangedHostiles = hostiles.filter(c => c.getActiveBodyparts(RANGED_ATTACK) > 0 ); 55 | if(rangedHostiles.length) { 56 | let closestRangedHostile = creep.pos.findClosestByRange(rangedHostiles); 57 | if(creep.pos.getRangeTo(closestRangedHostile) <= 5) { 58 | return; 59 | } 60 | } 61 | else if(meleeHostiles.length) { 62 | let closestMeleeHostile = creep.pos.findClosestByRange(meleeHostiles); 63 | if(creep.pos.getRangeTo(closestMeleeHostile) <= 3) { 64 | return; 65 | } 66 | } 67 | } 68 | else if(!creep.memory.danger) { 69 | creep.memory.fleeing = false; 70 | } 71 | 72 | if(!creep.memory.full && creep.store.getFreeCapacity() == 0) { 73 | creep.memory.full = true; 74 | } 75 | if(creep.memory.full) { 76 | if(creep.room.controller && (creep.room.controller.level <= 6 && creep.store[RESOURCE_ENERGY] < 50 || creep.room.controller.level == 7 && creep.store[RESOURCE_ENERGY] < 100 || creep.room.controller.level == 8 && creep.store[RESOURCE_ENERGY] < 200)) { 77 | creep.memory.full = false; 78 | creep.memory.t = false; 79 | } 80 | } 81 | 82 | 83 | 84 | if(!creep.memory.full) { 85 | let bin; 86 | let storage; 87 | if(creep.room.memory.Structures) { 88 | bin = Game.getObjectById(creep.room.memory.Structures.bin) || creep.room.findBin(storage); 89 | storage = Game.getObjectById(creep.room.memory.Structures.storage) || creep.room.findStorage(); 90 | } 91 | if(bin && bin.store[RESOURCE_ENERGY] >= MaxStorage) { 92 | if(creep.pos.isNearTo(bin)) { 93 | let result = creep.withdraw(bin, RESOURCE_ENERGY); 94 | if(result == 0) { 95 | creep.memory.full = true; 96 | } 97 | } 98 | else { 99 | creep.MoveCostMatrixSwampPrio(bin, 1); 100 | } 101 | } 102 | else if(storage && storage.store[RESOURCE_ENERGY] > 0) { 103 | let result = creep.withdrawStorage(storage); 104 | if(result == 0) { 105 | creep.memory.full = true; 106 | } 107 | } 108 | else if(!creep.room.memory.danger) { 109 | creep.acquireEnergyWithContainersAndOrDroppedEnergy(); 110 | } 111 | } 112 | 113 | if(creep.memory.full) { 114 | let storage; 115 | if(creep.room.memory.Structures) { 116 | storage = Game.getObjectById(creep.room.memory.Structures.storage) || creep.room.findStorage(); 117 | } 118 | 119 | 120 | let target = Game.getObjectById(creep.memory.t) || creep.findFillerTarget(); 121 | if(target) { 122 | if(target.store.getFreeCapacity(RESOURCE_ENERGY) == 0) { 123 | target = creep.findFillerTarget(); 124 | } 125 | if(target) { 126 | if(creep.pos.isNearTo(target)) { 127 | let result = creep.transfer(target, RESOURCE_ENERGY); 128 | if(result == 0) { 129 | let indexOfTargetId = creep.room.memory.reserveFill.indexOf(target.id); 130 | if(indexOfTargetId !== -1) { 131 | creep.room.memory.reserveFill = creep.room.memory.reserveFill.splice(indexOfTargetId, 1); 132 | } 133 | } 134 | if(creep.store[RESOURCE_ENERGY] > target.store.getFreeCapacity(RESOURCE_ENERGY)) { 135 | let newTarget = creep.findFillerTarget(); 136 | if(newTarget && creep.pos.getRangeTo(newTarget) > 1) { 137 | creep.MoveCostMatrixRoadPrio(newTarget, 1); 138 | } 139 | } 140 | else { 141 | creep.memory.full = false; 142 | if(storage) { 143 | creep.MoveCostMatrixRoadPrio(storage, 1); 144 | } 145 | } 146 | } 147 | else { 148 | if(creep.room.memory.danger) { 149 | creep.moveToSafePositionToRepairRampart(target, 1); 150 | }else { 151 | creep.MoveCostMatrixRoadPrio(target, 1) 152 | 153 | } 154 | } 155 | } 156 | } 157 | 158 | } 159 | } 160 | 161 | const roleFiller = { 162 | run, 163 | //run: run, 164 | //function2, 165 | //function3 166 | }; 167 | export default roleFiller; 168 | --------------------------------------------------------------------------------