NES Networking

;;;
;;; Register addresses
;;;
#org $40f0
#var FIFO_DATA, 1
#var FIFO_STATUS, 1

;;; SRAM Table for Freezes

;;; Format - FF AA AA VV MM SS WW CA CA CV CS CT XX XX XX XX
;	0	FF - Used flag/fingerprint - AB indicates valid in-use slot
;	1-2	AA - Address
;	3	VV - Value
;	4	MM - Mask
;	5	SS - Size
;	6	WW - Write Type
;	7-8	CA - Compare Address
;	9	CV - Compare Value
;	A	CS - Compare Size
;	B	CT - Compare Type
;	C-F XX - Unused/Expansion

#org $7F00
FreezeTable:
#org $7F80
FreezeScratch:

;Non SRAM value to detect freeze table needing to be initialized
#org $07FF
FreezeInit:

#org $07FE
CommReady:


;;;
;;; Variables in zero page to make code size small
;;;
#org $cc ; cc-d2 appears to be unused? Should probably verify somehow.
#var payloadOffset, 1
#var payloadNewValue, 1
#var payloadOldValue, 1
#var payloadSize, 1

;;;
;;; Well known and useful locations of game state
;;;
#org $0657
itemStateTable:

;;;
;;; Bottom of stack area, used as scratch area to put code into from usb communications.
;;;
#org $7FA0 ; $0100-010f is technically part of stack but appears to be used by game code a bunch
codeScratchArea:

#org $0700
messageReturn:


;;;
;;; The usb write message header. This never changes, so it can just sit in rom and be copied.
;;;
#org $ed94, $1eda4, $C
sendItemStateChangeMsgHeader:
; n8pro protocol header, '+', '+'^0xff, CMD_USB_WR, CMD_USB_WR^0xff, len in LE BO
#byte '+', $2b ^ $ff, $22, $22 ^ $ff
#byte 4, 0
; our header, 'i' for 'item'.
#byte 'i'
sendItemStateChangeMsgHeaderEnd:

;;; address of the original nmi hook function
#org $E484
originalNMI:

;;;
;;; nmi hook function to check for code dump from usb interface, loads code into ram and jumps to it
;;; it's up to the host to include code to signal that it has successfully handled the data
;;; by writing a completion message to the fifo.
;;;
#org $ffc0, $1ffd0
usbDataHook:

	LDA #$0E ; NMI bank
	;LDA #$05 ; main bank
	JSR $FFAC
	JMP usbMain

#org $B290, $1B2A0
	usbMain:


	lda FIFO_STATUS
	bmi .done
	cmp #$40 ; extra check for special value mesen returns for unknown registers so we don't break everything
	beq .done
	lda FIFO_DATA
	sta payloadSize

	LDA #$AB
	STA CommReady

	ldx #$0
	.loop:
	cpx payloadSize
	beq .done

	.waitByteLoop:
	;lda FIFO_STATUS
	;bmi .waitByteLoop
	lda FIFO_DATA
	sta codeScratchArea,X

	inx
	jmp .loop

	.done:


	;LDA #$1E
	;STA $2001

	jmp originalNMI
	;JMP $6CC0




;;;
;;; rewrite nmi pointer to be the above function.
;;;
#org $fffa, $2000a, 2
nmiPointer:
#word usbDataHook

;Main routine hijack instead of NMI
#org $ed89, $1ed99
	LDA #$0E
	JSR $FFAC

	JSR MainFunc
	JMP MainEnd

#org $fae4, $1faf4
MainEnd:
	LDA #$05 ; main bank
	JSR $FFAC
	JSR $B1E6
	JMP $6CC0

#org $B390, $1B3A0
MainFunc:

	LDA CommReady
	CMP #$AB
	BNE :+

	JSR CommFunc

	LDA #$00
	STA CommReady
	:

	JSR ExecuteFreezes

	JMP MainEnd

