Quickly Avoid the Spiders in the ZX81 Game Tarantula

Tarantula, August’s program of the month, was part of a pair of games that made me think I was a game developer. At the age of fourteen, I didn’t let problems like the lack of a distribution channel tarnish my dreams. Although I didn’t make it into gaming, it’s still fun to look back on what could have been.

Using art to spark spark the imagination.
When I wrote Tarantula and Block £ Spear, the other part of the pair, I wasn’t thinking about playability. Instead, I was dreaming about what it would be like to release a game. I thought about game art and how it told a story.

My inspiration was the classic Atari VCS box and cartridge art. Given the blocky nature of the VCS graphics, the art helped convey the spirt of the game. The artwork was imaginative and fanciful. My favorites were Adventure, Super Breakout and, of course, Basic Programming.

Although the ZX81 had better graphics, they were still crude and lacked color. So after completing my games, I dreamed about creating art for them. The two games had similar styles, using a smaller part of the screen with simple movements. They were also both hard and unfair. As such, they were a fitting pair.

Spending almost as much time drawing as programing, my dreams soon became reality. I combined the two games into a single artwork. Although I didn’t published my games then, I remember my poster with fondness. 23 years later, I can share my attempt.

Tarantula and Block & Spear by Steven Reid, on Flickr

How does it play?
The game itself holds a special place in my heart that isn’t well founded. At the time, I thought Tarantula quite clever. The idea isn’t without merit. The moving and spiders and shifting stalactites make for good obstacles.

In fact, they do work pretty well—too well, in fact. Jumping and moving can be quite difficult. It takes a bit of time to get used to the pattern. Your jump is quite long, but it can be difficult to time it and move without hitting something.

In fact, the last stalactite is almost impossible due to the random nature of the game. You have to time your jump to make it past, no easy feat. And, to make things worse, you are teleported to the start where a spider could already be. Needless to say, I’ve only made it once in my testing.

On the positive side, the difficulty is a challenge. I spent a good amount of time relearning how to jump and avoid the spiders and stalactites. The patterns, although difficult, are learnable. In that respect, it succeeds as a game. Correct a few problems and it would make a great game.

The good.
As hard as the game is, the code isn’t bad. It reads okay, although a bit convoluted at times with various GOTO and GOSUB routines. Although functional, there is room for improvement.

Let’s start with the positives. Foremost, it is a fast game. The jumps are smooth and look nice. The routines that control the stalactites work well. The random nature is good, even if often leads to an unfair death.

Although rarely seen due to the difficulty, Tarantula prints titles if you get a high enough score. I’m sure I got the idea from another game, although I don’t remember which. Yet, it is a nice touch, and one I wish I’d used more often.

The death routine also acts as the teleport routine. Nice reuse of code! The effect works well and fits with the theme. The teleport routine in visible in the earlier artwork, timing in with the routine. The movement looks is good too, but I wish I’d added some movement.

The bad.
Yet, problems abound. First, the game has a few flaws that make it quite impossible. For example, if you by some magic make it to the end, you are most likely to teleport on top of a spider. It is unfair and y shouldn’t have allowed that to happen.

Next, you start with a good jump distance—five spaces to be exact. You need two spaces to complete the jump as your avatar is two characters wide. As a difficulty feature—like this game needs another, I when you reach the end. But, that routine doesn’t work right. Take a look at line 310:

 310 LET E=SP-(SP<2)-(SP<3)-(SP<
4)-(SP<5)

Do you see the problem? Let me help. Tarantula uses the variable E to set the length of the jump. SP holds the current length. The program reduces it each successful attempt until it reaches 2. With me so far?

Okay, so in line 310 the program sets E to the jump size, subtracting one space depending on the size of SP. The routine doesn’t work. Staring with SP means I’m actually making the space even smaller. Not good.

What I should have done is either used the starting size, in this case 5. Or, even better, omit the routine altogether. Looking at the code I don’t need E at all. I could use SP instead, and remove this whole line.

And the ugly.
Another problem arises with printing each frame. Printing a number is super slow on the ZX81. Changing it to print later would have sped up the game, better matching the jump routine.

On that same line, I overwrite the spiders with spaces before printing them. Although the routine is simple, it causes a jarring fliker over the charter’s legs. Using spaces after the spiders would look smoother.

Speaking of the character, the use of an array made no sense here. If I’d added movement, as suggested earlier, it might make more sense. But, as is, it takes more memory and doesn’t add much value.

A good try.
Besides to the bugs noted, there are other places where I could merge and simplify the code. Rendering some things would have helped readability. But, what I need to do is fix the game play issues.

For all its flaws, though, I still like Tarantula. Its heart is in the right place. With some minor tweaks it could be a killer game. Plus, the art is what matters. It conveys a since of imagination that the graphics couldn't.