AI strategy generator: generating scenarios, not verdicts

Strategy games have a lot of surface: unit rosters, tech trees, scenario setups, victory conditions, event tables. Producing a first version of all that by hand is slow and mostly clerical, and it stands between you and the moment you can finally play a match.

This is where generation earns its place. Ask for a roster of eight units with rock-paper-scissors relationships and an economy with two resources, and it exists as GDScript in your Godot project. Ask for four scenario setups with different starting positions and they exist too.

What generation cannot tell you is whether the roster is interesting. That answer is only available from the far side of a match.

Every single-player strategy game runs into the same wall: the computer opponent. A weak one makes the game pointless and a cheating one makes it insulting, and the space between those is narrow.

Director 1 writes opponent logic into your project as ordinary code, so you can push on it repeatedly. Say that it expands too greedily, or never defends its second base, or reads your intentions in a way it should not be able to. Each of those is a change, and each change is a few minutes rather than a week.

Over enough passes you get an opponent that plays your game the way your game wants to be played. That is a long road in any engine. It is just a much cheaper road when you are not writing the code.

You build maps yourself in the builder, placing terrain, elevation, water and structures. Strategy players read maps closely and remember them, and a procedurally spat-out map rarely survives that scrutiny.

Nothing stops you from having the game generate maps at runtime if that is your design; Director 1 can write that generator. The point is that the pieces and the sense of place come from a person.

Stage Engine is a desktop app for Mac and Windows. You install it, it bundles Godot, and your game runs locally on your machine rather than in a browser or over a stream. The project is a plain Godot project.

Building needs a network connection. The model, asset generation and world data all come over it, so there is no offline building. Playing what you built has no such requirement.

It is free to download with a free plan, Indie at $10 a month and Pro at $50, and the paid plans buy usage rather than features.

Ask for twelve units and you will get twelve units. They will be internally consistent, they will have sensible costs, and roughly four of them will be worth building. That is not a failing of generation; it is what happens whenever a roster is produced without a shape in mind.

The shape is the thing to specify. Every unit should be the best answer to some situation and a bad answer to another, and you should be able to say in one sentence what each is for. If you cannot, the player certainly cannot, and they will settle on whichever three are safest.

So it is worth generating a small roster and pruning hard rather than generating a large one and hoping. Four units that each own a role make a better game than twelve where eight are decoration, and you can always add once the four are proven.

A generated scenario is fun once. The second time through, the player knows where everything is and the whole thing collapses into an optimal sequence. That is fine for a campaign mission and fatal for anything you expect people to replay.

If replayability is the goal, the variation has to come from the systems rather than the setup: a different starting position that genuinely changes the plan, an opponent that opens differently, resources that are placed differently each match. Generating a hundred scenarios does not solve this. One map with real strategic depth outlasts all of them.