Davaned Production

src/Colony.ts

@@ -3,6 +3,7 @@ import {$} from './caching/GlobalCache';
 import {log} from './console/log';
 import {StoreStructure} from './declarations/typeGuards';
 import {DirectiveExtract} from './directives/resource/extract';
+import {DirectivePoisonRoom} from './directives/offense/poisonRoom';
 import {_HARVEST_MEM_DOWNTIME, _HARVEST_MEM_USAGE, DirectiveHarvest} from './directives/resource/harvest';
 import {HiveCluster} from './hiveClusters/_HiveCluster';
 import {CommandCenter} from './hiveClusters/commandCenter';
@@ -311,7 +312,7 @@ export class Colony {
 		$.set(this, 'sources', () => _.sortBy(_.flatten(_.map(this.rooms, room => room.sources)),
 											  source => source.pos.getMultiRoomRangeTo(this.pos)));
 		for (const source of this.sources) {
-			DirectiveHarvest.createIfNotPresent(source.pos, 'pos');
+			!DirectivePoisonRoom.isPresent(source.pos, 'room') && DirectiveHarvest.createIfNotPresent(source.pos, 'pos');
 		}
 		$.set(this, 'extractors', () =>
 			_(this.rooms)
@@ -320,7 +321,7 @@ export class Colony {
 				.filter(e => (e!.my && e!.room.my)
 							 || Cartographer.roomType(e!.room.name) != ROOMTYPE_CONTROLLER)
 				.sortBy(e => e!.pos.getMultiRoomRangeTo(this.pos)).value() as StructureExtractor[]);
-		if (this.controller.level >= 6) {
+		if (this.controller.level >= 6 && this.terminal) {
 			_.forEach(this.extractors, extractor => DirectiveExtract.createIfNotPresent(extractor.pos, 'pos'));
 		}
 		$.set(this, 'repairables', () => _.flatten(_.map(this.rooms, room => room.repairables)));
@@ -546,6 +547,13 @@ export class Colony {
 		return allAssets;
 	}
 
+	private runPowerSpawn() {
+		if (this.powerSpawn && this.assets.energy > 300000 && this.powerSpawn.energy > 50
+			&& this.powerSpawn.power > 0) {
+			this.powerSpawn.processPower();
+		}
+	}
+
 	/**
 	 * Initializes the state of the colony each tick
 	 */
@@ -567,6 +575,7 @@ export class Colony {
 		this.linkNetwork.run();												// Run the link network
 		this.roadLogistics.run();											// Run the road network
 		this.roomPlanner.run();												// Run the room planner
+		this.runPowerSpawn();												// Run power spawn - short term
 		this.stats();														// Log stats per tick
 	}
 

src/Overseer.ts

@@ -8,6 +8,7 @@ import {DirectiveOutpost} from './directives/colony/outpost';
 import {DirectiveGuard} from './directives/defense/guard';
 import {DirectiveInvasionDefense} from './directives/defense/invasionDefense';
 import {DirectiveOutpostDefense} from './directives/defense/outpostDefense';
+import {DirectivePoisonRoom} from './directives/offense/poisonRoom';
 import {Directive} from './directives/Directive';
 import {Notifier} from './directives/Notifier';
 import {DirectiveBootstrap} from './directives/situational/bootstrap';
@@ -215,7 +216,7 @@ export class Overseer implements IOverseer {
 				// Place defensive directive after hostiles have been present for a long enough time
 				const safetyData = RoomIntel.getSafetyData(colony.room.name);
 				const invasionIsPersistent = safetyData.unsafeFor > 20;
-				if (invasionIsPersistent) {
+				if (invasionIsPersistent && !DirectivePoisonRoom.isPresent(colony.pos, 'room')) {
 					DirectiveInvasionDefense.createIfNotPresent(colony.controller.pos, 'room');
 				}
 			}
@@ -242,10 +243,14 @@ export class Overseer implements IOverseer {
 			if (alreadyAColony || alreadyAnOutpost) {
 				return false;
 			}
-			const alreadyOwned = RoomIntel.roomOwnedBy(roomName);
-			const alreadyReserved = RoomIntel.roomReservedBy(roomName);
-			const disregardReservations = !onPublicServer() || MY_USERNAME == MUON;
-			if (alreadyOwned || (alreadyReserved && !disregardReservations)) {
+			let alreadyOwned = RoomIntel.roomOwnedBy(roomName);
+			let alreadyReserved = RoomIntel.roomReservedBy(roomName);
+			let isBlocked = Game.flags[roomName+"-Block"] != null;
+			if (isBlocked) {
+				//Game.notify("Room " + roomName + " is blocked, not expanding there.");
+			}
+			let disregardReservations = !onPublicServer() || MY_USERNAME == MUON;
+			if (alreadyOwned || (alreadyReserved && !disregardReservations) || isBlocked) {
 				return false;
 			}
 			const neighboringRooms = _.values(Game.map.describeExits(roomName)) as string[];
@@ -297,7 +302,8 @@ export class Overseer implements IOverseer {
 			}
 			// Place pioneer directives in case the colony doesn't have a spawn for some reason
 			if (Game.time % 25 == 0 && colony.spawns.length == 0 &&
-				!DirectiveClearRoom.isPresent(colony.pos, 'room')) {
+				!DirectiveClearRoom.isPresent(colony.pos, 'room') &&
+				!DirectivePoisonRoom.isPresent(colony.pos, 'room')) {
 				// verify that there are no spawns (not just a caching glitch)
 				const spawns = Game.rooms[colony.name]!.find(FIND_MY_SPAWNS);
 				if (spawns.length == 0) {

src/console/Console.ts

@@ -5,6 +5,7 @@ import {color, toColumns} from '../utilities/utils';
 import {asciiLogoRL, asciiLogoSmall} from '../visuals/logos';
 import {DEFAULT_OVERMIND_SIGNATURE, MY_USERNAME, USE_PROFILER} from '../~settings';
 import {log} from './log';
+import {Overlord} from "../overlords/Overlord";
 
 type RecursiveObject = { [key: string]: number | RecursiveObject };
 
@@ -26,6 +27,7 @@ export class OvermindConsole {
 		global.setLogLevel = log.setLogLevel;
 		global.suspendColony = this.suspendColony;
 		global.unsuspendColony = this.unsuspendColony;
+		global.listSuspendedColonies = this.listSuspendedColonies;
 		global.openRoomPlanner = this.openRoomPlanner;
 		global.closeRoomPlanner = this.closeRoomPlanner;
 		global.cancelRoomPlanner = this.cancelRoomPlanner;
@@ -36,6 +38,7 @@ export class OvermindConsole {
 		global.listConstructionSites = this.listConstructionSites;
 		global.listDirectives = this.listDirectives;
 		global.listPersistentDirectives = this.listPersistentDirectives;
+		global.directiveInfo = this.directiveInfo;
 		global.removeAllLogisticsDirectives = this.removeAllLogisticsDirectives;
 		global.removeFlagsByColor = this.removeFlagsByColor;
 		global.removeErrantFlags = this.removeErrantFlags;
@@ -44,6 +47,7 @@ export class OvermindConsole {
 		global.endRemoteDebugSession = this.endRemoteDebugSession;
 		global.profileMemory = this.profileMemory;
 		global.cancelMarketOrders = this.cancelMarketOrders;
+		global.setRoomUpgradeRate = this.setRoomUpgradeRate;
 	}
 
 	// Help, information, and operational changes ======================================================================
@@ -68,6 +72,7 @@ export class OvermindConsole {
 		descr['setLogLevel(int)'] = 'set the logging level from 0 - 4';
 		descr['suspendColony(roomName)'] = 'suspend operations within a colony';
 		descr['unsuspendColony(roomName)'] = 'resume operations within a suspended colony';
+		descr['listSuspendedColonies()'] = 'Prints all suspended colonies';
 		descr['openRoomPlanner(roomName)'] = 'open the room planner for a room';
 		descr['closeRoomPlanner(roomName)'] = 'close the room planner and save changes';
 		descr['cancelRoomPlanner(roomName)'] = 'close the room planner and discard changes';
@@ -78,6 +83,7 @@ export class OvermindConsole {
 		descr['listConstructionSites(filter?)'] = 'list all construction sites matching an optional filter';
 		descr['listDirectives(filter?)'] = 'list directives, matching a filter if specified';
 		descr['listPersistentDirectives()'] = 'print type, name, pos of every persistent directive';
+		descr['directiveInfo(directiveFlag)'] = 'print type, name, pos of every creep in directive';
 		descr['removeFlagsByColor(color, secondaryColor)'] = 'remove flags that match the specified colors';
 		descr['removeErrantFlags()'] = 'remove all flags which don\'t match a directive';
 		descr['deepCleanMemory()'] = 'deletes all non-critical portions of memory (be careful!)';
@@ -250,6 +256,17 @@ export class OvermindConsole {
 		}
 	}
 
+	static listSuspendedColonies(): string {
+		let msg = 'Colonies currently suspended: \n';
+		for (let i in Memory.colonies) {
+			let colonyMemory = Memory.colonies[i] as ColonyMemory | undefined;
+			if (colonyMemory && colonyMemory.suspend == true) {
+				msg += 'Colony ' + i + ' \n';
+			}
+		}
+		return msg;
+	}
+
 	// Room planner control ============================================================================================
 
 	static openRoomPlanner(roomName: string): string {
@@ -377,6 +394,40 @@ export class OvermindConsole {
 		return `Removed ${count} flags.`;
 	}
 
+	static directiveInfo(flagName: string): string {
+		let msg = '';
+		let directive = Overmind.directives[flagName];
+		if (!directive) {
+			return `ERROR: Name is not a current directive`
+		}
+		msg += `Type: ${directive.directiveName}`.padRight(20) +
+			`Name: ${directive.name}`.padRight(25) +
+			`Pos: ${directive.pos.print}\n`;
+		for (let overlordName of Object.keys(directive.overlords)) {
+			let overlord = directive.overlords[overlordName] as Overlord;
+			msg += JSON.stringify(overlord.creepUsageReport) + `\n`;
+			let zerg = overlord.getZerg();
+			let combatZerg = overlord.getCombatZerg();
+			for (let [roleName, zergArray] of Object.entries(zerg)) {
+				msg += `Role: ${roleName} \n`;
+				for (let zerg of zergArray) {
+					msg += `Name: ${zerg.name}   Room: ${zerg.pos.print}   TTL/Spawning: ${zerg.ticksToLive || zerg.spawning} \n`;
+				}
+			}
+			msg += `Combat zerg \n`;
+			for (let [roleName, zergArray] of Object.entries(combatZerg)) {
+				msg += `Role: ${roleName} \n`;
+				for (let zerg of zergArray) {
+					msg += `Name: ${zerg.name}   Room: ${zerg.pos.print}   TTL/Spawning: ${zerg.ticksToLive || zerg.spawning} \n`;
+				}
+			}
+		}
+
+		return msg;
+	}
+
+
+
 
 	// Structure management ============================================================================================
 
@@ -419,6 +470,15 @@ export class OvermindConsole {
 		return `Destroyed ${room.barriers.length} barriers.`;
 	}
 
+	// Colony Management =================================================================================================
+
+	static setRoomUpgradeRate(roomName: string, rate: number): string {
+		let colony: Colony = Overmind.colonies[roomName];
+		colony.upgradeSite.memory.speedFactor = rate;
+
+		return `Colony ${roomName} is now upgrading at a rate of ${rate} barriers.`;
+	}
+
 
 	// Memory management ===============================================================================================
 

src/creepSetups/setups.ts

@@ -23,6 +23,9 @@ export const Roles = {
 	healer    : 'transfuser',
 	bunkerGuard : 'bunkerGuard',
 	dismantler: 'lurker',
+	drill : 'drill',
+	coolant : 'coolant',
+	roomPoisoner: 'salter',
 };
 
 /**
@@ -32,8 +35,9 @@ export const Setups = {
 
 	drones: {
 		extractor: new CreepSetup(Roles.drone, {
-			pattern  : [WORK, WORK, CARRY, MOVE],
+			pattern  : [WORK, WORK, MOVE],
 			sizeLimit: Infinity,
+			prefix: [CARRY, CARRY]
 		}),
 
 		miners: {
@@ -178,7 +182,12 @@ export const Setups = {
 			sizeLimit: 5,
 		}),
 
-	}
+	},
+
+	roomPoisoner: new CreepSetup(Roles.roomPoisoner, {
+		pattern  : [WORK, CARRY, MOVE, MOVE],
+		sizeLimit: 4,
+	}),
 
 };
 
@@ -230,14 +239,19 @@ export const CombatSetups = {
 			sizeLimit: Infinity,
 		}),
 
+		distraction:  new CreepSetup(Roles.ranged, {
+			pattern  : [MOVE, MOVE, MOVE, RANGED_ATTACK, MOVE],
+			sizeLimit: 1,
+		}),
+
 		default: new CreepSetup(Roles.ranged, {
 			pattern  : [RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, MOVE, MOVE, MOVE, MOVE, HEAL],
 			sizeLimit: Infinity,
 		}),
 
 		boosted_T3: new CreepSetup(Roles.ranged, {
-			pattern  : [TOUGH, TOUGH, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK,
-						MOVE, MOVE, HEAL],
+			pattern  : [TOUGH, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK,
+						MOVE, MOVE, HEAL, HEAL],
 			sizeLimit: Infinity,
 		}),
 
@@ -349,4 +363,23 @@ export const CombatSetups = {
 
 	},
 
+	drill: {
+		default: new CreepSetup(Roles.drill, {
+			pattern  : [MOVE, ATTACK, ATTACK, MOVE],
+			sizeLimit: Infinity,
+		}),
+	},
+
+	coolant: {
+		default: new CreepSetup(Roles.coolant, {
+			pattern  : [HEAL, MOVE],
+			sizeLimit: Infinity,
+		}),
+		small: new CreepSetup(Roles.coolant, {
+			pattern  : [HEAL, MOVE],
+			sizeLimit: 16,
+		}),
+	}
+
+
 };

src/declarations/memory.d.ts

@@ -1,4 +1,11 @@
 type operationMode = 'manual' | 'semiautomatic' | 'automatic';
+/**
+ * 0: Basic
+ * 1: Collect from enemy storage/terminal
+ * 2: Collect from all sources TBD
+ * 3: Collect all and mine walls for energy TBD
+ */
+type resourceCollectionMode = number;
 
 interface RawMemory {
 	_parsed: any;
@@ -21,14 +28,25 @@ interface Memory {
 		operationMode: operationMode;
 		log: LoggerMemory;
 		enableVisuals: boolean;
-	};
+		resourceCollectionMode: resourceCollectionMode;
+		powerCollection: {
+			enabled: boolean;
+			maxRange: number;
+			minPower: number;
+		};
+	}
 	profiler?: any;
 	stats: any;
 	constructionSites: { [id: string]: number };
 	// suspend?: number;
 	resetBucket?: boolean;
 	haltTick?: number;
 	combatPlanner: any;
+	reinforcementLearning?: any;
+	playerCreepTracker: {
+		[playerName: string]: CreepTracker
+	};
+	zoneRooms: { [roomName: string]: { [type: string]: number} };
 	reinforcementLearning?: {
 		enabled?: boolean;
 		verbosity?: number;
@@ -127,6 +145,13 @@ interface PathingMemory {
 	weightedDistances: { [pos1Name: string]: { [pos2Name: string]: number; } };
 }
 
+interface CreepTracker {
+	creeps: { [name: string]: number }; 	// first tick seen
+	types: { [type: string]:  number}; 		// amount seen
+	parts: { [bodyPart: string]: number}; 	// quantity
+	boosts: { [boostType: string]: number};	// how many boosts are spent
+}
+
 interface FlagMemory {
 	[_MEM.TICK]?: number;
 	[_MEM.EXPIRATION]?: number;

src/declarations/prototypes.d.ts

@@ -7,6 +7,17 @@ interface Creep {
 	inRampart: boolean;
 }
 
+interface PowerCreep {
+	hitsPredicted?: number;
+	intel?: { [property: string]: number };
+	memory: CreepMemory;
+	fatigue: number;
+	body: BodyPartDefinition[];
+	boosts: _ResourceConstantSansEnergy[];
+	boostCounts: { [boostType: string]: number };
+	inRampart: boolean;
+}
+
 interface ConstructionSite {
 	isWalkable: boolean;
 }

src/directives/Directive.ts

@@ -317,6 +317,7 @@ export abstract class Directive {
 		if (this.isPresent(pos, scope)) {
 			return; // do nothing if flag is already here
 		}
+
 		const room = Game.rooms[pos.roomName] as Room | undefined;
 		if (!room) {
 			if (!opts.memory) {