Cool.

Fear not, it’s Boray to the rescue!  He provides a nice link to a Windows utility, PRG Starter, that will deter those PRG loading blues — particularly for PET, VIC 20, and C64 BASIC programs — although there is quite a bit of logic for the more esoteric program loads, too, and for the other VICE emulated machines.

After permission to examine his source code, I decided I could use a simply elegant utility such as this for my Fedora desktop — after all, like Windows, GNOME offers the same customized launching feature via an associated filetype extension.  You can find the C source archive to the simple launcher dubbed run.

After associating filetypes, such as .prg, p00, .a0, .crt, .d64, .g64, and .rom, to launch a customized command, run, you simply double-click the Commodore 8-bit binary file and it will run the correct VICE emulator with any associated command-line options, such as memory expansion, attach as a cartridge, or boot from a floppy or tape.

You can even do this from the command-line.  Here are some examples (with the verbose option on):

$ run -v quikman2k8.prg
**** Commodore VIC 20 ML program ****
xvic -memory none “quikman2k8.prg”

$ run -v berzerk-mmx+.prg
**** Commodore VIC 20 ML program with 16kb memory expansion ****
xvic -memory all “berzerk-mmx+.prg”

$ run -v Super\ Zaxxon.crt
**** Commodore 64 game cartridge ****
x64 -cartcrt “Super Zaxxon.crt”

And of course my favorite:

$ run -v mega-cart.rom
**** Commodore VIC 20 with Mega-Cart ****
xvic -cartmega “mega-cart.rom”

And I got all of it to fit with only the minimal 8kb memory expansion required for those software sprites — with BASIC reporting only 1-byte free after LOAD.  Funny how that always makes me feel good.

Berzerk MMX on VIC= 20

I thought I was really clever at the time writing my random dungeon level generator — it was my first practical use outside of a classroom to implement a recursive function.  Because the dungeon ‘walls’ were probability driven, a function was needed to validate that every ’tile’ in the arbitrarily-sized dungeon floor was accessible by the hero.  Without this kind of validation, the hero would eventually find himself ‘trapped’ on a floor with no means to escape.

The recursive function was simply invoked as chkroom(0,0), whereas the 0,0 passed were parameters to the starting point in the dungeon map matrix.  Upon entering each tile, a flag is cleared for that element in the matrix.  Next, a condition is checked if the tile to its right is accessible.  If it is, call chkroom() with +1 added to X.  If not, do the same condition checks for down, left, and up directions calling chkroom() passing values Y+1, X-1, and Y-1 respectively.

And at the conclusion of all this recursion, do a loop through the dungeon matrix to check if ALL of the flags had been cleared.  If any persist, do the dungeon regeneration and this validation again until it has passed.  The higher the frequency of random walls generated increases the pattern complexity of the floor, which exponentially increases the probability that the floor will not pass with an ‘all clear’.

Today, I am working on a port of an old arcade favorite, Berzerk, for the Commodore VIC 20.  The playfield for the game is a fixed 3-row by 5-column matrix for each floor.  Given that the game needs to be written using 8-bit assembler, I quickly dismissed the idea that using my C algorithm to validate a floor could be feasible.  After all, VIC 20 is a relic machine running at 1mHz and limited memory of only a few thousand bytes available for the program, graphics, and sound all the while using a 256-byte system stack.  Ah, but the challenge by it all . . .

Generating the random walls for each floor is a simple matter, but validating that all its ‘rooms’ are accessible was turning out to be very problematic.  Every time I thought I could solve this puzzle using bit operators (OR, AND, XOR) to assure that its rooms and corridors could not trap the hero, I would only later stumble upon an instance where even my most elaborate of schemes failed.  This was getting a bit frustrating, pun intended.

So I wandered back to my dungeon floor validation and decided it was so simple of an algorithm that it may be possible to translate it to assembler and still keep it within reason of the machine’s constraints.  After some writing and whittling, the resulting code turned out perfect!  It is called by simply zero-ing the starting cell (R0) and invoking CRAWL.  Here is its listing:

CRAWL:
  LDX R0
  LDA MAZE,X
  CMP #$80
  BCC @fini        ; been here?
  AND #$7F         ; clear accessible bit
  STA MAZE,X

@right:
  LSR
  BCS @down        ; right wall?
  PHA              ;++ push walls
  LDA R0
  PHA              ;++ push cell
  INC R0
  JSR CRAWL        ; explore right cell
  PLA              ;-- pop cell
  STA R0
  PLA              ;-- pop walls

@down:
  LSR
  BCS @left        ; bottom wall?
  PHA              ;++ push walls
  LDA R0
  PHA              ;++ push cell
  CLC
  ADC #5
  STA R0
  JSR CRAWL        ; explore cell below
  PLA              ;-- pop cell
  STA R0
  PLA              ;-- pop walls

@left:
  LSR
  BCS @up
  PHA              ;++ push walls
  LDA R0
  PHA              ;++ push cell
  DEC R0
  JSR CRAWL        ; explore left cell
  PLA              ;-- pop cell
  STA R0
  PLA              ;-- pop walls

