jak-project/test/decompiler/reference/jakx/engine/game/penetrate-h_REF.gc

;;-*-Lisp-*-
(in-package goal)

;; definition (debug) for function penetrate->string
;; WARN: Return type mismatch object vs string.
(defun-debug penetrate->string ((arg0 penetrate))
  (if (= (logand (penetrate jak-red-shockwave) arg0) (shl 4 32))
      (format #t "jak-red-shockwave ")
      )
  (if (= (logand arg0 (penetrate mech-bonk)) (penetrate mech-bonk))
      (format #t "mech-bonk ")
      )
  (if (= (logand (penetrate eco-blue) arg0) (shl #x8000 16))
      (format #t "eco-blue ")
      )
  (if (= (logand (penetrate explode) arg0) (penetrate explode))
      (format #t "explode ")
      )
  (if (= (logand arg0 (penetrate bonk)) (penetrate bonk))
      (format #t "bonk ")
      )
  (if (= (logand (penetrate eco-red) arg0) (penetrate eco-red))
      (format #t "eco-red ")
      )
  (if (= (logand arg0 (penetrate roll)) (penetrate roll))
      (format #t "roll ")
      )
  (if (= (logand arg0 (penetrate mech)) (penetrate mech))
      (format #t "mech ")
      )
  (if (= (logand arg0 (penetrate flut-attack)) (penetrate flut-attack))
      (format #t "flut-attack ")
      )
  (if (= (logand arg0 (penetrate mech-punch)) (penetrate mech-punch))
      (format #t "mech-punch ")
      )
  (if (= (logand (penetrate jak-dark-shot) arg0) (penetrate jak-dark-shot))
      (format #t "jak-dark-shot ")
      )
  (if (= (logand (penetrate dark-smack) arg0) (penetrate dark-smack))
      (format #t "dark-smack ")
      )
  (if (= (logand arg0 (penetrate flop)) (penetrate flop))
      (format #t "flop ")
      )
  (if (= (logand arg0 (penetrate spin)) (penetrate spin))
      (format #t "spin ")
      )
  (if (= (logand (penetrate dark-bomb) arg0) (penetrate dark-bomb))
      (format #t "dark-bomb ")
      )
  (if (= (logand arg0 (penetrate vehicle)) (penetrate vehicle))
      (format #t "vehicle ")
      )
  (if (= (logand arg0 (penetrate generic-attack)) (penetrate generic-attack))
      (format #t "generic-attack ")
      )
  (if (= (logand arg0 (penetrate touch)) (penetrate touch))
      (format #t "touch ")
      )
  (if (= (logand (penetrate eco-green) arg0) (shl 1 32))
      (format #t "eco-green ")
      )
  (if (= (logand (penetrate jak-red-shot) arg0) (penetrate jak-red-shot))
      (format #t "jak-red-shot ")
      )
  (if (= (logand arg0 (penetrate lunge)) (penetrate lunge))
      (format #t "lunge ")
      )
  (if (= (logand arg0 (penetrate punch)) (penetrate punch))
      (format #t "punch ")
      )
  (if (= (logand arg0 (penetrate tube)) (penetrate tube))
      (format #t "tube ")
      )
  (if (= (logand (penetrate jak-dark-nuke) arg0) (shl 8 32))
      (format #t "jak-dark-nuke ")
      )
  (if (= (logand (penetrate enemy-yellow-shot) arg0) (penetrate enemy-yellow-shot))
      (format #t "enemy-yellow-shot ")
      )
  (if (= (logand (penetrate knocked) arg0) (shl 2 32))
      (format #t "knocked ")
      )
  (if (= (logand (penetrate emp-blast) arg0) (shl 32 32))
      (format #t "emp-blast ")
      )
  (if (= (logand arg0 (penetrate uppercut)) (penetrate uppercut))
      (format #t "uppercut ")
      )
  (if (= (logand (penetrate dark-punch) arg0) (penetrate dark-punch))
      (format #t "dark-punch ")
      )
  (if (= (logand (penetrate shield) arg0) (penetrate shield))
      (format #t "shield ")
      )
  (if (= (logand (penetrate jak-yellow-shot) arg0) (penetrate jak-yellow-shot))
      (format #t "jak-yellow-shot ")
      )
  (if (= (logand arg0 (penetrate board)) (penetrate board))
      (format #t "board ")
      )
  (if (= (logand (penetrate flut) arg0) (penetrate flut))
      (format #t "flut ")
      )
  (if (= (logand (penetrate eco-yellow) arg0) (penetrate eco-yellow))
      (format #t "eco-yellow ")
      )
  (if (= (logand (penetrate dark-skin) arg0) (penetrate dark-skin))
      (format #t "dark-skin ")
      )
  (if (= (logand (penetrate jak-dark-blackhole) arg0) (shl 16 32))
      (format #t "jak-dark-blackhole ")
      )
  (if (= (logand (penetrate enemy-dark-shot) arg0) (penetrate enemy-dark-shot))
      (format #t "enemy-dark-shot ")
      )
  (the-as string (if (= (logand (penetrate jak-blue-shot) arg0) (penetrate jak-blue-shot))
                     (format #t "jak-blue-shot ")
                     )
          )
  )

;; definition for function penetrate-using->damage
(defun penetrate-using->damage ((arg0 penetrate))
  (cond
    ((logtest? (penetrate dark-bomb dark-smack) arg0)
     15.0
     )
    ((logtest? arg0 (penetrate mech-punch mech-bonk))
     5.0
     )
    ((logtest? (penetrate) arg0)
     4.0
     )
    ((logtest? (penetrate punch spin jak-dark-shot enemy-dark-shot) arg0)
     3.0
     )
    ((logtest? (penetrate
                 flop
                 uppercut
                 tube
                 flut-attack
                 dark-punch
                 explode
                 jak-yellow-shot
                 jak-red-shot
                 jak-blue-shot
                 enemy-yellow-shot
                 eco-yellow
                 )
               arg0
               )
     2.0
     )
    ((logtest? arg0 (penetrate generic-attack roll bonk board))
     1.0
     )
    (else
      0.0
      )
    )
  )

;; definition for function penetrated-by-all&hit-points->penetrated-by
;; WARN: Return type mismatch uint vs penetrate.
(defun penetrated-by-all&hit-points->penetrated-by ((arg0 penetrate) (arg1 int))
  (let ((a0-1 arg1))
    (the-as penetrate (logior (logclear arg0 (penetrate
                                               generic-attack
                                               flop
                                               punch
                                               spin
                                               roll
                                               uppercut
                                               bonk
                                               tube
                                               flut-attack
                                               board
                                               mech-punch
                                               mech-bonk
                                               dark-skin
                                               dark-punch
                                               dark-bomb
                                               dark-smack
                                               shield
                                               explode
                                               jak-yellow-shot
                                               jak-red-shot
                                               jak-blue-shot
                                               jak-dark-shot
                                               enemy-yellow-shot
                                               enemy-dark-shot
                                               eco-yellow
                                               knocked
                                               )
                                        )
                              (cond
                                ((or (zero? a0-1) (= a0-1 1))
                                 (the-as int (the-as uint #x23fefdbfa))
                                 )
                                ((= a0-1 2)
                                 #x3fcecab8
                                 )
                                ((= a0-1 3)
                                 #x140cc030
                                 )
                                ((= a0-1 4)
                                 #xcc000
                                 )
                                ((= a0-1 5)
                                 #xcc000
                                 )
                                ((or (= a0-1 6)
                                     (= a0-1 7)
                                     (= a0-1 8)
                                     (= a0-1 9)
                                     (= a0-1 10)
                                     (= a0-1 11)
                                     (= a0-1 12)
                                     (= a0-1 13)
                                     (= a0-1 14)
                                     (= a0-1 15)
                                     )
                                 #xc0000
                                 )
                                (else
                                  0
                                  )
                                )
                              )
            )
    )
  )

;; definition for function pu->knocked-type
;; WARN: Return type mismatch int vs knocked-type.
(defun pu->knocked-type ((arg0 penetrate))
  (the-as knocked-type (cond
                         ((logtest? arg0 (penetrate vehicle))
                          7
                          )
                         ((logtest? (penetrate jak-blue-shot) arg0)
                          6
                          )
                         ((logtest? (penetrate jak-yellow-shot enemy-yellow-shot) arg0)
                          4
                          )
                         ((logtest? (penetrate jak-red-shot) arg0)
                          5
                          )
                         ((logtest? (penetrate explode jak-dark-shot enemy-dark-shot) arg0)
                          2
                          )
                         ((logtest? (penetrate dark-bomb dark-smack) arg0)
                          3
                          )
                         ((logtest? arg0 (penetrate mech-punch))
                          1
                          )
                         (else
                           0
                           )
                         )
          )
  )