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

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

;; definition of type fact-bank
(deftype fact-bank (basic)
  ((eco-level-max               float)
   (eco-single-inc              float)
   (eco-full-inc                float)
   (eco-single-timeout          seconds)
   (eco-full-timeout            seconds)
   (dummy                       seconds)
   (health-max-default          float)
   (health-max-max              float)
   (health-small-inc            float)
   (health-single-inc           float)
   (health-default-inc          float)
   (eco-pill-green-max-default  float)
   (eco-pill-dark-max-default   float)
   (eco-pill-light-max-default  float)
   (eco-green-max-default       float)
   (default-eco-pill-green-inc  float)
   (default-eco-pill-dark-inc   float)
   (default-eco-pill-light-inc  float)
   (buzzer-max-default          float)
   (buzzer-single-inc           float)
   (suck-bounce-dist            meters)
   (suck-suck-dist              meters)
   (shield-max                  float)
   (shield-use-speed            float)
   (shield-time-min             seconds)
   (trick-point-max             float)
   (super-skill-inc             float)
   (darkjak-spin-inc            float)
   (darkjak-punch-inc           float)
   (darkjak-flop-inc            float)
   (darkjak-uppercut-inc        float)
   (darkjak-bomb0-inc           float)
   (darkjak-bomb1-inc           float)
   (darkjak-smack-inc           float)
   (darkjak-bomb-min            float)
   (darkjak-button-invis-inc    float)
   )
  )

