The Blitz Way

You've arrived. Over fourteen units you went from typing one compiled line to steering, animating, colliding, scrolling, writing the colour hardware and flying hardware sprites by hand — every part a game is made of. This last unit isn't a new idea; it's a look back. We'll put a pile of those parts into one program, then notice the thing that's been true the whole way: with Blitz, you built each piece. That's the exact opposite of the bargain AMOS makes — a different deal, not a better one, and choosing it is what this whole primer has been about.

What you'll see by the end

Twenty-four objects, all moving at once, each bouncing off the edges, the whole screen redrawn fifty times a second without a flicker. It's the promise from unit 5 — many things at once — pushed as far as it'll go, and it doesn't even break a sweat. That's compiled code doing what interpreted BASIC can't.

The whole program

; The Blitz way: parts you assembled yourself, running at compiled speed.
BLITZ
  ; one ball shape, grabbed once
  BitMap 2,16,16,2
  Circle 8,8,7,2
  Circle 8,8,4,6
  GetaShape 0,0,0,16,16

  ; two display pages for flicker-free motion
  BitMap 0,320,256,3
  BitMap 1,320,256,3
  Slice 0,44,320,256,$fff8,3,8,8,320,320

  ; give 24 balls a starting place and a velocity
  Dim px.w(23)
  Dim py.w(23)
  Dim vx.w(23)
  Dim vy.w(23)
  cx.w=10
  cy.w=20
  For i=0 To 23
    px(i)=cx
    py(i)=cy
    cx=cx+48
    If cx>290 Then cx=10 : cy=cy+44
    vx(i)=2
    vy(i)=1
    If i<8 Then vy(i)=-2
    If i>15 Then vx(i)=-1
    If i>15 Then vy(i)=2
  Next

  db=0
  While Joyb(0)=0
    VWait
    Show db
    db=1-db
    Use BitMap db
    Cls 0
    For i=0 To 23
      px(i)=px(i)+vx(i)
      py(i)=py(i)+vy(i)
      If px(i)<0 Then px(i)=0 : vx(i)=-vx(i)
      If px(i)>303 Then px(i)=303 : vx(i)=-vx(i)
      If py(i)<0 Then py(i)=0 : vy(i)=-vy(i)
      If py(i)>239 Then py(i)=239 : vy(i)=-vy(i)
      Blit 0,px(i),py(i)
    Next
  Wend

Nothing here is new. Read it and you should recognise every line: a shape grabbed once (unit 7), two bitmaps for flicker-free double-buffering (unit 8), a slice to show them (unit 6), arrays holding each object's position and speed (unit 13), and the frame loop that moves them all and blits each one (units 4, 8). That recognition is the measure of how far you've come — the whole primer, strung into one scene.

What you did yourself

Now the point of the whole track. Look back at the AMOS primer's closer and it counts what AMOS did for you — opened the screen, drew the bob, ran the animation, all behind a single keyword. This program is the mirror image. Count what you did:

• You made the bitmaps and chose their depth, and you built the slice that turns them into a display.
• You grabbed the shape, you kept the two pages, and you wrote the Show/Use flip that makes the motion flicker-free.
• You held each object's position and velocity, moved them, bounced them off the edges, and blitted every one — by hand, every frame.

AMOS hands you a finished machine and asks you to drive it. Blitz hands you the parts — bitmaps, slices, shapes, the blitter, the colour registers — and the speed to bolt them together however you like. You write more; in return you understand exactly what runs, and nothing stands between you and the hardware. That's the Blitz way, and it's the same disposition the assembly track asks of you — just with the sharp edges filed off.

Where Blitz fits

There's a temptation to rank these — to call one a beginner's toy and another the "real" tool. Resist it. AMOS and Blitz are two valid roads into Amiga game-making, and which suits you is about temperament and the game in front of you, not skill:

• AMOS — interpreted and immediate, with a huge toolkit built in: Bobs, AMAL, sprites, sound. A game comes together fast, and you change it and see the result at once. When you want to make a game now, AMOS is hard to beat.
• Blitz — compiled and quick, close to the hardware. You build more of the pieces yourself, and in return you get speed AMOS can't reach and the chips at your fingertips. When you want many things moving fast, or to touch the metal, Blitz is the one.

Neither is the senior. Each is better at some things — AMOS at getting going and at its rich built-in objects, Blitz at raw speed and reaching the hardware — and plenty of Amiga developers picked whichever fit the job. You've learnt Blitz; learning AMOS too just means you can choose.

Beyond both lies 68000 assembly — not a step up but the deep end: total control, total responsibility, every byte yours. It's harder, and you rarely need it — but the habits you built here, thinking in bitmaps and registers and owning the frame loop, are exactly the ones it asks for. If you ever want to go there, Blitz has quietly been getting you ready.

It shipped a classic

If you doubt a BASIC can make a real game, here's the proof. In 1993 Amiga Format and Acid Software — the people who wrote Blitz — ran a Blitz BASIC 2 game competition. The entries were real games: Derring Do, a polished Mr. Do! conversion; Blitz Bombers, a Dyna Blaster take. And one entry, a turn-based artillery game by a reader named Andy Davidson, didn't even win. He took it to Team17 instead, who published it as Worms — which went on to become one of the best-selling, longest-running game franchises the Amiga, and gaming, ever produced.

Written in Blitz BASIC 2. The same BitMap, Shape, Blit and frame loop you've been using these past fourteen units. The tools are real, and so is what you can build with them.

Type it and compile it

Type the program into Ted and press right-Amiga + X (recompile if Blitz asks about memory). Two dozen objects fill the screen and bounce. Press fire — or reset — to stop. Then try raising the 23s to 49 for fifty objects, and watch it still hold a steady fifty frames a second.

What you've learnt

You've finished Meet Blitz. You can type, compile and run; you know Amiga mode from Blitz mode and Blitz's typed variables; you can make decisions and loops, run many things at once, carve the display into slices, grab and blit shapes, animate and collide them, scroll a world wider than the screen, write the colour hardware directly, and fly the Amiga's hardware sprites. More than any single command, you've learnt the Blitz way — build it yourself, run it fast, reach the metal when you need to.

What's next

There's a deeper end of the pool whenever you want it. When you're ready to write a game in the Amiga's own language — every byte yours, the chips under your fingers — the 68000 assembly track is waiting. The habits you built in Blitz are the ones it asks for. Now you'll learn to say them in machine code.