#org $BE90, $1BEA0, $31
CommFunc:
	LDX #$00
	;Read message ID
	LDA codeScratchArea,x
	STA $03
	INX
	;Read action
	LDA codeScratchArea,x
	STA $04
	INX

	;system messages
	CMP #$FF
	BNE :+
	JMP NullMsg
	:
	CMP #$FE
	BNE :+
	JMP Version
	:
	;All actions over 4 get sent to return
	CMP #$06
	BCC :+
	LDA #$05
	:

	;jump table for actions
	ASL
    TAY
    LDA Actions,y
    STA $00
    LDA Actions+1,y
    STA $01
    JMP ($0000)

#org $BD90, $1BDA0,$C
Actions:
	#byte <Reads,  >Reads,  <ArrayReads,  >ArrayReads
	#byte <Writes, >Writes, <ArrayWrites, >ArrayWrites
	#byte <Freeze, >Freeze, <CommReturn, >CommReturn

#org $BC90, $1BCA0
Reads:

	;Read number of addresses
	LDA codeScratchArea,x
	STA $02

	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA $02
	CLC
	ADC #$03
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (0)
	STA FIFO_DATA



	LDY #$00

	INX

	;loop through addresses sent
	:
	LDA codeScratchArea,x
	STA $00
	INX
	LDA codeScratchArea,x
	STA $01
	INX

	;use indirect addressing to read value with 00 as a pointer
	TYA
	PHA
	LDY #$00
	LDA ($00),Y
	STA FIFO_DATA
	PLA
	TAY

	;loop until reaching saved number of addresses
	INY
	CPY $02
	BNE :-


CommReturn:
	RTS


#org $BB90, $1BBA0
ArrayReads:

	;Read array length
	LDA codeScratchArea,x
	STA $02

	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA $02
	CLC
	ADC #$03
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (1)
	STA FIFO_DATA




	INX

	;store base address to pointer

	LDA codeScratchArea,x
	STA $00
	INX
	LDA codeScratchArea,x
	STA $01
	INX

	;use indirect addressing to read value with 00 as a pointer
	LDY #$00
	:
	LDA ($00),Y
	STA FIFO_DATA


	;loop until reaching array length
	INY
	CPY $02
	BNE :-

	RTS



#org $BA90, $1BAA0
Writes:

	;Read number of addresses
	LDA codeScratchArea,x
	STA $02

	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA #$03
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (2)
	STA FIFO_DATA


	LDY #$00

	INX

	;loop through addresses sent
	:

	;address
	LDA codeScratchArea,x
	STA $00
	INX
	LDA codeScratchArea,x
	STA $01
	INX

	;value
	LDA codeScratchArea,x
	STA $05
	INX



	;use indirect addressing to read value with 00 as a pointer
	TYA
	PHA
	LDY #$00
	LDA $05
	STA ($00),Y
	PLA
	TAY

	;loop until reaching saved number of addresses
	INY
	CPY $02
	BNE :-

	RTS


#org $B990, $1B9A0
ArrayWrites:

	;Read array length
	LDA codeScratchArea,x
	STA $02

	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA #$03
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (3)
	STA FIFO_DATA


	INX

	;store base address to pointer
	LDA codeScratchArea,x
	STA $00
	INX
	LDA codeScratchArea,x
	STA $01
	INX

	;use indirect addressing to read value with 00 as a pointer
	LDY #$00
	:

	;values
	LDA codeScratchArea,x
	INX
	STA ($00),Y

	;loop until reaching array length
	INY
	CPY $02
	BNE :-

	RTS



