XeO3: Colour....

Mmm... the more I look at the Plus4 version, the more I wish it had colour. If you followed the way spectrum games work - that is the background gets colour and ships dont, they just fly through it - then you might be able to pull it off. The biggest problem is moving the colour screen. Unlike the C64, you can't scroll a whole colour screen over 8 game cycles as I have to double buffer the software sprites (C64 doesn't need that due to hardware sprites), but...... if you could afford to lose another 4k (ouch!) then it might JUST be possible...

Basically you have 4 screens. 2 are active at any one time over 8 game cycles and the other 2 are hidden. Normal character rendering goes on as normal, but the hidden 2 screens get the colour slowly moved (or rather copied!) from screens 1&2 to 3&4 - but 1 character further on. It still requires you to shift around 5 lines per frame but thats a far cry from blitting a whole 21 line high screen each game cycle as I do now. However, if you did that (and you might have to drop a sprite to fit it in), you could get XeO3 - with colour!

Its way too late for me to add that now, but once the source is released, it be cool if someone else did it. 9 software sprites is still loads! So drop 1 sprite, and free 4K+space for colour tiles, and it should work!

Okay...More minor optimisations. I've removed a couple of functions and inline'd them whilst making them faster, and finally removed the old, slow PATH allocator. It was still using the simple loop rather than the stack method, so thats now changed. I got fed up writing that bloody thing, so I've macro-ized it even more, and here it is.

;****************************************************************************************
;
; Allocate/Free a Turret.
; Out: X=spare slot or -1 for error
;
; Best 29 - OLD
; Worst 134 - OLD
;
; Alloc - BEST/WORST - 12/18
; Free - Best/Worst - 24   (constant)
;
;
; Usage:-  FastAlloc  [xy], ListAddress, ObjectOnOff
;          X or Y      = index register to use
;          ListAddress = Base of pre-filled stack
;          ObjectOnOff = Value to clear/set when allocated/free'd
;
;****************************************************************************************
FastAlloc macro
          ld\0  \1FreeIndex       ; 3    ldx  FreeIndex
          lda   \1FreeList,\0     ; 4    lda  FreeList
          bmi   !NoneFree         ; 2    bmi  !NoneFree
          in\0                    ; 2    inx
          st\0  \1FreeIndex       ; 3    stx  FreeIndex
!NoneFree:                        ;      tax
          ta\0                    ; 2    get next free bullet (or $ff for none left)
          endm

;****************************************************************************************
;
; Usage:- FreeTurret  [xy], ListAddress, ObjectOnOff
;         X or Y      = index register to use (and hold the object to free)
;         ListAddress = Base of pre-filled stack
;         ObjectOnOff = Value to clear/set when allocated/free'd
;
;****************************************************************************************
FastFree macro
         t\0a                   ; 2   txa
         ld\0  \1FreeIndex      ; 3   ldx   FreeIndex
         de\0                   ; 2   dex
         st\0  \1FreeIndex      ; 3   stx   FreeIndex
         sta   \1FreeList,\0    ; 5   sta   FreeList,x
         ta\0                   ; 2   tax   -  restore index
         lda   #0               ; 2   lda   #0
         sta   \2,\0            ; 5   sta   BullInUse,x
         endm
 

And this is how I use it - Its pretty simple although I do have to replicate a branch which technically speaking I could do without. However, if it comes down to the game not working because of 2 cycles wasted here....I'll kill myself!

        FastAlloc x,Path,PathsInUse 

These are obviously SNASM macros. SNASM has a really cool macro feature in that it lets you build new opcodes, labaels or anything! using the paramaters. This means I can decide later what register to use, and prepend a name and have a new label - cool eh!

Oh! And for the record....the micro-optimisations I've been doing are generally called peep-hole optimisations by compilers. That is were they look are a few instructions at a time and try and make them better - I'm pretty much doing the same.