Tunnel Hunt

Copyright © 2020 by Víctor Parada

This is a little game for the 2020 NOMAM's BASIC 10-liners Contest. This program fits in the EXTREM-256 category, and it was written using FastBasic 4.3 for the 8-bits ATARI XL/XE. Development started on 2019-04-24, and it took 4+10 days. The final version's date is 2020-03-20.

UPDATE: It obtained the 8th place of 25 entries in the category.

Description

Chase and shoot the enemy ships through the tunnel without hitting the walls.

Instructions

	Press START key to enter the tunnel.
	Fly through the tunnel without hitting the walls. Move the joystick in the same direction than the tunnel moves.
	Your shield protects you when you crashes into a wall, but it will loose it strength and it won't recover.
	When you fly in the right direction, you will approach to an enemy ship, but it will escape if you don't follow it.
	You can fire a short-range laser ball when the ship is close enougth to destroy it. If it is not so close, you will miss the shot and you will have to try again.
	When you hit a shoot to to a ship, you will destroy it and score. Then, you will have to follow the next ship.
	The game is over when the shield is completely destroyed. Press START key to begin a new chase.

Development of the game

While I was reading some of the Atari history, something called my attention and it was the first game that Atari licensed to another manufacturer: Tunnel Hunt. It was licensed in 1982 to Centuri. I had never hear about that arcade game, so I did a quick search and found that the game was developed by Owen Rubin at Atari in 1978, but it started as Tube Chase with color vector graphics and then turned into raster graphics, first with ellipses and finally with sqares. Before licensing it to Centuri, Exidy also tried it with the name Vertigo.

Tunnel Hunt flyer

Descriptive flyer

Gameplay

I view some online videos and also tried it in MAME, so I thought that it could simplified to be programmed as a tenliner. In a couple of days (not full days, just a couple of hours on those days), I could write some prototypes in DMSC's FastBasic for the tunnel, with a nice travel effect using graphics mode 2 (ANTIC mode 7), with four color registers for the tunnel (including background) and one color for the text. My idea was to program a little game only with some of the elements of the original game: following the tunnel and shooting enemies.

1st prototype

Prototype at the end of the 2nd day

I forgot this project for a couple of weeks, but when I resumed it, I thought that I could add another color to the tunnel effect asigning the register reserved for the text. Then I had to modify the parameters for routine that generated each of the 9 screens into a cache. As the text should have every time a different color than the background, it would be readable. But I had to change from graphics mode 2 to one, in order to reduce the distance between squares borders. I had to draw the new screens in a spreadsheet in order to find the best parameters for the routine.

Tunnel in graphics mode 1 using 5 color registers

After a redesign

I was thinking about how to add the next elements of the game, but then I thought that it could be great to have a way to split the screen colors in orde to have a non flashing text window for the score and other counters. As the standard way to get that is by using Display Lists Interrupts (DLI), I asked DMSC if DLIs were in his roadmap. He replied that he would like it, so we talk about it for some months, trying to find the best way to do it in a flexible and practical way for many purposes. In the meantime, I forgot this project again for about 9 months, and resumed it when FastBasic 4.3 with DLI support was released.

It was time to add the enemy ship and the gunsight. I tried to improve the perspective, so I tried to adjust some of the elements of the game and adjust lots of parameters, bitmaps, etc. Also, the shield counter was implemented, starting from 99 instead of 999 as it was planned (internally, it starts from 9999 but only 2 chars are displayed only when they change for speed reasons). This took some short periods of time during many days, and I didn't add a DLI yet!!!

Adding P/M for enemies and calibrate positions

Adjusting bitmaps

One special item it made me to think about was the fact that in most of the pilot games you have to move the joystick to the top when you want to go down, but while I played it, I realized that the joystick needs to be moved in the same direction from where the tunnel advances. I finally decided to preserve the original game's feature.

With the enemy ship OK, the next step was to add the fireball and the explosion effect. I was running out of space just because I did not optimize the resources, so I rewrote some portions of the code to see how much free space I had to continue with the adition of more features. I had enough space to add a title screen or to add a color table to make the tunnel look like the original game, without using just a counter which jumps from a light color to a dark one like in the classic rainbow effect. I decided to add a title screen similar to the original one and to see if it fits in the available space. I packed data in a simple Run-length Encoding (RLE), and the unpack routine was also short, so I still had space for the color table. Instead of insert a static table as binary data, I tried a routine to create that table, and it was too short that I was surprised. I also used the new color table for the title screen, as in the arcade.

New title screen

No big color & brights changes in the tunnel

With the DLI enabled and the bogus title out of the score bar, I had some extra space to turn the shield counter into a bar like in the original game using the same chars designed for the title screen. Another idea was to include a laser temp meter, but I prefered to control the trigger, in order to dissallow continuous fire. There was more available space to code, but I used some of it optimizing the code to speed up things instead of to save space. With the contest's deadline being reached in few hours, I decided to stop improving the game, to pack it and to send it.

Technical info about the released version:

• There are 9 predesigned screens in a caché: NW-N-NE-W-C-E-SW-S-SE (numbered from 0 to 8).
• The game sets a GRAPHICS 0 screen, but enables its own display list like a GRAPHICS 1, where the top area is for the predesigned screens and the bottom area pointing to the GR.0 memory. No screen channel #6 is required to print the messages and score.
• To change the tunnel position, just the MSB memory address of the screen needs to be changed in the custom display list.
• The game ends when the damage counter reaches zero
• Damage counter decreases when you delay too much to react, but there is a delay before start counting the hits.
• There is an intermitent hit sound when you fail to react in one axis, and a continuous sound when you fail in boths or when you go to the opposite side. The shield counter decreases faster in the later case.
• The distance of the enemy ship has its own counter between 30 (close) and 399 (far away). It decreases by 1 while you keep the joystick to the same side than the tunnel goes, but it increases in the same amount than the damage counter. So, the enemy escapes faster than you can reach it. You can shoot to the enemy when it is at a distance lower than 75.
• The distance divided by 100 gives an index from 0 to 3, and there is a bitmap and size and screen position parameters for the ship to every the index value, where a value of 3 has no visible player.
• There is another counter to add an horizontal oscillation of the enemy ship. It does not affect the precision for the shoots.

