The collision routine will be 7 cycles slower if the y values are in the collision range, but it will be 115 cycles faster if they are not.

Also, if you're aiming for speed, you may want to use this instead of what I originally suggested for the second routine. Optimizing for size and optimizing for speed are two different beasts altogether!

Compared to my size-optimized suggestion: 8 bytes larger, ~1200 cycles faster
Lbl W
→{r₂sub(W0)*10*6+(r₁+Vsub(W0))+J+L₃}
Return
Lbl W0
/2/2+1/2
Return


Are you sure he/his message had nothing to do with it? His real message contained a vertical bar and was something like:

pipe signs cut the line off :P | if i am correct IRC will not be able to see this

I know the OmnomIRC bot had problems with vertical bars in the past.

Interrupts are basically "blocks" of code that are executed thousands of times per second (though it can vary in frequency by how you set up the interrupts).

*hundreds of times per second

Fixing a few errors. Also, some reformatting and optimizations.

.TILEMAPR

.Tileset
[]→Pic0T
[F0F0F0F0]Zeros(4)[F0F0F0F0]Zeros(4)
[C0C0C0C0]Zeros(4)[00000000]Zeros(4)

.Tilemap
[]→Pic0M
[01010101]
[01000001]
[01000001]
[01010101]

While 1
 4*4+Pic0M→C
 16
 While 1
  -4→B
  16
  While 1
   -4→A
   If {C-1→C}
    *16+Pic0T→D
    Pt-On(A,B,D)
    Pt-On(A,B,D+8)ʳ
   End
  End!If A
 End!If B
 DispGraphʳ
EndIf getKey(15)


After a little bit of research and coding, this is what I have come up with! Calling GetTotalArc will return a pointer to a string containing the total amount of user archive. Calling GetFreeArc will return a pointer to a string containing the amount of free archive.

All the routines put together are 76 bytes, which isn't too bad I guess. If anyone knows of any super top secret OS calls that can make this smaller/easier, feel free to suggest them. And before you suggest it, I purposely avoided Disp32 because it doesn't work on all OS versions. Also if I used any calls that don't work on every OS version, feel free to point that out as well.


GetTotalArc:
;——————————————————————————————————————————————;
;—> Returns the total amount of user archive as a 7-character decimal string
;INPUTS:    none
;OUTPUTS:   hl=pointer to string (OP3)
;DESTROYS:  af  bc  de  ix
;——————————————————————————————————————————————;
B_CALL($80BA) ;GetHWVer
add a,a
add a,a
ld d,0
ld e,a
ld hl,GetTotalArc_HWValues
add hl,de
jr ConvArc
GetTotalArc_HWValues:
.db (10*$4000)>>24&$FF,(10*$4000)>>16&$FF,(10*$4000)>>8&$FF,(10*$4000)&$FF
.db (94*$4000)>>24&$FF,(94*$4000)>>16&$FF,(94*$4000)>>8&$FF,(94*$4000)&$FF
.db (30*$4000)>>24&$FF,(30*$4000)>>16&$FF,(30*$4000)>>8&$FF,(30*$4000)&$FF
.db (94*$4000)>>24&$FF,(94*$4000)>>16&$FF,(94*$4000)>>8&$FF,(94*$4000)&$FF


GetFreeArc:
;——————————————————————————————————————————————;
;—> Returns the amount of free archive as a 7-character decimal string
;INPUTS:    none
;OUTPUTS:   hl=pointer to string (OP3)
;DESTROYS:  af  bc  de  ix
;——————————————————————————————————————————————;
B_CALL($5014) ;ArcChk
ex de,hl
inc hl


ConvArc:
;——————————————————————————————————————————————;
;—> Converts a 32-bit integer into a 7-character decimal string
;INPUTS:    hl=pointer to 32-bit integer (big-endian)
;OUTPUTS:   hl=pointer to string (OP3)
;DESTROYS:  af  bc  de  ix
;——————————————————————————————————————————————;
rst 20h
ld hl,OP3+7
ld de,10
ld (hl),d
ld b,7
ConvArc_Loop1:
push bc
push hl
B_CALL($80B1) ;Div32By16
pop hl
pop bc
ld a,(OP2+3)
add a,'0'
dec hl
ld (hl),a
djnz ConvArc_Loop1
ld d,h
ld e,l
ld bc,6<<8+'0'
ConvArc_Loop2:
ld a,(de)
cp c
ret nz
ld a,' '
ld (de),a
inc de
djnz ConvArc_Loop2
ret


Currently: none.

You could draw one like this:
DrawInv
Line()
DrawInv

But that's a lot of extra time spent inverting the buffer twice for a simple line.

I personally like the argument syntax as well. I think DispGraph(L₃) looks better than L₃→DispGraph, too. This would also make DispGraph(L₆,L₁)^rr a possibility. *hint hint*


EDIT: And in response to Freyaday, since Pxl-Command()→Buffer isn't supported, Pxl-On(W,0)→I not only doesn't operate on the bytes pointed to by I, but it stores a value into I, overwriting the value you want it to hold. That's probably why you're not seeing what you want from the copying.