Posts by Runic_Rain

org $someaddress
JMP routine

freecode
JMP routine

main:

!sfx_number = $29
!sfx_port = $1DFC

if read1($00FFD5) == $23	;sa-1 compatibility
	!addr = $6000
else
	!addr = $0000
endif

main:
	LDA $18
	AND #$80
	ORA $16
	AND #$90
	BEQ .no_press	; check start, a, & b for press
	LDA #!sfx_number
	STA !sfx_port|!addr
	LDA #$00
	STA $0100
.no_press:

!counter = (table_end-table_start)
!prev = table_start+!counter
!flag = 0
while !counter
	if table_start+!counter-1 != !prev
		!flag #= 1
	!counter #= !counter--
endif

table_start
	db $00, $00, $00
table_end

Global UberASM:
	; Every frame (you could modify this to be a larger gap)
	if (Blinking%fps != current_frame)
		Blinking = 0			; Turn off blinking
Light:
	if (Blinking)
		On = current_frame % 1
	else
		if (On == 1) return
	Blinking = current_frame+1	; +1 so we can detect fully off (0) also cheap compare in UberASM

Please Excuse the Code Vomit: Show/Hide
!On = $C2,x
!Blinking = $FF,x		; some unused sprite table, change this (or freeram, doesn't matter)
!MaxValFor14 = #$00FF		; max frame (I thought the cap was 24 or 60, didn't realize it went to the end...)
; Therefore the code won't work as-is.
; Blinking would need to be a 16-bit
; (So we can compare the ranges Blinking[1,256] to Frame$14[0,255])

GlobalUberASM: ; Every frame (game mode/level/etc.)
	JSR ModulusFunction
	; A now has 8-bit version of !Blinking which is previous frame +1
	; (to handle our detection, it's never 0 unless Blinking is disabled)
	; Conveniently this means we can pretend it's == current_frame
	; after we did modulus on 16-bit range above
	CMP $14		; compare to current_frame
	; ^^^ just checked if predicted next frame is actually correct
	; since this code is running every frame,
	; we don't have to worry about missing check for 256 frames and being the same value.
	BEQ .return			; If predicted frame is correct return
		LDA #$00
		STA !Blinking	; zero 16-bit blinking, we were wrong, we should be off
.return:
	RTL

Sprite:
	; blinking validity CHECK
	LDA !Blinking
	BEQ .else
		; valid: run blinking code
		LDA $14
		AND #$01 ; <--- this single frame is important! Which is why I talked about it...
		; ^^^adjust validity check if you want a longer time between blinks
		; EDIT: Hmmm, was it actually important in the end? Idr =___=
		STA !On
		BRA .endif ; ---> update !Blinking prediction
	.else:	; Not Blinking, are we ON?
		LDA !On
		BEQ .endif
		RTL	; return, we're on, leave alone (or run whatever a light does while on)
	.endif:
	; We're not officially blinking yet. We're also "off". (I assume you want to start blinking when turning off?)
	; OR we just came from blinking. We may be off.
	; Update !Blinking prediction
	;;;; TODO: do we need to clear the B-register here? idk ;;;;
	LDA $14
	REP #$20		; 16-bit blinking
	INC				; +1 so we can tell a 0th frame from off
	STA !Blinking	; blinking set
	SEP #$20
	RTL

LightBlock:
	; we're not touching this but noting it does the equivalent of:
	LDA !On
	EOR #$01
	STA !On

ModulusFunction:
	; some math. lazy "mod"; should work?
	REP #$20
	LDA !Blinking
	CMP !MaxValFor14	; "fps", mislabeled in pseudocode, sorry.
	BPL .overflow
	SEP #$20	; our 16-bit Blinking should 8-bit
	RTS
.overflow:	; 16-bit Blinking, didn't fit in 8-bit
	; we know we're 256, which means we're 0
	LDA #$00
	SEP #$20
	RTS