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

;; definition of type enemy-focus
(deftype enemy-focus (focus)
  ((aware  enemy-aware)
   (flags  enemy-flag)
   )
  (:methods
    (try-update-focus (_type_ process-focusable enemy) symbol :replace)
    (enemy-focus-method-13 (_type_ process-focusable enemy-aware) symbol)
    )
  )

;; definition for method 3 of type enemy-focus
(defmethod inspect ((this enemy-focus))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-focus)
  (format #t "~1Thandle: ~D~%" (-> this handle))
  (format #t "~1Tcollide-with: ~D~%" (-> this collide-with))
  (format #t "~1Taware: ~D~%" (-> this aware))
  (format #t "~1Tflags: ~D~%" (-> this flags))
  (label cfg-4)
  this
  )

;; definition of type enemy-info
(deftype enemy-info (basic)
  ((fact-defaults                        fact-info-enemy-defaults)
   (use-die-falling                      symbol)
   (use-victory                          symbol)
   (use-jump-blocked                     symbol)
   (debug-draw-neck                      symbol)
   (jump-debug-draw                      symbol)
   (move-to-ground                       symbol)
   (hover-if-no-ground                   symbol)
   (idle-anim-script                     (pointer idle-control-frame))
   (idle-anim                            int32)
   (notice-anim                          int32)
   (hostile-anim                         int32)
   (hit-anim                             int32)
   (knocked-anim                         int32)
   (knocked-land-anim                    int32)
   (die-anim                             int32)
   (die-falling-anim                     int32)
   (victory-anim                         int32)
   (jump-wind-up-anim                    int32)
   (jump-in-air-anim                     int32)
   (jump-land-anim                       int32)
   (neck-joint                           int32)
   (look-at-joint                        int32)
   (bullseye-joint                       int32)
   (sound-hit                            sound-name)
   (sound-die                            sound-name)
   (notice-distance                      meters)
   (notice-distance-delta                meters)
   (proximity-notice-distance            meters)
   (default-hit-points                   int32)
   (gnd-collide-with                     collide-spec)
   (overlaps-others-collide-with-filter  collide-spec)
   (penetrate-flinch                     penetrate)
   (penetrate-knocked                    penetrate)
   (movement-gravity                     meters)
   (friction                             float)
   (slip-factor                          float)
   (attack-shove-back                    meters)
   (attack-shove-up                      meters)
   (attack-mode                          symbol)
   (attack-damage                        int32)
   (recover-gnd-collide-with             collide-spec)
   (jump-height-min                      meters)
   (jump-height-factor                   float)
   (knocked-seek-ry-clamp                float)
   (knocked-soft-vxz-lo                  float)
   (knocked-soft-vxz-hi                  float)
   (knocked-soft-vy-lo                   float)
   (knocked-soft-vy-hi                   float)
   (knocked-medium-vxz-lo                float)
   (knocked-medium-vxz-hi                float)
   (knocked-medium-vy-lo                 float)
   (knocked-medium-vy-hi                 float)
   (knocked-hard-vxz-lo                  float)
   (knocked-hard-vxz-hi                  float)
   (knocked-hard-vy-lo                   float)
   (knocked-hard-vy-hi                   float)
   (knocked-huge-vxz-lo                  float)
   (knocked-huge-vxz-hi                  float)
   (knocked-huge-vy-lo                   float)
   (knocked-huge-vy-hi                   float)
   (knocked-yellow-vxz-lo                float)
   (knocked-yellow-vxz-hi                float)
   (knocked-yellow-vy-lo                 float)
   (knocked-yellow-vy-hi                 float)
   (knocked-red-vxz-lo                   float)
   (knocked-red-vxz-hi                   float)
   (knocked-red-vy-lo                    float)
   (knocked-red-vy-hi                    float)
   (knocked-blue-vxz-lo                  float)
   (knocked-blue-vxz-hi                  float)
   (knocked-blue-vy-lo                   float)
   (knocked-blue-vy-hi                   float)
   (shadow-size                          meters)
   (shadow-max-y                         meters)
   (shadow-min-y                         meters)
   (shadow-locus-dist                    meters)
   (gem-joint                            int32)
   (gem-seg                              uint32)
   (gem-no-seg                           uint32)
   (gem-offset                           sphere  :inline)
   )
  (:methods
    (copy-enemy-info! (_type_ _type_) none)
    )
  )

;; definition for method 3 of type enemy-info
;; INFO: Used lq/sq
(defmethod inspect ((this enemy-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tfact-defaults: ~A~%" (-> this fact-defaults))
  (format #t "~1Tuse-die-falling: ~A~%" (-> this use-die-falling))
  (format #t "~1Tuse-victory: ~A~%" (-> this use-victory))
  (format #t "~1Tuse-jump-blocked: ~A~%" (-> this use-jump-blocked))
  (format #t "~1Tdebug-draw-neck: ~A~%" (-> this debug-draw-neck))
  (format #t "~1Tjump-debug-draw: ~A~%" (-> this jump-debug-draw))
  (format #t "~1Tmove-to-ground: ~A~%" (-> this move-to-ground))
  (format #t "~1Thover-if-no-ground: ~A~%" (-> this hover-if-no-ground))
  (format #t "~1Tidle-anim-script: #x~X~%" (-> this idle-anim-script))
  (format #t "~1Tidle-anim: ~D~%" (-> this idle-anim))
  (format #t "~1Tnotice-anim: ~D~%" (-> this notice-anim))
  (format #t "~1Thostile-anim: ~D~%" (-> this hostile-anim))
  (format #t "~1Thit-anim: ~D~%" (-> this hit-anim))
  (format #t "~1Tknocked-anim: ~D~%" (-> this knocked-anim))
  (format #t "~1Tknocked-land-anim: ~D~%" (-> this knocked-land-anim))
  (format #t "~1Tdie-anim: ~D~%" (-> this die-anim))
  (format #t "~1Tdie-falling-anim: ~D~%" (-> this die-falling-anim))
  (format #t "~1Tvictory-anim: ~D~%" (-> this victory-anim))
  (format #t "~1Tjump-wind-up-anim: ~D~%" (-> this jump-wind-up-anim))
  (format #t "~1Tjump-in-air-anim: ~D~%" (-> this jump-in-air-anim))
  (format #t "~1Tjump-land-anim: ~D~%" (-> this jump-land-anim))
  (format #t "~1Tneck-joint: ~D~%" (-> this neck-joint))
  (format #t "~1Tlook-at-joint: ~D~%" (-> this look-at-joint))
  (format #t "~1Tbullseye-joint: ~D~%" (-> this bullseye-joint))
  (format #t "~1Tsound-hit: ~D~%" (-> this sound-hit))
  (format #t "~1Tsound-die: ~D~%" (-> this sound-die))
  (format #t "~1Tnotice-distance: (meters ~m)~%" (-> this notice-distance))
  (format #t "~1Tnotice-distance-delta: (meters ~m)~%" (-> this notice-distance-delta))
  (format #t "~1Tproximity-notice-distance: (meters ~m)~%" (-> this proximity-notice-distance))
  (format #t "~1Tdefault-hit-points: ~D~%" (-> this default-hit-points))
  (format #t "~1Tgnd-collide-with: ~D~%" (-> this gnd-collide-with))
  (format #t "~1Toverlaps-others-collide-with-filter: ~D~%" (-> this overlaps-others-collide-with-filter))
  (format #t "~1Tpenetrate-flinch: ~D~%" (-> this penetrate-flinch))
  (format #t "~1Tpenetrate-knocked: ~D~%" (-> this penetrate-knocked))
  (format #t "~1Tmovement-gravity: (meters ~m)~%" (-> this movement-gravity))
  (format #t "~1Tfriction: ~f~%" (-> this friction))
  (format #t "~1Tslip-factor: ~f~%" (-> this slip-factor))
  (format #t "~1Tattack-shove-back: (meters ~m)~%" (-> this attack-shove-back))
  (format #t "~1Tattack-shove-up: (meters ~m)~%" (-> this attack-shove-up))
  (format #t "~1Tattack-mode: ~A~%" (-> this attack-mode))
  (format #t "~1Tattack-damage: ~D~%" (-> this attack-damage))
  (format #t "~1Trecover-gnd-collide-with: ~D~%" (-> this recover-gnd-collide-with))
  (format #t "~1Tjump-height-min: (meters ~m)~%" (-> this jump-height-min))
  (format #t "~1Tjump-height-factor: ~f~%" (-> this jump-height-factor))
  (format #t "~1Tknocked-seek-ry-clamp: ~f~%" (-> this knocked-seek-ry-clamp))
  (format #t "~1Tknocked-soft-vxz-lo: ~f~%" (-> this knocked-soft-vxz-lo))
  (format #t "~1Tknocked-soft-vxz-hi: ~f~%" (-> this knocked-soft-vxz-hi))
  (format #t "~1Tknocked-soft-vy-lo: ~f~%" (-> this knocked-soft-vy-lo))
  (format #t "~1Tknocked-soft-vy-hi: ~f~%" (-> this knocked-soft-vy-hi))
  (format #t "~1Tknocked-medium-vxz-lo: ~f~%" (-> this knocked-medium-vxz-lo))
  (format #t "~1Tknocked-medium-vxz-hi: ~f~%" (-> this knocked-medium-vxz-hi))
  (format #t "~1Tknocked-medium-vy-lo: ~f~%" (-> this knocked-medium-vy-lo))
  (format #t "~1Tknocked-medium-vy-hi: ~f~%" (-> this knocked-medium-vy-hi))
  (format #t "~1Tknocked-hard-vxz-lo: ~f~%" (-> this knocked-hard-vxz-lo))
  (format #t "~1Tknocked-hard-vxz-hi: ~f~%" (-> this knocked-hard-vxz-hi))
  (format #t "~1Tknocked-hard-vy-lo: ~f~%" (-> this knocked-hard-vy-lo))
  (format #t "~1Tknocked-hard-vy-hi: ~f~%" (-> this knocked-hard-vy-hi))
  (format #t "~1Tknocked-huge-vxz-lo: ~f~%" (-> this knocked-huge-vxz-lo))
  (format #t "~1Tknocked-huge-vxz-hi: ~f~%" (-> this knocked-huge-vxz-hi))
  (format #t "~1Tknocked-huge-vy-lo: ~f~%" (-> this knocked-huge-vy-lo))
  (format #t "~1Tknocked-huge-vy-hi: ~f~%" (-> this knocked-huge-vy-hi))
  (format #t "~1Tknocked-yellow-vxz-lo: ~f~%" (-> this knocked-yellow-vxz-lo))
  (format #t "~1Tknocked-yellow-vxz-hi: ~f~%" (-> this knocked-yellow-vxz-hi))
  (format #t "~1Tknocked-yellow-vy-lo: ~f~%" (-> this knocked-yellow-vy-lo))
  (format #t "~1Tknocked-yellow-vy-hi: ~f~%" (-> this knocked-yellow-vy-hi))
  (format #t "~1Tknocked-red-vxz-lo: ~f~%" (-> this knocked-red-vxz-lo))
  (format #t "~1Tknocked-red-vxz-hi: ~f~%" (-> this knocked-red-vxz-hi))
  (format #t "~1Tknocked-red-vy-lo: ~f~%" (-> this knocked-red-vy-lo))
  (format #t "~1Tknocked-red-vy-hi: ~f~%" (-> this knocked-red-vy-hi))
  (format #t "~1Tknocked-blue-vxz-lo: ~f~%" (-> this knocked-blue-vxz-lo))
  (format #t "~1Tknocked-blue-vxz-hi: ~f~%" (-> this knocked-blue-vxz-hi))
  (format #t "~1Tknocked-blue-vy-lo: ~f~%" (-> this knocked-blue-vy-lo))
  (format #t "~1Tknocked-blue-vy-hi: ~f~%" (-> this knocked-blue-vy-hi))
  (format #t "~1Tshadow-size: (meters ~m)~%" (-> this shadow-size))
  (format #t "~1Tshadow-max-y: (meters ~m)~%" (-> this shadow-max-y))
  (format #t "~1Tshadow-min-y: (meters ~m)~%" (-> this shadow-min-y))
  (format #t "~1Tshadow-locus-dist: (meters ~m)~%" (-> this shadow-locus-dist))
  (format #t "~1Tgem-joint: ~D~%" (-> this gem-joint))
  (format #t "~1Tgem-seg: ~D~%" (-> this gem-seg))
  (format #t "~1Tgem-no-seg: ~D~%" (-> this gem-no-seg))
  (format #t "~1Tgem-offset: #<sphere @ #x~X>~%" (-> this gem-offset))
  (label cfg-4)
  this
  )

;; definition of type enemy-knocked-info
(deftype enemy-knocked-info (structure)
  ((anim-speed          float)
   (on-surface-count    int32)
   (move-count          int32)
   (land-can-land-time  time-frame)
   )
  )

;; definition for method 3 of type enemy-knocked-info
(defmethod inspect ((this enemy-knocked-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-knocked-info)
  (format #t "~1Tanim-speed: ~f~%" (-> this anim-speed))
  (format #t "~1Ton-surface-count: ~D~%" (-> this on-surface-count))
  (format #t "~1Tmove-count: ~D~%" (-> this move-count))
  (format #t "~1Tland-can-land-time: ~D~%" (-> this land-can-land-time))
  (label cfg-4)
  this
  )

;; definition of type enemy-jump-info
(deftype enemy-jump-info (structure)
  ((flags       enemy-jump-flags)
   (anim-speed  float)
   (hang-time   time-frame)
   (start-pos   vector      :inline)
   (dest-pos    vector      :inline)
   (traj        trajectory  :inline)
   )
  )

;; definition for method 3 of type enemy-jump-info
(defmethod inspect ((this enemy-jump-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-jump-info)
  (format #t "~1Tflags: ~D~%" (-> this flags))
  (format #t "~1Tanim-speed: ~f~%" (-> this anim-speed))
  (format #t "~1Thang-time: ~D~%" (-> this hang-time))
  (format #t "~1Tstart-pos: #<vector @ #x~X>~%" (-> this start-pos))
  (format #t "~1Tdest-pos: #<vector @ #x~X>~%" (-> this dest-pos))
  (format #t "~1Ttraj: #<trajectory @ #x~X>~%" (-> this traj))
  (label cfg-4)
  this
  )

;; definition of type enemy-init-by-other-params
(deftype enemy-init-by-other-params (structure)
  ((trans                       vector      :inline)
   (quat                        quaternion  :inline)
   (entity                      entity)
   (directed?                   symbol)
   (no-initial-move-to-ground?  symbol)
   )
  )

;; definition for method 3 of type enemy-init-by-other-params
(defmethod inspect ((this enemy-init-by-other-params))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-init-by-other-params)
  (format #t "~1Ttrans: #<vector @ #x~X>~%" (-> this trans))
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
  (format #t "~1Tentity: ~A~%" (-> this entity))
  (format #t "~1Tdirected?: ~A~%" (-> this directed?))
  (format #t "~1Tno-initial-move-to-ground?: ~A~%" (-> this no-initial-move-to-ground?))
  (label cfg-4)
  this
  )

;; definition of type enemy-attack-info
(deftype enemy-attack-info (structure)
  ((attack-id          uint32)
   (knocked-type       knocked-type)
   (blue-juggle-count  uint8)
   (attacker-handle    handle)
   (attack-time        time-frame)
   (penetrate-using    penetrate)
   (attacker-pos       vector  :inline)
   (attack-direction   vector  :inline)
   )
  )

;; definition for method 3 of type enemy-attack-info
(defmethod inspect ((this enemy-attack-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-attack-info)
  (format #t "~1Tattack-id: ~D~%" (-> this attack-id))
  (format #t "~1Tknocked-type: ~D~%" (-> this knocked-type))
  (format #t "~1Tblue-juggle-count: ~D~%" (-> this blue-juggle-count))
  (format #t "~1Tattacker-handle: ~D~%" (-> this attacker-handle))
  (format #t "~1Tattack-time: ~D~%" (-> this attack-time))
  (format #t "~1Tpenetrate-using: ~D~%" (-> this penetrate-using))
  (format #t "~1Tattacker-pos: ~`vector`P~%" (-> this attacker-pos))
  (format #t "~1Tattack-direction: ~`vector`P~%" (-> this attack-direction))
  (label cfg-4)
  this
  )

;; definition of type enemy-best-focus
(deftype enemy-best-focus (structure)
  ((proc    process)
   (rating  float)
   (aware   enemy-aware)
   )
  )

;; definition for method 3 of type enemy-best-focus
(defmethod inspect ((this enemy-best-focus))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'enemy-best-focus)
  (format #t "~1Tproc: ~A~%" (-> this proc))
  (format #t "~1Trating: ~f~%" (-> this rating))
  (format #t "~1Taware: ~D~%" (-> this aware))
  (label cfg-4)
  this
  )

;; definition of type enemy
(deftype enemy (process-focusable)
  ((root                       collide-shape-moving :override)
   (fact                       fact-info-enemy      :override)
   (enemy-flags                enemy-flag)
   (enemy-info                 enemy-info)
   (hit-points                 int32)
   (gnd-collide                uint32)
   (attack-id                  uint32)
   (persistent-attack-id       uint32)
   (water-max-height           meters)
   (water-surface-height       meters)
   (desired-angle              degrees)
   (jump-why                   uint64)
   (penetrated-by-all          penetrate)
   (penetrated-flinch          penetrate)
   (penetrated-knocked         penetrate)
   (reaction-time              time-frame)
   (notice-time                time-frame)
   (state-timeout              time-frame)
   (auto-reset-penetrate-time  time-frame)
   (hit-focus-time             time-frame)
   (last-draw-time             time-frame)
   (starting-time              time-frame)
   (fated-time                 time-frame)
   (focus-pos                  vector                :inline)
   (event-param-point          vector                :inline)
   (jump-dest                  vector                :inline :overlay-at event-param-point)
   (focus                      enemy-focus           :inline)
   (incoming                   enemy-attack-info     :inline)
   (actor-group                (pointer actor-group))
   (actor-group-count          int32)
   (neck                       joint-mod)
   (on-notice                  pair)
   (on-active                  pair)
   (on-hostile                 pair)
   (on-death                   pair)
   (idle-anim-player           idle-control          :inline)
   (rand-gen                   symbol)
   )
  (:state-methods
    dormant
    dormant-aware
    hit
    knocked
    idle
    active
    notice
    flee
    stare
    hostile
    victory
    die
    die-falling
    die-fast
    directed
    jump
    jump-blocked
    ambush
    view-anims
    )
  (:methods
    (enemy-method-46 (_type_ int) none)
    (enemy-method-47 (_type_ vector) float)
    (take-damage-from-attack (_type_ process event-message-block) int)
    (enemy-method-49 (_type_) time-frame :behavior enemy)
    (enemy-method-50 (_type_ vector) vector)
    (enemy-method-51 (_type_) float)
    (enemy-method-52 (_type_ vector) none)
    (enemy-method-53 (_type_ process-focusable) symbol)
    (enemy-method-54 (_type_) enemy-flag)
    (common-post (_type_) none)
    (damage-amount-from-attack (_type_ process event-message-block) int)
    (update-target-awareness! (_type_ process-focusable enemy-best-focus) enemy-aware)
    (enemy-method-58 (_type_ process event-message-block) symbol)
    (get-penetrate-info (_type_) penetrate)
    (coin-flip? (_type_) symbol)
    (enemy-method-61 (_type_ int) int :behavior enemy)
    (enemy-method-62 (_type_) none)
    (enemy-method-63 (_type_ process-focusable enemy-aware) symbol)
    (go-dormant (_type_) object)
    (go-dormant-aware (_type_) object)
    (go-ambush (_type_) object)
    (go-stare (_type_) object)
    (go-stare2 (_type_) object)
    (go-directed (_type_) object)
    (go-hostile (_type_) object)
    (go-flee (_type_) object)
    (react-to-focus (_type_) object)
    (kill-prefer-falling (_type_) object)
    (general-event-handler (_type_ process int symbol event-message-block) object)
    (enemy-method-75 (_type_ process event-message-block) object)
    (enemy-method-76 (_type_ process event-message-block) symbol)
    (enemy-method-77 (_type_ enemy-knocked-info) symbol)
    (enemy-method-78 (_type_ enemy-knocked-info) symbol)
    (enemy-method-79 (_type_ int enemy-knocked-info) symbol)
    (enemy-method-80 (_type_ enemy-knocked-info) symbol)
    (enemy-method-81 (_type_) symbol)
    (enemy-method-82 (_type_ enemy-jump-info) symbol)
    (enemy-method-83 (_type_ enemy-jump-info) none)
    (enemy-method-84 (_type_ enemy-jump-info) none)
    (enemy-method-85 (_type_) float)
    (enemy-method-86 (_type_) symbol)
    (enemy-method-87 (_type_ enemy-jump-info) symbol)
    (enemy-method-88 (_type_ enemy-jump-info) symbol)
    (enemy-method-89 (_type_ enemy-jump-info) symbol)
    (enemy-method-90 (_type_ int enemy-jump-info) symbol)
    (enemy-method-91 (_type_ int enemy-jump-info) none)
    (enemy-method-92 (_type_ int enemy-jump-info) none)
    (enemy-method-93 (_type_) none)
    (enemy-method-94 (_type_ vector float) symbol)
    (enemy-method-95 (_type_ vector float) symbol)
    (enemy-method-96 (_type_ float symbol) symbol)
    (enemy-method-97 (_type_) process)
    (in-aggro-range? (_type_ process-focusable vector) symbol)
    (enemy-method-99 (_type_ process-focusable) symbol)
    (enemy-method-100 (_type_) symbol)
    (enemy-method-101 (_type_) none)
    (enemy-method-102 (_type_) symbol)
    (enemy-method-103 (_type_) collide-spec)
    (enemy-method-104 (_type_ process touching-shapes-entry uint) symbol :behavior process)
    (enemy-method-105 (_type_ process) enemy-flag)
    (set-incoming-attack-info (_type_ process object penetrate attack-info) none :behavior enemy)
    (get-enemy-target (_type_) process-focusable)
    (enemy-method-108 (_type_ process-drawable event-message-block) int)
    (look-at-target! (_type_ enemy-flag) none)
    (stop-looking-at-target! (_type_) none)
    (enemy-method-111 (_type_) none :behavior enemy)
    (set-enemy-info! (_type_ enemy-info) none)
    (init-enemy-behaviour-and-stats! (_type_ enemy-info) none)
    (init-enemy-collision! (_type_) none)
    (init-enemy! (_type_) none)
    (go-idle (_type_) none)
    (rnd-float (_type_) float)
    (rnd-float-range (_type_ float float) float)
    (rnd-int-count (_type_ int) int)
    (rnd-bit (_type_ int int) int)
    (rnd-int-range (_type_ int int) int)
    (rnd-percent? (_type_ float) symbol)
    (rnd-go-idle? (_type_ float) symbol)
    (enemy-method-124 (_type_) collide-spec)
    (ground-pat-set! (_type_ collide-query collide-spec float float float) pat-surface)
    (enemy-above-ground? (_type_ collide-query vector collide-spec float float float) symbol)
    (enemy-method-127 (_type_ float float symbol collide-spec) symbol)
    (enemy-method-128 (_type_ vector move-above-ground-params) none)
    (enemy-method-129 (_type_) none)
    (enemy-method-130 (_type_ float) symbol)
    (penetrate-using->knocked (_type_ penetrate) knocked-type)
    (dying (_type_) none)
    (enemy-method-133 (_type_) symbol)
    (get-attacker (_type_ process attack-info) process-focusable)
    (enemy-method-135 (_type_ int) sound-id)
    (enemy-method-136 (_type_) enemy-flag)
    )
  )

;; definition for method 3 of type enemy
(defmethod inspect ((this enemy))
  (when (not this)
    (set! this this)
    (goto cfg-79)
    )
  (let ((t9-0 (method-of-type process-focusable inspect)))
    (t9-0 this)
    )
  (format #t "~2Tenemy-flags: #x~X : (enemy-flag " (-> this enemy-flags))
  (let ((s5-0 (-> this enemy-flags)))
    (if (= (logand (enemy-flag lock-focus) s5-0) (enemy-flag lock-focus))
        (format #t "lock-focus ")
        )
    (if (= (logand (enemy-flag death-start) s5-0) (shl 8 32))
        (format #t "death-start ")
        )
    (if (= (logand s5-0 (enemy-flag enable-on-active)) (enemy-flag enable-on-active))
        (format #t "enable-on-active ")
        )
    (if (= (logand (enemy-flag checking-water) s5-0) (enemy-flag checking-water))
        (format #t "checking-water ")
        )
    (if (= (logand (enemy-flag check-water) s5-0) (enemy-flag check-water))
        (format #t "check-water ")
        )
    (if (= (logand (enemy-flag spawn-gem) s5-0) (enemy-flag spawn-gem))
        (format #t "spawn-gem ")
        )
    (if (= (logand (enemy-flag chase-startup) s5-0) (enemy-flag chase-startup))
        (format #t "chase-startup ")
        )
    (if (= (logand s5-0 (enemy-flag attackable-backup)) (enemy-flag attackable-backup))
        (format #t "attackable-backup ")
        )
    (if (= (logand s5-0 (enemy-flag look-at-focus)) (enemy-flag look-at-focus))
        (format #t "look-at-focus ")
        )
    (if (= (logand s5-0 (enemy-flag use-notice-distance)) (enemy-flag use-notice-distance))
        (format #t "use-notice-distance ")
        )
    (if (= (logand s5-0 (enemy-flag enable-on-notice)) (enemy-flag enable-on-notice))
        (format #t "enable-on-notice ")
        )
    (if (= (logand s5-0 (enemy-flag look-at-move-dest)) (enemy-flag look-at-move-dest))
        (format #t "look-at-move-dest ")
        )
    (if (= (logand s5-0 (enemy-flag notice)) (enemy-flag notice))
        (format #t "notice ")
        )
    (if (= (logand s5-0 (enemy-flag auto-reset-penetrate)) (enemy-flag auto-reset-penetrate))
        (format #t "auto-reset-penetrate ")
        )
    (if (= (logand (enemy-flag jump-check-blocked) s5-0) (shl 4 32))
        (format #t "jump-check-blocked ")
        )
    (if (= (logand (enemy-flag drawn-mirrored) s5-0) (shl #x8000 16))
        (format #t "drawn-mirrored ")
        )
    (if (= (logand (enemy-flag multi-focus) s5-0) (enemy-flag multi-focus))
        (format #t "multi-focus ")
        )
    (if (= (logand s5-0 (enemy-flag alert)) (enemy-flag alert))
        (format #t "alert ")
        )
    (if (= (logand s5-0 (enemy-flag victory)) (enemy-flag victory))
        (format #t "victory ")
        )
    (if (= (logand s5-0 (enemy-flag dangerous-backup)) (enemy-flag dangerous-backup))
        (format #t "dangerous-backup ")
        )
    (if (= (logand s5-0 (enemy-flag actor-pause-backup)) (enemy-flag actor-pause-backup))
        (format #t "actor-pause-backup ")
        )
    (if (= (logand (enemy-flag trackable) s5-0) (enemy-flag trackable))
        (format #t "trackable ")
        )
    (if (= (logand (enemy-flag called-dying) s5-0) (shl 1 32))
        (format #t "called-dying ")
        )
    (if (= (logand (enemy-flag check-water-backup) s5-0) (enemy-flag check-water-backup))
        (format #t "check-water-backup ")
        )
    (if (= (logand (enemy-flag no-initial-move-to-ground) s5-0) (shl 2 32))
        (format #t "no-initial-move-to-ground ")
        )
    (if (= (logand s5-0 (enemy-flag cam-attack-mode)) (enemy-flag cam-attack-mode))
        (format #t "cam-attack-mode ")
        )
    (if (= (logand (enemy-flag trackable-backup) s5-0) (enemy-flag trackable-backup))
        (format #t "trackable-backup ")
        )
    (if (= (logand s5-0 (enemy-flag enable-on-hostile)) (enemy-flag enable-on-hostile))
        (format #t "enable-on-hostile ")
        )
    (if (= (logand (enemy-flag directed-ready) s5-0) (enemy-flag directed-ready))
        (format #t "directed-ready ")
        )
    (if (= (logand (enemy-flag use-trigger) s5-0) (enemy-flag use-trigger))
        (format #t "use-trigger ")
        )
    (if (= (logand (enemy-flag directed) s5-0) (enemy-flag directed))
        (format #t "directed ")
        )
    (if (= (logand (enemy-flag dislike-combo) s5-0) (enemy-flag dislike-combo))
        (format #t "dislike-combo ")
        )
    (if (= (logand (enemy-flag recover-applied-velocity) s5-0) (enemy-flag recover-applied-velocity))
        (format #t "recover-applied-velocity ")
        )
    (if (= (logand s5-0 (enemy-flag vulnerable-backup)) (enemy-flag vulnerable-backup))
        (format #t "vulnerable-backup ")
        )
    (if (= (logand s5-0 (enemy-flag vulnerable)) (enemy-flag vulnerable))
        (format #t "vulnerable ")
        )
    (if (= (logand (enemy-flag recover) s5-0) (enemy-flag recover))
        (format #t "recover ")
        )
    )
  (format #t ")~%")
  (format #t "~2Tenemy-info: ~A~%" (-> this enemy-info))
  (format #t "~2Thit-points: ~D~%" (-> this hit-points))
  (format #t "~2Tgnd-collide-with: ~D~%" (-> this gnd-collide))
  (format #t "~2Tattack-id: ~D~%" (-> this attack-id))
  (format #t "~2Tpersistent-attack-id: ~D~%" (-> this persistent-attack-id))
  (format #t "~2Twater-max-height: ~f~%" (-> this water-max-height))
  (format #t "~2Twater-surface-height: ~f~%" (-> this water-surface-height))
  (format #t "~2Tdesired-angle: ~f~%" (-> this desired-angle))
  (format #t "~2Tjump-why: ~D~%" (-> this jump-why))
  (format #t "~2Tpenetrated-by-all: ~D~%" (-> this penetrated-by-all))
  (format #t "~2Tpenetrate-flinch: ~D~%" (-> this penetrated-flinch))
  (format #t "~2Tpenetrate-knocked: ~D~%" (-> this penetrated-knocked))
  (format #t "~2Treaction-time: ~D~%" (-> this reaction-time))
  (format #t "~2Tnotice-time: ~D~%" (-> this notice-time))
  (format #t "~2Tstate-timeout: ~D~%" (-> this state-timeout))
  (format #t "~2Tauto-reset-penetrate-time: ~D~%" (-> this auto-reset-penetrate-time))
  (format #t "~2Thit-focus-time: ~D~%" (-> this hit-focus-time))
  (format #t "~2Tlast-draw-time: ~D~%" (-> this last-draw-time))
  (format #t "~2Tstarting-time: ~D~%" (-> this starting-time))
  (format #t "~2Tfated-time: ~D~%" (-> this fated-time))
  (format #t "~2Tfocus-pos: ~`vector`P~%" (-> this focus-pos))
  (format #t "~2Tevent-param-point: ~`vector`P~%" (-> this event-param-point))
  (format #t "~2Tjump-dest: ~`vector`P~%" (-> this event-param-point))
  (format #t "~2Tfocus: #<enemy-focus @ #x~X>~%" (-> this focus))
  (format #t "~2Tincoming: #<enemy-attack-info @ #x~X>~%" (-> this incoming))
  (format #t "~2Tactor-group: #x~X~%" (-> this actor-group))
  (dotimes (s5-1 (-> this actor-group-count))
    (format #t "~T  [~D]~2Tactor-group: ~`actor-group`P~%" s5-1 (-> this actor-group s5-1))
    )
  (format #t "~2Tactor-group-count: ~D~%" (-> this actor-group-count))
  (format #t "~2Tneck: ~A~%" (-> this neck))
  (format #t "~2Ton-notice: ~A~%" (-> this on-notice))
  (format #t "~2Ton-active: ~A~%" (-> this on-active))
  (format #t "~2Ton-hostile: ~A~%" (-> this on-hostile))
  (format #t "~2Ton-death: ~A~%" (-> this on-death))
  (format #t "~2Tidle-anim-player: #<idle-control @ #x~X>~%" (-> this idle-anim-player))
  (format #t "~2Trand-gen: ~A~%" (-> this rand-gen))
  (label cfg-79)
  this
  )

;; definition of type anim-info
(deftype anim-info (structure)
  ((anim-index    int32)
   (travel-speed  meters)
   )
  )

;; definition for method 3 of type anim-info
(defmethod inspect ((this anim-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'anim-info)
  (format #t "~1Tanim-index: ~D~%" (-> this anim-index))
  (format #t "~1Ttravel-speed: (meters ~m)~%" (-> this travel-speed))
  (label cfg-4)
  this
  )

;; definition for method 12 of type enemy-focus
(defmethod try-update-focus ((this enemy-focus) (arg0 process-focusable) (arg1 enemy))
  (let* ((t9-0 (method-of-type focus try-update-focus))
         (s3-0 (t9-0 this arg0))
         )
    (when (not s3-0)
      (logclear! (-> this flags) (enemy-flag look-at-focus))
      (set! (-> this aware)
            (the-as
              enemy-aware
              (enemy-method-61 arg1 (the-as int (update-target-awareness! arg1 arg0 (the-as enemy-best-focus #f))))
              )
            )
      )
    s3-0
    )
  )

;; definition for method 13 of type enemy-focus
(defmethod enemy-focus-method-13 ((this enemy-focus) (arg0 process-focusable) (arg1 enemy-aware))
  (let* ((t9-0 (method-of-type focus try-update-focus))
         (v0-0 (t9-0 this arg0))
         )
    (set! (-> this aware) arg1)
    (if (not v0-0)
        (logclear! (-> this flags) (enemy-flag look-at-focus))
        )
    v0-0
    )
  )

;; definition for method 9 of type enemy-focus
;; WARN: Return type mismatch enemy-flag vs none.
(defmethod clear-focused ((this enemy-focus))
  "Reset the focus' handle."
  (let ((t9-0 (method-of-type focus clear-focused)))
    (t9-0 this)
    )
  (set! (-> this aware) (enemy-aware enemy-aware-0))
  (logclear! (-> this flags) (enemy-flag look-at-focus))
  (none)
  )