#org $B490, $1B4A0
Freeze:

	;size
	LDA codeScratchArea,x
	STA FreezeScratch+4
	INX

	;compare size
	LDA codeScratchArea,x
	STA FreezeScratch+9
	INX

	;address
	LDA codeScratchArea,x
	STA $00
	STA FreezeScratch
	INX
	LDA codeScratchArea,x
	STA $01
	STA FreezeScratch+1
	INX



	;value
	LDA codeScratchArea,x
	STA FreezeScratch+2
	INX

	;mask
	LDA codeScratchArea,x
	STA FreezeScratch+3
	INX


	;write mode
	LDA codeScratchArea,x
	STA FreezeScratch+5
	INX

	;compare address
	LDA codeScratchArea,x
	STA FreezeScratch+6
	INX
	LDA codeScratchArea,x
	STA FreezeScratch+7
	INX

	;compare value
	LDA codeScratchArea,x
	STA FreezeScratch+8
	INX

	;compare type
	LDA codeScratchArea,x
	STA FreezeScratch+10
	INX

	JSR FindFreezeAddr
	BCC .notfound

	;address exists in table
	LDA FreezeScratch+10
	BNE :+

	;Compare is never, erase freeze entry
	LDA #$01
	STA $05
	LDA #$00
	STA FreezeTable,x
	BEQ .finish

	:
	;overwrite existing entry
	JSR SaveFreeze
	LDA #$01
	STA $05
	SEC
	BCS .finish

	.notfound:

	JSR FindFreezeEmpty
	BCS :+

	;No empty slot
	LDA #$00
	STA $05
	BEQ .finish

	:
	JSR SaveFreeze
	LDA #$01
	STA $05

	.finish:

	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA #$04
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (04)
	STA FIFO_DATA
	LDA $05   ;success
	STA FIFO_DATA

	RTS

;Looks for Address matching $00,$01 - sets X to that slot and sets carry if found, otherwise clear carry
FindFreezeAddr:
	LDX #$00
	:
	LDA FreezeTable,x
	CMP #$AB
	BNE :+
	LDA FreezeTable+1,x
	CMP $00
	BNE :+
	LDA FreezeTable+2,x
	CMP $01
	BNE :+
	SEC
	RTS
	:
	TXA
	CLC
	ADC #$10
	TAX
	CMP #$80
	BNE :--
	CLC
	RTS

;Looks for unused slot - sets X to that slot and sets carry if found, otherwise clear carry
FindFreezeEmpty:
	LDX #$00
	:
	LDA FreezeTable,x
	CMP #$AB
	BEQ :+
	SEC
	RTS
	:
	TXA
	CLC
	ADC #$10
	TAX
	CMP #$80
	BNE :--
	CLC
	RTS

;Copies the incoming values into the current freeze slot pointed to in X
SaveFreeze:

	LDA #$AB
	STA FreezeTable,x
	INX

	LDY #$00
	:
	LDA FreezeScratch,y
	STA FreezeTable,x
	INX
	INY
	CPY #$0B
	BNE :-
	RTS

;loops over freeze table, tests compares and then calls writes
ExecuteFreezes:

	LDA FreezeInit
	CMP #$AB
	BEQ :+

	LDA #$AB
	STA FreezeInit

	LDA #$00
	STA FreezeTable
	STA FreezeTable+$10
	STA FreezeTable+$20
	STA FreezeTable+$30
	STA FreezeTable+$40
	STA FreezeTable+$50
	STA FreezeTable+$60
	STA FreezeTable+$70
	:

	LDX #$00
	:
	LDA FreezeTable,x
	CMP #$AB
	BNE :+

	JSR TestCompare
	BCC :+

	JSR FreezeWrite

	:
	TXA
	CLC
	ADC #$10
	TAX
	CMP #$80
	BNE :--
	CLC


	RTS


;public enum CompareType : byte
;{
;    Never = 0x00,
;    Equal = 0x01,
;    NotEqual = 0x02,//6,A,C,E
;    Always = 0x03,//7,B,D,F
;    GreaterThan = 0x04,
;    GreaterThanOrEqual = 0x05,
;    LessThan = 0x08,
;    LessThanOrEqual = 0x09,
;    NotLessThan = 0x05,
;    NotGreaterThan = 0x09,
;
;    MaskSet = 0x11,
;    MaskUnset = 0x12,
;
;}

