<=====------======------[ 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. ruleofsix 2024/09/17 <=====------======------======------======------======------=====>