Routines |
Prev: AF73 | Up: Map | Next: B16B |
Used by the routine at Messaging_DartNumber.
|
||||
AFB5 | XOR A | Write 00 to *B417. | ||
AFB6 | LD ($B417),A | |||
AFB9 | LD HL,($B40A) | HL=*B40A. | ||
AFBC | LD BC,$006E | BC=006E. | ||
AFBF | AND A | Set flags. | ||
AFC0 | SBC HL,BC | HL-=BC. | ||
AFC2 | ADD HL,BC | HL+=BC. | ||
AFC3 | JR C,$AFD6 | Jump to AFD6 if ?? is less than A. | ||
AFC5 | LD A,$14 | A=14. | ||
AFC7 | LD BC,($B431) | IX=*B431 (using the stack). | ||
AFCB | PUSH BC | |||
AFCC | POP IX | |||
AFCE | LD C,$FF | C=FF. | ||
AFD0 | CALL $B29C | Call B29C. | ||
AFD3 | JP $B0BA | Jump to B0BA. | ||
AFD6 | LD A,L | Jump to B068 if L is less than 32. | ||
AFD7 | CP $32 | |||
AFD9 | JP C,$B068 | |||
AFDC | LD A,$FF | Write FF to *B416. | ||
AFDE | LD ($B416),A | |||
AFE1 | LD A,($B41A) | B=*B41A. | ||
AFE4 | LD B,A | |||
AFE5 | LD A,L | Jump to B05C if L is equal to B. | ||
AFE6 | CP B | |||
AFE7 | JR Z,$B05C | |||
AFE9 | SUB $32 | A-=32. | ||
AFEB | CP $15 | Jump to AFFE if A is greater than or equal to 15. | ||
AFED | JR NC,$AFFE | |||
AFEF | LD BC,($B433) | IX=*B433 (using the stack). | ||
AFF3 | PUSH BC | |||
AFF4 | POP IX | |||
AFF6 | LD C,$00 | C=00. | ||
AFF8 | CALL $B29C | Call B29C. | ||
AFFB | JP $B0BA | Jump to B0BA. | ||
AFFE | LD D,A | Jump to B016 if D is greater than or equal to 29. | ||
AFFF | CP $29 | |||
B001 | JR NC,$B016 | |||
B003 | BIT 0,A | Test bit 0 of A. | ||
B005 | JR NZ,$B016 | Jump to B016 if A is not equal to 29. | ||
B007 | SRL A | Shift A right. | ||
B009 | LD BC,($B437) | IX=*B437 (using the stack). | ||
B00D | PUSH BC | |||
B00E | POP IX | |||
B010 | CALL $B342 | Call B342. | ||
B013 | JP $B0BA | Jump to B0BA. | ||
B016 | LD D,A | D=A. | ||
B017 | LD C,$00 | C=00. | ||
B019 | SUB $03 | A-=03. | ||
B01B | INC C | Increment C by one. | ||
B01C | SUB $03 | A-=03. | ||
B01E | JR Z,$B024 | Jump to B024 if C is equal to 00. | ||
B020 | JR C,$B035 | Jump to B035 if C is less than 00. | ||
B022 | JR $B01B | Jump to B01B. | ||
B024 | INC C | Increment C by one. | ||
B025 | LD A,C | A=C. | ||
B026 | LD BC,($B431) | IX=*B431 (using the stack). | ||
B02A | PUSH BC | |||
B02B | POP IX | |||
B02D | LD C,$FF | C=FF. | ||
B02F | CALL $B29C | Call B29C. | ||
B032 | JP $B0BA | Jump to B0BA. | ||
B035 | LD A,D | A=D. | ||
B036 | BIT 0,A | Test bit 0 of A. | ||
B038 | JR NZ,$B04B | Jump to B04B if C is not equal to FF. | ||
B03A | LD A,$14 | A=14. | ||
B03C | LD BC,($B431) | IX=*B431 (using the stack). | ||
B040 | PUSH BC | |||
B041 | POP IX | |||
B043 | LD C,$FF | C=FF. | ||
B045 | CALL $B29C | Call B29C. | ||
B048 | JP $B0BA | Jump to B0BA. | ||
B04B | LD A,$13 | A=13. | ||
B04D | LD BC,($B431) | IX=*B431 (using the stack). | ||
B051 | PUSH BC | |||
B052 | POP IX | |||
B054 | LD C,$FF | C=FF. | ||
B056 | CALL $B29C | Call B29C. | ||
B059 | JP $B0BA | Jump to B0BA. | ||
B05C | LD BC,($B439) | IX=*B439 (using the stack). | ||
B060 | PUSH BC | |||
B061 | POP IX | |||
B063 | CALL $B3B6 | Call B3B6. | ||
B066 | JR $B0BA | Jump to B0BA. | ||
B068 | LD A,L | Jump to B073 if L is less than 29. | ||
B069 | CP $29 | |||
B06B | JR C,$B073 | |||
B06D | BIT 0,A | Test bit 0 of A. | ||
B06F | JR Z,$B09A | Jump to B09A if A is equal to 29. | ||
B071 | JR $B079 | Jump to B079. | ||
B073 | BIT 0,A | Test bit 0 of A. | ||
B075 | JR Z,$B0AA | Jump to B0AA if A is equal to 29. | ||
B077 | JR $B08A | Jump to B08A. | ||
B079 | LD A,$13 | A=13. | ||
B07B | LD BC,($B433) | IX=*B433 (using the stack). | ||
B07F | PUSH BC | |||
B080 | POP IX | |||
B082 | LD C,$00 | C=00. | ||
B084 | CALL $B29C | Call B29C. | ||
B087 | JP $B0BA | Jump to B0BA. | ||
B08A | LD A,$01 | A=01. | ||
B08C | LD BC,($B433) | IX=*B433 (using the stack). | ||
B090 | PUSH BC | |||
B091 | POP IX | |||
B093 | LD C,$00 | C=00. | ||
B095 | CALL $B29C | Call B29C. | ||
B098 | JR $B0BA | Jump to B0BA. | ||
B09A | LD A,$14 | A=14. | ||
B09C | LD BC,($B433) | IX=*B433 (using the stack). | ||
B0A0 | PUSH BC | |||
B0A1 | POP IX | |||
B0A3 | LD C,$00 | C=00. | ||
B0A5 | CALL $B29C | Call B29C. | ||
B0A8 | JR $B0BA | Jump to B0BA. | ||
B0AA | LD A,L | A=L. | ||
B0AB | SRL A | Shift A right. | ||
B0AD | LD BC,($B437) | IX=*B437 (using the stack). | ||
B0B1 | PUSH BC | |||
B0B2 | POP IX | |||
B0B4 | CALL $B342 | Call B342. | ||
B0B7 | JP $B0BA | Jump to B0BA. | ||
B0BA | LD A,($B416) | A=*B416. | ||
B0BD | BIT 0,A | Test bit 0 of A. | ||
B0BF | JR Z,$B0DC | Jump to B0DC if A is equal to 00. | ||
B0C1 | LD A,L | Jump to B0D1 if L is greater than or equal to 7F. | ||
B0C2 | CP $7F | |||
B0C4 | JR NC,$B0D1 | |||
B0C6 | CP $02 | Jump to B0DC if L is greater than or equal to 02. | ||
B0C8 | JR NC,$B0DC | |||
B0CA | LD A,($B412) | A=*B412. | ||
B0CD | BIT 0,A | Test bit 0 of A. | ||
B0CF | JR NZ,$B0E0 | Jump to B0E0 if A is not equal to 02. | ||
B0D1 | LD HL,($B40E) | Write *B40E to *B40A. | ||
B0D4 | LD ($B40A),HL | |||
B0D7 | LD A,$01 | Write 01 to *B417. | ||
B0D9 | LD ($B417),A | |||
B0DC | XOR A | Write 00 to *B412. | ||
B0DD | LD ($B412),A | |||
B0E0 | PUSH HL | Stash HL on the stack. | ||
B0E1 | LD A,($B415) | A=*B415. | ||
B0E4 | INC A | Increment A by one. | ||
B0E5 | CP $03 | Jump to B0ED if A is not equal to 03. | ||
B0E7 | JR NZ,$B0ED | |||
B0E9 | LD ($B40E),HL | Write HL to *B40E. | ||
B0EC | XOR A | Write 00 to *B415. | ||
B0ED | LD ($B415),A | |||
B0F0 | POP HL | Restore HL from the stack. | ||
B0F1 | LD DE,$ACF6 | DE=Current_Total. | ||
B0F4 | LD ($B40A),HL | Write HL to *B40A. | ||
B0F7 | CALL $AEF0 | Call AEF0. | ||
B0FA | LD DE,$AD0E | DE=AD0E. | ||
B0FD | LD A,($B410) | A=*B410. | ||
B100 | LD H,$00 | H=00. | ||
B102 | LD L,A | L=A. | ||
B103 | CALL $AEF0 | Call AEF0. | ||
B106 | LD DE,$AD36 | DE=AD36. | ||
B109 | LD A,($B40C) | A=*B40C. | ||
B10C | LD L,A | L=A. | ||
B10D | LD H,$00 | H=00. | ||
B10F | CALL $AEF0 | Call AEF0. | ||
B112 | LD DE,$AD75 | DE=AD75. | ||
B115 | LD A,($B411) | A=*B411. | ||
B118 | LD H,$00 | H=00. | ||
B11A | LD L,A | L=A. | ||
B11B | CALL $AEF0 | Call AEF0. | ||
B11E | LD B,$03 | B=03. | ||
B120 | LD HL,$ACF6 | HL=Current_Total. | ||
B123 | LD A,(HL) | A=*HL. | ||
B124 | CP $20 | Jump to B12B if A is equal to 20. | ||
B126 | JR Z,$B12B | |||
B128 | ADD A,$30 | A+=30. | ||
B12A | LD (HL),A | Write A to *HL. | ||
B12B | INC HL | Increment HL by one. | ||
B12C | DJNZ $B123 | Decrease counter by one and loop back to B123 until counter is zero. | ||
B12E | LD B,$03 | B=03. | ||
B130 | LD HL,$AD0E | HL=AD0E. | ||
B133 | LD A,(HL) | A=*HL. | ||
B134 | CP $20 | Jump to B13B if A is equal to 20. | ||
B136 | JR Z,$B13B | |||
B138 | ADD A,$30 | A+=30. | ||
B13A | LD (HL),A | Write A to *HL. | ||
B13B | INC HL | Increment HL by one. | ||
B13C | DJNZ $B133 | Decrease counter by one and loop back to B133 until counter is zero. | ||
B13E | LD B,$03 | B=03. | ||
B140 | LD HL,$AD36 | HL=AD36. | ||
B143 | LD A,(HL) | A=*HL. | ||
B144 | CP $20 | Jump to B14B if A is equal to 20. | ||
B146 | JR Z,$B14B | |||
B148 | ADD A,$30 | A+=30. | ||
B14A | LD (HL),A | Write A to *HL. | ||
B14B | INC HL | Increment HL by one. | ||
B14C | DJNZ $B143 | Decrease counter by one and loop back to B143 until counter is zero. | ||
B14E | LD B,$03 | B=03. | ||
B150 | LD HL,$AD75 | HL=AD75. | ||
B153 | LD A,(HL) | A=*HL. | ||
B154 | CP $20 | Jump to B15B if A is equal to 20. | ||
B156 | JR Z,$B15B | |||
B158 | ADD A,$30 | A+=30. | ||
B15A | LD (HL),A | Write A to *HL. | ||
B15B | INC HL | Increment HL by one. | ||
B15C | DJNZ $B153 | Decrease counter by one and loop back to B153 until counter is zero. | ||
B15E | LD A,($B418) | Write *B418 to *AD0E. | ||
B161 | LD ($AD0E),A | |||
B164 | LD A,($B419) | Write *B419 to *AD75. | ||
B167 | LD ($AD75),A | |||
B16A | RET | Return. |
Prev: AF73 | Up: Map | Next: B16B |