UFO Attack!

Copyright © 2019 by Víctor Parada

This is a little game for the 2019 NOMAM's BASIC 10-liners Contest. This program fits in the "stock" PUR-80 category, and it was written using Atari BASIC for the 8-bits ATARI XL/XE. Development started on 2019-03-01, and it took 2+5 days. The final version's date is 2019-03-16.

UPDATE: It obtained the 14th place of 35 entries in the category.

Description

Use the shields to protect the earth from the attack of an aggressive flying saucer.

Instructions

	An Unidentified Flying Object is approaching and releasing bombs.
	Use a paddle controller to move the shields in order to block the bombs.
	If a bomb is missed during a wave, one of the shields is destroyed.
	A new shield is generated when a wave is cleared, but you can have a maximum of 3 shields at the same time.
	The game is over when the last shield is destroyed. You will see the number of completed waves and the number of destroyed boms. Press the trigger to defend the earth from another attack.

Development of the game

I was thinking about a simple paddle game that could fit in the PUR-80 category, because I like paddles and I want to put a game in the podium of this category, and Activision's Kaboom! came into my mind. The challenge was to write the program in plain Atari BASIC (stock 800XL). I thought that 800 chars were enough for a simplified version of the game, but I was worried about the speed. Could it be fast enough?

I started writing a prototype just to test the concept. At the beginning, I thought about the use of P/M graphics for the bomber and the buckets because they can be moved to any horizontal position after setup with a single POKE for each of them (one for the bomber and one for all the buckets), and let the bombs be just scrolled down by OS's PRINT routine by inserting lines, but then I had to discard this method because there is no scrolling available in graphics mode 1 or 2 (big colour chars) like in graphics mode 0. As Atari BASIC has no MOVE statement, I decided to use the same string management I did in my game Deep Canyon. While I was setting this up, I realized that the bomber could also be managed with strings almost as fast as a POKE to HPOSx register.

When the falling bombs routine was working, with the bomber moving from side to side randomly and dropping the bombs, I added the buckets also as substrings, and that looked nice, but still without bitmaps (redefined charset). I could then manage the remove of the captured bombs without having to manage P/M collisions detection. The code at that time had 6 lines, but there wasn't sound, score or nice bitmaps. I had to decide between good looking graphics, sound FX and a way of scoring to be put in the remaining 2 lines. A simple calculation said that to add a bitmap for the 4 chars in use would require a bit more than a complete line. But there was another pending setup that would use the remaining space, and no scoring or waves yet!!! So I decided to discard the bitmaps and to replace the assigned chars with some standard ASCII chars to give tho look&feel of Kaboom!, and finally to add rounds of increasing difficulty and simple round based scoring. The result? A very hard game to play with a paddle (mouse) in the Altirra emulator, even when it was noticeable slow compared to the original Kaboom! game, without the posibility to increase speed in every new level. I changed the code to support a joystick instead of a paddle expecting for a better control of the game, but the result was very similar. I decided to drop this prototype for the PUR-80 category, and to start looking for another game or idea for the category.

Initial proof of concept

Using standard chars instead of bitmaps

A week later, Kevin Savetz submitted another port of Kaboom! to the contest called "Bomber". His game was written in TurboBasic XL and it was impressively fast, much more than mine. He also used a paddle controller, and then I realized that he used a single bucket (pad) that was very wide, and I guess that it was to make the game playable. This made me try a wider bucket in my version and I resumed the development of it.

Kevin Savetz's Bomber

With a couple of modifications, I could play my version with a wider bucket and reach level 4 or 5. Wow! But I was still unconfortable with the ASCII graphic, so I tried many combination of letters and symbols to represent both the head and the body of the bomber, until I decided to add additional symbols to represent the arms surrounding the body. The result: it looked like a spaceship or flying saucer from the 50's or the 60's!!! That gave me the idea to turn this game into a new one: the bomber turned into a UFO, the buckets into shields and bombs into... into... into another kind of bombs. Also, I reversed the order in wich the buckets were removed: instead of remove buckets from bottom to top, the shields would be removed from top to bottom. At last, I included a way to detect collisions and play a sound at that moment.

Wider buckets and bomber with arms

I did lots of code simplification and earned a line and a half of free space, so I decided to try the code to change the charset, but it could only provide 4 chars and some of them should be used many times, having to define some patterns. But, what if instead of a spaceship I draw the bomber as it was originally designed? After merging both branches of the development, the result was a playable game, but still difficult to play with a mouse in the emulator. I unpacked my real 800XL and connected it to the PC via SIO2PC-USB and booted it with the same ATR I was using in the emulator. Yee-haw! It was really enjoyable to play it using a real paddle controller.

Using bitmaps for Mini Kaboom

It was easy to add the shield recovery at the end of a wave and to count the number of bombs destroyed to be displayed when the game ends, because both required only few extra bytes, but forced me to minimize the message with the score at the end of the game.

