mirror of
https://github.com/open-goal/jak-project
synced 2026-07-30 16:04:33 -04:00
Hat Kid
fc43870d85
This renames the method object in `defmethod`s to `this` and adds detection for the `set-time!` and `time-elapsed?` macros. Definitely my biggest PR yet...
749 lines
37 KiB
Common Lisp
Vendored
Generated
749 lines
37 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type enemy-focus
|
|
(deftype enemy-focus (focus)
|
|
((aware enemy-aware :offset-assert 16)
|
|
(flags enemy-flag :offset-assert 24)
|
|
)
|
|
:method-count-assert 14
|
|
:size-assert #x20
|
|
:flag-assert #xe00000020
|
|
(:methods
|
|
(try-update-focus (_type_ process-focusable enemy) symbol :replace 12)
|
|
(enemy-focus-method-13 (_type_ process-focusable enemy-aware) symbol 13)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-focus
|
|
(defmethod inspect enemy-focus ((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 :offset-assert 4)
|
|
(use-die-falling symbol :offset-assert 8)
|
|
(use-victory symbol :offset-assert 12)
|
|
(use-jump-blocked symbol :offset-assert 16)
|
|
(debug-draw-neck symbol :offset-assert 20)
|
|
(jump-debug-draw symbol :offset-assert 24)
|
|
(move-to-ground symbol :offset-assert 28)
|
|
(hover-if-no-ground symbol :offset-assert 32)
|
|
(idle-anim-script (pointer idle-control-frame) :offset-assert 36)
|
|
(idle-anim int32 :offset-assert 40)
|
|
(notice-anim int32 :offset-assert 44)
|
|
(hostile-anim int32 :offset-assert 48)
|
|
(hit-anim int32 :offset-assert 52)
|
|
(knocked-anim int32 :offset-assert 56)
|
|
(knocked-land-anim int32 :offset-assert 60)
|
|
(die-anim int32 :offset-assert 64)
|
|
(die-falling-anim int32 :offset-assert 68)
|
|
(victory-anim int32 :offset-assert 72)
|
|
(jump-wind-up-anim int32 :offset-assert 76)
|
|
(jump-in-air-anim int32 :offset-assert 80)
|
|
(jump-land-anim int32 :offset-assert 84)
|
|
(neck-joint int32 :offset-assert 88)
|
|
(look-at-joint int32 :offset-assert 92)
|
|
(bullseye-joint int32 :offset-assert 96)
|
|
(sound-hit sound-name :offset-assert 112)
|
|
(sound-die sound-name :offset-assert 128)
|
|
(notice-distance meters :offset-assert 144)
|
|
(notice-distance-delta meters :offset-assert 148)
|
|
(proximity-notice-distance meters :offset-assert 152)
|
|
(default-hit-points int32 :offset-assert 156)
|
|
(gnd-collide-with collide-spec :offset-assert 160)
|
|
(overlaps-others-collide-with-filter collide-spec :offset-assert 164)
|
|
(penetrate-flinch penetrate :offset-assert 168)
|
|
(penetrate-knocked penetrate :offset-assert 176)
|
|
(movement-gravity meters :offset-assert 184)
|
|
(friction float :offset-assert 188)
|
|
(slip-factor float :offset-assert 192)
|
|
(attack-shove-back meters :offset-assert 196)
|
|
(attack-shove-up meters :offset-assert 200)
|
|
(attack-mode symbol :offset-assert 204)
|
|
(attack-damage int32 :offset-assert 208)
|
|
(recover-gnd-collide-with collide-spec :offset-assert 212)
|
|
(jump-height-min meters :offset-assert 216)
|
|
(jump-height-factor float :offset-assert 220)
|
|
(knocked-seek-ry-clamp float :offset-assert 224)
|
|
(knocked-soft-vxz-lo float :offset-assert 228)
|
|
(knocked-soft-vxz-hi float :offset-assert 232)
|
|
(knocked-soft-vy-lo float :offset-assert 236)
|
|
(knocked-soft-vy-hi float :offset-assert 240)
|
|
(knocked-medium-vxz-lo float :offset-assert 244)
|
|
(knocked-medium-vxz-hi float :offset-assert 248)
|
|
(knocked-medium-vy-lo float :offset-assert 252)
|
|
(knocked-medium-vy-hi float :offset-assert 256)
|
|
(knocked-hard-vxz-lo float :offset-assert 260)
|
|
(knocked-hard-vxz-hi float :offset-assert 264)
|
|
(knocked-hard-vy-lo float :offset-assert 268)
|
|
(knocked-hard-vy-hi float :offset-assert 272)
|
|
(knocked-huge-vxz-lo float :offset-assert 276)
|
|
(knocked-huge-vxz-hi float :offset-assert 280)
|
|
(knocked-huge-vy-lo float :offset-assert 284)
|
|
(knocked-huge-vy-hi float :offset-assert 288)
|
|
(knocked-yellow-vxz-lo float :offset-assert 292)
|
|
(knocked-yellow-vxz-hi float :offset-assert 296)
|
|
(knocked-yellow-vy-lo float :offset-assert 300)
|
|
(knocked-yellow-vy-hi float :offset-assert 304)
|
|
(knocked-red-vxz-lo float :offset-assert 308)
|
|
(knocked-red-vxz-hi float :offset-assert 312)
|
|
(knocked-red-vy-lo float :offset-assert 316)
|
|
(knocked-red-vy-hi float :offset-assert 320)
|
|
(knocked-blue-vxz-lo float :offset-assert 324)
|
|
(knocked-blue-vxz-hi float :offset-assert 328)
|
|
(knocked-blue-vy-lo float :offset-assert 332)
|
|
(knocked-blue-vy-hi float :offset-assert 336)
|
|
(shadow-size meters :offset-assert 340)
|
|
(shadow-max-y meters :offset-assert 344)
|
|
(shadow-min-y meters :offset-assert 348)
|
|
(shadow-locus-dist meters :offset-assert 352)
|
|
(gem-joint int32 :offset-assert 356)
|
|
(gem-seg uint32 :offset-assert 360)
|
|
(gem-no-seg uint32 :offset-assert 364)
|
|
(gem-offset sphere :inline :offset-assert 368)
|
|
)
|
|
:method-count-assert 10
|
|
:size-assert #x180
|
|
:flag-assert #xa00000180
|
|
(:methods
|
|
(copy-enemy-info! (_type_ _type_) none 9)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-info
|
|
;; INFO: Used lq/sq
|
|
(defmethod inspect enemy-info ((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 :offset-assert 0)
|
|
(on-surface-count int32 :offset-assert 4)
|
|
(move-count int32 :offset-assert 8)
|
|
(land-can-land-time time-frame :offset-assert 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x18
|
|
:flag-assert #x900000018
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-knocked-info
|
|
(defmethod inspect enemy-knocked-info ((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 uint8 :offset-assert 0)
|
|
(anim-speed float :offset-assert 4)
|
|
(hang-time time-frame :offset-assert 8)
|
|
(start-pos vector :inline :offset-assert 16)
|
|
(dest-pos vector :inline :offset-assert 32)
|
|
(traj trajectory :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x58
|
|
:flag-assert #x900000058
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-jump-info
|
|
(defmethod inspect enemy-jump-info ((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 :offset-assert 0)
|
|
(quat quaternion :inline :offset-assert 16)
|
|
(entity entity :offset-assert 32)
|
|
(directed? symbol :offset-assert 36)
|
|
(no-initial-move-to-ground? symbol :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-init-by-other-params
|
|
(defmethod inspect enemy-init-by-other-params ((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 :offset-assert 0)
|
|
(knocked-type knocked-type :offset-assert 4)
|
|
(blue-juggle-count uint8 :offset-assert 5)
|
|
(attacker-handle handle :offset-assert 8)
|
|
(attack-time time-frame :offset-assert 16)
|
|
(penetrate-using uint64 :offset-assert 24)
|
|
(attacker-pos vector :inline :offset-assert 32)
|
|
(attack-direction vector :inline :offset-assert 48)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x40
|
|
:flag-assert #x900000040
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-attack-info
|
|
(defmethod inspect enemy-attack-info ((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 :offset-assert 0)
|
|
(rating float :offset-assert 4)
|
|
(aware enemy-aware :offset-assert 8)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|
|
;; definition for method 3 of type enemy-best-focus
|
|
(defmethod inspect enemy-best-focus ((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 :offset-assert 208)
|
|
(enemy-info enemy-info :offset-assert 216)
|
|
(hit-points int32 :offset-assert 220)
|
|
(gnd-collide uint32 :offset-assert 224)
|
|
(attack-id uint32 :offset-assert 228)
|
|
(persistent-attack-id uint32 :offset-assert 232)
|
|
(water-max-height meters :offset-assert 236)
|
|
(water-surface-height meters :offset-assert 240)
|
|
(desired-angle degrees :offset-assert 244)
|
|
(jump-why uint64 :offset-assert 248)
|
|
(penetrated-by-all penetrate :offset-assert 256)
|
|
(penetrated-flinch penetrate :offset-assert 264)
|
|
(penetrated-knocked penetrate :offset-assert 272)
|
|
(reaction-time time-frame :offset-assert 280)
|
|
(notice-time time-frame :offset-assert 288)
|
|
(state-timeout time-frame :offset-assert 296)
|
|
(auto-reset-penetrate-time time-frame :offset-assert 304)
|
|
(hit-focus-time time-frame :offset-assert 312)
|
|
(last-draw-time time-frame :offset-assert 320)
|
|
(starting-time time-frame :offset-assert 328)
|
|
(fated-time time-frame :offset-assert 336)
|
|
(focus-pos vector :inline :offset-assert 352)
|
|
(event-param-point vector :inline :offset-assert 368)
|
|
(jump-dest vector :inline :offset 368)
|
|
(focus enemy-focus :inline :offset-assert 384)
|
|
(incoming enemy-attack-info :inline :offset-assert 416)
|
|
(actor-group (pointer actor-group) :offset-assert 480)
|
|
(actor-group-count int32 :offset-assert 484)
|
|
(neck joint-mod :offset-assert 488)
|
|
(on-notice symbol :offset-assert 492)
|
|
(on-active symbol :offset-assert 496)
|
|
(on-hostile symbol :offset-assert 500)
|
|
(on-death symbol :offset-assert 504)
|
|
(idle-anim-player idle-control :inline :offset-assert 512)
|
|
(rand-gen symbol :offset-assert 528)
|
|
)
|
|
:heap-base #x1a0
|
|
:method-count-assert 137
|
|
:size-assert #x214
|
|
:flag-assert #x8901a00214
|
|
(:methods
|
|
(dormant () _type_ :state 27)
|
|
(dormant-aware () _type_ :state 28)
|
|
(hit () _type_ :state 29)
|
|
(knocked () _type_ :state 30)
|
|
(idle () _type_ :state 31)
|
|
(active () _type_ :state 32)
|
|
(notice () _type_ :state 33)
|
|
(flee () _type_ :state 34)
|
|
(stare () _type_ :state 35)
|
|
(hostile () _type_ :state 36)
|
|
(victory () _type_ :state 37)
|
|
(die () _type_ :state 38)
|
|
(die-falling () _type_ :state 39)
|
|
(die-fast () _type_ :state 40)
|
|
(directed () _type_ :state 41)
|
|
(jump () _type_ :state 42)
|
|
(jump-blocked () _type_ :state 43)
|
|
(ambush () _type_ :state 44)
|
|
(view-anims () _type_ :state 45)
|
|
(enemy-method-46 (_type_ int) none 46)
|
|
(enemy-method-47 (_type_ vector) float 47)
|
|
(take-damage-from-attack (_type_ process event-message-block) int 48)
|
|
(enemy-method-49 (_type_) time-frame :behavior enemy 49)
|
|
(enemy-method-50 (_type_ vector) vector 50)
|
|
(enemy-method-51 (_type_) float 51)
|
|
(enemy-method-52 (_type_ vector) none 52)
|
|
(enemy-method-53 (_type_ process-focusable) symbol 53)
|
|
(enemy-method-54 (_type_) enemy-flag 54)
|
|
(track-target! (_type_) none 55)
|
|
(damage-amount-from-attack (_type_ process event-message-block) int 56)
|
|
(update-target-awareness! (_type_ process-focusable enemy-best-focus) enemy-aware 57)
|
|
(enemy-method-58 (_type_ process event-message-block) symbol 58)
|
|
(get-penetrate-info (_type_) penetrate 59)
|
|
(coin-flip? (_type_) symbol 60)
|
|
(enemy-method-61 (_type_ int) int :behavior enemy 61)
|
|
(enemy-method-62 (_type_) none 62)
|
|
(enemy-method-63 (_type_ process-focusable enemy-aware) symbol 63)
|
|
(enemy-method-64 (_type_) none 64)
|
|
(enemy-method-65 (_type_) none 65)
|
|
(go-ambush (_type_) object 66)
|
|
(go-stare (_type_) object 67)
|
|
(go-stare2 (_type_) object 68)
|
|
(go-directed (_type_) object 69)
|
|
(go-hostile (_type_) object 70)
|
|
(go-flee (_type_) object 71)
|
|
(react-to-focus (_type_) object 72)
|
|
(kill-prefer-falling (_type_) object 73)
|
|
(general-event-handler (_type_ process int symbol event-message-block) object 74)
|
|
(enemy-method-75 (_type_ process event-message-block) object 75)
|
|
(enemy-method-76 (_type_ process event-message-block) symbol 76)
|
|
(enemy-method-77 (_type_ (pointer float)) symbol 77)
|
|
(enemy-method-78 (_type_ (pointer float)) symbol 78)
|
|
(enemy-method-79 (_type_ int enemy-knocked-info) symbol 79)
|
|
(enemy-method-80 (_type_ enemy-knocked-info) symbol 80)
|
|
(enemy-method-81 (_type_) symbol 81)
|
|
(enemy-method-82 (_type_ enemy-jump-info) symbol 82)
|
|
(enemy-method-83 (_type_ enemy-jump-info) none 83)
|
|
(enemy-method-84 (_type_ enemy-jump-info) none 84)
|
|
(enemy-method-85 (_type_) float 85)
|
|
(enemy-method-86 (_type_) symbol 86)
|
|
(enemy-method-87 (_type_ enemy-jump-info) symbol 87)
|
|
(enemy-method-88 (_type_ enemy-jump-info) symbol 88)
|
|
(enemy-method-89 (_type_ enemy-jump-info) symbol 89)
|
|
(enemy-method-90 (_type_ int enemy-jump-info) symbol 90)
|
|
(enemy-method-91 (_type_ int enemy-jump-info) none 91)
|
|
(enemy-method-92 (_type_ int nav-poly) none 92)
|
|
(enemy-method-93 (_type_) none 93)
|
|
(enemy-method-94 (_type_ vector float) symbol 94)
|
|
(enemy-method-95 (_type_ vector float) symbol 95)
|
|
(enemy-method-96 (_type_ float symbol) symbol 96)
|
|
(enemy-method-97 (_type_) process 97)
|
|
(in-aggro-range? (_type_ process-focusable vector) symbol 98)
|
|
(enemy-method-99 (_type_ process-focusable) symbol 99)
|
|
(enemy-method-100 (_type_) symbol 100)
|
|
(enemy-method-101 (_type_) none 101)
|
|
(enemy-method-102 (_type_) symbol 102)
|
|
(enemy-method-103 (_type_) collide-spec 103)
|
|
(enemy-method-104 (_type_ process touching-shapes-entry uint) symbol :behavior process 104)
|
|
(enemy-method-105 (_type_ process) enemy-flag 105)
|
|
(enemy-method-106 (_type_ process object int attack-info) none :behavior enemy 106)
|
|
(get-enemy-target (_type_) process-focusable 107)
|
|
(enemy-method-108 (_type_ enemy event-message-block) int 108)
|
|
(look-at-target! (_type_ enemy-flag) none 109)
|
|
(stop-looking-at-target! (_type_) none 110)
|
|
(enemy-method-111 (_type_) none :behavior enemy 111)
|
|
(set-enemy-info! (_type_ enemy-info) none 112)
|
|
(init-enemy-behaviour-and-stats! (_type_ enemy-info) none 113)
|
|
(init-enemy-collision! (_type_) none 114)
|
|
(init-enemy! (_type_) none 115)
|
|
(go-idle (_type_) none 116)
|
|
(get-rand-float (_type_) float 117)
|
|
(get-rand-float-range (_type_ float float) float 118)
|
|
(get-rand-int (_type_ int) int 119)
|
|
(enemy-method-120 (_type_ int int) int 120)
|
|
(get-rand-int-range (_type_ int int) int 121)
|
|
(rng-hit? (_type_ float) symbol 122)
|
|
(enemy-method-123 (_type_ float) symbol 123)
|
|
(enemy-method-124 (_type_) collide-spec 124)
|
|
(enemy-method-125 (_type_ collide-query collide-spec float float float) pat-surface 125)
|
|
(enemy-above-ground? (_type_ collide-query vector collide-spec float float float) symbol 126)
|
|
(enemy-method-127 (_type_ float float symbol collide-spec) symbol 127)
|
|
(enemy-method-128 (_type_ vector move-above-ground-params) none 128)
|
|
(enemy-method-129 (_type_) none 129)
|
|
(enemy-method-130 (_type_ float) symbol 130)
|
|
(enemy-method-131 (_type_ int) uint 131)
|
|
(dispose! (_type_) none 132)
|
|
(enemy-method-133 (_type_) symbol 133)
|
|
(enemy-method-134 (_type_ process attack-info) process-focusable 134)
|
|
(enemy-method-135 (_type_ int) sound-id 135)
|
|
(enemy-method-136 (_type_) enemy-flag 136)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type enemy
|
|
(defmethod inspect enemy ((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 actor-pause-backup) s5-0) (enemy-flag actor-pause-backup))
|
|
(format #t "lock-focus ")
|
|
)
|
|
(if (= (logand (enemy-flag recover) s5-0) (shl 8 32))
|
|
(format #t "death-start ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag jump-check-blocked)) (enemy-flag jump-check-blocked))
|
|
(format #t "enable-on-active ")
|
|
)
|
|
(if (= (logand (enemy-flag directed-ready) s5-0) (enemy-flag directed-ready))
|
|
(format #t "checking-water ")
|
|
)
|
|
(if (= (logand (enemy-flag trackable-backup) s5-0) (enemy-flag trackable-backup))
|
|
(format #t "check-water ")
|
|
)
|
|
(if (= (logand (enemy-flag cam-attack-mode) s5-0) (enemy-flag cam-attack-mode))
|
|
(format #t "spawn-gem ")
|
|
)
|
|
(if (= (logand (enemy-flag dangerous-backup) s5-0) (enemy-flag dangerous-backup))
|
|
(format #t "chase-startup ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag look-at-move-dest)) (enemy-flag look-at-move-dest))
|
|
(format #t "attackable-backup ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag lock-focus)) (enemy-flag lock-focus))
|
|
(format #t "look-at-focus ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag enable-on-notice)) (enemy-flag enable-on-notice))
|
|
(format #t "use-notice-distance ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag auto-reset-penetrate)) (enemy-flag auto-reset-penetrate))
|
|
(format #t "enable-on-notice ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag death-start)) (enemy-flag death-start))
|
|
(format #t "look-at-move-dest ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag spawn-gem)) (enemy-flag spawn-gem))
|
|
(format #t "notice ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag attackable-backup)) (enemy-flag attackable-backup))
|
|
(format #t "auto-reset-penetrate ")
|
|
)
|
|
(if (= (logand (enemy-flag vulnerable) s5-0) (shl 4 32))
|
|
(format #t "jump-check-blocked ")
|
|
)
|
|
(if (= (logand (enemy-flag dislike-combo) s5-0) (shl #x8000 16))
|
|
(format #t "drawn-mirrored ")
|
|
)
|
|
(if (= (logand (enemy-flag trackable) s5-0) (enemy-flag trackable))
|
|
(format #t "multi-focus ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag chase-startup)) (enemy-flag chase-startup))
|
|
(format #t "alert ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag look-at-focus)) (enemy-flag look-at-focus))
|
|
(format #t "victory ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag check-water)) (enemy-flag check-water))
|
|
(format #t "dangerous-backup ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag notice)) (enemy-flag notice))
|
|
(format #t "actor-pause-backup ")
|
|
)
|
|
(if (= (logand (enemy-flag check-water-backup) s5-0) (enemy-flag check-water-backup))
|
|
(format #t "trackable ")
|
|
)
|
|
(if (= (logand (enemy-flag recover-applied-velocity) s5-0) (shl 1 32))
|
|
(format #t "called-dying ")
|
|
)
|
|
(if (= (logand (enemy-flag enable-on-hostile) s5-0) (enemy-flag enable-on-hostile))
|
|
(format #t "check-water-backup ")
|
|
)
|
|
(if (= (logand (enemy-flag vulnerable-backup) s5-0) (shl 2 32))
|
|
(format #t "no-initial-move-to-ground ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag use-notice-distance)) (enemy-flag use-notice-distance))
|
|
(format #t "cam-attack-mode ")
|
|
)
|
|
(if (= (logand (enemy-flag no-initial-move-to-ground) s5-0) (enemy-flag no-initial-move-to-ground))
|
|
(format #t "trackable-backup ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag drawn-mirrored)) (enemy-flag drawn-mirrored))
|
|
(format #t "enable-on-hostile ")
|
|
)
|
|
(if (= (logand (enemy-flag victory) s5-0) (enemy-flag victory))
|
|
(format #t "directed-ready ")
|
|
)
|
|
(if (= (logand (enemy-flag called-dying) s5-0) (enemy-flag called-dying))
|
|
(format #t "use-trigger ")
|
|
)
|
|
(if (= (logand (enemy-flag alert) s5-0) (enemy-flag alert))
|
|
(format #t "directed ")
|
|
)
|
|
(if (= (logand (enemy-flag multi-focus) s5-0) (enemy-flag multi-focus))
|
|
(format #t "dislike-combo ")
|
|
)
|
|
(if (= (logand (enemy-flag directed) s5-0) (enemy-flag directed))
|
|
(format #t "recover-applied-velocity ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag checking-water)) (enemy-flag checking-water))
|
|
(format #t "vulnerable-backup ")
|
|
)
|
|
(if (= (logand s5-0 (enemy-flag enable-on-active)) (enemy-flag enable-on-active))
|
|
(format #t "vulnerable ")
|
|
)
|
|
(if (= (logand (enemy-flag use-trigger) s5-0) (enemy-flag use-trigger))
|
|
(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 :offset-assert 0)
|
|
(travel-speed meters :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type anim-info
|
|
(defmethod inspect anim-info ((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 enemy-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 lock-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 enemy-focus ((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 lock-focus))
|
|
)
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 9 of type enemy-focus
|
|
;; WARN: Return type mismatch enemy-flag vs none.
|
|
(defmethod clear-focused enemy-focus ((this enemy-focus))
|
|
(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 lock-focus))
|
|
(none)
|
|
)
|