;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Boomerang (for Boomerang Brother), by mikeyk
;;
;; Description: This is the boomerang that the Boomerang Brother throws.
;;
;; BIG FAT NOTE: This sprite depends on the boomerang brother sprite.  Make sure you
;; insert the boomerang brother right before this sprite.  (ex. If this is sprite 1C,
;; make the boomerang brother 1B)
;;
;; Uses first extra bit: NO
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

incsrc subroutinedefs_trasm.asm

                    EXTRA_BITS = $7FAB10

                    SLOW_DOWN_TIMER = $1504
                    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; sprite data
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

                    SLOWDOWN_TIME = $20
                    TIME_UNTIL_CHANGE = $38
                    TILES_PER_FRAME = $00

TILEMAP             dcb $4B,$4E,$4B,$4E
PROPERTIES          dcb $C9,$09,$09,$C9

SPEED_TABLE         dcb $20,$E0,$18,$E8     ; speed of sprite, right, left
Y_SPEED             dcb $F8,$F8,$09,$09
                    dcb $00,$00,$08,$08



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; init JSL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

                    dcb "INIT"
                    STZ SLOW_DOWN_TIMER,x
                    RTL
                    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; main sprite JSL
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

                    dcb "MAIN"
HAMMER_BRO_JSL      PHB                     ; \
                    PHK                     ;  | main sprite function, just calls local subroutine
                    PLB                     ;  |
	            JSR DecrementTimers
                    JSR START_SPRITE_CODE   ;  |
                    PLB                     ;  |
                    RTL                     ; /
DecrementTimers:
	LDA $14C8,x
	CMP #$08
	BNE DoneDec
	LDA $9D
	BNE DoneDec
	LDA SLOW_DOWN_TIMER,x
	BEQ DoneDec
	DEC SLOW_DOWN_TIMER,x
DoneDec:
	RTS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; main sprite routine
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

RETURN              RTS                    
START_SPRITE_CODE   JSR SUB_GFX             ; draw sprite gfx
                    LDA $14C8,x             ; \ if sprite status != 8...
                    CMP #$08                ;  }   
                    BNE RETURN              ; /    ... return
                    LDA $9D                 ; \ if sprites locked...
                    BNE RETURN              ; /    ... return

                    JSL  SubOffscreenX3   ; only process sprite while on screen
                    INC $1570,x             ; increment number of frames sprite has been on screen

                    ;STZ $AA,x              ; no y speed
                    
                    LDA $157C,x             
                    TAY                     
                    LDA SLOW_DOWN_TIMER,x             ; \ if the slow down timer is set, 
                    BNE SLOW_DOWN           ; / then slow down the sprite
                    LDA $1540,x             ; \ also slow down the sprite if its about
                    BEQ SET_SPEED           ;  | to change direction.
                    CMP #SLOWDOWN_TIME      ;  | ( 0 < timer < SLOWDOWN_TIME )
                    BCS SET_SPEED           ; /
SLOW_DOWN           INY                     ; \ increment index to use slower speeds
                    INY                     ; /
SET_SPEED           LDA SPEED_TABLE,y       ; \ set the x speed
                    STA $B6,x               ; / 
                    
                    LDA $C2,x   
                    BEQ NO_INCS
                    INY
                    INY
                    INY
                    INY
NO_INCS             LDA Y_SPEED,y
                    STA $AA,x  
                    
                    JSL $81802A             ; update position based on speed values

                    LDA $1540,x             ; \ check if its time to change directions
                    CMP #$01                ;  | ($1540 about to expire)
                    BNE LABEL17             ; /
                    LDA $157C,x             ; \ change direction
                    EOR #$01                ;  |
                    STA $157C,x             ; /
                    LDA #SLOWDOWN_TIME      ; \ set time to slow down sprite
                    STA SLOW_DOWN_TIMER,x             ; /
                    INC $C2,x               ; increment turn count
LABEL17             

                    JSL $81A7DC             ; check for mario/sprite contact

                    RTS                     ; return


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; graphics routine
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

SUB_GFX             JSL GetDrawInfo       ; after: Y = index to sprite tile map ($300)
                                            ;      $00 = sprite x position relative to screen boarder 
                                            ;      $01 = sprite y position relative to screen boarder  
                    
                    LDA $1570,x             ; \ calculate which frame to show
                    LSR A                   ;  |   based on how long sprite's been alive
                    LSR A                   ;  |   based on how long sprite's been alive
                    ;LSR A                   ;  |   based on how long sprite's been alive
                    AND #$03                ;  | 
                    STA $03                 ; /
                  
                    LDA $157C,x             ; \ $02 = sprite direction
                    PHY
                    LDY $1540,x 
                    BEQ NOT_TURNING
                    CPY #SLOWDOWN_TIME
                    BCS NOT_TURNING
                    EOR #$01
NOT_TURNING         PLY
                    STA $02                 ; /
            
                    PHX                     ; push sprite index

                    LDX #TILES_PER_FRAME    ; loop counter = (number of tiles per frame) - 1
LOOP_START          PHX                     ; push current tile number
                                        
                    LDA $00                 ; \ tile x position = sprite x location ($00)
                    STA $0300,y             ; /
                    
                    LDA $01                 ; \ tile y position = sprite y location ($01) + tile displacement
                    STA $0301,y             ; /
                    
                    LDX $03
                    LDA TILEMAP,x           ; \
                    STA $0302,y             ; / 
        
                    ;LDX $03                    ; \
                    LDA PROPERTIES,x        ;  | get sprite pallette
                    ;LDX $02                    ;  |
                    ;BNE NO_FLIP_TILE       ;  |
                    ;ORA #$40               ;  | put in sprite direction
NO_FLIP_TILE        ORA $64                 ;  | put in level properties
                    STA $0303,y             ; / store tile properties
                    
                    PLX                     ; \ pull, X = current tile of the frame we're drawing

                    INY                     ;  | increase index to sprite tile map ($300)...
                    INY                     ;  |    ...we wrote 4 bytes...
                    INY                     ;  |    
                    INY                     ;  |    ...so increment 4 times

                    DEX                     ;  | go to next tile of frame and loop
                    BPL LOOP_START          ; / 

                    PLX                     ; pull, X = sprite index
                    LDY #$02                ; \ 02, because 16x16 tiles
                    LDA #TILES_PER_FRAME    ;  | A = number of tiles drawn - 1
                    JSL $81B7B3             ; / don't draw if offscreen
                    RTS                     ; return




             