But since I was happy with my derivative idea of an UFO attack, I included the new changes of the Kaboom branch into the UFO branch, and tried some different designs in the modified charset to get nice patterns. As the final one looked nice in the LCD TV screen of my 800XL, I decided to fork the joystick branch again and try it with all the code changes. It turned out to be too easy with a real joystick, so I decided to decrease the width of the force shields again, like in the dropped prototype.

Trying some different bitmaps

Joystick version with narrower shields

Few hours AFTER I sent this game to the contest, another simple optimization came into my mind, so I emailed Gunnar to wait for a moment and to not publish it yet in the entries list. The optimization gave me about one complete line, so I could add more bitmaps instead of the pattern used for the UFO. Some hours later, I had a new version with new graphics and better sound effects. Also, I could accomodate the lines in a way that all 3 versions of the game look the same in the ATASCII listing.

New bitmaps with 6 chars

I also found a bug in the joystick version. I had changed the STICK(0) read and manipulation for STRIG(0) and STRIG(1) in order to be able to split the positioning formula and acommodate it in two lines, because those functions read the same pins from the horizontal movement of the joystick. To save coding space and speed up a bit, I used their complement values, so the formula always added one position to either side when the joystick is released, and the net result was to stay, but when the joystick is moved to one side, what was really happening is that it was signaling that the other side was released. The problem was that Atari BASIC was too slow that sometimes the delay between the read of both triggers was enough to make the program believe that the player wanted to move the shields to the other side.

An interesting fact in this development is that IF-THEN, IF-GOTO, ON-GOTO, ON-GOSUB, GOTO or GOSUB statements where not used. All conditions were included in expressions, and loops were implemented using FOR-NEXT statements, most of them using the 0 to 1 range, but resetting the index variable to 0 just before performing the NEXT statement for an infinite loop, or allowing it to be 1 to exit as in a REPEAT-UNTIL loop.

Download and try

Get the UFOATAK.ATR file and set it as drive 1 in a real Atari with paddle controllers in port 1. Turn on the computer with BASIC enabled (without pressing OPTION key) and the game should start after loading.

Emulator Advice: a mouse does not replace the experience of a real paddle controller, and the game turns very hard. Play it at your own risk!!!

Bonus: the same disk contains a joystick version of UFO Attack! ("UFOATAKJ.BAS") and my Mini Kaboom game ("KABOOM.BAS").

TurboBasic XL hack! To play this game using TurboBasic XL, you must change memory adresses in a pair of POKE at line 3:
- 48485 instead of 40293
- 48484 instead of 40292
The game will be run faster, but would you be able to finish a couple of waves at this speed?

The code

The abbreviated BASIC code of UFO Attack! is the following:

The full and expanded BASIC listing is:

l=440
dim a$(20),b$(60),f$(32276-adr(b$)),z$(l),
  c$(248),s$(40),p$(l),q$(l),t$(l)

graphics 17

d=1

z$="{binary char}"
z$(l)=z$
z$(2)=z$

a$=z$

b$=z$
b$(20,20)="{binary char}"
b$(39,41)="{binary string}"

for g=0 to 1

  f=1
  r=0
  m=0
  x=9
  y=8
  u=3

  for h=0 to 1

    s$=z$
    p$=z$
    q$=z$

    poke 77,0

    poke 756,128

    poke 40293,129
    poke 40292,0

    for i=r*4+34 to 0 step -1

      s$=b$(21-x)

      h=(x=2)+(x=18)+(rnd(0)<0.1)

      d=d*(h=0)-d*(h>0)

      x=x+d

      t$=a$
      t$(21)=q$

      t$(x,x)=chr$((i>21)*f)

      q$=t$

      y=int(paddle(0)/13.5)

      for v=1 to u

        w=477-60*v-y

        c=q$(w,w+2)<>"{binary string}"

        sound 0,20+3*x,8,c*8

        m=m+c

        q$(w,w+2)=a$
        t$(w,w+2)="{binary string}"

      next v

      p$=t$

      k=q$(421)=a$

      f=1-f

      i=i*k
    next i

    for i=0 to 15
      sound 0,180-i*k*9,8+2*k,15-i
    next i

    u=u-(k=0)+k*(u<3)

    r=r+k

    h=u=0
  next h

  graphics 17
  position 4,9
  ?#6;"{binary}";r;"  {binary}";m

  for i=0 to 1
    i=1-ptrig(0)
  next i

  g=0
next g

Details of the bonus games

The abbreviated BASIC code for the game variations are the following:

UFO Attack! (Joystick Version)

Mini Kaboom

The code is almost the same than the one listed above, changing only data lengths or formulas in string manipulation and/or values. For the joystick version, a variable should be initialized to start in the middle of the screen and store the current position, and it was also needed to check to stay within screen limits. For Mini Kaboom, the extra bitmaps were used to improve the buckets.

Return to my 10-liners page.