<=====------======------[ Back to BASICs ]------======------=====>
I've wanted to learn assembly languages for a while now, and I
wanted to start with the 6502 instruction set for a variety of
reasons that mostly boil down to "because it'll be fun that
way." I decided to set up a C64 emulator as my target machine
because, well, I thought it would be fun. I was pointed towards
VICE by an SDF user and got it set up pretty easily- it's very
intuitive software. However, this is where I got entirely
sidetracked- I decided to go through the Commodore 64 User's
Guide, given my complete unfamiliarity with the C64 prior.
Going through the manual and the examples within made it very
obvious very quickly why the C64 was so successful and is so
iconic to this day. There was something that felt simply magical
about the sound and graphics capabilities it had and putting
them into the hands of the user to create whatever they want
from the very beginning. No wonder so many games were (and still
are) made for it. I found it not only immediately impressive but
also simply fascinating- needing to manually read and write to
seemingly arbitrary memory locations within BASIC in order to
accomplsh so many tasks certainly made it more frustrating to
use, but to me looking back from a modern perspective feels very
charming. I was simply having fun. And I couldn't help but think
back to the first programming I had ever done: a simple game in
TI-BASIC on my calculator back in school.
Essentially, wanting games on my calculator but finding few that
were compatible with my model online (and not having a cable
with which to transfer files to my calculator in any case), I
had typed in someone's code for a Pong clone that I found
online. Then, I analyzed it as much as I could to figure out how
it was operating and keeping track of the game state, then tried
to apply similar concepts to my own game. I ended up, after a
lot of trial and error, managing to create a simple top down
game in which you (represented by an O) walk around and hit
targets (represented with an X) with your sword (which was an em
dash or an I depending on if was horizontal or vertical to you).
That was the whole game. A few waves of targets would spawn, and
at the end you would see your score. It had taken a LOT of
messing about to figure out how to count the defeated targets
(originally, the game didn't know or care if you had hit an X,
you were simply overwriting the character with your sword). And
even in the final version, you could just as well simply run
through the Xs with your body.
The game was fundamentally simple and objectively bad, but I was
very proud of myself at the time for managing to make it at all
(manually typing in all those GOTOs on a calculator was not my
idea of fun). I had some fun trying to get a higher score
between classes, and eventually I erased it because I had to
reset my calculator for a test. I didn't have a backup (again,
no cable) so that was that.
Reminiscing about this as I was playing about with the Commodore
64's BASIC interpreter, I decided to rewrite the game for it. It
was much, much easier this time, both because I am a better
programmer and because the C64 is much more suited to this sort
of thing. I even implemented collision detection so you couldn't
run through enemies this time. It only took a couple hours and
it was both a fun trip through memory lane for me and also a fun
trip into a programming environment far before my time.
Ultimately the whole thing was a distraction from my original
goal (6502 assembly), but it was a very fun one that let me
satisfy my inner child who was frustrated about the bug in my
old game all these years. I am glad to have found a rekindled
appreciation for the clunky languages that got me and so many
others started.