Download and try

Get the TUNNEL.ATR file and set it as drive 1 in a real Atari (or emulator). Turn the computer on and the game should start after the loading completes. A joystick in port 1 is required.

The code

The abbreviated BASIC code is the following:

The full and expanded BASIC listing is:

graphics 0

e=adr("{binary data}")+1

t=adr("{binary data}")+1

dim sc(8) byte, cx(2) byte, cy(2) word,
    ex(11) byte, ey(11) word,
    jx(15) byte, jy(15) byte,
    di(3) byte, wi(3) byte, dd(3) byte

move e,adr(sc),97

mset $9400,$1400,0

poke 752,1

poke 82,0

dli set in = $C8 into $D01A, $E into $D016

move e+97,$9F00,34
dpoke 560,$9F00

move $E000,$8000,512
mset $8008,8,$0F
mset $8010,8,$F0
mset $8018,8,$FF
poke 756,$80

poke 54279,$94

poke 623,1

poke 559,42

poke 53277,2

move e+198,53256,4

move e+140,$A072,8

move e+148,$A16E,16
move e+164,$A272,7
move e+171,$A373,5
move e+176,$A46E,16
move e+192,$A572,6

x=e+202
y=x+4
z=y+4
w=z+4
v=w+12

m=$8200

for i=0 to 8

  for j=0 to 3

    a=peek(v+(i/3)*4+j)
    b=peek(w+(i mod 3)*4+j)
    c=peek(z+j)
    d=peek(x+j)

    for k=0 to peek(y+j)
      mset m+(a+k)*20+b, d, c
    next k
  next j

  m=m+512
next i

m=$9840

for i=0 to 53
  d=peek(t+i)
  a=d/64
  b=d&63
  mset m,b,a
  m=m+b
next i

cc=$9A00
for i=1 to 15
  for j=0 to 7
    mset cc+(i-1)*15+j,15-2*j,i*16+j*2
  next j
next i

position 24,0
print "PRESS START"

dli in

do

  mset $9400,$400,0

  move e+131,704,9

  poke $9F05,$98

  repeat
    i=(i+1)*(i<210)
    j=peek(cc+i)
    pause 2
    poke 708,j
  until peek(53279)=6

  poke $9F05,sc(4)

  position 21,0
  print "HITS:0   SHIELD:99"

  sound 2,255,10,1
  sound 3,254,10,1

  x=1
  y=1

  z=4

  c=0

  u=1
  v=1

  j=0

  d=0

  p=32

  q=1

  w=399
  h=3

  b=0

  f=20

  g=f

  i=0

  m=0
  mm=1

  o=0

  oo=0

  n=0

  s=9999

  t=9900

  ss=0

  ci=0

  repeat

    poke 77,0

    p=p+q
    if p=0 or p=63 or rand(70)=0
      q=-q
    endif
    i=(i+1)&15
    if i mod 4=0

      g=g-(g>3)

      if rand(g)=0

        a=rand(3)-1

        if rand(2)

          a=a+x

          if a>=0 and a<3
            x=a
          else
            x=1
          endif
        else

          a=a+y

          if a>=0 and a<3
            y=a
          else
            y=1
          endif
        endif

        z=y*3+x

        g=f
      endif

      ci=(ci+1)*(ci<210)
      pause 0
      move cc+210-ci,708,5
      poke $9F05,sc(z)
    endif

    if h<>b or c<>z
      move ey(y+di(h)),$9700,$80
      poke 53258,wi(h)
      b=h
    endif

    d=j
    j=stick(0)

    if c<>z or d<>j
      u=jx(j)
      v=jy(j)
      poke 53248,cx(u)
      move cy(v),$9600,$80
      c=z
    endif

    r=ex(x+di(h))+p/dd(h)
    poke 53250,r

    if m

      if m=2

        poke 53249,255

        if w<75

          sound 1,10,8,10

          move ey(y)+$300,$9780,$80
          poke 53251,r

          poke 53250,255
          w=399
          h=3
          o=40

          n=n+(n<999)
          position 26,0
          print n

          poke 706,rand(14)*16+$1A

          f=f-(f>8)
        endif

        mm=-mm

        oo=0
      else

        move cy(v)+$500-m,$9680,$80
        poke 53249,cx(u)-m*mm

        sound 1,80-2*m,12,m/6
        poke 705,2*m
      endif

      m=m-(m>0)*2
    else

      oo=oo+strig(0)

      m=40*(1-strig(0))*(o=0)*(oo>0)
    endif

    if o

      poke 707,o/3+16*rand(16)
      sound 1,100,4,o/4
      o=o-(o>0)
    else

      poke 53251,255
    endif

    a=abs(u-x)+abs(v-y)

    if a
      if ss=0

        sound 0,92,8,2*((a>1)+(i<8 and a=1)>0)

        s=s-a

        if s<t
          position 37,0
          t=t-100*(t>0)
          print t/100;" ";
        endif

        w=w+a*(w<395)
      else
        ss=ss-(ss>0)
      endif
    else

      sound 0

      w=w-(w>30)

      ss=40
    endif
    h=w/100

  until t=0

  sound

  position 30,0
  print "game over"

loop

Return to my 10-liners page.