I thought I'd bring up this idea and see if it holds up in the light.
I'm a big fan of strategy games, especially strategy RPGs, but the most fun I have is when I can conquer the world in the order I choose. This is actually pretty rare: you could do it in Dune, in one of the Dynasty Warriors, Brigandine, and a few other games, but overall it's very, very rare to be given a map and told to get to it.
It's not the same as a space-conquest game like Masters of Orion! I'm not talking about a game where the main complexity is in the landscape. I'm talking about a game where the main complexity is in the game part, and the landscape simply gives you... an outer play loop. Control over your vector. You play the main game because of your strategic choices, rather than the strategic choices being the main game. And these games are rare.
I can understand that to some extent. While it's not particularly difficult to program, it does make the game flow hard to control. That means both difficulty balancing and difficulty making meaningful plot arcs. So these games tend to have a wonky, unbalanced feel at times, and they never have a plot more complex than "oh, hey, you're the new king of the world!"
Well, let's think about how we could potentially overcome those problems and give our players as meaningful a plot experience as in any linear game.
One method would be to divorce the plot from the strategic game. Brigandine does this to some extent: the various knights often have plot arcs which progress regardless of your tactical choices, although they sometimes halt until you accomplish a major strategic victory such as destroying a specific kingdom.
This is a simple idea where there are linear plots tossed into the nonlinear game, and they progress pretty much independently of the nonlinear part. This is simple, but it isn't very tightly connected to the choices the player makes, so I'm not a big fan of leaving it like this.
There are a few kinds of events we can use as "anchors" or "linchpins" for the character arcs instead of having them simply progress linearly. A few are obvious: taking or losing specific zones, killing or acquiring specific heroes, finding specific unique items, etc. However, perhaps the more interesting ones are ones which are not linked to unique game events but are instead linked to general game events.
For example, if your character arc goes one way if you're on the main team most of the time, or another way if you're usually relegated to the back. How about if it changes based on whether you're badly injured in combat, or after you make a certain number of kills? A certain number of consecutive victories or losses? And, of course, whether your buddy is on the same team as you most of the time, and whether your buddy gets injured.
Now the difficulty is the large amount of scripting required per character. It would be very difficult to script up the usual two-dozen cast, because each character would have dozens of pages of branching script!
You could use some of the cheap tricks I tend to use, such as making it so no characters actually speak at any point. That cuts the amount of work by about 90%. But, of course, how to make it interesting and comprehendable without dialog?
Another choice would be to try to create "landscaped" characters instead of scripted characters. This is basically just writing the main dialog sequences, then writing much more generic "connective" sequences (often not even character-unique) to allow the player to get from one scripted event to the next via any valid means.
Your savings won't be nearly as much, but you'll get a lot more nonlinearity for the same amount of effort.
As an example, you could write the love interest scene. But to reach the scene, maybe the player visits a romantic spot with her. Or maybe he gets critically injured in combat. Or maybe he rescues her from certain doom in combat. Or maybe he does something unspeakably nice. All of these things are nonunique, and the point is that the player can progress through the characters' arcs without adhering to a script.
Basically, we're abstracting out most of the linchpin/anchor events.
I guess that's it.