;; definition for method 3 of type fact-bank
(defmethod inspect ((this fact-bank))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Teco-level-max: ~f~%" (-> this eco-level-max))
  (format #t "~1Teco-single-inc: ~f~%" (-> this eco-single-inc))
  (format #t "~1Teco-full-inc: ~f~%" (-> this eco-full-inc))
  (format #t "~1Teco-single-timeout: (seconds ~e)~%" (-> this eco-single-timeout))
  (format #t "~1Teco-full-timeout: (seconds ~e)~%" (-> this eco-full-timeout))
  (format #t "~1Tdummy: (seconds ~e)~%" (-> this dummy))
  (format #t "~1Thealth-max-default: ~f~%" (-> this health-max-default))
  (format #t "~1Thealth-max-max: ~f~%" (-> this health-max-max))
  (format #t "~1Thealth-small-inc: ~f~%" (-> this health-small-inc))
  (format #t "~1Thealth-single-inc: ~f~%" (-> this health-single-inc))
  (format #t "~1Thealth-default-inc: ~f~%" (-> this health-default-inc))
  (format #t "~1Teco-pill-green-max-default: ~f~%" (-> this eco-pill-green-max-default))
  (format #t "~1Teco-pill-dark-max-default: ~f~%" (-> this eco-pill-dark-max-default))
  (format #t "~1Teco-pill-light-max-default: ~f~%" (-> this eco-pill-light-max-default))
  (format #t "~1Teco-green-max-default: ~f~%" (-> this eco-green-max-default))
  (format #t "~1Tdefault-eco-pill-green-inc: ~f~%" (-> this default-eco-pill-green-inc))
  (format #t "~1Tdefault-eco-pill-dark-inc: ~f~%" (-> this default-eco-pill-dark-inc))
  (format #t "~1Tdefault-eco-pill-light-inc: ~f~%" (-> this default-eco-pill-light-inc))
  (format #t "~1Tbuzzer-max-default: ~f~%" (-> this buzzer-max-default))
  (format #t "~1Tbuzzer-single-inc: ~f~%" (-> this buzzer-single-inc))
  (format #t "~1Tsuck-bounce-dist: (meters ~m)~%" (-> this suck-bounce-dist))
  (format #t "~1Tsuck-suck-dist: (meters ~m)~%" (-> this suck-suck-dist))
  (format #t "~1Tshield-max: ~f~%" (-> this shield-max))
  (format #t "~1Tshield-use-speed: ~f~%" (-> this shield-use-speed))
  (format #t "~1Tshield-time-min: (seconds ~e)~%" (-> this shield-time-min))
  (format #t "~1Ttrick-point-max: ~f~%" (-> this trick-point-max))
  (format #t "~1Tsuper-skill-inc: ~f~%" (-> this super-skill-inc))
  (format #t "~1Tdarkjak-spin-inc: ~f~%" (-> this darkjak-spin-inc))
  (format #t "~1Tdarkjak-punch-inc: ~f~%" (-> this darkjak-punch-inc))
  (format #t "~1Tdarkjak-flop-inc: ~f~%" (-> this darkjak-flop-inc))
  (format #t "~1Tdarkjak-uppercut-inc: ~f~%" (-> this darkjak-uppercut-inc))
  (format #t "~1Tdarkjak-bomb0-inc: ~f~%" (-> this darkjak-bomb0-inc))
  (format #t "~1Tdarkjak-bomb1-inc: ~f~%" (-> this darkjak-bomb1-inc))
  (format #t "~1Tdarkjak-smack-inc: ~f~%" (-> this darkjak-smack-inc))
  (format #t "~1Tdarkjak-bomb-min: ~f~%" (-> this darkjak-bomb-min))
  (format #t "~1Tdarkjak-button-invis-inc: ~f~%" (-> this darkjak-button-invis-inc))
  (label cfg-4)
  this
  )

;; definition for symbol *FACT-bank*, type fact-bank
(define *FACT-bank* (new 'static 'fact-bank
                      :eco-level-max 2.0
                      :eco-single-inc 1.0
                      :eco-full-inc 5.0
                      :eco-single-timeout (seconds 5)
                      :eco-full-timeout (seconds 20)
                      :dummy (seconds 15)
                      :health-max-default 8.0
                      :health-max-max 16.0
                      :health-small-inc 1.0
                      :health-single-inc 1.0
                      :health-default-inc 2.0
                      :eco-pill-green-max-default 50.0
                      :eco-pill-dark-max-default 100.0
                      :eco-pill-light-max-default 100.0
                      :eco-green-max-default 100.0
                      :buzzer-max-default 7.0
                      :buzzer-single-inc 1.0
                      :suck-bounce-dist (meters 18)
                      :suck-suck-dist (meters 7.5)
                      :shield-max 100.0
                      :shield-use-speed 10.0
                      :shield-time-min (seconds 1.5)
                      :trick-point-max 999999.0
                      :super-skill-inc 3.0
                      :darkjak-spin-inc 4.0
                      :darkjak-punch-inc 4.0
                      :darkjak-flop-inc 6.0
                      :darkjak-uppercut-inc 6.0
                      :darkjak-bomb0-inc 100.0
                      :darkjak-bomb1-inc 100.0
                      :darkjak-smack-inc 15.0
                      :darkjak-bomb-min 50.0
                      :darkjak-button-invis-inc 20.0
                      )
        )

;; definition (debug) for function pickup-type->string
(defun-debug pickup-type->string ((arg0 pickup-type))
  (case arg0
    (((pickup-type eco-pill-dark))
     "eco-pill-dark"
     )
    (((pickup-type ammo-dark-light-random))
     "ammo-dark-light-random"
     )
    (((pickup-type ammo-random))
     "ammo-random"
     )
    (((pickup-type eco-blue))
     "eco-blue"
     )
    (((pickup-type gun-yellow-1))
     "gun-yellow-1"
     )
    (((pickup-type pass-red))
     "pass-red"
     )
    (((pickup-type eco-pill-green))
     "eco-pill-green"
     )
    (((pickup-type eco-red))
     "eco-red"
     )
    (((pickup-type dark-eco-crystal))
     "dark-eco-crystal"
     )
    (((pickup-type skill))
     "skill"
     )
    (((pickup-type karma))
     "karma"
     )
    (((pickup-type eco-dark))
     "eco-dark"
     )
    (((pickup-type gun-red-3))
     "gun-red-3"
     )
    (((pickup-type gun-dark-1))
     "gun-dark-1"
     )
    (((pickup-type gun-yellow-3))
     "gun-yellow-3"
     )
    (((pickup-type gem))
     "gem"
     )
    (((pickup-type eco-green))
     "eco-green"
     )
    (((pickup-type darkjak))
     "darkjak"
     )
    (((pickup-type ammo-yellow))
     "ammo-yellow"
     )
    (((pickup-type gun-blue-1))
     "gun-blue-1"
     )
    (((pickup-type pass-blue))
     "pass-blue"
     )
    (((pickup-type ammo-light-random))
     "ammo-light-random"
     )
    (((pickup-type gun-dark-2))
     "gun-dark-2"
     )
    (((pickup-type ammo-red))
     "ammo-red"
     )
    (((pickup-type lightjak))
     "lightjak"
     )
    (((pickup-type fuel-cell))
     "fuel-cell"
     )
    (((pickup-type gun-blue-2))
     "gun-blue-2"
     )
    (((pickup-type buzzer))
     "buzzer"
     )
    (((pickup-type gun-dark-3))
     "gun-dark-3"
     )
    (((pickup-type gun-red-1))
     "gun-red-1"
     )
    (((pickup-type gun-blue-3))
     "gun-blue-3"
     )
    (((pickup-type shield))
     "shield"
     )
    (((pickup-type eco-pill-random))
     "eco-pill-random"
     )
    (((pickup-type health-max))
     "health-max"
     )
    (((pickup-type light-eco-crystal))
     "light-eco-crystal"
     )
    (((pickup-type board))
     "board"
     )
    (((pickup-type none))
     "none"
     )
    (((pickup-type pass-green))
     "pass-green"
     )
    (((pickup-type light-random))
     "light-random"
     )
    (((pickup-type gun-yellow-2))
     "gun-yellow-2"
     )
    (((pickup-type pass-slumb-genb))
     "pass-slumb-genb"
     )
    (((pickup-type money))
     "money"
     )
    (((pickup-type eco-yellow))
     "eco-yellow"
     )
    (((pickup-type ammo-dark))
     "ammo-dark"
     )
    (((pickup-type trick-judge))
     "trick-judge"
     )
    (((pickup-type eco-pill-light))
     "eco-pill-light"
     )
    (((pickup-type trick-point))
     "trick-point"
     )
    (((pickup-type ammo-blue))
     "ammo-blue"
     )
    (((pickup-type pass-yellow))
     "pass-yellow"
     )
    (((pickup-type gun-red-2))
     "gun-red-2"
     )
    (((pickup-type health))
     "health"
     )
    (else
      "*unknown*"
      )
    )
  )

;; definition of type fact-info
(deftype fact-info (basic)
  ((process              process)
   (pickup-type          pickup-type)
   (pickup-amount        float)
   (pickup-spawn-amount  float)
   (options              actor-option)
   (fade-time            time-frame)
   )
  (:methods
    (new (symbol type process pickup-type float) _type_)
    (drop-pickup (_type_ symbol process-tree fact-info int symbol) (pointer process))
    (reset! (_type_ symbol) none)
    (pickup-collectable! (_type_ pickup-type float handle) float)
    )
  )

;; definition for method 3 of type fact-info
(defmethod inspect ((this fact-info))
  (when (not this)
    (set! this this)
    (goto cfg-62)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tpickup-type: #x~X : ~S~%" (-> this pickup-type) (pickup-type->string (-> this pickup-type)))
  (format #t "~1Tpickup-amount: ~f~%" (-> this pickup-amount))
  (format #t "~1Tpickup-spawn-amount: ~f~%" (-> this pickup-spawn-amount))
  (format #t "~1Toptions: #x~X : (actor-option " (-> this options))
  (let ((s5-1 (-> this options)))
    (if (= (logand s5-1 (actor-option respawn-delay)) (actor-option respawn-delay))
        (format #t "respawn-delay ")
        )
    (if (= (logand s5-1 (actor-option draw-blocker)) (actor-option draw-blocker))
        (format #t "draw-blocker ")
        )
    (if (= (logand (actor-option user20) s5-1) (actor-option user20))
        (format #t "user20 ")
        )
    (if (= (logand (actor-option no-amb-sound) s5-1) (actor-option no-amb-sound))
        (format #t "no-amb-sound ")
        )
    (if (= (logand s5-1 (actor-option auto-pickup)) (actor-option auto-pickup))
        (format #t "auto-pickup ")
        )
    (if (= (logand (actor-option no-track) s5-1) (actor-option no-track))
        (format #t "no-track ")
        )
    (if (= (logand s5-1 (actor-option no-shadow)) (actor-option no-shadow))
        (format #t "no-shadow ")
        )
    (if (= (logand s5-1 (actor-option loop)) (actor-option loop))
        (format #t "loop ")
        )
    (if (= (logand s5-1 (actor-option fuel-cell-no-jump)) (actor-option fuel-cell-no-jump))
        (format #t "fuel-cell-no-jump ")
        )
    (if (= (logand (actor-option fall) s5-1) (actor-option fall))
        (format #t "fall ")
        )
    (if (= (logand (actor-option user18) s5-1) (actor-option user18))
        (format #t "user18 ")
        )
    (if (= (logand s5-1 (actor-option big-collision)) (actor-option big-collision))
        (format #t "big-collision ")
        )
    (if (= (logand s5-1 (actor-option no-reaction)) (actor-option no-reaction))
        (format #t "no-reaction ")
        )
    (if (= (logand s5-1 (actor-option suck-in)) (actor-option suck-in))
        (format #t "suck-in ")
        )
    (if (= (logand s5-1 (actor-option racer-only)) (actor-option racer-only))
        (format #t "racer-only ")
        )
    (if (= (logand s5-1 (actor-option blocked)) (actor-option blocked))
        (format #t "blocked ")
        )
    (if (= (logand (actor-option no-distance-check-fadeout) s5-1) (actor-option no-distance-check-fadeout))
        (format #t "no-distance-check-fadeout ")
        )
    (if (= (logand (actor-option cond-hide) s5-1) (actor-option cond-hide))
        (format #t "cond-hide ")
        )
    (if (= (logand (actor-option dont-override-fact) s5-1) (actor-option dont-override-fact))
        (format #t "dont-override-fact ")
        )
    (if (= (logand (actor-option user17) s5-1) (actor-option user17))
        (format #t "user17 ")
        )
    (if (= (logand s5-1 (actor-option wait-for-cue)) (actor-option wait-for-cue))
        (format #t "wait-for-cue ")
        )
    (if (= (logand s5-1 (actor-option reflect)) (actor-option reflect))
        (format #t "reflect ")
        )
    (if (= (logand (actor-option user19) s5-1) (actor-option user19))
        (format #t "user19 ")
        )
    (if (= (logand (actor-option cond-respawn) s5-1) (actor-option cond-respawn))
        (format #t "cond-respawn ")
        )
    (if (= (logand s5-1 (actor-option wait-for-task-complete)) (actor-option wait-for-task-complete))
        (format #t "wait-for-task-complete ")
        )
    (if (= (logand s5-1 (actor-option fade-out)) (actor-option fade-out))
        (format #t "fade-out ")
        )
    (if (= (logand (actor-option cond-low-ammo) s5-1) (actor-option cond-low-ammo))
        (format #t "cond-low-ammo ")
        )
    (if (= (logand (actor-option mirror) s5-1) (actor-option mirror))
        (format #t "mirror ")
        )
    (if (= (logand s5-1 (actor-option spawns-fuel-cell)) (actor-option spawns-fuel-cell))
        (format #t "spawns-fuel-cell ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tfade-time: ~D~%" (-> this fade-time))
  (label cfg-62)
  this
  )

;; definition of type fact-info-enemy
(deftype fact-info-enemy (fact-info)
  ((speed             float)
   (idle-distance     meters)
   (notice-top        meters)
   (notice-bottom     meters)
   (cam-horz          meters)
   (cam-vert          meters)
   (cam-notice-dist   meters)
   (enemy-options     enemy-option)
   (trig-dist         meters)
   (trig-actor-group  (pointer actor-group))
   (trig-mask-count   int8)
   (trig-mask         uint8  2)
   )
  (:methods
    (new (symbol type process (pointer float)) _type_)
    (clear-mask-bits (_type_ int) none)
    )
  )

;; definition for method 3 of type fact-info-enemy
(defmethod inspect ((this fact-info-enemy))
  (when (not this)
    (set! this this)
    (goto cfg-114)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tpickup-type: #x~X : ~S~%" (-> this pickup-type) (pickup-type->string (-> this pickup-type)))
  (format #t "~1Tpickup-amount: ~f~%" (-> this pickup-amount))
  (format #t "~1Tpickup-spawn-amount: ~f~%" (-> this pickup-spawn-amount))
  (format #t "~1Toptions: #x~X : (actor-option " (-> this options))
  (let ((s5-1 (-> this options)))
    (if (= (logand s5-1 (actor-option respawn-delay)) (actor-option respawn-delay))
        (format #t "respawn-delay ")
        )
    (if (= (logand s5-1 (actor-option draw-blocker)) (actor-option draw-blocker))
        (format #t "draw-blocker ")
        )
    (if (= (logand (actor-option user20) s5-1) (actor-option user20))
        (format #t "user20 ")
        )
    (if (= (logand (actor-option no-amb-sound) s5-1) (actor-option no-amb-sound))
        (format #t "no-amb-sound ")
        )
    (if (= (logand s5-1 (actor-option auto-pickup)) (actor-option auto-pickup))
        (format #t "auto-pickup ")
        )
    (if (= (logand (actor-option no-track) s5-1) (actor-option no-track))
        (format #t "no-track ")
        )
    (if (= (logand s5-1 (actor-option no-shadow)) (actor-option no-shadow))
        (format #t "no-shadow ")
        )
    (if (= (logand s5-1 (actor-option loop)) (actor-option loop))
        (format #t "loop ")
        )
    (if (= (logand s5-1 (actor-option fuel-cell-no-jump)) (actor-option fuel-cell-no-jump))
        (format #t "fuel-cell-no-jump ")
        )
    (if (= (logand (actor-option fall) s5-1) (actor-option fall))
        (format #t "fall ")
        )
    (if (= (logand (actor-option user18) s5-1) (actor-option user18))
        (format #t "user18 ")
        )
    (if (= (logand s5-1 (actor-option big-collision)) (actor-option big-collision))
        (format #t "big-collision ")
        )
    (if (= (logand s5-1 (actor-option no-reaction)) (actor-option no-reaction))
        (format #t "no-reaction ")
        )
    (if (= (logand s5-1 (actor-option suck-in)) (actor-option suck-in))
        (format #t "suck-in ")
        )
    (if (= (logand s5-1 (actor-option racer-only)) (actor-option racer-only))
        (format #t "racer-only ")
        )
    (if (= (logand s5-1 (actor-option blocked)) (actor-option blocked))
        (format #t "blocked ")
        )
    (if (= (logand (actor-option no-distance-check-fadeout) s5-1) (actor-option no-distance-check-fadeout))
        (format #t "no-distance-check-fadeout ")
        )
    (if (= (logand (actor-option cond-hide) s5-1) (actor-option cond-hide))
        (format #t "cond-hide ")
        )
    (if (= (logand (actor-option dont-override-fact) s5-1) (actor-option dont-override-fact))
        (format #t "dont-override-fact ")
        )
    (if (= (logand (actor-option user17) s5-1) (actor-option user17))
        (format #t "user17 ")
        )
    (if (= (logand s5-1 (actor-option wait-for-cue)) (actor-option wait-for-cue))
        (format #t "wait-for-cue ")
        )
    (if (= (logand s5-1 (actor-option reflect)) (actor-option reflect))
        (format #t "reflect ")
        )
    (if (= (logand (actor-option user19) s5-1) (actor-option user19))
        (format #t "user19 ")
        )
    (if (= (logand (actor-option cond-respawn) s5-1) (actor-option cond-respawn))
        (format #t "cond-respawn ")
        )
    (if (= (logand s5-1 (actor-option wait-for-task-complete)) (actor-option wait-for-task-complete))
        (format #t "wait-for-task-complete ")
        )
    (if (= (logand s5-1 (actor-option fade-out)) (actor-option fade-out))
        (format #t "fade-out ")
        )
    (if (= (logand (actor-option cond-low-ammo) s5-1) (actor-option cond-low-ammo))
        (format #t "cond-low-ammo ")
        )
    (if (= (logand (actor-option mirror) s5-1) (actor-option mirror))
        (format #t "mirror ")
        )
    (if (= (logand s5-1 (actor-option spawns-fuel-cell)) (actor-option spawns-fuel-cell))
        (format #t "spawns-fuel-cell ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tfade-time: ~D~%" (-> this fade-time))
  (format #t "~1Tspeed: ~f~%" (-> this speed))
  (format #t "~1Tidle-distance: (meters ~m)~%" (-> this idle-distance))
  (format #t "~1Tnotice-top: (meters ~m)~%" (-> this notice-top))
  (format #t "~1Tnotice-bottom: (meters ~m)~%" (-> this notice-bottom))
  (format #t "~1Tcam-horz: (meters ~m)~%" (-> this cam-horz))
  (format #t "~1Tcam-vert: (meters ~m)~%" (-> this cam-vert))
  (format #t "~1Tcam-notice-dist: (meters ~m)~%" (-> this cam-notice-dist))
  (format #t "~1Tenemy-options: #x~X : (enemy-option " (-> this enemy-options))
  (let ((s5-2 (-> this enemy-options)))
    (if (= (logand s5-2 (enemy-option user11)) (enemy-option user11))
        (format #t "user11 ")
        )
    (if (= (logand (enemy-option spawner) s5-2) (enemy-option spawner))
        (format #t "spawner ")
        )
    (if (= (logand (enemy-option dormant-aware) s5-2) (enemy-option dormant-aware))
        (format #t "dormant-aware ")
        )
    (if (= (logand s5-2 (enemy-option user0)) (enemy-option user0))
        (format #t "user0 ")
        )
    (if (= (logand s5-2 (enemy-option user2)) (enemy-option user2))
        (format #t "user2 ")
        )
    (if (= (logand (enemy-option prespawned) s5-2) (enemy-option prespawned))
        (format #t "prespawned ")
        )
    (if (= (logand s5-2 (enemy-option user4)) (enemy-option user4))
        (format #t "user4 ")
        )
    (if (= (logand s5-2 (enemy-option user6)) (enemy-option user6))
        (format #t "user6 ")
        )
    (if (= (logand s5-2 (enemy-option user8)) (enemy-option user8))
        (format #t "user8 ")
        )
    (if (= (logand (enemy-option multi-focus) s5-2) (enemy-option multi-focus))
        (format #t "multi-focus ")
        )
    (if (= (logand (enemy-option ambush) s5-2) (enemy-option ambush))
        (format #t "ambush ")
        )
    (if (= (logand s5-2 (enemy-option user12)) (enemy-option user12))
        (format #t "user12 ")
        )
    (if (= (logand (enemy-option water) s5-2) (enemy-option water))
        (format #t "water ")
        )
    (if (= (logand s5-2 (enemy-option user14)) (enemy-option user14))
        (format #t "user14 ")
        )
    (if (= (logand (enemy-option knocked-into-water) s5-2) (enemy-option knocked-into-water))
        (format #t "knocked-into-water ")
        )
    (if (= (logand s5-2 (enemy-option user10)) (enemy-option user10))
        (format #t "user10 ")
        )
    (if (= (logand (enemy-option idle-til-trigger) s5-2) (enemy-option idle-til-trigger))
        (format #t "idle-til-trigger ")
        )
    (if (= (logand s5-2 (enemy-option user1)) (enemy-option user1))
        (format #t "user1 ")
        )
    (if (= (logand s5-2 (enemy-option user3)) (enemy-option user3))
        (format #t "user3 ")
        )
    (if (= (logand s5-2 (enemy-option user5)) (enemy-option user5))
        (format #t "user5 ")
        )
    (if (= (logand s5-2 (enemy-option user7)) (enemy-option user7))
        (format #t "user7 ")
        )
    (if (= (logand (enemy-option dormant) s5-2) (enemy-option dormant))
        (format #t "dormant ")
        )
    (if (= (logand s5-2 (enemy-option user9)) (enemy-option user9))
        (format #t "user9 ")
        )
    (if (= (logand s5-2 (enemy-option user13)) (enemy-option user13))
        (format #t "user13 ")
        )
    (if (= (logand s5-2 (enemy-option user15)) (enemy-option user15))
        (format #t "user15 ")
        )
    (if (= (logand (enemy-option has-trigger) s5-2) (enemy-option has-trigger))
        (format #t "has-trigger ")
        )
    )
  (format #t ")~%")
  (format #t "~1Ttrig-dist: (meters ~m)~%" (-> this trig-dist))
  (format #t "~1Ttrig-actor-group: #x~X~%" (-> this trig-actor-group))
  (format #t "~1Ttrig-mask-count: ~D~%" (-> this trig-mask-count))
  (format #t "~1Ttrig-mask[2] @ #x~X~%" (-> this trig-mask))
  (label cfg-114)
  this
  )

;; definition of type fact-info-crate
(deftype fact-info-crate (fact-info)
  ((suck-count  int32)
   )
  (:methods
    (new (symbol type process pickup-type float) _type_)
    )
  )

;; definition for method 3 of type fact-info-crate
(defmethod inspect ((this fact-info-crate))
  (when (not this)
    (set! this this)
    (goto cfg-62)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tprocess: ~A~%" (-> this process))
  (format #t "~1Tpickup-type: #x~X : ~S~%" (-> this pickup-type) (pickup-type->string (-> this pickup-type)))
  (format #t "~1Tpickup-amount: ~f~%" (-> this pickup-amount))
  (format #t "~1Tpickup-spawn-amount: ~f~%" (-> this pickup-spawn-amount))
  (format #t "~1Toptions: #x~X : (actor-option " (-> this options))
  (let ((s5-1 (-> this options)))
    (if (= (logand s5-1 (actor-option respawn-delay)) (actor-option respawn-delay))
        (format #t "respawn-delay ")
        )
    (if (= (logand s5-1 (actor-option draw-blocker)) (actor-option draw-blocker))
        (format #t "draw-blocker ")
        )
    (if (= (logand (actor-option user20) s5-1) (actor-option user20))
        (format #t "user20 ")
        )
    (if (= (logand (actor-option no-amb-sound) s5-1) (actor-option no-amb-sound))
        (format #t "no-amb-sound ")
        )
    (if (= (logand s5-1 (actor-option auto-pickup)) (actor-option auto-pickup))
        (format #t "auto-pickup ")
        )
    (if (= (logand (actor-option no-track) s5-1) (actor-option no-track))
        (format #t "no-track ")
        )
    (if (= (logand s5-1 (actor-option no-shadow)) (actor-option no-shadow))
        (format #t "no-shadow ")
        )
    (if (= (logand s5-1 (actor-option loop)) (actor-option loop))
        (format #t "loop ")
        )
    (if (= (logand s5-1 (actor-option fuel-cell-no-jump)) (actor-option fuel-cell-no-jump))
        (format #t "fuel-cell-no-jump ")
        )
    (if (= (logand (actor-option fall) s5-1) (actor-option fall))
        (format #t "fall ")
        )
    (if (= (logand (actor-option user18) s5-1) (actor-option user18))
        (format #t "user18 ")
        )
    (if (= (logand s5-1 (actor-option big-collision)) (actor-option big-collision))
        (format #t "big-collision ")
        )
    (if (= (logand s5-1 (actor-option no-reaction)) (actor-option no-reaction))
        (format #t "no-reaction ")
        )
    (if (= (logand s5-1 (actor-option suck-in)) (actor-option suck-in))
        (format #t "suck-in ")
        )
    (if (= (logand s5-1 (actor-option racer-only)) (actor-option racer-only))
        (format #t "racer-only ")
        )
    (if (= (logand s5-1 (actor-option blocked)) (actor-option blocked))
        (format #t "blocked ")
        )
    (if (= (logand (actor-option no-distance-check-fadeout) s5-1) (actor-option no-distance-check-fadeout))
        (format #t "no-distance-check-fadeout ")
        )
    (if (= (logand (actor-option cond-hide) s5-1) (actor-option cond-hide))
        (format #t "cond-hide ")
        )
    (if (= (logand (actor-option dont-override-fact) s5-1) (actor-option dont-override-fact))
        (format #t "dont-override-fact ")
        )
    (if (= (logand (actor-option user17) s5-1) (actor-option user17))
        (format #t "user17 ")
        )
    (if (= (logand s5-1 (actor-option wait-for-cue)) (actor-option wait-for-cue))
        (format #t "wait-for-cue ")
        )
    (if (= (logand s5-1 (actor-option reflect)) (actor-option reflect))
        (format #t "reflect ")
        )
    (if (= (logand (actor-option user19) s5-1) (actor-option user19))
        (format #t "user19 ")
        )
    (if (= (logand (actor-option cond-respawn) s5-1) (actor-option cond-respawn))
        (format #t "cond-respawn ")
        )
    (if (= (logand s5-1 (actor-option wait-for-task-complete)) (actor-option wait-for-task-complete))
        (format #t "wait-for-task-complete ")
        )
    (if (= (logand s5-1 (actor-option fade-out)) (actor-option fade-out))
        (format #t "fade-out ")
        )
    (if (= (logand (actor-option cond-low-ammo) s5-1) (actor-option cond-low-ammo))
        (format #t "cond-low-ammo ")
        )
    (if (= (logand (actor-option mirror) s5-1) (actor-option mirror))
        (format #t "mirror ")
        )
    (if (= (logand s5-1 (actor-option spawns-fuel-cell)) (actor-option spawns-fuel-cell))
        (format #t "spawns-fuel-cell ")
        )
    )
  (format #t ")~%")
  (format #t "~1Tfade-time: ~D~%" (-> this fade-time))
  (format #t "~1Tsuck-count: ~D~%" (-> this suck-count))
  (label cfg-62)
  this
  )

;; definition for method 0 of type fact-info
;; INFO: Used lq/sq
;; WARN: Return type mismatch object vs fact-info.
(defmethod new fact-info ((allocation symbol) (type-to-make type) (arg0 process) (arg1 pickup-type) (arg2 float))
  (let ((sv-16 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
    (let ((sv-20 (the-as res-lump (-> arg0 entity))))
      (let ((sv-24 (process-task-mask arg0)))
        (when (zero? sv-16)
          (go process-drawable-art-error "memory")
          (return (the-as fact-info 0))
          )
        (set! (-> sv-16 process) arg0)
        (set! (-> sv-16 pickup-type) arg1)
        (set! (-> sv-16 pickup-amount) arg2)
        (let ((s4-1 (-> (lookup-tag-idx sv-20 'eco-info 'base -1000000000.0) lo)))
          (when (>= (the-as int s4-1) 0)
            (let ((s3-0 (the-as int s4-1))
                  (s2-0 (-> sv-20 tag s4-1))
                  )
              0
              (while (= (-> s2-0 name) (-> sv-20 tag s4-1 name))
                (let ((v1-17 (make-property-data sv-20 0.0 (the-as res-tag-pair s3-0) (the-as pointer #f)))
                      (a0-7 (the int (-> s2-0 key-frame)))
                      )
                  (when (or (< a0-7 0) (and (-> arg0 entity) (logtest? sv-24 (ash 1 a0-7))))
                    (when v1-17
                      (let ((a0-15 (-> s2-0 elt-count)))
                        (set! (-> sv-16 pickup-type) (the-as pickup-type (-> (the-as (pointer int32) v1-17))))
                        (set! (-> sv-16 pickup-amount) (if (< (the-as uint 1) a0-15)
                                                           (the float (-> (the-as (pointer int32) v1-17) 1))
                                                           arg2
                                                           )
                              )
                        )
                      )
                    )
                  )
                (+! s3-0 1)
                (set! s2-0 (-> sv-20 tag s3-0))
                )
              )
            )
          )
        )
      (set! (-> sv-16 options) (res-lump-value sv-20 'options actor-option :time -1000000000.0))
      (if (logtest? (-> sv-16 options) (actor-option fade-out respawn-delay))
          (set! (-> sv-16 fade-time) (the-as time-frame (the int (* 300.0 (res-lump-float sv-20 'timeout)))))
          )
      )
    (the-as fact-info sv-16)
    )
  )

;; definition for method 11 of type fact-info
(defmethod pickup-collectable! ((this fact-info) (arg0 pickup-type) (arg1 float) (arg2 handle))
  0.0
  )

;; definition of type fact-info-enemy-defaults
(deftype fact-info-enemy-defaults (basic)
  ((idle-distance  meters)
   (pickup-type    int32)
   (pickup-amount  float)
   )
  )

;; definition for method 3 of type fact-info-enemy-defaults
(defmethod inspect ((this fact-info-enemy-defaults))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tidle-distance: (meters ~m)~%" (-> this idle-distance))
  (format #t "~1Tpickup-type: ~D~%" (-> this pickup-type))
  (format #t "~1Tpickup-amount: ~f~%" (-> this pickup-amount))
  (label cfg-4)
  this
  )

;; definition for symbol *fact-info-enemy-defaults*, type fact-info-enemy-defaults
(define *fact-info-enemy-defaults*
  (new 'static 'fact-info-enemy-defaults :idle-distance (meters 80) :pickup-type 9)
  )

;; definition for method 0 of type fact-info-enemy
;; INFO: Used lq/sq
(defmethod new fact-info-enemy ((allocation symbol) (type-to-make type) (arg0 process) (arg1 (pointer float)))
  (let ((gp-0
          (the-as
            fact-info-enemy
            ((method-of-type fact-info new) allocation type-to-make arg0 (the-as pickup-type (-> arg1 1)) (-> arg1 2))
            )
          )
        )
    (let ((s5-0 (-> gp-0 process entity)))
      (set! (-> gp-0 speed) (res-lump-float s5-0 'speed :default 1.0))
      (set! (-> gp-0 idle-distance) (res-lump-float s5-0 'idle-distance :default (-> arg1 0)))
      (set! (-> gp-0 notice-top) (res-lump-float s5-0 'notice-top :default 4096000.0))
      (set! (-> gp-0 notice-bottom) (res-lump-float s5-0 'notice-bottom :default 4096000.0))
      (set! (-> gp-0 cam-horz) (res-lump-float s5-0 'cam-horz))
      (set! (-> gp-0 cam-vert) (res-lump-float s5-0 'cam-vert))
      (set! (-> gp-0 cam-notice-dist) (res-lump-float s5-0 'cam-notice-dist :default -4096.0))
      (set! (-> gp-0 enemy-options) (res-lump-value s5-0 'enemy-options enemy-option :time -1000000000.0))
      (let ((s4-1 0))
        (let* ((sv-16 (new 'static 'res-tag))
               (v1-11 (res-lump-data s5-0 'trigger pointer :tag-ptr (& sv-16)))
               )
          (when v1-11
            (logior! (-> gp-0 enemy-options) (enemy-option has-trigger))
            (let ((a0-13 0))
              (dotimes (a1-11 (the-as int (-> sv-16 elt-count)))
                (let ((a2-12 (-> (the-as (pointer uint32) (&+ v1-11 (* a1-11 4))))))
                  (when (and (nonzero? a2-12) (< a0-13 2))
                    (set! (-> gp-0 trig-mask a0-13) a2-12)
                    (set! s4-1 (logior s4-1 a2-12))
                    (+! a0-13 1)
                    )
                  )
                )
              (set! (-> gp-0 trig-mask-count) a0-13)
              )
            )
          )
        (set! (-> gp-0 trig-dist) (if (logtest? s4-1 1)
                                      (res-lump-float s5-0 'trig-dist :default 327680.0)
                                      327680.0
                                      )
              )
        (when (logtest? s4-1 2)
          (let* ((sv-32 (new 'static 'res-tag))
                 (v1-20 (res-lump-data s5-0 'trig-ag pointer :tag-ptr (& sv-32)))
                 )
            (if (and v1-20 (nonzero? (-> sv-32 elt-count)))
                (set! (-> gp-0 trig-actor-group) (the-as (pointer actor-group) v1-20))
                (clear-mask-bits gp-0 2)
                )
            )
          )
        )
      )
    gp-0
    )
  )

;; definition for method 12 of type fact-info-enemy
;; WARN: Return type mismatch int vs none.
(defmethod clear-mask-bits ((this fact-info-enemy) (arg0 int))
  (let ((v1-0 (lognot arg0)))
    (dotimes (a1-1 (-> this trig-mask-count))
      (logand! (-> this trig-mask a1-1) v1-0)
      )
    )
  0
  (none)
  )

;; definition for method 0 of type fact-info-crate
(defmethod new fact-info-crate ((allocation symbol) (type-to-make type) (arg0 process) (arg1 pickup-type) (arg2 float))
  (let ((gp-0 (the-as fact-info-crate ((method-of-type fact-info new) allocation type-to-make arg0 arg1 arg2))))
    (let ((a0-1 (-> gp-0 process entity)))
      (set! (-> gp-0 suck-count) (res-lump-value a0-1 'suck-count int :time -1000000000.0))
      )
    gp-0
    )
  )

;; failed to figure out what this is:
0