Orbital IF

Hear me out.

Kerbal Space Program or Children of a Dead Earth, but as an IF game.

Time acceleration would just be setting the time passed between turns.

Fully interactive cockpit and accessible to both sighted and non-sighted players.

I’ve been thinking about different ways that orbital mechanics could be simplified to allow for this kind of format, and still be usable. Sort of an off-and-on idea I’ve been mulling over the last 6 months.

I don’t think there would be as much of an engineering focus; it’ll primarily focus on the piloting instead.

Curious to know what others might think of such a thing. I’ll admit I seem to be fascinated by the process of taking games that should never be IF titles and making them work anyways lol. It’s a really fun brain puzzle.


Not IF, but I once made a turn-based cave-flyer once as an overgrown 7-day Roguelike. And it was fascinating to watch people play it and make the exact same mistakes as people trying a real-time cave-flyer or Thrust clone for the first time. Holding the acceleration for WAY too long and then having no hope of stopping before hitting a wall, panicking and hammering keys in tough situations instead of calmly thinking it through…you almost had to physically restrain people to remind them that it was a turn-based game and they could take as much time as they wanted to try and figure out how to survive a tricky situation.

I’ve also done some 2D orbital experiments and it’s really cool to project the orbit and let people see how accelerating along your line of orbit expands or contracts the ellipse, and accelerating crosswise (“in” and “out”, roughly) doesn’t so much move you in and out as it just rotates the ellipse of your orbit. I expect if you’ve played simulationist space games you know that, but it’s still cool to put it in a really bare-bones scenario and just tinker with watching the shape of the orbit move and change.

I’m not sure how you describe that to a non-sighted player. Orientation of the ellipse and its size/aspect ratio (turning into a hyperbola eventually, right?) might be useful for understanding the principles of how it responds to your controls. But then when you’re navigating or matching orbits, you don’t care about the overall shape; you just want to know whether it passes through a different point (and a point that’s moving, so you have the time dimension too).

Though I guess there are tools for computing transfer orbits and such, and maybe those would be more approachable. I’ve never played any of the games, just made little simulations to goof around and try to learn an intuitive understanding of how to pilot…


Graphics are pretty much redundant for orbital navigation anyway. A diagram is nice but ultimately you’re trying to match up your numbers. I think it would be cool.


AFAIK, the first verb-noun based interface was that of the AGC (Apollo Guidance Computer), albeit there was no parser, the verbs and nouns being entered as decimal numbers.

Best regards from Italy,
dott. Piergiorgio.


Ahahahahaha, no way!! I learned something new today!

Commands were entered numerically, as two-digit numbers: Verb, and Noun. Verb described the type of action to be performed and Noun specified which data were affected by the action specified by the Verb command.

Wikipedia’s article on the Apollo Guidance Computer


Yeah, the idea was to give the player a proper orbital nav computer that would line up everything, so the player wouldn’t need to tweak the acceleration vectors for themselves. Honestly, I feel like this is something better left to other games, anyway; I might aim to automate this to focus on other aspects of the experience.

Would highly recommend both, honestly. They each offer the player an engineering space to solve ΔV budgets and maneuvers. Kerbal Space Program focuses more on landing/takeoff between celestial bodies, while Children of a Dead Earth focuses more on effectively projecting military force in orbit under a time and funding constraint.

Ah, then we both share a similar, little-known agony when it comes to programming orbital simulations.

These were my thoughts exactly.

1 Like

Took a photo last time I was at the Air&Space Museum.


I’m not sure if this is what you’re going for, but I was thinking of designing the game Timesync (based on the Infocom unmade game), but like, with graphics. Probably in Inform (even though I have no experience), but I’m not sure. (Would be cool to combine languages!) It would be a big collaboration project (each person doing a planet or so), and it would be cool to design an orbital thing for the spaceship. A lot of it on the ship would focus on controls and stuff, but still making it fun and not way too hard.

1 Like

