diff --git a/src/Overseer.ts b/src/Overseer.ts
index 051485ca3..b6293ec16 100644
--- a/src/Overseer.ts
+++ b/src/Overseer.ts
@@ -12,6 +12,7 @@ import {DirectivePoisonRoom} from './directives/offense/poisonRoom';
 import {Directive} from './directives/Directive';
 import {Notifier} from './directives/Notifier';
 import {DirectiveBootstrap} from './directives/situational/bootstrap';
+import {DirectiveDismantle} from './directives/targeting/dismantle';
 import {DirectiveNukeResponse} from './directives/situational/nukeResponse';
 import {DirectiveTerminalEvacuateState} from './directives/terminalState/terminalState_evacuate';
 import {RoomIntel} from './intel/RoomIntel';
@@ -203,10 +204,18 @@ export class Overseer implements IOverseer {
 				}
 			}
 			if (Game.time % 55 == 0) {
-				let cores = room.hostileStructures.filter(s => s.structureType.toString() == 'invaderCore');
-				if (cores.length > 0) {
+				let cores = room.hostileStructures.filter(s => s.structureType as any === 'invaderCore');
+				if (cores.length > 0 && <number>_.get(cores[0],['level']) == 0) {
 					log.alert(`Found core in ${room.name} with ${cores[0]}`);
 					let res = DirectiveModularDismantle.createIfNotPresent(cores[0].pos, 'pos');
+					DirectiveDismantle.createIfNotPresent(cores[0].pos, 'pos');
+					if (!!res) {
+						log.notify(`Creating stronghold clearing dismantle in room ${room.name}`);
+					}
+				} else if (cores.length > 0 && <number>_.get(cores[0],['level']) < 3) {
+					log.alert(`Found core in ${room.name} with ${cores[0]}`);
+					let res = DirectivePairDestroy.createIfNotPresent(cores[0].pos, 'pos', {name: ('pairDestroy:' + room.name)});
+					DirectiveDismantle.createIfNotPresent(cores[0].pos, 'pos');
 					if (!!res) {
 						log.notify(`Creating stronghold clearing dismantle in room ${room.name}`);
 					}
diff --git a/src/creepSetups/setups.ts b/src/creepSetups/setups.ts
index 0d243fc30..44436aad0 100644
--- a/src/creepSetups/setups.ts
+++ b/src/creepSetups/setups.ts
@@ -53,7 +53,8 @@ export const Setups = {
 			}),
 
 			standardCPU: new CreepSetup(Roles.drone, {
-				pattern  : [WORK, WORK, WORK, WORK, WORK, WORK, WORK, CARRY, MOVE, MOVE, MOVE, MOVE, WORK],
+				// pattern  : [WORK, WORK, WORK, WORK, WORK, WORK, WORK, CARRY, MOVE, MOVE, MOVE, MOVE, WORK],
+				pattern: [ WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, CARRY, MOVE, MOVE, MOVE, MOVE, MOVE],
 				sizeLimit: 1,
 			}),
 
@@ -75,6 +76,12 @@ export const Setups = {
 			sourceKeeper: new CreepSetup(Roles.drone, {
 				pattern  : [WORK, WORK, CARRY, MOVE],
 				sizeLimit: 5,
+			}),
+
+			sourceKeeperHeal: new CreepSetup(Roles.drone, {
+				pattern: [CARRY, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, WORK, 
+							MOVE, MOVE, MOVE, MOVE, MOVE, MOVE, HEAL],
+				sizeLimit: 1,
 			})
 		}
 	},
@@ -223,7 +230,8 @@ export const CombatSetups = {
 	zerglings: {
 
 		default: new CreepSetup(Roles.melee, {
-			pattern  : [ATTACK, MOVE],
+			// pattern  : [ATTACK, MOVE],
+			pattern  : [MOVE, ATTACK],
 			sizeLimit: Infinity,
 		}),
 
@@ -280,7 +288,8 @@ export const CombatSetups = {
 		}),
 
 		default: new CreepSetup(Roles.ranged, {
-			pattern  : [RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, MOVE, MOVE, MOVE, MOVE, HEAL],
+			// pattern  : [RANGED_ATTACK, RANGED_ATTACK, RANGED_ATTACK, MOVE, MOVE, MOVE, MOVE, HEAL],
+			pattern: [MOVE, MOVE, MOVE, MOVE,RANGED_ATTACK, RANGED_ATTACK, HEAL, HEAL],
 			sizeLimit: Infinity,
 		}),
 
@@ -320,7 +329,8 @@ export const CombatSetups = {
 	healers: {
 
 		default: new CreepSetup(Roles.healer, {
-			pattern  : [HEAL, MOVE],
+			// pattern  : [HEAL, MOVE],
+			pattern  : [MOVE, HEAL],
 			sizeLimit: Infinity,
 		}),
 
@@ -347,7 +357,8 @@ export const CombatSetups = {
 		}),
 
 		default: new CreepSetup(Roles.guardMelee, {
-			pattern  : [TOUGH, ATTACK, ATTACK, ATTACK, MOVE, MOVE, MOVE, MOVE, MOVE, HEAL],
+			// pattern  : [TOUGH, ATTACK, ATTACK, ATTACK, MOVE, MOVE, MOVE, MOVE, MOVE, HEAL],
+			pattern: [MOVE, MOVE, MOVE, MOVE,ATTACK, ATTACK,ATTACK, HEAL, HEAL, MOVE],
 			sizeLimit: Infinity,
 		}),
 
diff --git a/src/declarations/memory.d.ts b/src/declarations/memory.d.ts
index b6228c099..b70bab816 100644
--- a/src/declarations/memory.d.ts
+++ b/src/declarations/memory.d.ts
@@ -26,9 +26,11 @@ interface Memory {
 	settings: {
 		signature: string;
 		operationMode: operationMode;
+		resourcesBlackList: [string],
 		log: LoggerMemory;
 		enableVisuals: boolean;
 		allies: string[];
+		autoAttack: boolean;
 		resourceCollectionMode: resourceCollectionMode;
 		powerCollection: {
 			enabled: boolean;
diff --git a/src/directives/defense/invasionDefense.ts b/src/directives/defense/invasionDefense.ts
index f2af6c8a8..d849c828e 100644
--- a/src/directives/defense/invasionDefense.ts
+++ b/src/directives/defense/invasionDefense.ts
@@ -145,9 +145,9 @@ export class DirectiveInvasionDefense extends Directive {
 			// clean up, ya this shit
 			this.cleanUpPlayerMem();
 		}
-		if (this.room && (this.room!.name == 'W13N45' || this.room!.name == 'W18N49')) {
-			CombatIntel.computeCreepDamagePotentialMatrix(this.room, this.room.dangerousPlayerHostiles);
-		}
+		//if (this.room && (this.room!.name == 'W13N45' || this.room!.name == 'W18N49')) {
+		//	CombatIntel.computeCreepDamagePotentialMatrix(this.room, this.room.dangerousPlayerHostiles);
+		//}
 		// If there are no hostiles left in the room and everyone's healed, then remove the flag
 		if (this.room && this.room.hostiles.length == 0 &&
 			(Game.time - this.memory.safeSince) > this.safeEndTime) {
diff --git a/src/directives/offense/pairDestroy.ts b/src/directives/offense/pairDestroy.ts
index 8d47efdbd..350118a5e 100644
--- a/src/directives/offense/pairDestroy.ts
+++ b/src/directives/offense/pairDestroy.ts
@@ -21,8 +21,6 @@ export class DirectivePairDestroy extends Directive {
 	static color = COLOR_RED;
 	static secondaryColor = COLOR_CYAN;
 
-	specialRooms: ['W16N53'];
-
 	overlords: {
 		destroy: PairDestroyerOverlord;
 		distraction: DistractionOverlord;
@@ -42,8 +40,7 @@ export class DirectivePairDestroy extends Directive {
 
 	run(): void {
 		// If there are no hostiles left in the room then remove the flag and associated healpoint
-		if (this.room && this.room.hostiles.length == 0 && this.room.hostileStructures.length == 0 && this.room.controller
-			&& this.room.name != 'W17N47' && this.room.name != 'W16N53' && this.room.name != 'W16N54') {
+		if (this.room && this.room.hostiles.length == 0 && this.room.hostileStructures.length == 0 && this.room.controller) {
 			log.notify(`Pair destroyer mission at ${this.pos.roomName} completed successfully.`);
 			this.remove();
 		}
diff --git a/src/directives/powerCreeps/baseOperator.ts b/src/directives/powerCreeps/baseOperator.ts
index cbc14be57..c08093b32 100644
--- a/src/directives/powerCreeps/baseOperator.ts
+++ b/src/directives/powerCreeps/baseOperator.ts
@@ -7,6 +7,8 @@ import {Power} from "./powers/genericPower";
 import {GenerateOps} from "./powers/generateOps";
 import {DirectiveNukeResponse} from "../situational/nukeResponse";
 import {OperateExtension} from "./powers/operateExtension";
+import {OperateSource} from "./powers/operateSource";
+import {OperateSpawn} from "./powers/operateSpawn";
 
 
 interface DirectiveBaseOperatorMemory extends FlagMemory {
@@ -93,152 +95,48 @@ export class DirectiveBaseOperator extends Directive {
 
 	usePower(powerCreep: PowerCreep, power: PowerConstant) {
 		//console.log(`The power constant is ${power}`)
-		switch(power) {
+		switch (power) {
 			case PWR_GENERATE_OPS: return new GenerateOps(powerCreep);
 			case PWR_OPERATE_EXTENSION: return new OperateExtension(powerCreep);
-//			case PWR_OPERATE_SPAWN: return this.operateSpawn();
+			case PWR_REGEN_SOURCE: return new OperateSource(powerCreep);
+			case PWR_OPERATE_SPAWN: return new OperateSpawn(powerCreep);
 		}
 
 	}
-	//
-	// /**
-	//  * Generate 1/2/4/6/8 ops resource units. Cooldown 50 ticks. Required creep level: 0/2/7/14/22.
-	//  */
-	// generateOps() {
-	// 	if (powerCreep.powers[PWR_GENERATE_OPS].cooldown !> 0) {
-	// 		return powerCreep.usePower(PWR_GENERATE_OPS);
-	// 	}
-	// 	return ERR_TIRED;
-	// }
-	//
-	// operateSpawn(spawn?: StructureSpawn) {
-	// 	// if (powerCreep.powers[PWR_oper])
-	// 	// if (!spawn) {
-	// 	// 	spawn = _.first(this.room!.spawns.filter(spawn => spawn.effects.length == 0));
-	// 	// 	if (!spawn) {
-	// 	// 		return ERR;
-	// 	// 	}
-	// 	// }
-	// 	if (this.pos.inRangeToPos(spawn.pos, 1)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_SPAWN, spawn);
-	// 	} else {
-	// 		return powerCreep.moveTo(spawn);
-	// 	}
-	// }
-	//
-	// operateTower(tower: StructureTower) {
-	// 	if (this.pos.inRangeToPos(tower.pos, POWER_INFO[PWR_OPERATE_TOWER].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_TOWER, tower);
-	// 	} else {
-	// 		return powerCreep.moveTo(tower);
-	// 	}
-	// }
-	//
-	// operateStorage(storage: StructureStorage) {
-	// 	if (this.pos.inRangeToPos(storage.pos, POWER_INFO[PWR_OPERATE_STORAGE].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_STORAGE, storage);
-	// 	} else {
-	// 		return powerCreep.moveTo(storage);
-	// 	}
-	// }
-	//
-	// operateExtensions(container: StructureStorage | StructureTerminal | StructureContainer) {
-	// 	if (this.pos.inRangeToPos(container.pos, POWER_INFO[PWR_OPERATE_EXTENSION].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_EXTENSION, container);
-	// 	} else {
-	// 		return powerCreep.moveTo(container);
-	// 	}
-	// }
-	//
-	// operateObserver(observer: StructureObserver) {
-	// 	if (this.pos.inRangeToPos(observer.pos, POWER_INFO[PWR_OPERATE_OBSERVER].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_OBSERVER, observer);
-	// 	} else {
-	// 		return powerCreep.moveTo(observer);
-	// 	}
-	// }
-	//
-	// operateTerminal(terminal: StructureTerminal) {
-	// 	if (this.pos.inRangeToPos(terminal.pos, POWER_INFO[PWR_OPERATE_TERMINAL].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_TERMINAL, terminal);
-	// 	} else {
-	// 		return powerCreep.moveTo(terminal);
-	// 	}
-	// }
-	//
-	// operatePower(power: StructurePowerSpawn) {
-	// 	if (this.pos.inRangeToPos(power.pos, POWER_INFO[PWR_OPERATE_POWER].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_POWER, power);
-	// 	} else {
-	// 		return powerCreep.moveTo(power);
-	// 	}
-	// }
-	//
-	// operateController(controller: StructureController) {
-	// 	if (this.pos.inRangeToPos(controller.pos, POWER_INFO[PWR_OPERATE_CONTROLLER].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_CONTROLLER, controller);
-	// 	} else {
-	// 		return powerCreep.moveTo(controller);
-	// 	}
-	// }
-	//
-	// // operateFactory(factory: StructureFactory) {
-	// // 	if (this.pos.inRangeToPos(factory.pos, POWER_INFO[PWR_OPERATE_FACTORY].range)) {
-	// // 		return powerCreep.usePower(PWR_OPERATE_FACTORY, factory);
-	// // 	} else {
-	// // 		return this.moveTo(factory);
-	// // 	}
-	// // }
-	//
-	// shield() {
-	// 	if (powerCreep.powers[PWR_SHIELD].cooldown !> 0) {
-	// 		return powerCreep.usePower(PWR_SHIELD);
-	// 	}
-	// 	return ERR_TIRED;
-	// }
-	//
-	// regenSource(source : Source) {
-	// 	if (this.pos.inRangeToPos(source.pos, POWER_INFO[PWR_REGEN_SOURCE].range)) {
-	// 		return powerCreep.usePower(PWR_REGEN_SOURCE, source);
-	// 	} else {
-	// 		return powerCreep.moveTo(source);
-	// 	}
-	// }
-	//
-	// regenMineral(mineral: Mineral) {
-	// 	if (this.pos.inRangeToPos(mineral.pos, POWER_INFO[PWR_REGEN_MINERAL].range)) {
-	// 		return powerCreep.usePower(PWR_REGEN_MINERAL, mineral);
-	// 	} else {
-	// 		return powerCreep.moveTo(mineral);
-	// 	}
-	// }
-	//
-	// fortify(rampart: StructureRampart) {
-	// 	if (this.pos.inRangeToPos(rampart.pos, POWER_INFO[PWR_FORTIFY].range)) {
-	// 		return powerCreep.usePower(PWR_FORTIFY, rampart);
-	// 	} else {
-	// 		return powerCreep.moveTo(rampart);
-	// 	}
-	// }
-	//
-	// operateLab(lab: StructureLab) {
-	// 	if (this.pos.inRangeToPos(lab.pos, POWER_INFO[PWR_OPERATE_LAB].range)) {
-	// 		return powerCreep.usePower(PWR_OPERATE_LAB, lab);
-	// 	} else {
-	// 		return powerCreep.moveTo(lab);
-	// 	}
-	// }
-
 
 	runPowers(powerCreep: PowerCreep) {
+		let b = false;
+		let pri = 0;
 		const priorities = this.memory.powerPriorities;
 		for (let powerId in priorities) {
-			//console.log(`Powerid of ${powerId} and list of ${priorities}`);
 			let powerToUse = this.usePower(powerCreep, priorities[powerId]);
 			if (powerToUse && powerToUse.operatePower()) {
+				b = true;
+				pri = priorities[powerId];
 				break;
 			}
 		}
+		if(b == true){
+			return pri;
+		} else {
+			if(Game.flags[powerCreep.name]){
+				powerCreep.moveTo(Game.flags[powerCreep.name], 
+					{ ignoreRoads: true, range: 0, swampCost: 1, reusePath: 0, visualizePathStyle: 
+					{ lineStyle: "dashed", fill: 'yellow' } });
+				if(powerCreep.pos.isEqualTo(Game.flags[powerCreep.name])) {
+					powerCreep.usePower(PWR_SHIELD);
+				}
+				if(powerCreep.hits < powerCreep.hitsMax) {
+					if(powerCreep.room && powerCreep.room.controller && powerCreep.room.controller.my){
+						for (const tower of Overmind.colonies[powerCreep.room.name].towers) {
+							tower.heal(powerCreep);
+						}
+						console.log(`healing powerCreep ${powerCreep.name} in ${powerCreep.room.name} hits = ${powerCreep.hits}`)
+					}
+				}
+			}
+			return 'none';
+		}
 	}
 
 
@@ -267,19 +165,14 @@ export class DirectiveBaseOperator extends Directive {
 			// Spawn creep
 			let res = powerCreep.spawn(this.room.powerSpawn);
 			log.alert(`Running ${powerCreep} with spawn of ${res}`);
-		} else if (this.room.controller && !this.room.controller.isPowerEnabled) {
+		} else if (this.room.controller && this.room.controller.my && !this.room.controller.isPowerEnabled) {
 			// Enable power
 			let res = this.enablePower(powerCreep, this.room.controller);
 			log.alert(`Running ${powerCreep} with enable power of ${res}`);
 		} else if (powerCreep && powerCreep.ticksToLive && powerCreep.ticksToLive < 900 && this.room.powerSpawn) {
 			let res = this.renew(powerCreep, this.room.powerSpawn);
 			log.alert(`Running ${powerCreep} with renew of ${res}`);
-		} else {
-			let res = this.runPowers(powerCreep);
-			//log.alert(`Running ${powerCreep} with power of ${res}`);
-		}
-
-		if (this.room.hostiles.length > 2 || (powerCreep.pos && DirectiveNukeResponse.isPresent(powerCreep.pos, 'room'))) {
+		} else if (this.room.hostiles.length > 2 || (powerCreep.pos && DirectiveNukeResponse.isPresent(powerCreep.pos, 'room'))) {
 			const towersToBoost = this.colony.towers.filter(tower => !tower.effects || tower.effects.length == 0);
 			if (towersToBoost.length > 0) {
 				powerCreep.usePower(PWR_OPERATE_TOWER, towersToBoost[0])
@@ -287,7 +180,9 @@ export class DirectiveBaseOperator extends Directive {
 			if ((!powerCreep.carry.ops || powerCreep.carry.ops < 20) && this.room.storage && this.room.storage.store.ops && this.room.storage.store.ops > 100) {
 				powerCreep.withdraw(this.room.storage, RESOURCE_OPS, 100);
 			}
+		} else {
+			let res = this.runPowers(powerCreep);
+			//log.alert(`Running ${powerCreep} with power of ${res}`);
 		}
 	}
-
 }
\ No newline at end of file
diff --git a/src/directives/powerCreeps/powers/generateOps.ts b/src/directives/powerCreeps/powers/generateOps.ts
index bb0229c19..812d4ee28 100644
--- a/src/directives/powerCreeps/powers/generateOps.ts
+++ b/src/directives/powerCreeps/powers/generateOps.ts
@@ -19,13 +19,21 @@ export class GenerateOps extends Power {
 			const storage = this.powerCreep.room!.storage;
 			if (!storage) {
 				log.error(`Ops power creep with no storage`);
-			} else {
-				this.powerCreep.moveTo(storage);
-				this.powerCreep.transfer(storage, RESOURCE_OPS, this.powerCreep.carry.ops);
+				return false;
 			}
-		} else {
-			return this.powerCreep.usePower(powerId);
+			else {
+				this.powerCreep.moveTo(storage, 
+					{ ignoreRoads: true, range: 1, swampCost: 1, reusePath: 0, visualizePathStyle: 
+					{ lineStyle: "dashed", fill: 'yellow' } });
+				this.powerCreep.transfer(storage, RESOURCE_OPS, this.powerCreep.carry.ops - 200);
+				return true;
+			}
+		}
+		else if (this.powerCreep.room && this.powerCreep.powers[PWR_GENERATE_OPS] 
+			&& this.powerCreep.powers[PWR_GENERATE_OPS].cooldown == 0) {
+			this.powerCreep.usePower(powerId);
+			return true;
 		}
-		return ERR_TIRED;
+		return false;
 	}
 }
\ No newline at end of file
diff --git a/src/directives/powerCreeps/powers/operateExtension.ts b/src/directives/powerCreeps/powers/operateExtension.ts
index dac9c6021..12f96c2af 100644
--- a/src/directives/powerCreeps/powers/operateExtension.ts
+++ b/src/directives/powerCreeps/powers/operateExtension.ts
@@ -15,16 +15,24 @@ export class OperateExtension extends Power {
 	}
 
 	operatePower() {
-		if (this.powerCreep.carry.ops && this.powerCreep.carry.ops > 2 && this.powerCreep.room
-			&& this.powerCreep.room.energyAvailable < this.powerCreep.room.energyCapacityAvailable * 0.5) {
-			const terminal = this.powerCreep.room!.storage;
-			if (!terminal) {
-				log.error(`Ops power creep with no storage`);
-			} else {
-				this.powerCreep.moveTo(terminal);
-				return this.powerCreep.usePower(powerId, terminal);
+		if(this.powerCreep.room && this.powerCreep.room.controller && this.powerCreep.room.controller.isPowerEnabled) {
+			if (this.powerCreep.carry.ops && this.powerCreep.carry.ops > 2 && this.powerCreep.room
+				&& this.powerCreep.room.energyAvailable < this.powerCreep.room.energyCapacityAvailable * 0.5
+				&& this.powerCreep.powers[PWR_OPERATE_EXTENSION] && this.powerCreep.powers[PWR_OPERATE_EXTENSION].cooldown == 0) {
+				const terminal = this.powerCreep.room.storage;
+				if (!terminal) {
+					log.error(`Ops power creep with no storage`);
+					return false;
+				}
+				else {
+					this.powerCreep.moveTo(terminal, 
+						{ ignoreRoads: true, range: 1, swampCost: 1, reusePath: 0, visualizePathStyle: 
+						{ lineStyle: "dashed", fill: 'yellow' } });
+					this.powerCreep.usePower(powerId, terminal);
+					return true;
+				}
 			}
 		}
-		return ERR_TIRED;
+		return false;
 	}
 }
\ No newline at end of file
diff --git a/src/directives/powerCreeps/powers/operateSource.ts b/src/directives/powerCreeps/powers/operateSource.ts
new file mode 100644
index 000000000..5a7b535b0
--- /dev/null
+++ b/src/directives/powerCreeps/powers/operateSource.ts
@@ -0,0 +1,35 @@
+import {profile} from "../../../profiler/decorator";
+import {Power} from "./genericPower";
+import {log} from "../../../console/log";
+
+export const powerId = PWR_REGEN_SOURCE;
+
+/**
+ * An abstract class for encapsulating power creep power usage.
+ */
+@profile
+export class OperateSource extends Power {
+
+	constructor(powerCreep: PowerCreep, target?: RoomObject) {
+		super(powerCreep, target);
+	}
+
+	operatePower() {
+		if(this.powerCreep.room && this.powerCreep.room.controller && this.powerCreep.room.controller.isPowerEnabled){
+			if (this.powerCreep.room && this.powerCreep.powers[PWR_REGEN_SOURCE] 
+				&& (this.powerCreep.powers[PWR_REGEN_SOURCE].cooldown! | 0 ) < 40) {
+				let sources = _.filter(this.powerCreep.room.sources, source => 
+					(!source.effects || (source.effects && (!source.effects[0] || source.effects[0].ticksRemaining < 40))))
+				let source = _.first(sources);
+				if(source) {
+					this.powerCreep.moveTo(source, 
+						{ maxRooms: 1,ignoreRoads: true, range: 1, swampCost: 1, reusePath: 0, visualizePathStyle: 
+						{ lineStyle: "dashed", fill: 'yellow' } });
+					this.powerCreep.usePower(powerId, source);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+}
\ No newline at end of file
diff --git a/src/directives/powerCreeps/powers/operateSpawn.ts b/src/directives/powerCreeps/powers/operateSpawn.ts
new file mode 100644
index 000000000..523cefeac
--- /dev/null
+++ b/src/directives/powerCreeps/powers/operateSpawn.ts
@@ -0,0 +1,35 @@
+import {profile} from "../../../profiler/decorator";
+import {Power} from "./genericPower";
+import {log} from "../../../console/log";
+
+export const powerId = PWR_OPERATE_SPAWN;
+
+/**
+ * An abstract class for encapsulating power creep power usage.
+ */
+@profile
+export class OperateSpawn extends Power {
+
+	constructor(powerCreep: PowerCreep, target?: RoomObject) {
+		super(powerCreep, target);
+	}
+
+	operatePower() { 
+		if(this.powerCreep.room && this.powerCreep.room.controller && this.powerCreep.room.controller.isPowerEnabled) {
+			if (this.powerCreep.room && this.powerCreep.carry.ops && this.powerCreep.carry.ops >= 100 
+				&& Memory.colonies[this.powerCreep.room.name].hatchery.stats.uptime > 0.9 
+				&& this.powerCreep.powers[PWR_OPERATE_SPAWN] && (this.powerCreep.powers[PWR_OPERATE_SPAWN].cooldown || 0) < 25) {
+				const spawns = _.filter(this.powerCreep.room.spawns, 
+								spawn => (!spawn.effects || (spawn.effects && (!spawn.effects[0] || spawn.effects[0].ticksRemaining < 25))))
+				const spawn = _.first(spawns);
+				if(spawn) {
+					this.powerCreep.moveTo(spawn, { ignoreRoads: true, range: 1, swampCost: 1, reusePath: 0, visualizePathStyle: 
+					{ lineStyle: "dashed", fill: 'yellow' } });
+					this.powerCreep.usePower(powerId, spawn);
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+}
diff --git a/src/directives/targeting/modularDismantle.ts b/src/directives/targeting/modularDismantle.ts
index 6efdf3c5e..80782ebaa 100644
--- a/src/directives/targeting/modularDismantle.ts
+++ b/src/directives/targeting/modularDismantle.ts
@@ -53,7 +53,7 @@ export class DirectiveModularDismantle extends Directive {
 					return structure;
 				}
 			}
-			if (structure.structureType.toString() == 'invaderCore') {
+			if (structure.structureType as any === 'invaderCore') {
 				this.memory.attackInsteadOfDismantle = true;
 				return structure;
 			}
diff --git a/src/hiveClusters/evolutionChamber.ts b/src/hiveClusters/evolutionChamber.ts
index 2dbf8119d..8e5a0324e 100644
--- a/src/hiveClusters/evolutionChamber.ts
+++ b/src/hiveClusters/evolutionChamber.ts
@@ -409,8 +409,9 @@ export class EvolutionChamber extends HiveCluster {
 		for (const resourceType in this.neededBoosts) {
 			const needAmount = Math.max(this.neededBoosts[resourceType] - (this.colony.assets[resourceType] || 0), 0);
 			if (needAmount > 0) {
-				this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType,
-													 needAmount, true, 0);
+				const allowBuy = (Memory.settings.resourcesBlackList.indexOf(<ResourceConstant>resourceType) == -1);
+				this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType, needAmount, allowBuy, 0);
+				// this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType, needAmount, true, 0);
 			}
 		}
 		// Obtain resources for reaction queue
@@ -421,10 +422,17 @@ export class EvolutionChamber extends HiveCluster {
 		const missingBasicMinerals = this.colony.abathur.getMissingBasicMinerals(queue);
 		for (const resourceType in missingBasicMinerals) {
 			if (missingBasicMinerals[resourceType] > 0) {
-				this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType,
-													 missingBasicMinerals[resourceType], true);
+				const allowBuy = (Memory.settings.resourcesBlackList.indexOf(resourceType) == -1);
+				this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType, 
+					missingBasicMinerals[<ResourceConstant>resourceType], allowBuy);
+				// this.terminalNetwork.requestResource(this.terminal, <ResourceConstant>resourceType,
+				//									 missingBasicMinerals[resourceType], true);
 			}
 		}
+		// buy RESOURCE_POWER
+		if(this.terminal && (this.terminal.store[RESOURCE_POWER]! | 0) < 500 ) {
+			this.terminalNetwork.requestResource(this.terminal, RESOURCE_POWER, 500, true);
+		}
 		// Run the reactions
 		if (this.memory.status == LabStatus.Synthesizing) {
 			const [lab1, lab2] = this.reagentLabs;
diff --git a/src/intel/RoomIntel.ts b/src/intel/RoomIntel.ts
index 7925178f6..479ce936d 100644
--- a/src/intel/RoomIntel.ts
+++ b/src/intel/RoomIntel.ts
@@ -8,6 +8,9 @@ import {getCacheExpiration, irregularExponentialMovingAverage} from '../utilitie
 import {Zerg} from '../zerg/Zerg';
 import {MY_USERNAME} from '../~settings';
 import {DirectivePowerMine} from "../directives/resource/powerMine";
+import {DirectivePairDestroy} from "../directives/offense/pairDestroy";
+import {DirectiveOutpostDefense} from "../directives/defense/OutpostDefense";
+import {DirectiveControllerAttack} from "../directives/offense/controllerAttack";
 import {Cartographer, ROOMTYPE_ALLEY} from "../utilities/Cartographer";
 import {getAllColonies} from "../Colony";
 import {Segmenter} from "../memory/Segmenter";
@@ -451,6 +454,55 @@ export class RoomIntel {
 		console.log("total ENERGY transfer = " + total);
 	}
 
+	static autoAttackAroundMe(room: Room) {
+		if(room.name == 'W33N33') {
+			return;
+		}
+
+		const nameOutpost =  'OutpostDefend: ' + room.name;
+		const namePair =  'PairDefend: ' + room.name;
+		const nameController =  'ControllerAttack: ' + room.name;
+		
+		let autoAttack = Memory.settings.autoAttack;
+		if (autoAttack && !room.my && room.controller && 
+			!room.controller.safeMode && room.controller.level > 0 && room.controller.level < 6) {
+			const allies = Memory.settings.allies;
+			if(allies.indexOf(_.get(room.controller, ['owner', 'username'])) >= 0){
+				return;
+			}
+			let hasSpawn = _.first(room.find(FIND_STRUCTURES).filter(struct => struct.structureType == STRUCTURE_SPAWN));
+			if (hasSpawn != undefined) {
+				if (DirectivePairDestroy.isPresent(hasSpawn.pos, 'pos')) {
+					return;
+				}
+				let colonies = getAllColonies().filter(colony => colony.level > 6);
+				for (let colony of colonies) {
+					let route = Game.map.findRoute(colony.room, room);
+					if (route != -2 && route.length <= 12) {
+						Game.notify(`FOUND ENEMY IN RANGE ${route.length}, STARTING attacking ${room}`);
+						DirectivePairDestroy.create(hasSpawn.pos,{name: namePair });
+						return;
+					}
+				}
+			} else if (room.controller.pos.availableNeighbors(true).length > 0){
+				if(room.hostiles.length > 0 && !DirectiveOutpostDefense.isPresent(room.controller.pos, 'pos')){
+					DirectiveOutpostDefense.create(room.controller.pos,{name: nameOutpost });
+				}
+				if (DirectiveControllerAttack.isPresent(room.controller.pos, 'pos')) {
+					return;
+				}
+				let colonies = getAllColonies().filter(colony => colony.level > 6);
+				for (let colony of colonies) {
+					let route = Game.map.findRoute(colony.room, room);
+					if (room.name != 'W24N31'  && route != -2 && route.length <= 8) {
+						Game.notify(`CAN DOWNGRADE ENEMY CONTROLLER @ RANGE ${route.length}, STARTING DOWNGRADE ${room}`);
+						DirectiveControllerAttack.create(room.controller.pos,{name: nameController});
+						return;
+					}
+				}
+			}
+		}
+	}
 
 	static run(): void {
 		let alreadyComputedScore = false;
@@ -499,6 +551,7 @@ export class RoomIntel {
 				this.recordControllerInfo(room.controller);
 			}
 			this.minePowerBanks(room);
+			this.autoAttackAroundMe(room);
 		}
 	}
 
diff --git a/src/logistics/TerminalNetwork.ts b/src/logistics/TerminalNetwork.ts
index 31584e247..2481bbac2 100644
--- a/src/logistics/TerminalNetwork.ts
+++ b/src/logistics/TerminalNetwork.ts
@@ -494,11 +494,22 @@ export class TerminalNetwork implements ITerminalNetwork {
 				}
 			}
 
+			// Order more power if needed
+			if (Game.market.credits > TraderJoe.settings.market.energyCredits) {
+				const averageEnergy = _.sum(this.terminals, terminal => colonyOf(terminal).assets[RESOURCE_POWER] || 0)
+					/ this.terminals.length;
+				if (averageEnergy < 10000) {
+					const poorestTerminal = minBy(this.terminals, terminal => colonyOf(terminal).assets[RESOURCE_POWER] || 0);
+					if (poorestTerminal) {
+						const amount = 10000;
+						Overmind.tradeNetwork.maintainBuyOrder(poorestTerminal, RESOURCE_POWER, amount, 5);
+					}
+				}
+			}
 		}
 		// Do notifications
 		if (this.notifications.length > 0) {
 			log.info(`Terminal network activity: ` + alignedNewline + this.notifications.join(alignedNewline));
 		}
 	}
-
 }
diff --git a/src/logistics/TradeNetwork.ts b/src/logistics/TradeNetwork.ts
index 2cda69f57..a8bb30703 100644
--- a/src/logistics/TradeNetwork.ts
+++ b/src/logistics/TradeNetwork.ts
@@ -50,16 +50,17 @@ const TraderStatsDefaults: TraderStats = {
 // Maximum prices I'm willing to pay to buy various resources - based on shard2 market data in June 2018
 // (might not always be up to date)
 export const maxMarketPrices: { [resourceType: string]: number } = {
-	default             : 5.0,
-	[RESOURCE_HYDROGEN] : 0.3,
-	[RESOURCE_OXYGEN]   : 0.25,
-	[RESOURCE_UTRIUM]   : 0.3,
-	[RESOURCE_LEMERGIUM]: 0.25,
-	[RESOURCE_KEANIUM]  : 0.25,
-	[RESOURCE_ZYNTHIUM] : 0.25,
-	[RESOURCE_CATALYST] : 0.5,
-	[RESOURCE_ENERGY]   : 0.05,
-	[RESOURCE_CATALYZED_GHODIUM_ACID]	: 1.2,
+	default				: 0.6,
+	[RESOURCE_HYDROGEN]	: 0.09,
+	[RESOURCE_OXYGEN]	: 0.07,
+	[RESOURCE_UTRIUM]	: 0.022,
+	[RESOURCE_LEMERGIUM]: 0.085,
+	[RESOURCE_KEANIUM]	: 0.01,
+	[RESOURCE_ZYNTHIUM]	: 0.012,
+	[RESOURCE_CATALYST]	: 0.1,
+	[RESOURCE_ENERGY]	: 0.007,
+	[RESOURCE_CATALYZED_GHODIUM_ACID]: 1.2,
+	[RESOURCE_POWER]	: 0.36,
 };
 
 export const MAX_ENERGY_SELL_ORDERS = 5;
@@ -78,9 +79,9 @@ export class TraderJoe implements ITradeNetwork {
 			timeout: 25,
 		},
 		market: {
-			reserveCredits: 10000,	// Always try to stay above this amount
-			boostCredits  : 25000,	// You can buy boosts directly off market while above this amount
-			energyCredits : 50000, 	// Can buy energy off market if above this amount
+			reserveCredits: 1000000, // 10000 Always try to stay above this amount
+			boostCredits  : Infinity,	// 25000 You can buy boosts directly off market while above this amount
+			energyCredits : 2000000, // 50000 Can buy energy off market if above this amount
 			orders        : {
 				timeout      : 100000,	// Remove orders after this many ticks if remaining amount < cleanupAmount
 				cleanupAmount: 10,		// RemainingAmount threshold to remove expiring orders
diff --git a/src/memory/Memory.ts b/src/memory/Memory.ts
index 0cfd4dca0..fdf51210e 100644
--- a/src/memory/Memory.ts
+++ b/src/memory/Memory.ts
@@ -208,8 +208,10 @@ export class Mem {
 			operationMode: DEFAULT_OPERATION_MODE,
 			log          : {},
 			enableVisuals: true,
+			resourcesBlackList: ['XGH2O'],
 			resourceCollectionMode: 0,
 			allies: [MY_USERNAME],
+			autoAttack: false,
 			powerCollection: {
 				enabled: false,
 				maxRange: 5,
diff --git a/src/overlords/colonization/reserver.ts b/src/overlords/colonization/reserver.ts
index ab844432a..0acf518a8 100644
--- a/src/overlords/colonization/reserver.ts
+++ b/src/overlords/colonization/reserver.ts
@@ -26,10 +26,16 @@ export class ReservingOverlord extends Overlord {
 	}
 
 	init() {
+		if(this.room && this.room.hostileStructures.filter(s => s.structureType as any === 'invaderCore').length > 0) {
+			// wait for it to be destroyed
+			return;
+		}
 		let amount = 0;
-		if (this.room) {
-			if (this.room.controller!.needsReserving(this.reserveBuffer)) {
+		if (this.room && this.room.controller) {
+			if (this.room.controller.needsReserving(this.reserveBuffer)) {
 				amount = 1;
+			} else if(RoomIntel.roomReservedBy(this.pos.roomName) == 'Invader') {
+				amount = this.room.controller.pos.availableNeighbors(true).length;
 			}
 		} else if (RoomIntel.roomReservedBy(this.pos.roomName) == MY_USERNAME &&
 				   RoomIntel.roomReservationRemaining(this.pos.roomName) < 1000) {
@@ -48,6 +54,10 @@ export class ReservingOverlord extends Overlord {
 				} else {
 					reserver.task = Tasks.signController(this.room.controller!);
 				}
+			} 
+			else if(RoomIntel.roomReservedBy(this.pos.roomName) == 'Invader') {
+				reserver.goTo(this.room.controller!.pos);
+				reserver.attackController(this.room.controller!);
 			} else {
 				reserver.task = Tasks.reserve(this.room.controller!);
 			}
diff --git a/src/overlords/core/manager.ts b/src/overlords/core/manager.ts
index c0a04f1ec..f441facb8 100644
--- a/src/overlords/core/manager.ts
+++ b/src/overlords/core/manager.ts
@@ -216,26 +216,33 @@ export class CommandCenterOverlord extends Overlord {
 		const storageAmount = _.sum(storage.store);
 		const terminalAmount = _.sum(terminal.store);
 		const maxFillRatio = 0.95;
-		const terminalT3Amount = 8000;
+		const terminalT3Amount = 3800; // zGeneral: from 8000 to 3800
 		const terminalOtherAmount = 10000;
 		// Move all non-energy resources from storage to terminal
 		for (const resourceType in terminal.store) {
-			if (storageAmount < storageAmount * maxFillRatio && resourceType != RESOURCE_ENERGY
+			/* if (storageAmount < storageAmount * maxFillRatio && resourceType != RESOURCE_ENERGY
 				&& ((terminal.store[<ResourceConstant>resourceType]! > terminalT3Amount && resourceType.length == 5)
-					|| (terminal.store[<ResourceConstant>resourceType]! > terminalOtherAmount))) {
-				if (this.unloadCarry(manager))
-					return true;
+					|| (terminal.store[<ResourceConstant>resourceType]! > terminalOtherAmount))) { */
+			if (storageAmount < storageAmount * maxFillRatio 
+				&& resourceType != RESOURCE_ENERGY 
+				&& (terminal.store[<ResourceConstant>resourceType]! | 0 ) > terminalT3Amount 
+				&& (resourceType.length == 5 || resourceType == RESOURCE_OPS)) {
+				if (this.unloadCarry(manager)) return true;
 				manager.task = Tasks.withdraw(terminal, <ResourceConstant>resourceType);
 				manager.task.parent = Tasks.transfer(storage, <ResourceConstant>resourceType);
 				return true;
 			}
 		}
 		for (const resourceType in storage.store) {
-			if (terminalAmount < terminal.storeCapacity * maxFillRatio && resourceType != RESOURCE_ENERGY && storage.store[<ResourceConstant>resourceType]! > 0
+			/* if (terminalAmount < terminal.storeCapacity * maxFillRatio && resourceType != RESOURCE_ENERGY && storage.store[<ResourceConstant>resourceType]! > 0
 				&& (terminal.store[<ResourceConstant>resourceType]! < (terminalT3Amount-2000) || resourceType.length != 5
-					&& (terminal.store[<ResourceConstant>resourceType]! < (terminalOtherAmount-2000)) || resourceType == RESOURCE_POWER)) {
-				if (this.unloadCarry(manager))
-					return true;
+					&& (terminal.store[<ResourceConstant>resourceType]! < (terminalOtherAmount-2000)) || resourceType == RESOURCE_POWER)) { */
+				if (terminalAmount < terminal.storeCapacity * maxFillRatio 
+					&& resourceType != RESOURCE_ENERGY 
+					&& (storage.store[<ResourceConstant>resourceType]! | 0 ) > 0 
+					&& ((terminal.store[<ResourceConstant>resourceType]! | 0 ) < (terminalT3Amount - 800)
+					|| (resourceType.length != 5 && resourceType != RESOURCE_OPS))) {			
+				if (this.unloadCarry(manager)) return true;
 				manager.task = Tasks.withdraw(storage, <ResourceConstant>resourceType);
 				manager.task.parent = Tasks.transfer(terminal, <ResourceConstant>resourceType);
 				return true;
diff --git a/src/overlords/core/worker.ts b/src/overlords/core/worker.ts
index e58ac3103..edb99f499 100644
--- a/src/overlords/core/worker.ts
+++ b/src/overlords/core/worker.ts
@@ -187,15 +187,9 @@ export class WorkerOverlord extends Overlord {
 											structure => structure.hitsMax - structure.hits) / REPAIR_POWER;
 					const paveTicks = _.sum(this.colony.rooms,
 										  room => this.colony.roadLogistics.energyToRepave(room)) / 1; // repairCost=1
-					let fortifyTicks = 0;
-					let shouldFortify = this.colony.assets.energy > (Game.map.getRoomLinearDistance(this.room.name, 'W16N48') * 15000);
-					if (shouldFortify) {
-						fortifyTicks = 0.25 * _.sum(this.fortifyBarriers, barrier =>
-							Math.max(0, WorkerOverlord.settings.barrierHits[this.colony.level]
-										- barrier.hits)) / REPAIR_POWER;
-					}
+					
 					// max constructionTicks for private server manually setting progress
-					let numWorkers = Math.ceil(2 * (5 * buildTicks + repairTicks + paveTicks + fortifyTicks) /
+					let numWorkers = Math.ceil(2 * (5 * buildTicks + repairTicks + paveTicks) /
 											   (workPartsPerWorker * CREEP_LIFE_TIME));
 					numWorkers = Math.min(numWorkers, MAX_WORKERS);
 					if (this.colony.controller.ticksToDowngrade <= (this.colony.level >= 4 ? 10000 : 2000)) {
@@ -205,9 +199,9 @@ export class WorkerOverlord extends Overlord {
 				});
 			}
 		}
-		if (this.colony.name == 'W14N57') {
+		//if (this.colony.name == 'W14N57') {
 			//numWorkers = 8;
-		}
+		//}
 		this.wishlist(numWorkers, setup);
 	}
 
diff --git a/src/overlords/defense/outpostDefense.ts b/src/overlords/defense/outpostDefense.ts
index ae673d243..a8aa07c6b 100644
--- a/src/overlords/defense/outpostDefense.ts
+++ b/src/overlords/defense/outpostDefense.ts
@@ -28,6 +28,18 @@ export class OutpostDefenseOverlord extends CombatOverlord {
 
 	private handleCombat(zerg: CombatZerg): void {
 		if (this.room && this.room.hostiles.length == 0) {
+			// OutpostDefenseOverlord can be used to harass low RCL rooms., stomp csites codes
+			if(this.room.name == zerg.room.name && zerg.hits == zerg.hitsMax){
+				const enemyConstructionSites = zerg.room.find(FIND_HOSTILE_CONSTRUCTION_SITES, {
+					filter: function(csite: ConstructionSite) {
+						return csite.progress > 0;
+					}
+				});
+				if (enemyConstructionSites.length > 0 && enemyConstructionSites[0].pos.isWalkable(true)) {
+					zerg.goTo(enemyConstructionSites[0].pos);
+					return;
+				}
+			}
 			zerg.doMedicActions(this.room.name);
 		} else {
 			zerg.autoSkirmish(this.pos.roomName);
diff --git a/src/overlords/mining/extractor.ts b/src/overlords/mining/extractor.ts
index b73169a84..c80ed7f5b 100644
--- a/src/overlords/mining/extractor.ts
+++ b/src/overlords/mining/extractor.ts
@@ -62,7 +62,7 @@ export class ExtractorOverlord extends Overlord {
 
 	private registerOutputRequests(): void {
 		if (this.container) {
-			if (_.sum(this.container.store) > 0.5 * this.container.storeCapacity ||
+			if (_.sum(this.container.store) > 0.25 * this.container.storeCapacity || // changed from 0.5 to 0.25
 				(_.sum(this.container.store) > 0 && this.drones.length == 0)) {
 				this.colony.logisticsNetwork.requestOutput(this.container, {resourceType: 'all'});
 			}
@@ -106,17 +106,42 @@ export class ExtractorOverlord extends Overlord {
 	}
 
 	init() {
+		if (this.room && !this.room.my && 
+			(this.room.invaders.length == 4 || 
+			 this.room.dangerousPlayerHostiles.length > 0 || 
+			 this.room.hostileStructures.filter(s => s.structureType as any === 'invaderCore').length > 0)) {
+			return;
+		}
 		const amount = this.mineral && this.mineral.mineralAmount > 0 ? this.mineral.pos.availableNeighbors().length : 0;
 		this.wishlist(Math.min(amount, ExtractorOverlord.settings.maxDrones), Setups.drones.extractor);
 		this.registerOutputRequests();
-
-		// if(Cartographer.roomType(this.pos.roomName) == ROOMTYPE_SOURCEKEEPER || Cartographer.roomType(this.pos.roomName) == ROOMTYPE_CORE){
-		// 	this.container && console.log(printRoomName(this.pos.roomName)  + ' ' + this.pos + ' ' + this.container + ' ' + this.container.hits*100/this.container.hitsMax);
-		// 	!this.container && console.log(printRoomName(this.pos.roomName) + ' NO CONTAINER');
-		// }
 	}
 
 	private handleDrone(drone: Zerg): void {
+		// fix: Build container
+		if (drone.room == this.room && !this.container) {
+			const containerCsites = _.filter(this.room.constructionSites, csite => csite.structureType == STRUCTURE_CONTAINER);
+			const containerCsite = this.pos.findClosestByLimitedRange(containerCsites, 1);
+			if (containerCsite && _.sum(drone.carry) == 0) {
+				drone.task = Tasks.recharge();
+				return;
+			}
+			if (containerCsite && drone.carry.energy > 0) {
+				drone.task = Tasks.build(containerCsite);
+				return;
+			}
+		}
+		// fix: repair container
+		if (drone.room == this.room && this.container && this.container.hits / this.container.hitsMax < 0.5) {
+			if (_.sum(drone.carry) == 0) {
+				drone.task = Tasks.recharge();
+				return;
+			}
+			if (drone.carry.energy > 0) {
+				drone.task = Tasks.repair(this.container);
+				return;
+			}
+		}
 		// Ensure you are in the assigned room
 		if (drone.room == this.room && !drone.pos.isEdge) {
 			if (_.sum(drone.carry) == 0) {
diff --git a/src/overlords/mining/miner.ts b/src/overlords/mining/miner.ts
index 61aee57d6..c58353ba2 100644
--- a/src/overlords/mining/miner.ts
+++ b/src/overlords/mining/miner.ts
@@ -5,6 +5,7 @@ import {bodyCost, CreepSetup} from '../../creepSetups/CreepSetup';
 import {Roles, Setups} from '../../creepSetups/setups';
 import {DirectiveOutpost} from '../../directives/colony/outpost';
 import {DirectiveHarvest} from '../../directives/resource/harvest';
+import {CombatTargeting} from '../../targeting/CombatTargeting';
 import {Pathing} from '../../movement/Pathing';
 import {OverlordPriority} from '../../priorities/priorities_overlords';
 import {profile} from '../../profiler/decorator';
@@ -73,7 +74,8 @@ export class MiningOverlord extends Overlord {
 		// Decide operating mode
 		if (Cartographer.roomType(this.pos.roomName) == ROOMTYPE_SOURCEKEEPER) {
 			this.mode = 'SK';
-			this.setup = Setups.drones.miners.sourceKeeper;
+			// this.setup = Setups.drones.miners.sourceKeeper;
+			this.setup = Setups.drones.miners.sourceKeeperHeal;
 		} else if (this.colony.room.energyCapacityAvailable < StandardMinerSetupCost) {
 			this.mode = 'early';
 			this.setup = Setups.drones.miners.default;
@@ -87,7 +89,8 @@ export class MiningOverlord extends Overlord {
 			this.setup = Setups.drones.miners.linkOptimized;
 		} else {
 			this.mode = 'standard';
-			this.setup = Game.cpu.bucket < 9500 ? Setups.drones.miners.standardCPU : Setups.drones.miners.standard;
+			// this.setup = Game.cpu.bucket < 9500 ? Setups.drones.miners.standardCPU : Setups.drones.miners.standard;
+			this.setup = Setups.drones.miners.standardCPU;
 			// todo: double miner condition
 		}
 		const miningPowerEach = this.setup.getBodyPotential(WORK, this.colony);
@@ -243,7 +246,7 @@ export class MiningOverlord extends Overlord {
 	private registerEnergyRequests(): void {
 		if (this.container) {
 			const transportCapacity = 200 * this.colony.level;
-			const threshold = this.colony.stage > ColonyStage.Larva ? 0.8 : 0.5;
+			const threshold = this.colony.stage > ColonyStage.Larva ? 0.65 : 0.5; // zGeneral: from 0.8 to 0.65
 			if (_.sum(this.container.store) > threshold * transportCapacity) {
 				this.colony.logisticsNetwork.requestOutput(this.container, {
 					resourceType: 'all',
@@ -261,6 +264,12 @@ export class MiningOverlord extends Overlord {
 	}
 
 	init() {
+		if (this.room && !this.room.my && 
+			(this.room.invaders.length == 4 || 
+			 this.room.dangerousPlayerHostiles.length > 0 || 
+			 this.room.hostileStructures.filter(s => s.structureType as any === 'invaderCore').length > 0)) {
+			return;
+		}
 		this.wishlist(this.minersNeeded, this.setup);
 		this.registerEnergyRequests();
 	}
@@ -336,15 +345,17 @@ export class MiningOverlord extends Overlord {
 	 * Actions for handling link mining
 	 */
 	private linkMiningActions(miner: Zerg) {
-
+		// Approach mining site
+		if (this.goToMiningSite(miner)) {
+			return;
+		}
 		// Link mining
 		if (this.link) {
-			const res = miner.harvest(this.source!);
-			if (res == ERR_NOT_IN_RANGE) {
-				// Approach mining site
-				if (this.goToMiningSite(miner)) return;
+			if(this.link.energy < this.link.energyCapacity || 
+				(this.source!.energy/this.source!.ticksToRegeneration > miner.getActiveBodyparts(WORK)*1.8)) {
+				miner.harvest(this.source!);
 			}
-			if (miner.carry.energy > 0.9 * miner.carryCapacity) {
+			if (miner.carry.energy > 0.8 * miner.carryCapacity) {
 				miner.transfer(this.link, RESOURCE_ENERGY);
 			}
 			return;
@@ -366,7 +377,8 @@ export class MiningOverlord extends Overlord {
 			if (this.container.hits < this.container.hitsMax
 				&& miner.carry.energy >= Math.min(miner.carryCapacity, REPAIR_POWER * miner.getActiveBodyparts(WORK))) {
 				return miner.repair(this.container);
-			} else {
+			} else if(this.container.store[RESOURCE_ENERGY] < this.container.storeCapacity || 
+					 (this.source!.energy/this.source!.ticksToRegeneration > miner.getActiveBodyparts(WORK)*1.8)) {
 				return miner.harvest(this.source!);
 			}
 		}
@@ -475,6 +487,25 @@ export class MiningOverlord extends Overlord {
 	}
 
 	private handleMiner(miner: Zerg) {
+		if(miner.getActiveBodyparts(HEAL) > 0){
+			if(miner.hits < miner.hitsMax){
+				miner.heal(miner);
+			} else {
+				const target = CombatTargeting.findClosestHurtFriendly(miner);
+				if (target) {
+					// Approach the target
+					const range = miner.pos.getRangeTo(target);
+					// Heal or ranged-heal the target
+					if (range <= 1) {
+						miner.heal(target);
+					}
+					else if (range <= 3) {
+						miner.rangedHeal(target);
+					}
+				}
+
+			}
+		}
 		// Flee hostiles
 		if (miner.flee(miner.room.fleeDefaults, {dropEnergy: true})) {
 			return;
diff --git a/src/overlords/scouting/stationary.ts b/src/overlords/scouting/stationary.ts
index 826c2bf37..9748791b9 100644
--- a/src/overlords/scouting/stationary.ts
+++ b/src/overlords/scouting/stationary.ts
@@ -26,10 +26,9 @@ export class StationaryScoutOverlord extends Overlord {
 		for (const scout of this.scouts) {
 			if (this.pos.roomName == scout.room.name) {
 				const enemyConstructionSites = scout.room.find(FIND_HOSTILE_CONSTRUCTION_SITES);
-				const squashTarget = _.first(enemyConstructionSites);
-				if (squashTarget) {
-					scout.goTo(squashTarget);
-					return;
+				if (enemyConstructionSites.length > 0 && enemyConstructionSites[0].pos.isWalkable(true)) {
+					scout.goTo(enemyConstructionSites[0].pos);
+					return true;
 				}
 			}
 
diff --git a/src/priorities/priorities_structures.ts b/src/priorities/priorities_structures.ts
index 76a2276e1..9dfd6fa52 100644
--- a/src/priorities/priorities_structures.ts
+++ b/src/priorities/priorities_structures.ts
@@ -50,6 +50,7 @@ export const AttackStructurePriorities: BuildableStructureConstant[] = [
 	STRUCTURE_TERMINAL,
 	STRUCTURE_RAMPART,
 	STRUCTURE_WALL,
+	STRUCTURE_INVADER_CORE,
 ];
 
 export const AttackStructureScores = _.zipObject(_.map(AttackStructurePriorities, type =>
diff --git a/src/prototypes/Room.ts b/src/prototypes/Room.ts
index 32bedafed..7130f6f2d 100644
--- a/src/prototypes/Room.ts
+++ b/src/prototypes/Room.ts
@@ -64,8 +64,12 @@ Object.defineProperty(Room.prototype, 'creeps', {
 
 Object.defineProperty(Room.prototype, 'hostiles', {
 	get() {
+		if(!this._allies) {
+			this._allies = Memory.settings.allies;
+		}
 		if (!this._hostiles) {
-			this._hostiles = _.filter(this.find(FIND_HOSTILE_CREEPS), (creep: Creep) => creep &&  creep.owner.username != 'zGeneral');
+			this._hostiles = this.find(FIND_HOSTILE_CREEPS, 
+				{ filter: (creep: Creep) => this._allies.indexOf(creep.owner.username) == -1 });
 		}
 		return this._hostiles;
 	},
@@ -169,8 +173,12 @@ Object.defineProperty(Room.prototype, 'structures', {
 // Hostile structures currently in the room
 Object.defineProperty(Room.prototype, 'hostileStructures', {
 	get() {
+		if(!this._allies) {
+			this._allies = Memory.settings.allies;
+		}
 		if (!this._hostileStructures) {
-			this._hostileStructures = this.find(FIND_HOSTILE_STRUCTURES, {filter: (s: Structure) => s.hitsMax});
+			this._hostileStructures = this.find(FIND_HOSTILE_STRUCTURES, 
+				{ filter: (s: Structure) => (s.hitsMax) && (this._allies.indexOf(_.get(s, ['owner', 'username'])) == -1) });
 		}
 		return this._hostileStructures;
 	},
diff --git a/src/resources/Abathur.ts b/src/resources/Abathur.ts
index b7ce2c9ad..d67231d5f 100644
--- a/src/resources/Abathur.ts
+++ b/src/resources/Abathur.ts
@@ -30,16 +30,16 @@ export const priorityStockAmounts: { [key: string]: number } = {
 export const wantedStockAmounts: { [key: string]: number } = {
 	UH   : 3000, 	// (+100 % attack)
 	KO   : 3000, 	// (+100 % ranged attack)
-	XGHO2: 10000, 	// (-70 % dmg taken)
-	XLHO2: 15000, 	// (+300 % heal)
-	XZHO2: 6000, 	// (+300 % fat decr - speed)
-	XZH2O: 6000, 	// (+300 % dismantle)
-	XKHO2: 20000, 	// (+300 % ranged attack)
-	XUH2O: 20000, 	// (+300 % attack)
+	XGHO2: 33000, 	// 10000, 	// (-70 % dmg taken)
+	XLHO2: 100000,	// 15000, 	// (+300 % heal)
+	XZHO2: 100000,	// 6000, 	// (+300 % fat decr - speed)
+	XZH2O: 10000,	// 6000, 	// (+300 % dismantle)
+	XKHO2: 50000,	// 20000, 	// (+300 % ranged attack)
+	XUH2O: 50000, 	// 20000, 	// (+300 % attack)
 	G    : 5000, 	// For nukes
-	XLH2O: 8000, 	// (+100 % build and repair)
+	XLH2O: 10000,	// 8000, 	// (+100 % build and repair)
 	LH   : 3000, 	// (+50 % build and repair)
-	XUHO2: 3000, 	// (+600 % harvest)
+	XUHO2: 20000,	// 3000, 	// (+600 % harvest)
 	XKH2O: 3000, 	// (+300 % carry)
 	ZK   : 800,	// intermediate
 	UL   : 800,	// intermediate
@@ -49,7 +49,7 @@ export const wantedStockAmounts: { [key: string]: number } = {
 	GH2O : 800,	// (+80 % upgrade)
 	LH2O : 800,	// (+80 % build and repair)
 	KH2O : 800,	// (+200 % carry)
-	XGH2O: 12000,	// (+100 % upgrade)
+	XGH2O: 20000,	//12000,	// (+100 % upgrade)
 };
 
 export const baseStockAmounts: { [key: string]: number } = {
@@ -59,7 +59,8 @@ export const baseStockAmounts: { [key: string]: number } = {
 	[RESOURCE_KEANIUM]  : 5000,
 	[RESOURCE_UTRIUM]   : 5000,
 	[RESOURCE_OXYGEN]   : 5000,
-	[RESOURCE_HYDROGEN] : 5000
+	[RESOURCE_HYDROGEN] : 5000,
+	[RESOURCE_POWER]: 5000
 };
 
 export interface Reaction {
diff --git a/src/roomPlanner/BarrierPlanner.ts b/src/roomPlanner/BarrierPlanner.ts
index 5e05264a7..6296a6183 100644
--- a/src/roomPlanner/BarrierPlanner.ts
+++ b/src/roomPlanner/BarrierPlanner.ts
@@ -170,6 +170,7 @@ export class BarrierPlanner {
 		let count = RoomPlanner.settings.maxSitesPerColony - this.colony.constructionSites.length;
 		for (const pos of bunkerPositions) {
 			if (count > 0 && !pos.lookForStructure(STRUCTURE_RAMPART)
+				&& pos.lookFor(LOOK_TERRAIN)[0] != 'wall'
 				&& pos.lookFor(LOOK_CONSTRUCTION_SITES).length == 0) {
 				const ret = pos.createConstructionSite(STRUCTURE_RAMPART);
 				if (ret != OK) {
diff --git a/src/targeting/CombatTargeting.ts b/src/targeting/CombatTargeting.ts
index 52674d039..b28e7dee1 100644
--- a/src/targeting/CombatTargeting.ts
+++ b/src/targeting/CombatTargeting.ts
@@ -137,7 +137,7 @@ export class CombatTargeting {
 				return zerg.pos.findClosestByRange(structures) as Structure | undefined;
 			}
 		}
-		const core = _.filter(zerg.room.hostileStructures, s => s.structureType.toString() == 'invaderCore');
+		const core = _.filter(zerg.room.hostileStructures, s => s.structureType as any === 'invaderCore');
 		if (core.length != 0) {
 			return core[0];
 		}