;performs the comparison check for the current freeze and sets carry if valid
TestCompare:
	;Get current value
	LDA FreezeTable+7,x
	STA $00
	LDA FreezeTable+8,x
	STA $01

	LDY #$00
	LDA ($00),y
	STA $02

	LDA FreezeTable+$B,x
	CMP #$01
	BNE :+

	;Equal
	LDA $02
	CMP FreezeTable+9,x
	BEQ Success
	BNE .fail

	:
	CMP #$02
	BNE :+

	;NotEqual
	LDA $02
	CMP FreezeTable+9,x
	BNE Success
	BEQ .fail

	:
	CMP #$03
	;Always
	BEQ Success
	CMP #$04
	BNE :+

	;GreaterThan
	LDA $02
	CMP FreezeTable+9,x
	BEQ .fail
	BCS Success
	BCC .fail

	:
	CMP #$05
	BNE :+
	;GreaterThanOrEqual
	LDA $02
	CMP FreezeTable+9,x
	BCC .fail
	BCS Success

	:
	CMP #$08
	BNE :+

	;LessThan
	LDA $02
	CMP FreezeTable+9,x
	BCS .fail
	BCC Success
	:
	CMP #$09
	BNE :+

	;LessThanOrEqual
	LDA $02
	CMP FreezeTable+9,x
	BEQ Success
	BCS .fail
	BCC Success
	:

	.fail:
	CLC
	RTS

	Success:
	SEC
	RTS

;public enum WriteType : byte
;{
;    None = 0,
;    WriteValue = 1,
;    IncrementBy = 2,
;    DecrementBy = 3,
;    WriteMasked = 4,
;}

FreezeWrite:

	LDA FreezeTable+1,x
	STA $00
	LDA FreezeTable+2,x
	STA $01

	LDA FreezeTable+6,x
	BNE :+

	;None
	RTS

	:
	CMP #$01
	BNE :+

	;WriteValue
	LDY #$00
	LDA FreezeTable+3,x
	STA ($00),y
	RTS

	:
	CMP #$02
	BNE :+

	;IncrementBy
	LDY #$00
	LDA ($00),y
	CLC
	ADC FreezeTable+3,x
	STA ($00),y
	RTS

	:
	CMP #$03
	BNE :+

	;DecrementBy
	LDY #$00
	LDA ($00),y
	SEC
	SBC FreezeTable+3,x
	STA ($00),y
	RTS

	:
	CMP #$04
	BNE :+

	;WriteMasked
	LDA FreezeTable+4,x
	STA $03
	AND FreezeTable+3,x
	STA $02

	LDA $03
	EOR #$FF
	STA $03

	LDY #$00
	LDA ($00),y
	AND $03
	ORA $02
	STA ($00),y


	:

	RTS

#org $B910, $1B920
Version:
	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA #$08
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (FE)
	STA FIFO_DATA

	;version number
	LDA #$00
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;max read size
	LDA #$10
	STA FIFO_DATA
	;max write size
	LDA #$10
	STA FIFO_DATA
	;max freezes
	LDA #$08
	STA FIFO_DATA
	RTS


#org $B890, $1B8A0
NullMsg:
	;send N8/USB header stuff
	ldy #$00
	.headerLoop:
	lda sendItemStateChangeMsgHeader, y
	STA FIFO_DATA
	iny
	cpy #4
	bne .headerLoop

	;send message length
	LDA #$03
	STA FIFO_DATA
	LDA #$00
	STA FIFO_DATA

	;Our return header
	LDA #$20  ;static part
	STA FIFO_DATA
	LDA $03   ;message ID
	STA FIFO_DATA
	LDA $04   ;action (FF)
	STA FIFO_DATA

	RTS