Yeah back when I was planning a game with an orbital system for TADS 3, the idea was to make a game about the absolutely incredible amounts of time that passes between orbital maneuvers. The player would pass it by planning maneuvers and then enter stasis/medical-coma/hypersleep/whatever.

When they woke up, some amount of time had passed, so various events would get discarded from a list, because you missed them.

The planned ending was that eventually you’d travel enough (and pass so much time) that you would slowly watch humankind become unrecognizable and ascend into computer-based minds and virtual lives. Eventually you would be the only biological human left in “meat space”, ferrying cargo between server worlds that longer communicated with you in a way you could understand.

I didn’t have any intent to model planetary exploration; the player would be confined to their ship for the whole game.

I hit an overwhelming obstacle attempting to calculate actual-scale orbital mechanics with 32-bit signed integers.

So yeah. Dropped that. Currently trying to finish a game for SpringThing lol.


That’s awesome, but also quite dark. I was wondering about passing time and rounds, and turn scripts. How would it work?

I’m noticing this is apparently a pattern I have, based on feedback I’m getting from others on other stories I do, lol.

I didn’t get around to coding this bit, but basically there would be events that would be spaced out in time long enough that you wouldn’t realistically spam the WAIT command enough to witness them by standing still.

So the idea was there would be a data structure representing different economic or sociological states, and a list of events. If you slept through certain events then they would still change the data of the world. However you would only get a summary when you woke up.

By arriving to witness events, you would read it unfolding in more detail, and maybe catch moments that would be forgotten or censored later.

The player didn’t have an active role. They were meant to be an observer outside of freighter missions. If there was a combat encounter, one of the militaries would basically put you in your own brig and fly your ship with an AI from a command ship (because human pilots could not possibly compete in a space battle scenario).

I had one idea where you’d be let out of your brig after enemy flak missiles filled your ship completely full of holes, and the allies assumed you had died.


Also, to add on: This is one of the major reasons why I wanted the player to be an observer and basically collecting moments to witness. Doing a fully-dynamic simulation on the scale of an entire solar system would be absolutely bonkers, especially if you were aiming to make all these moments interesting enough to want to show up to them.

But that was perfect for me, because I don’t like characters who are major heroes or would be mentioned in a history textbook in the future. I prefer stories about bystanders who live through the wildest stuff in a mundane world, and the fact that they’re completely not-special implies that this crazy stuff could happen anywhere.

Also, thematically I thought it was kinda neat, because the origin story was that you played as a soldier from a dictatorship around Jupiter, and were deployed to launch orbital strikes on Earth. The problem was when you arrived and the AI woke you up, the war was actually called off before you even got to Earth.

So your home nation is gone, you realize you had been brainwashed, and all the war you were preparing for was finished before you saw a single second of it. So the process of traveling the solar system to witness these cool events for yourself was meant to be like a soul-searching mission to discover who you were, and you would only have your answer when you were the last human still living outside of a server.


If you’re interested in the history of the AGC, I can recommend Mindell’s Digital Apollo. It’s not just about the Apollo Guidance Computer—it goes all the way back to the design of the first aircraft, and what sorts of design decisions were made to answer basic questions like “how much control should the pilot have and how much should the instrumentation attempt to prevent pilot error”. It’s aimed a lay audience and doesn’t require any technical background.

O’Brien’s The Apollo Guidance Computer: Architecture and Operation is more technical, and if you want more of the crunchy internals it’s probably the best single-volume reference on the subject. It’s aimed at a more technical audience, but it’s very beginner-friendly. All of the information is in the public domain (you can get PDFs of the original design documents at various stages of development directly from NASA) but if you’re looking for a summary/overview something like the O’Brien book (or one of the many detailed webpages on the subject) is worth it for the curation effect.

Keep in mind that during the Space Race nobody had 32 bit computers either (with a tiny asterisk here that there were one or two proof-of-concept things that technically could do 32 bit arithmetic, like the Manchester Baby). The AGC, for example, had a word size of 15 bits plus a parity bit.

Not trying to talk you into anything, but remember that you do computationally-expensive things by precomputing them and then using an elaborate lookup table at runtime.


