Electroblasters

Copyright © 2025 by Víctor Parada

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

Description

Use an electric cannon to blast bubbles with lightning faster than your opponent.

Instructions

	This is a two players game and each player controls a cannon with a paddle controller. Try to be in the midrange of the paddle, going to the extremes will take the cannon out of the screen. A green bubble will appear somewhere in the playfield.
	Press the trigger to fire a lightning across the playfield. You cannot move while the lightning is active.
	Each of the players will earn a point when they hit the bubble. Both can hit the same bubble at the same time.
	If time goes without hitting a bubble, it will pop and another bubble will appear. No player will score in this case. Every time the bubbles will last less time in the playfield.
	The game is over when one of the players completes 21 bubbles. If both players score 21 at the same time, the game will continue until only one of the players get the bubble. Press the button to play again.

Development of the game

Once again, I was lacking of fresh ideas for a PUR-80 minigame. This category must be programmed in Atari BASIC in the case of the Atari XL/XE computer lines. This is a hard category, because programs are small and Atari BASIC interpreter is quite slow for an action game, and many tricks must be performed to get a playable game.

In my last PUR-80 game, Endless Road Runner, I used fixed bitmaps in a couple of P/M sprites, requiring just two POKEs to move horizontally them and create obstacles to avoid. Another single POKE on the screen data pointer allowed me to move and make the Roadrunner character jump in the playfield. The remaining things are just decorations that do not affect the performance of the game, and make it more attractive.

With that in mind, I thought what more could be done with P/M sprites that only move horizontally. Then I recall Bounce & Catch, which has one paddle controlled pad, and a ball that also move vertically but introduces a slowdown. So, what if I fix the vertical axis? Instead of a sprite that moves up and down I just enable or disable a tall vertical object like a laser beam? That is enough to kill standstill enemies. Then, I need to set up a scoring system and rules. We always need more paddle games.

Just after I started coding a prototype and proof of concept, what if I set up player versus player scenary? I added a second sprite at the top and managed both at the same time within a FOR-NEXT loop. This turn the game into a kind of race between the players, trying to catch the target before the other player. Great, I now have an action game and, better, a two players game. We always need more two players games.

I wanted to add lots of features, but the coding space got exhausted quickly, so I had to remove one of them (decreasing delay time between bubbles) in order to inlude other (sound effects). Also, even when I had the space, I couldn't make the code fit the line length and the last couple of instructions fall in the eleventh line. My problem was a single IF statement in the middle of the code that must be right justified in its line in order to be able to use the remaining bytes of the line fo more code.

Note aside, it is not a secret that after writing the abbreviated code of my first two tenliners by hand, to simplify the programming process I developed my own tool to abbreviate and pack the BASIC source code. This allows me to use a free form text editor with syntax highlighting in my PC and then pack the code and load it in the emulator to test.

So, I had to make a lot of changes in the source code with the cost of clarity in order to transfer some bytes from the bottom half to the top half of the source code, with the IF in the middle. When I could finally make the program fit in 10 lines of 80 columns, I tried to use the free bytes in the top half to add more pixels to the bitmaps. I made lots of attempts on how to sort the statements in order to get the most extra bits in the lightning bitmap when a splitted line made showed me that I had 2 free half lines to code. WHAT!!!! I didn't notice that all my previous effort was to make the game fit in only 9 lines. My own tool fooled me! By mistake, I forced the line following the IF statement to be one more than needed, skipping a line number in the middle.

With the extra 80 bytes (10%) I could put back the removed features and sounds. I could even manage the game restart in a far better way... and double the size of the pattern for the lightning bitmap.

About the coding techniques, this game uses and abuses of FOR-NEXT loops. It changes the value of some index variables to convert the corresponding loop into a REPEAT-UNTIL structure that Atari BASIC does not have. There is only one GOTO statement at the end to restart the game without using RUN statement, but the jumping destination line includes some initialization code that re-executes on each game, but it does not harm. This program, like my previous Atari BASIC games, initializes a string variable in a way that it is aligned with P/M graphics memory, in order to manage sprite bitmaps using string assignments instead of a series of POKEs. And talking about POKE, this game inludes a string with 17 pairs of Address/Value bytes in a string, and iterates over it to set up the playfield by POKing in a lot of system/shadow HW registers, saving a lot of coding space.

Download and try

Get the BLASTERS.ATR file and set it as drive 1 in a real Atari (or emulator). Turn on the computer and the game should start after loading. Don't press OPTION key as internal BASIC is required. A joystick in port 1 is also required.

NOTE: This is a PAL game. To run in NTSC computers, press [RESET] key and type:

The code

The abbreviated BASIC code is the following:

The full and expanded BASIC listing is:

0

dim a$(88)
a=adr(a$)

dim f$(25000-a),m$(512),s(1),x(1)

m$="{binary data}"
m$(512)=m$
m$(2)=m$

graphics 18

a$="{binary data}"

p=40600

c=53252

m$(281)="{binary data}"

m$(484)="{binary data}"

m$(30,47)="{binary data}"
m$(48,94)=m$(30)

m$(163,227)=m$(30)

for i=0 to 49 step 3
  poke peek(a+i)*256+peek(a+i+1),
    peek(a+i+2)
next i

4

print #6;"{binary data}";

s(0)=0
s(1)=0

n=50

g=c-2

b=g-2

for k=0 to 1

  r=rnd(0)*159

  poke r+p,111

  h=0
  poke 53278,0

  for j=0 to n

    for i=0 to 1

      t=1-ptrig(i)

      if t-1 then x(i)=(x(i)-paddle(i)+228)/2

      sound 0,abs(29-s(i)),2,8*t

      poke g+i,x(i)

      poke b+i,x(i)*t

      h=h+peek(c+i)

    next i

    j=j+h*n
  next j

  poke r+p,0

  n=n-2*(n>14)

  for i=0 to 1

    h=peek(c+i)>0

    sound 0,9,10,8*h

    s=s(i)+h

    position 9,i*11
    print #6;s;

    s(i)=s

  next i

  d=s(0)-s

  k=(s(0)>20 or s>20) and  d

next k

position 7,(d<0)*7+2

9

print #6;"{binary data}"

for k=0 to 30
  sound 0,200,12,10-k/3
next k

for k=0 to 1

  k=stick(0)<15
next k

goto 3