@up:
  LSR
  BCS @fini        ; top wall?
  PHA              ;++ push walls
  LDA R0
  PHA              ;++ push cell
  SEC
  SBC #5
  STA R0
  JSR CRAWL        ; explore cell above
  PLA              ;-- pop cell
  STA R0
  PLA              ;-- pop walls
@fini:
  RTS

This old dog is always happy to re-implement an old trick!

OpenCBM provides an API library and some useful command-line tools.  The following is an example of how to format and copy Commodore files to the floppy drive:

$ sudo modprobe cbm

$ dmesg | tail
cbm_init: using passive (XM1541) cable (auto), irq 7
cbm: resetting devices
cbm: waiting for free bus...

$ cbmctrl detect
 8: 1540 or 1541 

$ cbmctrl command 8 "N0:VIC20 3-JAN-2010,10"
$ cbmctrl status 8
00, ok,00,00
$ cbmctrl dir 8
0 ."vic20 3-jan-2010" 10 2a
664 blocks free.
00, ok,00,00

$ cbmwrite 8 quikman+8k.prg
[Info] writing quikman+8k.prg -> QUIKMAN+8K.PRG,P,W
[Info] identified a 1540 or 1541 drive
............-
[Info] 00, OK,00,00
$ cbmwrite 8 omega-fury.prg 
[Info] writing omega-fury.prg -> OMEGA-FURY.PRG,P,W
[Info] identified a 1540 or 1541 drive
....................\
[Info] 00, OK,00,00

$ cbmctrl dir 8
0 ."vic20 3-jan-2010" i1 2a
47   "quikman+8k.prg"   prg
76   "omega-fury.prg"   prg
541 blocks free.
00, ok,00,00

Of course, I can now hook-up this drive to a real VIC 20 computer and play what’s on the diskette(s).  But for giggles, I can even use the Commodore 8-bit emulator, VICE, to test drive my floppies, for example:

$ xvic -memory 8k -device8 2 +truedrive \
-keybuf 'LOAD "QUIKMAN+8K.PRG",8\0D'
...
sucessfully loaded libopencbm.so
/dev/cbm opened.
...

VICE 2.2 on a 24" HP display

Nice!

Nevertheless, I am perfectly fine with a backup dump of my Mega-Cart, to be played using the new release of VICE 2.2 which supports the 2mb image, 8kb NvRAM, and all the appropriate bank-switching.  Cool!!

VICE Mega-Cart

xvic -cartmega mega-cart.rom -mcnvramwriteback -mcnvramfile mega-cart.nv

Opening screen title

This past winter I envisioned making a sequel to the Bally-Midway arcade hit, Omega Race, and a favorite among many VIC 20 users when Commodore bought the licensing rights to make its home computer versions.  Three months later, I released a beta version of the fully playable game.  At the time, I did not think I would spend much more time with it, because it was so close to the game I thought it could be.

But there lies the problem — it was close.  Again, that feeling of an incomplete job, so after a nice break with the Summer days, I came back to this personal gaming project and began looking for ways to get it done.  Here is a list of changes made that brings the game to a new milestone:

• some core software sprite library optimizations for speed;
• energy bolts fired from the Fury’s ship travel faster;
• energy replenishment was increased to keep the pace of the action intense;
• all Thargoid ships round their turns, rather than jerky N-S-E-W moves;
• animations for Fury’s death and game over has been re-sequenced to incite the user to play again;
• a new firing solution AI for Thargoid scouts and space carrier.
• and of course, many bug fixes!

I am pretty excited how these improvements and finishing touches have made the game more playable and more appealing.  It has a nice arcade feel to it with the progressive, intense action.

The binary and its source code for VIC 20 can be downloaded from my tribute page. The current version can be played online here.  And a demo of the game play can be watched here.  Happy hunting!

This past year, I moved on to other VIC 20 related projects, including a slick software sprite library and a sequel to Omega Race that implemented the new graphics handler.  This past week, I returned to Quikman to retro-fit it with the improved video… and a few more features.

The result is Quikman+ requiring an additional 8k of memory expansion, mainly due to the software sprite’s requirement to double-buffer the video display.  For those not familiar with the term “k”, it was short for “kilobyte” which is 1,024 bytes.  Yes, read that again — a thousand bytes, not millions as in megabytes and certainly not billions as in gigabytes.  So, eight of those are an additional 8,192 bytes over the 3,584 bytes available in a stock VIC 20.  In 8-bit computing, that is a sizeable amount to do some nifty programming.  You can appreciate these meager numbers more if you compare it to a simple Windows cursor file in C:\Windows\Cursors — some of those simplest of icons would challenge the VIC 20′s ability to load it into memory!

With the double-buffering in place, the game play is smoother because of the flicker-free animation.  But the expanded address space allowed the game’s core to be expanded to include:

• an opening splash screen (top)
• a gaming options menu (left)
• one or two player mode
• choice of arcade maze run: original Pac-Man or progression through the four Ms. Pac-Man mazes (sample of the first one below)
• starting fruit level
• pressing the STOP key aborts the current game in progress; at the menu, it returns the machine back to BASIC

1st new level

A bonus feature was the inclusion of auto-detection code for the presence of a Mega-Cart.  If this cartridge is plugged in, the game’s high score will be saved to its NVRAM, allowing its persistence to be retrieved by future games to try to beat.  Cool!

Or click to watch the demo on YouTube.