Wasn’t there a main computer during the first space landing (yes, it did land, anyone out there who doesn’t believe) that survived off 2 MB?


The Apollo Guidance Computer had around 4 kB, of magnetic core memory (bits that could be twiddled) and about 74 kB of read-only memory (bits that couldn’t be twiddled). So substantially less than a single MB.

It’s actually slightly tricky to talk about the capabilities of the AGC in terms of modern hardware because it was all purpose-built and idiosyncratic compared to modern designs.


There was also a Soviet-made handheld calculator, the Elektronika Mk-52, which was expandable via plugin ROM modules (kinda like cartridges on an old video game console…although the Mk-52’s modules look more like overgrown ICs with a bunch of exposed and easily-bent pins). One of the modules was an astronavigation module intended to be a backup for Soyuz onboard computer.

I don’t know how many total instructions were on the astronav module, but the Mk-52 itself had 4 kb (512 bytes) of onboard non-volatile memory. Provided by EEPROM, which makes it one of the few (only?) handheld calculator to ever use EEPROM for non-volatile storage.


And, while I’m following a train of thought here, the backup computer on the Apollo 11 mission was…a slide rule. Specifically a Pickett N600.

So there’s a seriously mathcore idea for an IF game: an alternate history space adventure where you’re on Apollo 11 and the AGC has failed and you have to complete the landing using only a slide rule.


Just dropping in to say this idea sounds amazing and is the kind of thing I love in sci-fi. Millennia-spanning stories where you watch familiar worlds and civilizations slowly change into something alien are great fun, and the existential horror is a plus. I’d play the heck out of this game. You’d have to use a different system that supports 64-bit numbers or higher for easy calculations though, right?


Reminds me of a part in Death’s End by Cixin Liu, with a person orbiting a planet in a space where the speed of light had been lowered to something like 100k miles/hour.


Thank you!!! That really means a lot. I’m always self-conscious about how my story ideas are niche or ditch the “rule of cool” in favor of just exploring the experiences of intense and often-overlooked consequences of things.

I read the first book, and loved it, but didn’t read the other books. Then I discovered Peter Watts and read nearly every novel and short story he wrote. Then I went back to re-read Three-Body Problem because I planned to finish the series, and for some reason it hit completely different and just didn’t engage me the same way.

However, Cixin Liu has absolutely massive ideas and focuses on the consequences of things, so I’m honored if anything I come up reminds anyone of his stuff.

Yes, even though @jbg keeps tangling the fruit of “do more with caching, tables, amd smaller data types” like a committed professor.

(Hides my white board of attempted solutions behind a curtain)

However, TADS 3 has a BigNumber data type, but performing calculations with it is slowwwwwwwwww, especially as you do more and more of them in nested loops. This is totally conjecture, but I’m guessing the reason why is Mike (creator of TADS) did not want to rely on the CPU to handle floating-point math (because you can do multiplayer in TADS 3, and floating-point can cause desyncs between computers). So to make the results both deterministic and consistent across all platforms, I assume his BigNumber class does a homebrew implementation of floating-point math, probably in an above-metal abstraction layer. Also, every calculation done with BigNumber drops at least one or two more objects into garbage collection, so there’s also that.

(Again, hearsay and conjecture; I don’t think I can email the guy to satisfy my curiosity, lol)

RTS games like StarCraft get around this by forcing the CPU to use a specific kind of floating point calculation/circuit, but I assume Mike’s goal was to allow TADS 3 to run on anything, even computers that cannot have that floating-point standard enforced.

So my goal was to create a multi-word fixed-point data type with zero impact on garbage collection, and a heavy use of macros to unroll code during compile.

Of course, anyone can tell you that this created the ANTITHESIS of clean code, though it was necessary for performance.

This was still necessary, even after I tried caching and tabling everything, by the way.

Eventually I lost all of my steam, had many sleepless nights, and the problem was starting to get to me. Also, I wanted to try my luck at joining a comp, so I switched to my current SpringThing project, which is making me lose sleep for different reasons!