View Monthly Tag

I saw the Commodore 64 maze generator for years, but ignored it on my ZX81 for different reasons. For one, the characters needed didn’t exist on the ZX81 keyboard. The other was the lack of automatic scroll. Undeterred this month, I created my own version in Sinclair BASIC. I’m quite happy with the results, even if not quite the same.

In my final article about Mandelbrot sets, I’m sharing the hybrid program built from the last two. After finishing the chunky graphics version, I envisioned a merged version. This split graphic version is a nice compromise to showcase the beauty of the fractal.

After completing my Chunk Graphics mode, my thoughts went to how best to use it. My first idea was something new, such as a flight simulator. After pondering, I stuck with something current by modifying my Mandelbrot Set program. With three gradients, it would be an interesting use of the mode.

Out on a run back in November of last year, I had this idea to create a 3-color screen mode of the ZX81. The idea was to use the checkered, or gray, graphic characters to add a third color. After reading about the C64 color modes, I called it chunky graphics as an homage to its wide pixel format. The pixel’s are chunky due to the 2x1 ratio and not being square. Let’s dig into the details.

After finishing the basic version of the cat animation, I wanted to improve the frame speed. This meant converting from BASIC to machine code. My first thought was to do the conversion with MCODER II. I dropped that idea, deciding to focus on a custom z80 Assembly version. Ergo, cat written in assembly or Fast Cat is, well, a faster version and a bit more.

The holiday's provided me a nice break to enjoy writing code. During that time, I revisited my digital rain program. For ZX81 Rain, I cleaned up the colors and added a little randomness to where the drops start. Nothing super exciting, but the overall effect is much nicer and looked good in both black/white and color on the ZX81.

I had this idea the other day. One of the problems I’ve had with the ZX81 is printing numbers, which is pretty slow. Due to this, many of my games avoided printing them. delaying showing score until after play has ended. My idea was to try to find a way to speed that up. Not only did I find a way, I decided to implement it in an older game of mine: E.T.

I’ve been on a retro computing binge lately and was recently watching one on programming on what it was like to program in the 80’s. Having lived and programmed during that time, I know full well what that was like. But the narrator was showing off an Apple ][+, a computer I didn’t own. Although I programmed on an Apple ][ in high school, my memory of it is vague at best. But what was really interesting was what he was programming: a snake game. Being something I’d never tried myself, I thought now would be as good time as any.

Okay, after finishing my BASIC program version of Mandelbrot Sets, I decided I needed more speed. I wasn’t sure if I could write a version in assembly. My concern was the floating point math. After a good amount of research, and trial and error, I finally got a version working. This is my story.

Fun with Mandelbrot sets. I never thought I’d say that, but here I am doing just that on the ZX81. I ran across some fun discussions on them. They are often used as benchmarks, but I just wanted to create some interesting pictures. This is my version using Sinclair BASIC that creates a few interesting ones.

Hey, it’s October. Well, it has been for a few weeks now. In any case, it is also time for a ZX81 program. I recently joined an 8-Bit Programming & Engineering Facebook group and its cover is a photo of a FizzBuzz program in Pascal. As a quick exercise, I thought I’d write my own in ZX81 BASIC.

I ran across a ZX81 forum post showing a fast way to print a circle in BASIC. It was based on an article for the Atari back in 1983. I was surprised how fast the routine was and wondered how it would in assembly. Long story short, I built a screen saver for the ZX81. Sure, the ZX81 really didn’t need one, but the circles are fun to watch.

Totally divergence from working on Gem Quest. I got around to cleaning up my scrolling demo from last month. In doing so, it made me wonder would it would be like to code it in assembly. The answer is both bland and interesting. Let’s discuss why that is.

Although I've been busy working with the ZX81 this month, it has been with my Gem Quest game. Not much to share yet there, but I am working on it. To get in something for the month, I thought I’d share an updated demo program.

I had this idea on Sunday that led to today’s program—more about that in a minute. One of those sit down and do it programs, I banged this out pretty quick yesterday. Not wasting time, I decided today I’d share it. Road is a very simple program that I never intended to make. But here it is, so lets talk about it more.

Not a lot of time for programming this month, but I did get around to adding coins to my running game. Funny how little things take time to hack about. I’m not completely happy with it, but it works. Run 3 ML does give a whole new meaning to infinite runner.

Well, hard to believe we are turning the corner on March and heading into April. Spring is edging its way in and it is time to get outside and work in the yard. This made me want to kick my ZX81 program to the curb, but it didn’t feel right. So, I bundled up my current progress on Run.

For some time now, I’ve wanted to build a running type game. The kind where there is a single key to press and releasing it makes you take an action. There are lots of variations on this theme, and it seemed like something fun to try. Idea in hand, I began by building out a rough look for the game.

I haven’t had much time for programming the last few months. To get back into things, I decided to take an old BASIC program of mine and rewrite it. Thinking about what to convert, my mind immediately went to Enlarger. It was a rather slow animation demo that could use an update.

For years, Water Bug II has been an interesting game for me. I was so excited when completing the first version, that I wanted to build another one with ten more boards. The funny thing is, the two games look a lot alike. In fact, if you weren’t paying attention, I wouldn’t be surprised if you thought you were playing the same game. Let’s dig deeper on both the similarities and the differences.

For most of the day, I’ve been thinking about my Water Bug game as I never really gave it a proper write-up. Finally got around to playing it again, I was surprised to find elements in that I thought were unique to Water Bug II are actually in this version. That made me want to walk through each board, understanding better what I had done, what worked, and what didn’t. Let’s dive right in.

Like many teenagers in the early eighties, I was playing video games on my Atari VCS. Yars’ Revenge was a popular purchase, and I spent many hours dodging that stupid missile and trying to take down the shields of the Qotile. It then should come at no surprise that I tried to recreate that game at 13. My attempt on the ZX81 didn’t look horrible, but it sure played bad. Let’s see how much.

My original plan was to create an z80 assembler version of Moon Lander. But with the trailer release for the next Matrix movie, I found myself revisiting another program. Built entirely in machine language, Z80 Digital Rain expands on my previous version with a splash of color. Let’s dive deeper.

Last month, I shared an old moon landing program I wrote back in the early 80s. Right after that, I decided to give it a bit of a face lift, updating the visuals without changing the game play. Moon Lander v2 is my updated game, yet still the same BASIC code under hood.

When I first started programming, one of the games we would play on the old teletype machines was a simple moon lander game. The premise is you would use your thrusters to softly land on the moon. Moon Lander was my take of that program a few years later.