Ponder's Blog

I now have an enemy to play against!

This was quite a headache to write and earlier edits came back to haunt me, but I solved all the problems and gained a whole new level of respect for those who had to debug more complex programs in the past!

Unlike the original, the game will eventually include lives. Please note, the flickering is just to show me how much CPU time is being used and won’t be present when I finish the major parts of the game.

I’m planning to draw the title screen next, but that won’t be until next weekend. Work is going to take a toll until then, but that leads to a long weekend off, hopefully with few distractions 🙂

Just a minor update today. Added chaser init and player movement detects collision with chaser. It does currently mean the first level never completes due to a static chaser, but tomorrow I’ll get them moving 🙂

Quite a bit of fine tuning today and a few routines added and updated.

Side panel text added. Player can now create a time limited gap to block chasers (NB this also blocks the player). Scoring and an end of level sequence also added.

I’m not planning on updating until Saturday, but my target then is to add the chasers, and maybe the intro screen text.

Today I got to work on the gradual draw routine. At first I tried the lazy way, but using loops as delays isn’t exactly neat and I had problems, so I dug straight into the interrupt driven timing.

After the usual schoolboy errors, which are becoming less frequent and easier to debug (and I’m looking at reference material less often now) the result was pretty decent, so to complete the map level data I decided to write the player routine, because that was the easiest way to count the blocks needed to complete a level.

Well another oops, the number of blocks needed more than 8 bits on the last 2 levels!

That sorted, here is the result so far. I’m quite pleased with the progress I made today 🙂

Test audio has now been added along with the screen driven interrupt routine that will form the main game loop, so it’ll run smoothly.

Tomorrow I’ll work on drawing the levels in a more interesting manner that fits the final game.

All 4 default levels have been designed and are easy to push to the draw routine.

I’ve been too busy to do much today and my head is currently in a mess so that’s all I’m doing until Sunday (out tomorrow).

The image shows loading the code, listing what’s visible to BASIC and running. Level displayed is changed by pressing the joystick button. Exits when all 4 have been displayed.

These images show the start locations of the player (blue) and the chasers for each level.

Today’s goal achieved after some hair pulling. My draw routine was giving nonsense results until I realised I’d used the same variable locations! Once I figured that out it went a lot faster.

The level draw routine is now working, and tested with map data! The map data holds number of blocks to cover to complete the level, player and chaser start locations, level draw start positions and draw data. The latter is shown here:

$27,$59,$26,$20,$6f,$21,$26,$58,$27,$21,$6e,$20,$00

This draws the following:

This is already the most complex 6502 code I’ve ever written and I’m learning all the time. Tomorrow’s target is to design the same levels as the original, and set up the interrupt driven routine that will be the core of the whole game.

I once wrote a port of the Spectrum game, “Cruising on Broadway” for the VIC 20.

The setup was in BASIC but the actual gameplay was in machine code, which I wrote on paper, converted to numbers that could be entered using DATA statements, before I understood the use of carry and overflow flags!

Well now I’ve decided to revisit the past, using more powerful development tools, and write the port again, on the C64, using 100% machine code.

I’m using the Vice 64 emulator with a folder attached to Drive #9 into which I save the assembled result.

I’m using the xa65 cross assembler and the kate text editor the actual development.

So far I have this:

It’s not much yet, but that demonstrates a split clear screen routine and the beginnings of a line draw routing using PETSCII graphics.

I’ve not used my blog for a while, but I think this a worthy reawakening, don’t you? 😉