Once upon a time, I was a student at Wren High School in upstate South Carolina, and I owned a TI-86 Calculator. It could download games just like it could download applications for doing math equations and such… not unlike what you can do in a much more advanced sense with modern day smart phones—holy shit, I am referencing back to an age before I had a cell phone… I am old—and it could be used for entertainment or homework. Like most people should, I chose to use it for both.

I discovered that even though there were games running on the device that were as complex as Doom and Tetris, that it also had it’s own BASIC Language before I even knew what BASIC was. TI-BASIC taught me the power of Goto and Labels, Variables and Output. But the calculator couldn't do all the teaching, no. I’m Huntermun, and I’ve got to learn things backwards apparently… stripping down something that already exists and discovering how it works.

Most applications’ code couldn’t be viewed… or, at least, none I had seen yet. All these games, I would learn, were self contained… inside an executable file of sorts. They were whole things that could run on the internal programming of the calculator, but they couldn’t actually be made on the calculator. As a result, they were nebulous things to me, just like programs were on the computer, in that I knew someone had to make them, but I didn’t know how it would be done.

I wanted to know how.

And then I found this simple little game called “Hick Quest III”. I don’t even remember all the details of this game, but it was a very simple fighting game of sorts. Very much a “press button, attack badguy” sort of affair, with your name on screen to one side and your opponent’s name to the other not unlike Pokémon. It was simple, but simple gave me hope. Long before I would complete the game—in which I recall my blood turning into alcohol, and dying—I would go into the programs on my calculator and discover it was my first TI-BASIC game.

The key difference between the other applications I’d downloaded to my phone and this one was that I could actually open up game as code rather than simply seeing it sitting there all "yup, I'm a program". Not only could I look around through all the code, I could read the code… because BASIC is super-basic, and it’s not hard to figure out “This Number is in X variable” and “This Goto tells the Code to skip to X Line”. At least, it wasn't hard for me to figure that out…

But far more importantly than simply looking at how the code probably worked and how the calculator read it was the quick realization that I could edit it. And with years of lost data experience behind me, I knew I needed to back the game up first, and I did. After that, I start fiddling with things… all the things.

At first, I replaced the names of the baddies, and that was neat. But shortly after that, I figured out how to add more… thereby doubling the number of enemies in the game by creating a second location. I altered the title screen, and changed up how the information for you and the opponent was laid out. I altered the opening plot and even added additional pages to it to set up the story.

And thus Maverick Hunter Fighter was born.

But was it? I was making this game for myself and my friends on a calculator at school, so I wasn't at all worried about copyright issues because, if nothing else, I was a minor. Suck it, Capcom! But, seriously, I loved Mega Man X then and still do now and I'd already been creating FanFiction in its universe long before this game. But the idea that I could make my own text-based Mega Man X game was crazy to me, and yet… here it sort of was.

Some of you are thinking about how you've done this same thing while others are thinking what I was thinking at this moment: you didn't really make a game… you gutted someone else's. And that got to me only a little, because I was already beyond the start of MHF. I'd learned. I understood all the above, and even started using Output to draw graphics onto the screen. Text-Based Graphics. I even animated them, and I was so proud of myself… still am.

The original MHF didn't last long, and it would fit the model of a different Capcom game of the fighting-variety, Street Fighter. Street Fighter, the first one, sucks, and that sort of became MHF. And just like Street Fighter, nothing carried over when I opened up SimpleText on my Performa 6220CD and started writing a new MHF from scratch. In a very short amount of time, the first version of that game came out and it was a hit.

And that's no joke. Maverick Hunter Fighter II had an animated Title Screen; It had Save Files for multiple playthroughs; there were Weapon and Armour Upgrades; Heart Tanks to expand your health; multiple locations to visit and different modes of transportation to acquire in order to travel to them; there was a stat screen and character sheet; and I even animated "READY!" to appear on screen whenever you started a new fight.

Instead of version numbers, the game's title mutated as a purposeful spoof on Street Fighter. Maverick Hunter Fighter II became II Turbo, II Hyper, III, Z, Zero, Alpha II Turbo, and any number of other permutations. It was great! And, best of all, it turned out the game also ran on the TI-85, a less powerful piece of hardware that was a lot more populous at Wren. And it was here I learned two additional things about my game: it was fun, and it was bloated.

It being fun was great… people I didn't even know or know people who knew them were sitting in the cafeteria playing MHF when I came in. I cannot express how amazing that feeling was. But that feeling was quickly stunted by a revelation that I'd put too much into the game… not for the 86, but for the 85. It was literally running out of space to hold the game and anything else.

This is how MHF taught me to code better.

You better believe there was a lot of junk code in the game. Every villain having a slight alteration to the fighting system? Check. Their own stats, even if they were duplicate? Check. Multiple variables for each linear upgrade item? Check.

Suddenly, my code was a mess again. How could I not have seen it? But I went after it with dedication, writing entire new swaths of code simpler so that more parts of the game could utilize the same variable and draws. But even as I hacked out unnecessary parts, I still ended up hitting that wall that was the TI-85… and like any good game dev, I both wanted to keep my install base while also giving those with the bigger memory and more powerful 86 something more.

This is how MHF taught me to code for cross-generational gaming.

Look, it may be simple, but it is a vital skill to learn. By keeping the items linear in the 85 Version, I could keep them in. Meanwhile, on the 86 I added a shop and expanded it to allow for multi-linear gameplay. Rather than always having a single weapon, you could swap out weapons. There was an additional area of the game to move to and fight. The 86 Version of the game was just a bigger experience, and each time I could shave off some little thing in the 85 version and put in a new feature, I would.

Way back in the late 1990's, this was a huge deal for me. Not only did I know coding—simple coding still counts!—but I had learned it all on my own. I felt really good about my product, and people at my school enjoyed it. I had, maybe, twenty or more people actually walking around with it in their pocket, enjoying their experience… and I always made sure to make it so Save Files would be able to carry forward into the next release.

All in all, I was very happy with what I had done… but after I graduated and went on to my first college, I quickly learned that TI-BASIC might have been a good primer, but it wasn't very fitting for the types of games I wanted to make. In time, I would hit my head against QBASIC and Visual Basic and C-Sharp and C++… and it wouldn't be until this time last year that I stumbled into something that would let me finally make a new and more expansive game than I'd ever made before.

But that's a story for a different day. For now, please join me in sparing a moment to recall that it was today, last year, that the first version of #AD21XX was typed into. While I had poked and prodded at the idea of Adaptation (20XX) before then, I had not really gotten my own hands to make my own code again until February 16, 2016. Yes, I had tried. All the above as well as Xcode had landed on my plate over the years, but nothing quite felt as much like home to me as TWINE and SugarCube 2.

Today I, if no one else, celebrates the One Year Anniversary of the first Code I wrote towards the game and series I hope will become Adaptation 21XX.


See you in the Future,
—Huntermun / Tyler N. Sewell