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.
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.
As hard as the game is, the code isnít bad. It reads okay, although a bit convoluted at times with various
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.
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<
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.