Hehe ... here comes another cautionary lesson from a totally unrelated game. Unix Empire again, dumb terminal alphanumeric text output. You can build planes (discrete units) and fly them as bombers over enemy airspace. Quasi-realtime, which means everybody stays up around each update time and hopes to catch their foe away from keyboard on vacation or real life. (Unix Empire is absolutely brutal that way.)
How shall your fighters auto-defend against a human-controlled probing of your air defenses? Unix Empire's solution was: fighters have interception ranges. If any nation that is at war with you overflies your sectors within range of an airfield sector with mobility points left that has fighters, those fighters will auto-scramble, intercept, and fight. The text output of such air battles could be several KB per furball, which the game process nicely sends to you as telegrams within the game (which is a simple email-like facility). People brag about the time they got a 50 KB telegram for one dogfight. You laugh, but already it illuminates some drawbacks(?) in this system:
- The game engine must compute interception-radii. During your interactive "fly" command, each step you take causes the engine to walk the linked list (or similar) of defensive radii, sweeping all hits into a bucket. Then every fighter in that bucket-of-hits scrambles and bounces you. If you die, that terminates your "fly" command. Otherwise, repeat. (This is actually pretty straightforward to code.)
- The "combat viewer"
for such automated battles is a thorny issue by itself. UE's solution was a dumb text dump. That's actually tolerable; most players just ignore the details anyways. Still, it's a vast amount of noise to deliver a tiny bit of signal.
This imposes some burden on the human players on both sides. We're flexible; we adapt. Those who adapt poorly gradually quit UE and play Moria.
- The defender must carefully design overlapping umbrellas of coverage. Before every real life road trip or friend's wedding. Or you'll just lose when you're not even logged in.
- The attacker (at keyboard) learns to send in sacrificial probes to nickel-and-dime the defense, until you run them out of mobility (or shoot them all down). It's kind of like pulling trumps in contract bridge.
Beyond that, it opens up vast potential for human ingenuity and flexible thinking. A friend of mine (and his buddy; they always played as a team of 2) found a way to add his own tier of genius on top of this.
- Suppose the defender is online at keyboard, and is watching the attacker's probes in real-time. The defender has the full power of Unix scripts. The defender was not a guru at Unix scripting ... but learned how
(Sidebar: This is why I advocate using scriptable games as a sandbox for undergraduate CS curricula: it motivates.)
- Given that the attacker is pulling your trumps, and you're ready for that ... how do you maximally punish it?
- So he wrote two sets of Unix scripts. This corresponds exactly to what I call the lifting of level, where he automated vaaaaast amounts of micro-grunge into a one-word script name, which freed him to play the game at the level of C block scoping: "{", wait a few seconds, "}", cackle and win.
- Script "}" did roughly: "for all triplets <warehouse $w, airfield $a, path $p> in list L: move $a.{ all planes } to $w via $p". Path $p consists of highway sectors at 100% efficiency. It's a UE game rule that movement costs mobility points per sector, but a 100% highway costs 0 points to cross. Ergo, running "}" has zero cost (except a few hundred milliseconds of CPU time). After running "}", he has no fighter umbrella. His entire country is totally naked!
- Script "{" did roughly the inverse of "}". After running "{", he has a fully staffed fighter umbrella.
- Being at keyboard, he is alerted (by the game) when neighboring enemy sends the first probe flight (which gets intercepted and shot down).
- Being utterly malevolent, he waits several minutes as his umbrella shoots down about 20 more weak probing flights. He laughs ...
- ... and runs "}". The next probe sees ... no umbrella at all. "OMG" says some foe, "he's out of mobility, I took down his umbrella."
- He waits another minute ... and the game informs him that a ginormous bomber fleet is now overflying him, headed straight for his capital.
- He runs "{". Between one step and the next, foe's ginormous bomber fleet strolls through clear skies ... and gets bounced by the sky. 50 KB, and he utterly wins.
- He laughs, and runs "}".
- After recovering from shock, foe sends another probe flight ... and sees no umbrella at all.
- After a few minutes, foe tentatively sends a Plan B fleet of weak old bombers. I used to fill the sky with my planes. Now I win or lose with --
- He laughs more, and runs "{". 12 KB, he wins that one, too.
- He runs "}". Foe's final biplane wanders over, and sees no umbrella at all.
- After an hour of no further action, he laughs one last time, runs "{", and logs off for the day. The next morning, he scans 8 telegrams indicating that his fighter umbrella auto-intercepted and shot down 8 weak probing flights at the border.
- ... time passes, many months, many games ...
- He is surrounded by opponents, every one of whom has been burned by the above technique more than once each. All of them now tread verrrry carefully around his borders, and are quite terrified.
Now, I draw some lessons from this that are relevant to any future game (including GC*).
- I love this story. This is exactly the way I would want to play a game like this. Automate the details, build tiers of complexity on top of it, until you're playing at tier-4 or so. Play like a CEO making sweeping corporate five-year decisions in 2 sentences, with an entire pyramid of micro-details all happening like clockwork at your beck and call, requiring no further attention. Then your brain duels the other guy's brain.
- Be wary of automation. Automated defenses, e.g. auto-interception, opens a vast can of worms: sheer computational effort, proper UI support, players' cognitive loads. At the minimum, it is game-able ... which forces good players to attempt to lift the level enough that they can game them properly. In the limit, a decent player will need to test (simulate?) his own auto-defenses to see how they'll work, or analyze why they failed ... which could require a single-step debugger
- For GC3, auto-interception might be out of the question.
- Even a simpler version of it, e.g. a sentry command that causes a ship to wake up when an enemy ship moves past, could cause weird burdens on AI ship-movement code.
- The simplest version is: for every hex of ship movement, traverse the list of all other ships in sentry, see if I entered their sensor range, flag them to wake up. Then AI ships don't stop moving, which simplifies AI ship traversal code -- but can produce odd results, e.g. his weak ship walked right up to my now-awake defender, and I win.
- The harder version is: whenever this hex-of-movement wakes up that enemy ship, suspend this ship-movement, mark it not-done, go to next ship. When done, some human ships are now awake, and some AI ships have only partially moved. Human does whatever, ends turn, and then the AI can resume movement with any ships still alive. Flaw: they still tend to be blind to whatever the human did.
- The even harder version is: if AI ship movement causes human ship to wake up, and then human ship moves toward me -- then the AI immediately re-plans that ship's actions, and the game engine interleaves your movements. So AI ships get to semi-intelligently turn tail and run away from you, or turn toward you and counter-intercept, or ignore you and press on. (Or maybe bounce you with ambushers, etc.)
- And yes, this was the simple version without auto-intercept! It is already complex in fascinating ways.
- Some boardgames have opportunity fire, where your tanks or Alesia defenders can interrupt enemy movement and say I shoot you right now! This is actually quite annoying even to do with two humans face-to-face. The accepted method is for the mover to move 1 unit at a time, slowly, with pauses at each hex. And if you don't interrupt him in time, tough. Interception, or reacting to invasions, presents some of the same design issues. Avalon Hill's Third Reich did this with naval fleet movements: the mover must trace out (with his finger on the board) the exact ship path his fleet will take, and then the defender picks the exact hex of the interception attempt. All of these seem to be aspects of the same general principle: when the abstraction of turn-based movement is too granular, we struggle to handle finer-grained divisions of movement.
Ultimately, be careful what you ask. Other games are valuable because they've explored different niches of the idea space, and may illuminate some non-obvious pitfalls. I happen to agree that a simple Sentry-like ship state with auto-wakeup is fairly simple and harmless, and would prove useful. But we already generally know that the click-per-ship UI is only a Beta placeholder while Stardock finishes many automation elements, e.g. governors, commands, fleet support components, fleet commanders, and ship types. Something better is sure to come.
GalCiv3 Forums
for such automated battles is a thorny issue by itself. UE's solution was a dumb text dump. That's actually tolerable; most players just ignore the details anyways. Still, it's a vast amount of noise to deliver a tiny bit of signal.
(Sidebar: This is why I advocate using scriptable games as a sandbox for undergraduate CS curricula: it motivates.)