Overmind Screeps AI

Overmind is a swarm-intelligence-themed AI for Screeps. Its architecture is composed of several key abstractions:

• Overlords: Orchestrate Creep actions within a specific Colony.
• Colony: A grouping of units and resources.
• Overseer: Monitors the colony and places Directives to adapt to environmental stimuli.
• Directives: Specific instructions or goals issued by the Overseer.
• Assimilator: A collective component that allows multiple players running Overmind to act as a single hivemind by sharing creeps, resources, and a master ledger of directives.

The AI can operate in fully automated, manual, or semiautomatic modes.

Overmind includes a Grafana dashboard to track operating statistics. To set it up:

1. Register for the Grafana service at screepspl.us.
2. Set up either the ScreepsPlus hosted agent or a NodeJS agent on a micro instance (e.g., Google Compute).
3. Import the dashboard configuration from assets/Grafana Dashboards/Overmind.json.
4. In the dashboard settings, replace the $User variable with your actual Screeps username.

Overmind uses a specific controller signature to avoid penalties. If your signature does not contain the substring overmind (or its small-caps variant), your operation will be penalized by skipping every 3rd tick.

The default signature is defined using the OVERMIND_SMALL_CAPS constant. You can override your signature using the console command setSignature().

If RL_TRAINING_MODE is enabled in your settings, Overmind switches to a specialized execution path designed for training reinforcement learning models.

In RL mode:

• The loop uses main_RL, which skips the standard lifecycle and instead performs a fresh instantiation of _Overmind every tick and runs ActionParser.run().
• The onGlobalReset function is replaced by onGlobalReset_RL, which only performs Mem.format().
• The console will print a training message via OvermindConsole.printTrainingMessage().

When running in standard mode, the loop follows a specific sequence of operations every tick:

1. Memory Operations: Loads previous memory via Mem.load(), checks if the loop should proceed via Mem.shouldRun(), and cleans memory via Mem.clean().
2. Instantiation:
   • If Overmind.shouldBuild is true or the object has expired, it deletes the old global.Overmind, runs garbage collection, and instantiates a new _Overmind object.
   • Otherwise, it calls Overmind.refresh() to update the existing state.
3. Tick Loop Cycle:
   • Overmind.init(): Handles spawning and energy requests.
   • Overmind.run(): Executes state-changing actions.
   • Overmind.visuals(): Renders visuals.
   • Stats.run(): Records statistics.
4. Post-run: Executes sandbox() code, runs the remoteDebugger, and finally calls Overmind.postRun() for error catching.

The ActionParser reads serialized JSON actions from a specific segment in RawMemory. The index of this segment is defined by the constant RL_ACTION_SEGMENT.

Value: 70

The RoadLogistics class uses a static settings object to control how road repairs are prioritized and managed. You can tune these values to change the sensitivity of the repair logic.

• allowedPaversPerRoom: The maximum number of workers allowed to be assigned to repaving roads in a single room simultaneously.
• criticalThreshold: A percentage (0.0 to 1.0) representing the HP level below which a road is considered 'critical' and triggers an immediate repair request.
• repairThreshold: A percentage (0.0 to 1.0) representing the HP level below which a road is considered 'repairable'.

```typescript
RoadLogistics.settings = {
	allowedPaversPerRoom: 1,
	criticalThreshold: 0.25,
	repairThreshold: 0.9
};
```埋

Use Pathing.isReachable() to determine if a target position can be reached from a starting position within the same room, given a set of obstacles. It returns true if a valid path exists and false otherwise.

const reachable = Pathing.isReachable(startPos, endPos, [obstaclePos1, obstaclePos2]);

Use Pathing.findKitingPath() to find a path that moves away from specific threats. It calculates a path that maximizes distance from the provided fleeFrom positions (which can be RoomPosition or any object with a pos property).

const path = Pathing.findKitingPath(creepPos, [hostilePos1, hostilePos2], {
  fleeRange: 5,
  terrainCosts: { plainCost: 1, swampCost: 5 }
});

To enable reinforcement learning control over your creeps, call ActionParser.run().

When called, the parser:

1. Identifies controllable actors (creeps where isBot is false) and uncontrollable actors (scripted bots).
2. Reads the JSON-serialized actions from RawMemory.segments[RL_ACTION_SEGMENT].
3. Executes the commands for controllable actors.
4. Runs TrainingOpponents.simpleCombat(bot) for uncontrollable actors.
5. Clears the action segment to prepare for the next tick.

Note: The parser automatically calls actor.autoEngage() after executing a valid command unless configured otherwise internally.

// In your main game loop
ActionParser.run();