.include "man/entity.h.s"
.include "man/animations.h.s"

;; 0000 -- muerte
;; 0001 -- down
;; 0010 -- up
;; 0011 -- left
;; 0100 -- right
;; 0101 -- s. down
;; 0110 -- s. down 
;; 0111 -- s. left 
;; 1000 -- s. right 
;; 1001 -- ataque down
;; 1010 -- ataque up
;; 1011 -- ataque left
;; 1100 -- ataque right
;; 1101 -- invencible
animations_calculate_status:
    ld b, #0x01        ;; estado base

    ;; MUERTA O MURIENDO
    ld a, e_tipo(ix)
    cp #e_type_dead
    jr nz, noMuerta
        ld b, #0x00
        ret
    noMuerta:

    ;; INVENCIBLE
    ld a, e_invencibilidad(ix)
    cp #1
    jr nz, noInvencible
        ld b, #0x0D
        ret
    noInvencible:

    ;; VELOCIDADES
    ld a, e_vy(ix)   ;; cargo la velocidad de y
    cp #0
    jr z, vyzero    ;; miro si es 0
    vynozero:
        jp m, vynegative ;; comrpuebo el signo
    vypositive: ;; si es positiva
        ld a, e_atacando(ix)
        cp #0
        jp z, sinataquevyp
        conataquevyp:
            ld b, #0x09
            ret
        sinataquevyp:
        ld b, #0x01
        ret
    vynegative: ;; si es negativa
        ld a, e_atacando(ix)
        cp #0
        jp z, sinataquevyn
        conataquevyn:
            ld b, #0x0A
            ret
        sinataquevyn:
        ld b, #0x02
        ret
    vyzero:

    ;; compruebo las velocidad en x si no hay en y
    ld a, e_vx(ix) ;; cargo la direccion en x
    cp #0
    jr z, vxzero    ;; miro si es 0
    vxnozero: 
        jp m, vxnegative ;; comrpuebo el signo
    vxpositive:     ;; si es positiva
        ld a, e_atacando(ix)
        cp #0
        jp z, sinataquevxp
        conataquevxp:
            ld b, #0x0C
            ret
        sinataquevxp:
        ld b, #0x04
        ret
    vxnegative:     ;; si es negativa
        ld a, e_atacando(ix)
        cp #0
        jp z, sinataquevxn
        conataquevxn:
            ld b, #0x0B
            ret
        sinataquevxn:
        ld b, #0x03
        ret
    vxzero:


    ;;DIRECCIONES
    ld a, e_last_dirY(ix)   ;; cargo la velocidad de y
    cp #0
    jr z, dyzero    ;; miro si es 0
    dynozero:
        jp m, dynegative ;; comrpuebo el signo
    dypositive: ;; si es positiva
        ld a, e_atacando(ix)
        cp #0
        jp nz, conataquevyp

        ld b, #0x05
        ret
    dynegative: ;; si es negativa
        ld a, e_atacando(ix)
        cp #0
        jp nz, conataquevyn

        ld b, #0x06
        ret
    dyzero:

    ;; compruebo las direcciones para ver su orientacion en x si no hay en y
    ld a, e_last_dir(ix) ;; cargo la direccion en x
    cp #0
    jr z, dxzero    ;; miro si es 0
    dxnozero: 
        jp m, dxnegative ;; comrpuebo el signo
    dxpositive:     ;; si es positiva
        ld a, e_atacando(ix)
        cp #0
        jp nz, conataquevxp

        ld b, #0x08
        ret
    dxnegative:     ;; si es negativa
        ld a, e_atacando(ix)
        cp #0
        jp nz, conataquevxn

        ld b, #0x07
    dxzero:
ret

animations_update_one:
    call animations_calculate_status ;; devuelve en b el estado de la animacion

    ld a, e_anim_st(ix)
    cp b
    jr z, continuoAnim  ;; si los estados son iguales continuo, sino cambio la animacion de la entidad
    newAnimationStatus:
        ld a, e_anim_especial(ix) ;; miro si es animacion especial (muerte, ataque o invencible)
        cp #0
        jp nz, continuoAnim ;; si es 1, es especial y no la cambio

        ld e_anim_st(ix),b ;; actualizo estado
        call animations_getAnimHL ;; devuelve en hl el puntero a la animacion que toca

        ld e_animL(ix), l   ;; guardo el puntero de animacion segun el estado
        ld e_animH(ix), h

        ;;si el nuevo estado es especial pongo el anim especial a 1 (muerte, ataque o invencible)
        ld a, b
        cp #0 ;;muerte
        jp z, newEspecial
        noMuerte:
            cp #0x09 ;; a partir del 9 son ataque e invencible
            jp m, continuoAnim ;; si el resultado es negativo es una animacion normal
        newEspecial:
            ld e_anim_especial(ix), #1 ;; actualizo valor especial si el estado es mayor que 8

    continuoAnim:
    ld a, e_animCounter(ix) ;; compruebo si toca pasar de frame o todavia no
    dec a
    cp #0
    jp nz, noCambioFrame
        cambioFrame:
        ld e_animCounter(ix), #0x0C ;; reseteo contador de animacion

        ld l, e_animL(ix) ;;paso actual en la animacion
        ld h, e_animH(ix)

        returnAnim:
            ld c, (hl)  ;;  
            inc hl      ;; bc = actual sprite
            ld b, (hl)  ;; 
            inc hl      ;; hl +=2 puntero al siguiemte paso de la animacion

            ld a, c         ;; si el sprite actual es null reseteo animacion
            or b
            jr z, resetAnim
                ld e_animL(ix), l   ;; guardo puntero a la siguiente animacion
                ld e_animH(ix), h

                ld e_spriteL(ix), c ;; guardo puntero al siguiente sprite
                ld e_spriteH(ix), b

                ret

            resetAnim:
                ld e_atacando(ix), #0
                ld e_anim_especial(ix), #0 ;; al terminar la animacion ya puede cambiar a otra
                ld e_invencibilidad(ix), #0 ;; al terminar la animacion ya puede cambiar a otra

                ld a, (hl)  ;; cargo en hl donde apuntaba hl
                inc hl
                ld h, (hl)
                ld l, a
                jr returnAnim
    noCambioFrame:
        ld e_animCounter(ix), a ;; modifico contador de animacion

ret

animations_update:
    ld hl, #animations_update_one
    ld b, #e_cmp_animated
    call entity_doForAll_matching
ret