From cdb61f69f8d3ebea922a862c4ef6ab26fc9cded0 Mon Sep 17 00:00:00 2001 From: Tyler Wilding Date: Tue, 29 Nov 2022 19:19:05 -0500 Subject: [PATCH] d/jak2: finish decompiling `enemy-h` | `enemy` | `grunt` and `flitter` (#2023) --- decompiler/config/jak2/all-types.gc | 252 +- decompiler/config/jak2/label_types.jsonc | 10 +- decompiler/config/jak2/stack_structures.jsonc | 6 +- decompiler/config/jak2/type_casts.jsonc | 105 +- decompiler/util/data_decompile.cpp | 8 +- goal_src/jak2/engine/ai/enemy-h.gc | 227 +- goal_src/jak2/engine/ai/enemy.gc | 3709 ++++++++++++++++ goal_src/jak2/engine/game/fact-h.gc | 27 +- goal_src/jak2/engine/nav/nav-enemy-h.gc | 24 +- goal_src/jak2/levels/common/flitter.gc | 1442 ++++++ goal_src/jak2/levels/common/grunt.gc | 1625 +++++++ .../reference/jak2/engine/ai/enemy-h_REF.gc | 753 ++++ .../reference/jak2/engine/ai/enemy_REF.gc | 3870 +++++++++++++++++ .../jak2/engine/camera/cam-layout_REF.gc | 190 + .../reference/jak2/engine/game/fact-h_REF.gc | 52 +- .../jak2/engine/gfx/tfrag/tfrag-near_REF.gc | 4 - .../jak2/engine/nav/nav-enemy-h_REF.gc | 21 +- .../jak2/engine/target/gun/gun-part_REF.gc | 4 - .../jak2/levels/common/flitter_REF.gc | 1515 +++++++ .../reference/jak2/levels/common/grunt_REF.gc | 1722 ++++++++ 20 files changed, 15263 insertions(+), 303 deletions(-) create mode 100644 test/decompiler/reference/jak2/engine/ai/enemy-h_REF.gc create mode 100644 test/decompiler/reference/jak2/engine/ai/enemy_REF.gc create mode 100644 test/decompiler/reference/jak2/levels/common/flitter_REF.gc create mode 100644 test/decompiler/reference/jak2/levels/common/grunt_REF.gc diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index 80a3ff17e8..9de2ebb412 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -14605,24 +14605,24 @@ (water 25) ;; hi 512 ) +(declare-type actor-group basic) (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 uint32) - (trig-mask-count int8) - (trig-mask uint8 2) + ((speed float :offset-assert 40) + (idle-distance meters :offset-assert 44) + (notice-top meters :offset-assert 48) + (notice-bottom meters :offset-assert 52) + (cam-horz meters :offset-assert 56) + (cam-vert meters :offset-assert 60) + (cam-notice-dist meters :offset-assert 64) + (enemy-options enemy-option :offset-assert 68) + (trig-dist meters :offset-assert 72) + (trig-actor-group (pointer actor-group) :offset-assert 76) ;; this is an array of handles...i think + (trig-mask-count int8 :offset-assert 80) + (trig-mask uint8 2 :offset-assert 81) ) :method-count-assert 13 :size-assert #x53 :flag-assert #xd00000053 - ;; Failed to read fields. (:methods (new (symbol type process (pointer float) pickup-type float) _type_ 0) (clear-mask-bits (_type_ int) none 12) @@ -15057,30 +15057,30 @@ (declare-type touching-shapes-entry structure) (deftype attack-info (structure) - ((trans vector :inline) - (vector vector :inline) - (attacker-velocity vector :inline) - (intersection vector :inline) - (attacker handle) - (attack-time time-frame) - (invinc-time time-frame) - (mask attack-info-mask) - (mode symbol) - (shove-back meters) - (shove-up meters) - (speed meters) - (dist meters) - (control float) - (angle symbol) - (rotate-to degrees) - (prev-state state) - (id uint32) - (count uint32) - (penetrate-using uint64) - (damage float) - (shield-damage float) - (knock uint8) - (test symbol) + ((trans vector :inline :offset-assert 0) + (vector vector :inline :offset-assert 16) + (attacker-velocity vector :inline :offset-assert 32) + (intersection vector :inline :offset-assert 48) + (attacker handle :offset-assert 64) + (attack-time time-frame :offset-assert 72) + (invinc-time time-frame :offset-assert 80) + (mask attack-info-mask :offset-assert 88) + (mode symbol :offset-assert 92) + (shove-back meters :offset-assert 96) + (shove-up meters :offset-assert 100) + (speed meters :offset-assert 104) + (dist meters :offset-assert 108) + (control float :offset-assert 112) + (angle symbol :offset-assert 116) + (rotate-to degrees :offset-assert 120) + (prev-state state :offset-assert 124) + (id uint32 :offset-assert 128) + (count uint32 :offset-assert 132) + (penetrate-using uint64 :offset-assert 136) + (damage float :offset-assert 144) + (shield-damage float :offset-assert 148) + (knock uint8 :offset-assert 152) + (test symbol :offset-assert 156) ) :method-count-assert 12 :size-assert #xa0 @@ -32328,15 +32328,12 @@ :flag-assert #xe00000020 (:methods (try-update-focus (_type_ process-focusable enemy) symbol :replace 12) - (enemy-focus-method-13 - "TODO - enemy-aware sets `aware` on the type (see enemy.gc), but it's also an `enemy` passed to method 12...what the hell is going on? - probably related to ';; skipped : handle creation is different, want to grab more.'" - (_type_ process-focusable enemy-aware) symbol 13) + (enemy-focus-method-13 (_type_ process-focusable enemy-aware) symbol 13) ) ) (deftype enemy-info (basic) - ((fact-defaults basic :offset-assert 4) + ((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) @@ -32344,7 +32341,7 @@ (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 uint32 :offset-assert 36) ;; TODO what is this + (idle-anim-script (pointer uint32) :offset-assert 36) ;; TODO very likely WRONG, possible `script-form`s? (idle-anim int32 :offset-assert 40) (notice-anim int32 :offset-assert 44) (hostile-anim int32 :offset-assert 48) @@ -32360,8 +32357,8 @@ (neck-joint int32 :offset-assert 88) (look-at-joint int32 :offset-assert 92) (bullseye-joint int32 :offset-assert 96) - (sound-hit uint128 :offset-assert 112) - (sound-die uint128 :offset-assert 128) + (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) @@ -32375,7 +32372,7 @@ (slip-factor float :offset-assert 192) (attack-shove-back meters :offset-assert 196) (attack-shove-up meters :offset-assert 200) - (attack-mode basic :offset-assert 204) + (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) @@ -32453,7 +32450,7 @@ (deftype enemy-init-by-other-params (structure) ((trans vector :inline :offset-assert 0) (quat quaternion :inline :offset-assert 16) - (entity basic :offset-assert 32) + (entity entity :offset-assert 32) (directed? symbol :offset-assert 36) (no-initial-move-to-ground? symbol :offset-assert 40) ) @@ -32465,6 +32462,7 @@ ;; +++enemy-h:knocked-type (defenum knocked-type :type uint8 + (knocked-type-0 0) (knocked-type-1 1) (knocked-type-2 2) (knocked-type-3 3) @@ -32491,9 +32489,9 @@ ) (deftype enemy-best-focus (structure) - ((proc basic :offset-assert 0) + ((proc process :offset-assert 0) (rating float :offset-assert 4) - (aware uint64 :offset-assert 8) + (aware enemy-aware :offset-assert 8) ) :method-count-assert 9 :size-assert #x10 @@ -32562,9 +32560,9 @@ (jump-blocked () _type_ :state 43) (ambush () _type_ :state 44) (view-anims () _type_ :state 45) - (enemy-method-46 "@abstract" (_type_) none 46) + (enemy-method-46 "@abstract" (_type_ int) none 46) (enemy-method-47 (_type_ vector) float 47) - (enemy-method-48 (_type_) none 48) + (enemy-method-48 (_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) @@ -32574,8 +32572,8 @@ (_type_ process-focusable) symbol 53) (enemy-method-54 (_type_) enemy-flag 54) (enemy-method-55 (_type_) none 55) - (enemy-method-56 (_type_ object enemy-attack-info) none 56) - (enemy-method-57 (_type_ process-focusable enemy-attack-info) none 57) + (enemy-method-56 (_type_ process event-message-block) int 56) + (enemy-method-57 (_type_ process-focusable enemy-best-focus) enemy-aware 57) (enemy-method-58 (_type_) symbol 58) (enemy-method-59 (_type_) penetrate 59) (coin-flip? @@ -32594,23 +32592,23 @@ (go-flee (_type_) none 71) (enemy-method-72 (_type_) none 72) (enemy-method-73 (_type_) none 73) - (enemy-method-74 (_type_ object object symbol event-message-block) none 74) + (enemy-method-74 (_type_ process object symbol event-message-block) none 74) (enemy-method-75 (_type_ process touching-shapes-entry) none 75) - (enemy-method-76 (_type_) none 76) - (enemy-method-77 (_type_ (pointer float)) none 77) - (enemy-method-78 (_type_ (pointer float)) none 78) - (enemy-method-79 (_type_) none 79) - (enemy-method-80 (_type_) none 80) + (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 "TODO - nav-poly is a guess" (_type_ nav-poly) none 82) + (enemy-method-82 "@abstract" (_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_) none 87) - (enemy-method-88 (_type_) none 88) - (enemy-method-89 (_type_) none 89) - (enemy-method-90 (_type_) none 90) + (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 "TODO - nav-poly is a guess @@ -32620,18 +32618,18 @@ (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_) none 97) + (enemy-method-97 (_type_) process 97) (enemy-method-98 (_type_ process-focusable vector) symbol 98) - (enemy-method-99 (_type_) symbol 99) + (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 uint uint) symbol :behavior process 104) - (enemy-method-105 (_type_) none 105) - (enemy-method-106 (_type_) none 106) - (enemy-method-107 (_type_) process 107) - (enemy-method-108 (_type_ object) none 108) + (enemy-method-105 (_type_ process) enemy-flag 105) + (enemy-method-106 (_type_ process object int attack-info) none :behavior enemy 106) + (enemy-method-107 (_type_) process-focusable 107) + (enemy-method-108 (_type_ enemy event-message-block) int 108) (enemy-method-109 (_type_ int) none 109) (enemy-method-110 (_type_) none 110) (enemy-method-111 (_type_) none :behavior enemy 111) @@ -32666,15 +32664,15 @@ (_type_ float) symbol 122) (enemy-method-123 "TODO" (_type_ float) symbol 123) (enemy-method-124 "TODO" (_type_) collide-spec 124) - (enemy-method-125 (_type_) none 125) + (enemy-method-125 (_type_ collide-query collide-spec float float float) pat-surface 125) (enemy-method-126 (_type_ collide-query vector collide-spec float float float) symbol 126) - (enemy-method-127 (_type_) none 127) + (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_) none 130) - (enemy-method-131 (_type_) none 131) + (enemy-method-130 (_type_ float) symbol 130) + (enemy-method-131 (_type_ int) uint 131) (enemy-method-132 (_type_) none 132) - (enemy-method-133 (_type_) none 133) + (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) @@ -32698,10 +32696,10 @@ (deftype nav-enemy-info (enemy-info) ((callback-info nav-callback-info :offset-assert 384) (use-momentum symbol :offset-assert 388) ;; guessed by decompiler - (use-frustration basic :offset-assert 392) - (use-stop-chase basic :offset-assert 396) - (use-circling basic :offset-assert 400) - (use-pacing basic :offset-assert 404) + (use-frustration symbol :offset-assert 392) + (use-stop-chase symbol :offset-assert 396) + (use-circling symbol :offset-assert 400) + (use-pacing symbol :offset-assert 404) (walk-anim int32 :offset-assert 408) (turn-anim int32 :offset-assert 412) (run-anim int32 :offset-assert 416) @@ -32719,7 +32717,7 @@ (blocked-time time-frame :offset-assert 472) (circle-dist-lo float :offset-assert 480) (circle-dist-hi float :offset-assert 484) - (nav-mesh basic :offset-assert 488) + (nav-mesh nav-mesh :offset-assert 488) ) :method-count-assert 11 :size-assert #x1ec @@ -32772,7 +32770,7 @@ (nav-enemy-method-160 (_type_) none 160) (nav-enemy-method-161 (_type_) none 161) (nav-enemy-method-162 (_type_) none 162) - (nav-enemy-method-163 (_type_) none 163) + (nav-enemy-method-163 (_type_) symbol 163) (nav-enemy-method-164 (_type_) none 164) (nav-enemy-method-165 (_type_) none 165) (nav-enemy-method-166 (_type_) none 166) @@ -34170,54 +34168,53 @@ ;; grunt ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype grunt-anim-info (structure) ((anim-index int32 :offset-assert 0) (travel-speed meters :offset-assert 4) ) + :pack-me :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype grunt-global-info (basic) ((prev-knocked-anim-index int32 :offset-assert 4) (prev-yellow-hit-anim-index int32 :offset-assert 8) (prev-blue-hit-anim-index int32 :offset-assert 12) - (patrol-anim UNKNOWN 4 :offset-assert 16) - (charge-anim UNKNOWN 3 :offset-assert 48) - (attack-anim UNKNOWN 2 :offset-assert 72) - (knocked-anim UNKNOWN 4 :offset-assert 88) - (knocked-land-anim UNKNOWN 4 :offset-assert 120) - (yellow-hit-anim UNKNOWN 4 :offset-assert 152) - (blue-hit-anim UNKNOWN 6 :offset-assert 184) + (patrol-anim grunt-anim-info 4 :inline :offset-assert 16) + (charge-anim grunt-anim-info 3 :inline :offset-assert 48) + (attack-anim grunt-anim-info 2 :inline :offset-assert 72) + (knocked-anim grunt-anim-info 4 :inline :offset-assert 88) + (knocked-land-anim grunt-anim-info 4 :inline :offset-assert 120) + (yellow-hit-anim grunt-anim-info 4 :inline :offset-assert 152) + (blue-hit-anim grunt-anim-info 6 :inline :offset-assert 184) ) :method-count-assert 9 :size-assert #xe8 :flag-assert #x9000000e8 ) -|# -#| (deftype grunt (nav-enemy) - ((patrol-anim grunt-anim-info :offset-assert 600) - (charge-anim grunt-anim-info :offset-assert 604) - (attack-anim grunt-anim-info :offset-assert 608) - (knocked-anim grunt-anim-info :offset-assert 612) - (yellow-hit-anim grunt-anim-info :offset-assert 616) - (blue-hit-anim grunt-anim-info :offset-assert 620) - (intro-path basic :offset-assert 624) + ((patrol-anim grunt-anim-info :offset-assert 604) + (charge-anim grunt-anim-info :offset-assert 608) + (attack-anim grunt-anim-info :offset-assert 612) + (knocked-anim grunt-anim-info :offset-assert 616) + (yellow-hit-anim grunt-anim-info :offset-assert 620) + (blue-hit-anim grunt-anim-info :offset-assert 624) + (intro-path path-control :offset-assert 628) (use-charge-anim-index int8 :offset-assert 632) (knocked-anim-index int8 :offset-assert 633) (jumping-ambush-path-pt int8 :offset-assert 634) (grunt-flags uint8 :offset-assert 635) - (state-timeout2 uint64 :offset-assert 636) - (next-warn-time time-frame :offset-assert 644) - (dest vector :inline :offset-assert 652) - (focus-pos vector :inline :offset-assert 348) - (minimap connection-minimap :offset-assert 684) + (unknown-byte-n1k2n3 int8 :offset 636) + (unknown-byte-m2j342 int8 :offset 637) + (unknown-byte-1ji2n3 int8 :offset 638) + (unknown-byte-n123n int8 :offset 639) + (state-timeout2 uint64 :offset-assert 640) + (next-warn-time time-frame :offset-assert 648) + (dest vector :inline :offset-assert 656) + (minimap connection-minimap :offset 688) ) :method-count-assert 186 :size-assert #x2b4 @@ -34229,32 +34226,30 @@ (jumping-ambush-cont () _type_ :state 181) (wait-for-focus () _type_ :state 182) (spin-attack () _type_ :state 183) - (grunt-method-184 () none 184) + (grunt-method-184 (_type_ float) process-focusable 184) (grunt-method-185 () none 185) ) ) -|# -;; (define-extern *grunt-global-info* grunt-global-info) -;; (define-extern *grunt-nav-enemy-info* nav-enemy-info) +(define-extern *grunt-global-info* grunt-global-info) +(define-extern *grunt-nav-enemy-info* nav-enemy-info) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; flitter ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype flitter (nav-enemy) - ((move-angle float :offset-assert 600) - (heading basic :offset-assert 604) - (change-dir-time time-frame :offset-assert 612) - (last-change-dir uint64 :offset-assert 620) - (off-screen-timer uint64 :offset-assert 628) - (amb-sound-timer uint64 :offset-assert 636) - (attack-time time-frame :offset-assert 644) - (target-pos vector :inline :offset-assert 652) - (attack-pos vector :inline :offset-assert 668) - (base-height float :offset-assert 684) - (minimap connection-minimap :offset-assert 688) + ((move-angle float :offset-assert 604) + (heading basic :offset-assert 608) + (change-dir-time time-frame :offset-assert 616) + (last-change-dir uint64 :offset-assert 624) + (off-screen-timer uint64 :offset-assert 632) + (amb-sound-timer uint64 :offset-assert 640) + (attack-time time-frame :offset-assert 648) + (target-pos vector :inline :offset-assert 656) + (attack-pos vector :inline :offset-assert 672) + (base-height float :offset-assert 688) + (minimap connection-minimap :offset-assert 692) ) :method-count-assert 184 :size-assert #x2b8 @@ -34262,17 +34257,16 @@ (:methods (attack () _type_ :state 178) (ambush-jumping () _type_ :state 179) - (flitter-method-180 () none 180) - (flitter-method-181 () none 181) - (flitter-method-182 () none 182) - (flitter-method-183 () none 183) + (flitter-method-180 (_type_) none 180) + (flitter-method-181 (_type_) none 181) + (flitter-method-182 (_type_ process-focusable) symbol 182) + (flitter-method-183 (_type_) float 183) ) ) -|# -;; (define-extern check-drop-level-flitter-dirt-rubble function) -;; (define-extern *flitter-nav-enemy-info* nav-enemy-info) -;; (define-extern flitter-fall-and-play-death-anim function) +(define-extern check-drop-level-flitter-dirt-rubble (function sparticle-system sparticle-cpuinfo vector none)) +(define-extern *flitter-nav-enemy-info* nav-enemy-info) +(define-extern flitter-fall-and-play-death-anim (function art-joint-anim float time-frame none :behavior flitter)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; battle ;; diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index 8f4a823607..3c68d67f76 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -524,5 +524,13 @@ ["L536", "attack-info"], ["L534", "attack-info"] ], - "gun-dark-shot": [["L125", "attack-info"]] + "gun-dark-shot": [["L125", "attack-info"]], + "grunt": [ + ["L225", "vector"], + ["L224", "vector"] + ], + "flitter": [ + ["L159", "vector"], + ["L158", "vector"] + ] } diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc index eef96e87cb..40177bbc99 100644 --- a/decompiler/config/jak2/stack_structures.jsonc +++ b/decompiler/config/jak2/stack_structures.jsonc @@ -1200,7 +1200,7 @@ [384, "vector"] ], "(method 20 collide-cache)": [[16, "matrix"]], - "col-rend-draw": [ - [16, "matrix"] - ] + "col-rend-draw": [[16, "matrix"]], + "(code jump enemy)": [[16, "enemy-jump-info"]], + "check-drop-level-flitter-dirt-rubble": [[16, "vector"]] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index 44b21e31d6..df9e59dca1 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -3893,16 +3893,26 @@ "(method 10 idle-control)": [[64, "v1", "art-joint-anim"]], "(method 136 enemy)": [[34, "a1", "process-focusable"]], "(method 107 enemy)": [[17, "v0", "process-focusable"]], - "(method 96 enemy)": [[16, "a0", "process-focusable"]], + "(method 96 enemy)": [[[16, 20], "a0", "process-focusable"]], "(method 129 enemy)": [[18, "a1", "process-focusable"]], - "(method 97 enemy)": [[16, "v1", "connection"]], + "(method 97 enemy)": [ + [16, "v1", "connection"], + [[17, 22], "v1", "collide-shape"], + [27, "s2", "process-focusable"], + [65, "v1", "connection"], + [[66, 71], "v1", "collide-shape"], + [76, "s2", "process-focusable"], + [112, "v1", "connection"], + [[113, 118], "v1", "collide-shape"], + [123, "s2", "process-focusable"] + ], "(method 75 enemy)": [[9, "s2", "process-focusable"]], "(code notice enemy)": [[31, "v1", "art-joint-anim"]], "(code stare enemy)": [[23, "gp", "art-joint-anim"]], "(code victory enemy)": [[30, "v1", "art-joint-anim"]], "(method 88 enemy)": [[28, "a1", "art-joint-anim"]], "(code hit enemy)": [[30, "v1", "art-joint-anim"]], - "(method 51 enemy)": [[27, "a0", "process-focusable"]], + "(method 51 enemy)": [[[27, 31], "a0", "process-focusable"]], "(method 78 enemy)": [[11, "v1", "art-joint-anim"]], "(code die enemy)": [[30, "v1", "art-joint-anim"]], "(code die-falling enemy)": [[32, "gp", "art-joint-anim"]], @@ -4679,7 +4689,10 @@ "(method 10 flow-control)": [["_stack_", 32, "flow-section"]], "(method 9 lod-set)": [["_stack_", 16, "res-tag"]], "execute-math-engine": [[[15, 28], "v1", "process-drawable"]], - "(method 14 draw-control)": [[13, "v1", "process-drawable"], [[58, 64], "t9", "(function object object object none)"]], + "(method 14 draw-control)": [ + [13, "v1", "process-drawable"], + [[58, 64], "t9", "(function object object object none)"] + ], "(method 17 process-drawable)": [[7, "v1", "collide-shape"]], "(method 10 process-drawable)": [[32, "a0", "collide-shape"]], "(code process-drawable-art-error)": [[[18, 50], "v1", "collide-shape"]], @@ -4961,9 +4974,7 @@ [164, "v1", "collide-shape-prim-sphere"], [[14, 152], "s3", "collide-cache-tri"] ], - "effect-param->sound-spec": [ - [178, "v1", "collide-shape-moving"] - ], + "effect-param->sound-spec": [[178, "v1", "collide-shape-moving"]], "(method 10 effect-control)": [ [128, "v1", "collide-shape-moving"], [183, "s3", "(pointer object)"], @@ -4977,6 +4988,82 @@ "(method 12 effect-control)": [ [99, "gp", "(pointer int8)"], ["_stack_", 112, "res-tag"] - ] - + ], + "(method 55 enemy)": [[[66, 70], "a0", "process-focusable"]], + "(method 74 enemy)": [ + [50, "s3", "process-drawable"], + [94, "v1", "attack-info"], + [[111, 205], "s2", "attack-info"], + [554, "a0", "vector"] + ], + "(method 56 enemy)": [[[0, 6], "v1", "attack-info"]], + "(method 89 enemy)": [[28, "a1", "art-joint-anim"]], + "(method 87 enemy)": [[52, "s5", "art-joint-anim"]], + "(code jump enemy)": [[30, "v0", "enemy-jump-info"]], + "(method 77 enemy)": [[17, "a1", "art-joint-anim"]], + "(method 108 enemy)": [[[2, 51], "s4", "touching-shapes-entry"]], + "(method 130 enemy)": [[37, "t1", "int"]], + "(method 113 enemy)": [["_stack_", 16, "res-tag"]], + "(code falling-ambush grunt)": [[53, "v1", "art-joint-anim"]], + "(code active grunt)": [ + [227, "gp", "art-joint-anim"], + [271, "gp", "art-joint-anim"], + [354, "v1", "art-joint-anim"], + [414, "v1", "art-joint-anim"], + [143, "gp", "art-joint-anim"] + ], + "(code hostile grunt)": [[122, "gp", "art-joint-anim"]], + "(code attack grunt)": [ + [55, "gp", "art-joint-anim"], + [155, "a0", "grunt-anim-info"] + ], + "(enter spin-attack grunt)": [[[43, 48], "gp", "process-focusable"]], + "(code spin-attack grunt)": [ + [45, "gp", "art-joint-anim"], + [[73, 77], "a0", "process-focusable"] + ], + "(code circling grunt)": [ + [260, "v1", "art-joint-anim"], + [308, "v1", "art-joint-anim"], + [153, "v1", "art-joint-anim"], + [153, "gp", "art-joint-anim"] + ], + "(code pacing grunt)": [[145, "gp", "art-joint-anim"]], + "(code stop-chase grunt)": [[77, "gp", "art-joint-anim"]], + "(method 77 grunt)": [ + [87, "s4", "art-joint-anim"], + [233, "a1", "art-joint-anim"], + [323, "s4", "art-joint-anim"] + ], + "(method 78 grunt)": [ + [53, "s4", "art-joint-anim"], + [91, "a1", "art-joint-anim"] + ], + "(trans wait-for-focus grunt)": [ + [40, "s5", "process-focusable"], + [13, "s5", "process-focusable"] + ], + "(method 132 grunt)": [[16, "t9", "(function nav-enemy none)"]], + "(method 77 flitter)": [ + [14, "v1", "art-joint-anim"], + [69, "v1", "art-joint-anim"] + ], + "(method 78 flitter)": [[15, "a1", "art-joint-anim"]], + "(code ambush flitter)": [[[72, 76], "a0", "process-focusable"]], + "(code ambush-jumping flitter)": [ + [14, "v1", "art-joint-anim"], + [191, "v1", "art-joint-anim"] + ], + "(method 180 flitter)": [[17, "s5", "process-focusable"]], + "(post active flitter)": [[9, "t9", "(function none)"]], + "(code stare flitter)": [[126, "v1", "art-joint-anim"]], + "(post stare flitter)": [[9, "t9", "(function none)"]], + "(trans circling flitter)": [[14, "gp", "process-focusable"]], + "(code circling flitter)": [[27, "v1", "art-joint-anim"]], + "(trans attack flitter)": [[16, "s5", "process-focusable"]], + "(code attack flitter)": [ + [20, "v1", "art-joint-anim"], + [147, "v1", "art-joint-anim"] + ], + "(method 132 flitter)": [[16, "t9", "(function nav-enemy none)"]] } diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp index 41000b7c39..affc337644 100644 --- a/decompiler/util/data_decompile.cpp +++ b/decompiler/util/data_decompile.cpp @@ -215,7 +215,8 @@ goos::Object decompile_at_label(const TypeSpec& type, return decompile_pair(label, labels, words, ts, true, file, version); } - throw std::runtime_error("Unimplemented decompile_at_label for " + type.print()); + throw std::runtime_error(fmt::format( + "Unimplemented decompile_at_label for Label: {} and Type: {}", label.name, type.print())); } /*! @@ -744,6 +745,11 @@ const std::unordered_map< {{"data", ArrayFieldDecompMeta(TypeSpec("int8"), 1, ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}}, + {"nav-enemy-info", + {{"idle-anim-script", + ArrayFieldDecompMeta(TypeSpec("uint32"), + 4, + ArrayFieldDecompMeta::Kind::REF_TO_INTEGER_ARR)}}}, // kinda want to add regex support now... {"bigmap-compressed-layers", {{"layer0", ArrayFieldDecompMeta(TypeSpec("uint32"), diff --git a/goal_src/jak2/engine/ai/enemy-h.gc b/goal_src/jak2/engine/ai/enemy-h.gc index f50a8bff33..2c6b390016 100644 --- a/goal_src/jak2/engine/ai/enemy-h.gc +++ b/goal_src/jak2/engine/ai/enemy-h.gc @@ -77,6 +77,7 @@ ;; +++knocked-type (defenum knocked-type :type uint8 + (knocked-type-0 0) (knocked-type-1 1) (knocked-type-2 2) (knocked-type-3 3) @@ -104,87 +105,87 @@ (deftype enemy-info (basic) - ((fact-defaults basic :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 uint32 :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 uint128 :offset-assert 112) - (sound-die uint128 :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 uint64 :offset-assert 168) - (penetrate-knocked uint64 :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 basic :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) + ((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 uint32) :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 uint64 :offset-assert 168) + (penetrate-knocked uint64 :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 @@ -224,7 +225,7 @@ (deftype enemy-init-by-other-params (structure) ((trans vector :inline :offset-assert 0) (quat quaternion :inline :offset-assert 16) - (entity basic :offset-assert 32) + (entity entity :offset-assert 32) (directed? symbol :offset-assert 36) (no-initial-move-to-ground? symbol :offset-assert 40) ) @@ -251,9 +252,9 @@ (deftype enemy-best-focus (structure) - ((proc basic :offset-assert 0) - (rating float :offset-assert 4) - (aware uint64 :offset-assert 8) + ((proc process :offset-assert 0) + (rating float :offset-assert 4) + (aware enemy-aware :offset-assert 8) ) :method-count-assert 9 :size-assert #x10 @@ -324,9 +325,9 @@ (jump-blocked () _type_ :state 43) (ambush () _type_ :state 44) (view-anims () _type_ :state 45) - (enemy-method-46 (_type_) none 46) + (enemy-method-46 (_type_ int) none 46) (enemy-method-47 (_type_ vector) float 47) - (enemy-method-48 (_type_) none 48) + (enemy-method-48 (_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) @@ -334,8 +335,8 @@ (enemy-method-53 (_type_ process-focusable) symbol 53) (enemy-method-54 (_type_) enemy-flag 54) (enemy-method-55 (_type_) none 55) - (enemy-method-56 (_type_ object enemy-attack-info) none 56) - (enemy-method-57 (_type_ process-focusable enemy-attack-info) none 57) + (enemy-method-56 (_type_ process event-message-block) int 56) + (enemy-method-57 (_type_ process-focusable enemy-best-focus) enemy-aware 57) (enemy-method-58 (_type_) symbol 58) (enemy-method-59 (_type_) penetrate 59) (coin-flip? (_type_) symbol 60) @@ -352,41 +353,41 @@ (go-flee (_type_) none 71) (enemy-method-72 (_type_) none 72) (enemy-method-73 (_type_) none 73) - (enemy-method-74 (_type_ object object symbol event-message-block) none 74) + (enemy-method-74 (_type_ process object symbol event-message-block) none 74) (enemy-method-75 (_type_ process touching-shapes-entry) none 75) - (enemy-method-76 (_type_) none 76) - (enemy-method-77 (_type_ (pointer float)) none 77) - (enemy-method-78 (_type_ (pointer float)) none 78) - (enemy-method-79 (_type_) none 79) - (enemy-method-80 (_type_) none 80) + (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_ nav-poly) none 82) + (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_) none 87) - (enemy-method-88 (_type_) none 88) - (enemy-method-89 (_type_) none 89) - (enemy-method-90 (_type_) none 90) + (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_) none 97) + (enemy-method-97 (_type_) process 97) (enemy-method-98 (_type_ process-focusable vector) symbol 98) - (enemy-method-99 (_type_) symbol 99) + (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 uint uint) symbol :behavior process 104) - (enemy-method-105 (_type_) none 105) - (enemy-method-106 (_type_) none 106) - (enemy-method-107 (_type_) process 107) - (enemy-method-108 (_type_ object) none 108) + (enemy-method-105 (_type_ process) enemy-flag 105) + (enemy-method-106 (_type_ process object int attack-info) none :behavior enemy 106) + (enemy-method-107 (_type_) process-focusable 107) + (enemy-method-108 (_type_ enemy event-message-block) int 108) (enemy-method-109 (_type_ int) none 109) (enemy-method-110 (_type_) none 110) (enemy-method-111 (_type_) none :behavior enemy 111) @@ -403,15 +404,15 @@ (rng-hit? (_type_ float) symbol 122) (enemy-method-123 (_type_ float) symbol 123) (enemy-method-124 (_type_) collide-spec 124) - (enemy-method-125 (_type_) none 125) + (enemy-method-125 (_type_ collide-query collide-spec float float float) pat-surface 125) (enemy-method-126 (_type_ collide-query vector collide-spec float float float) symbol 126) - (enemy-method-127 (_type_) none 127) + (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_) none 130) - (enemy-method-131 (_type_) none 131) + (enemy-method-130 (_type_ float) symbol 130) + (enemy-method-131 (_type_ int) uint 131) (enemy-method-132 (_type_) none 132) - (enemy-method-133 (_type_) none 133) + (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) @@ -438,7 +439,7 @@ (set! (-> obj aware) (the-as enemy-aware - (enemy-method-61 arg1 (the-as int (enemy-method-57 arg1 arg0 (the-as enemy-attack-info #f)))) + (enemy-method-61 arg1 (the-as int (enemy-method-57 arg1 arg0 (the-as enemy-best-focus #f)))) ) ) ) @@ -447,8 +448,6 @@ ) (defmethod enemy-focus-method-13 enemy-focus ((obj enemy-focus) (arg0 process-focusable) (arg1 enemy-aware)) - "TODO - enemy-aware sets `aware` on the type (see enemy.gc), but it's also an `enemy` passed to method 12...what the hell is going on? - probably related to ';; skipped : handle creation is different, want to grab more.'" (let* ((t9-0 (method-of-type focus try-update-focus)) (v0-0 (t9-0 obj arg0)) ) diff --git a/goal_src/jak2/engine/ai/enemy.gc b/goal_src/jak2/engine/ai/enemy.gc index 4b0b92762b..3f2a55a777 100644 --- a/goal_src/jak2/engine/ai/enemy.gc +++ b/goal_src/jak2/engine/ai/enemy.gc @@ -7,3 +7,3712 @@ ;; DECOMP BEGINS +(defmethod copy-enemy-info! enemy-info ((obj enemy-info) (obj-to-copy enemy-info)) + "Copies the given [[enemy-info]] into the current [[enemy-info]]" + (mem-copy! (&-> obj type) (&-> obj-to-copy type) 384) + 0 + (none) + ) + +(define *enemy-dummy-shadow-control* + (new 'static 'shadow-control :settings (new 'static 'shadow-settings + :flags (shadow-flags shdf03 disable-draw) + :shadow-dir (new 'static 'vector :y -1.0 :w 614400.0) + :bot-plane (new 'static 'plane :y 1.0 :w 4096.0) + :top-plane (new 'static 'plane :y 1.0 :w -4096.0) + ) + ) + ) + +;; WARN: Return type mismatch process-focusable vs enemy. +(defmethod relocate enemy ((obj enemy) (arg0 int)) + (if (nonzero? (-> obj neck)) + (&+! (-> obj neck) arg0) + ) + (the-as + enemy + ((the-as (function process-focusable int process-focusable) (find-parent-method enemy 7)) obj arg0) + ) + ) + +(defmethod get-rand-float enemy ((obj enemy)) + "@returns the result of calling [[rand-vu]]" + (rand-vu) + ) + +(defmethod get-rand-float-range enemy ((obj enemy) (low float) (high float)) + "@param low The lower bound of the range (inclusive) + @param high The upper bound of the range (exclusive) + @returns A random float in the specified range" + (+ low (* (rand-vu) (- high low))) + ) + +(defmethod get-rand-int enemy ((obj enemy) (high int)) + "@param high The upper bound of the range (exclusive) + @returns a random integer in the range 0 to `high` + @see [[rand-vu]]" + (the int (* (rand-vu) (the float high))) + ) + +(defmethod get-rand-int-range enemy ((obj enemy) (low int) (high int)) + "@param low The lower bound of the range (inclusive) + @param high The upper bound of the range (exclusive) + @returns A random integer in the specified range" + (+ low (the int (* (rand-vu) (the float (+ (- 1 low) high))))) + ) + +(defmethod rng-hit? enemy ((obj enemy) (chance float)) + "TODO - not the best name + @param chance The value to compare ([[>=]]) with the result from [[rand-vu]]. + @returns If `chance` is greater than the random draw" + (>= chance (rand-vu)) + ) + +;; WARN: new jak 2 until loop case, check carefully +(defmethod enemy-method-120 enemy ((obj enemy) (arg0 int) (arg1 int)) + "TODO" + (let ((v1-0 0) + (s5-0 0) + ) + (let ((a2-1 1)) + (while (nonzero? arg0) + (+! arg0 -1) + (if (not (logtest? arg1 a2-1)) + (+! v1-0 1) + ) + (set! a2-1 (* a2-1 2)) + ) + ) + (when (> v1-0 0) + (let ((v1-1 (get-rand-int obj v1-0)) + (a0-1 1) + ) + (until #f + (while (logtest? arg1 a0-1) + (nop!) + (nop!) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + (if (zero? v1-1) + (goto cfg-14) + ) + (+! v1-1 -1) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + ) + #f + ) + (label cfg-14) + s5-0 + ) + ) + +(defmethod enemy-method-123 enemy ((obj enemy) (arg0 float)) + "TODO" + (let* ((v1-5 (-> *display* frames (-> *display* last-screen) run-time)) + (f1-2 (fmax 0.0 (fmin 1.0 (* 0.001 (+ -7000.0 (the float v1-5)))))) + ) + (>= (+ arg0 (* f1-2 (- 1.0 arg0))) (rand-vu)) + ) + ) + +(defmethod coin-flip? enemy ((obj enemy)) + "@returns The result of a 50/50 RNG roll" + (zero? (get-rand-int obj 2)) + ) + +;; WARN: disable def twice: 40. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare. +(defmethod run-logic? enemy ((obj enemy)) + (cond + ((logtest? (-> obj mask) (process-mask actor-pause)) + (let ((draw (-> obj draw))) + (or (and (nonzero? draw) + (>= (+ (-> *ACTOR-bank* pause-dist) (-> obj root-override2 pause-adjust-distance)) + (vector-vector-distance (-> obj root-override2 trans) (camera-pos)) + ) + (or (logtest? (-> draw status) (draw-control-status on-screen)) + (not (and (-> obj next-state) (= (-> obj next-state name) 'idle))) + ) + ) + (and (nonzero? (-> obj skel)) (!= (-> obj skel root-channel 0) (-> obj skel channel))) + (and (nonzero? draw) (logtest? (-> draw status) (draw-control-status uninited))) + ) + ) + ) + (else + #t + ) + ) + ) + +;; WARN: Return type mismatch object vs symbol. +(defmethod enemy-method-53 enemy ((obj enemy) (proc-focus process-focusable)) + "TODO" + (the-as symbol (and proc-focus (!= obj proc-focus) (collide-check? (-> obj focus) proc-focus))) + ) + +(defmethod get-trans enemy ((obj enemy) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (let ((s4-0 (-> obj root-override2))) + (cond + ((zero? arg0) + (-> s4-0 trans) + ) + ((and (= arg0 1) (type? s4-0 collide-shape-moving)) + (-> s4-0 gspot-pos) + ) + ((= arg0 2) + (vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info look-at-joint))) + ) + ((= arg0 3) + (let ((v0-0 (vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info bullseye-joint))))) + (set! (-> v0-0 w) (-> obj root-override2 root-prim prim-core world-sphere w)) + v0-0 + ) + ) + (else + (-> s4-0 trans) + ) + ) + ) + ) + +(defmethod enemy-method-124 enemy ((obj enemy)) + "TODO" + (let* ((v1-0 (-> obj enemy-info)) + (v0-0 (if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (-> v1-0 recover-gnd-collide-with) + (-> v1-0 gnd-collide-with) + ) + ) + ) + (set! (-> obj gnd-collide) (the-as uint v0-0)) + v0-0 + ) + ) + +(defmethod enemy-method-59 enemy ((obj enemy)) + (penetrated-by-all&hit-points->penetrated-by (-> obj penetrated-by-all) (-> obj hit-points)) + ) + +(defmethod get-water-height enemy ((obj enemy)) + (-> obj water-surface-height) + ) + +(defmethod enemy-method-54 enemy ((obj enemy)) + (let ((s4-0 (-> obj root-override2))) + (when (>= (-> obj water-max-height) (-> s4-0 trans y)) + (let ((s5-0 (new 'stack-no-clear 'water-info))) + (water-info-init! s4-0 s5-0 (collide-action solid semi-solid)) + (let ((s3-0 (-> s5-0 flags))) + (when (logtest? (water-flags touch-water) s3-0) + (set! (-> obj enemy-flags) (logior (enemy-flag directed-ready) (-> obj enemy-flags))) + (set! (-> obj water-surface-height) (-> s5-0 trans y)) + (when (not (logtest? (-> obj focus-status) (focus-status touch-water under-water))) + (let ((s2-0 (new 'stack-no-clear 'vector))) + (set! (-> s2-0 quad) (-> obj root-override2 trans quad)) + (set! (-> s2-0 y) (+ 409.6 (-> s5-0 trans y))) + (let ((s1-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when s1-0 + (let ((t9-2 (method-of-type part-tracker activate))) + (t9-2 + (the-as part-tracker s1-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-3 run-function-in-process) + (a0-8 s1-0) + (a1-3 part-tracker-init) + (a2-5 (-> *part-group-id-table* 121)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> s2-0 quad)) + ((the-as (function object object object object object object object object none) t9-3) + a0-8 + a1-3 + a2-5 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> s1-0 ppointer) + ) + ) + ) + (cond + ((logtest? s3-0 (water-flags dark-eco)) + (sound-play "eco-splash") + (send-event obj 'instant-death) + ) + (else + (sound-play "splash") + ) + ) + ) + (logior! (-> obj focus-status) (focus-status touch-water)) + (let* ((v1-32 (-> s4-0 root-prim prim-core)) + (f0-5 (+ (-> v1-32 world-sphere y) (-> v1-32 world-sphere w))) + ) + (if (logtest? (-> obj focus-status) (focus-status under-water)) + (set! f0-5 (+ -819.2 f0-5)) + ) + (if (< f0-5 (-> s5-0 trans y)) + (logior! (-> obj focus-status) (focus-status under-water)) + (logclear! (-> obj focus-status) (focus-status under-water)) + ) + ) + (return (the-as enemy-flag #f)) + ) + ) + ) + ) + ) + (logclear! (-> obj focus-status) (focus-status touch-water under-water)) + (when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))) + (let ((v0-9 (logclear (-> obj enemy-flags) (enemy-flag directed-ready)))) + (set! (-> obj enemy-flags) v0-9) + v0-9 + ) + ) + ) + +(defmethod enemy-method-55 enemy ((obj enemy)) + (with-pp + (if (and (nonzero? (-> obj draw)) (logtest? (-> obj draw status) (draw-control-status on-screen))) + (set! (-> obj last-draw-time) (the-as uint (-> pp clock frame-counter))) + ) + (enemy-method-129 obj) + (if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (enemy-method-100 obj) + ) + (when *target* + (if *target* + (look-at! + (-> *target* neck) + (the-as vector (-> obj root-override2 root-prim prim-core)) + (if (logtest? (-> obj enemy-flags) (enemy-flag use-notice-distance)) + 'attacking + ) + obj + ) + ) + ) + (when (nonzero? (-> obj neck)) + (when (logtest? (-> obj enemy-flags) (enemy-flag lock-focus)) + (let ((a0-9 (handle->process (-> obj focus handle)))) + (if a0-9 + (target-set! (-> obj neck) (get-trans (the-as process-focusable a0-9) 2)) + ) + ) + ) + ) + (when (and (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup)) + (>= (- (-> pp clock frame-counter) (the-as int (-> obj auto-reset-penetrate-time))) (seconds 0.1)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag attackable-backup)) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + (let ((v1-48 0)) + (if (logtest? (penetrate knocked) (-> obj root-override2 penetrate-using)) + (set! v1-48 (logior (shl 1 32) v1-48)) + ) + (set! (-> obj root-override2 penetrate-using) (the-as penetrate v1-48)) + ) + ) + (if (logtest? (-> obj enemy-flags) (enemy-flag look-at-focus)) + (enemy-method-136 obj) + ) + (if (logtest? (enemy-flag trackable-backup directed-ready) (-> obj enemy-flags)) + (enemy-method-54 obj) + ) + (if (and *debug-segment* (-> obj enemy-info debug-draw-neck) (nonzero? (-> obj neck))) + (joint-mod-debug-draw (-> obj neck)) + ) + (ja-post) + 0 + (none) + ) + ) + +(defmethod enemy-method-136 enemy ((obj enemy)) + (with-pp + (when (or (>= (- (-> pp clock frame-counter) (the-as int (-> obj hit-focus-time))) (seconds 2)) + (and (handle->process (-> obj focus handle)) + (zero? (logand (-> (the-as process-focusable (handle->process (-> obj focus handle))) focus-status) + (focus-status disable dead ignore grabbed) + ) + ) + ) + ) + (let ((v0-0 (logclear (-> obj enemy-flags) (enemy-flag look-at-focus)))) + (set! (-> obj enemy-flags) v0-0) + v0-0 + ) + ) + ) + ) + +;; WARN: Return type mismatch int vs penetrate. +(defun get-penetrate-using-from-attack-event ((arg0 process-drawable) (arg1 event-message-block)) + (let ((v1-0 (the-as attack-info (-> arg1 param 1)))) + (if (logtest? (attack-info-mask penetrate-using) (-> v1-0 mask)) + (return (the-as penetrate (-> v1-0 penetrate-using))) + ) + ) + (let* ((gp-0 arg0) + (v1-3 (if (type? gp-0 process-drawable) + gp-0 + ) + ) + ) + (when v1-3 + (let* ((gp-1 (-> v1-3 root)) + (v1-4 (if (type? gp-1 collide-shape) + (the-as collide-shape gp-1) + ) + ) + ) + (if v1-4 + (return (the-as penetrate (logior (-> v1-4 penetrate-using) (penetrate generic-attack)))) + ) + ) + ) + ) + (the-as penetrate 2) + ) + +;; WARN: Return type mismatch process vs process-focusable. +(defmethod enemy-method-107 enemy ((obj enemy)) + (let ((v0-0 (handle->process (-> obj focus handle)))) + (if (and v0-0 + (not (and v0-0 + (zero? (logand (-> (the-as process-focusable v0-0) focus-status) (focus-status disable dead ignore grabbed))) + ) + ) + ) + (set! v0-0 (the-as process #f)) + ) + (the-as process-focusable v0-0) + ) + ) + +;; WARN: Return type mismatch symbol vs none. +(defmethod enemy-method-63 enemy ((obj enemy) (arg0 process-focusable) (arg1 symbol)) + (if arg1 + (enemy-focus-method-13 (-> obj focus) arg0 (the-as enemy-aware arg1)) + (try-update-focus (-> obj focus) arg0 obj) + ) + (none) + ) + +(defmethod enemy-method-62 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (let* ((s4-0 (handle->process (-> obj incoming attacker-handle))) + (s5-0 (if (type? s4-0 process-focusable) + s4-0 + ) + ) + ) + (when (enemy-method-53 obj (the-as process-focusable s5-0)) + (enemy-method-63 obj (the-as process-focusable s5-0) #f) + (logior! (-> obj focus flags) (enemy-flag lock-focus)) + ) + ) + ) + 0 + (none) + ) + +(defmethod enemy-method-108 enemy ((obj enemy) (arg0 enemy) (arg1 event-message-block)) + (let ((s4-0 (the-as touching-shapes-entry (-> arg1 param 0)))) + (when (and s4-0 + (and (logtest? (-> obj incoming penetrate-using) 4096) (zero? (logand (-> obj incoming penetrate-using) 32))) + (begin + (let ((s3-0 (-> s4-0 head))) + (while s3-0 + (let ((s2-0 (get-touched-prim s3-0 (-> arg0 root-override2) s4-0))) + (get-touched-prim s3-0 (-> obj root-override2) s4-0) + (when (logtest? (-> s2-0 prim-core action) (collide-action solid semi-solid deadly)) + (let* ((a0-5 obj) + (t9-2 (method-of-object a0-5 enemy-method-104)) + (a1-3 arg0) + (a2-3 s4-0) + (v1-13 *game-info*) + (a3-1 (+ (-> v1-13 attack-id) 1)) + ) + (set! (-> v1-13 attack-id) a3-1) + (if (t9-2 a0-5 a1-3 (the-as uint a2-3) a3-1) + (return 0) + ) + ) + ) + ) + (set! s3-0 (-> s3-0 next)) + ) + ) + #f + ) + ) + ) + ) + 0 + ) + +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-64 enemy ((obj enemy)) + (let ((v1-1 (-> obj root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (collide-spec)) + (set! (-> v1-1 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logior! (-> obj focus-status) (focus-status disable)) + (go (method-of-object obj dormant)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-65 enemy ((obj enemy)) + (let ((v1-1 (-> obj root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (collide-spec)) + (set! (-> v1-1 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logior! (-> obj focus-status) (focus-status disable)) + (go (method-of-object obj dormant-aware)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-stare enemy ((obj enemy)) + (go (method-of-object obj stare)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-stare2 enemy ((obj enemy)) + (go (method-of-object obj stare)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-hostile enemy ((obj enemy)) + (go (method-of-object obj hostile)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-ambush enemy ((obj enemy)) + (go (method-of-object obj ambush)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-flee enemy ((obj enemy)) + (go (method-of-object obj flee)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-directed enemy ((obj enemy)) + (go (method-of-object obj directed)) + (none) + ) + +(defmethod enemy-method-72 enemy ((obj enemy)) + (let ((s5-0 (-> obj focus aware))) + (cond + ((and (= s5-0 (enemy-aware enemy-aware-3)) (enemy-method-107 obj)) + (go-hostile obj) + ) + ((<= (the-as int s5-0) 0) + (go (method-of-object obj idle)) + ) + ((>= 1 (the-as int s5-0)) + (go (method-of-object obj active)) + ) + ((= s5-0 (enemy-aware enemy-aware-4)) + (go-flee obj) + ) + (else + (go-stare obj) + ) + ) + ) + (none) + ) + +(defmethod enemy-method-93 enemy ((obj enemy)) + (if (logtest? (enemy-flag alert) (-> obj enemy-flags)) + (go-directed obj) + (enemy-method-72 obj) + ) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-73 enemy ((obj enemy)) + (if (-> obj enemy-info use-die-falling) + (go (method-of-object obj die-falling)) + (go (method-of-object obj die)) + ) + (none) + ) + +(defmethod enemy-method-135 enemy ((obj enemy) (arg0 int)) + (let ((gp-0 (make-u128 0 0))) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (set! gp-0 (the-as uint (-> obj enemy-info sound-hit))) + ) + ((= v1-0 1) + (set! gp-0 (the-as uint (-> obj enemy-info sound-die))) + ) + ) + ) + (if (nonzero? gp-0) + (sound-play-by-name (the-as sound-name gp-0) (new-sound-id) 1024 0 0 (sound-group sfx) #t) + ) + ) + ) + +(defmethod enemy-method-94 enemy ((obj enemy) (arg0 vector) (arg1 float)) + (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-0 quad) (-> arg0 quad)) + (set! (-> s4-0 y) 0.0) + (vector-normalize! s4-0 1.0) + (set! (-> s5-0 y) 0.0) + (vector-normalize! s5-0 1.0) + (>= (vector-dot s4-0 s5-0) (cos arg1)) + ) + ) + +(defmethod enemy-method-95 enemy ((obj enemy) (arg0 vector) (arg1 float)) + (let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj root-override2 trans)))) + (enemy-method-94 obj v1-1 arg1) + ) + ) + +(defmethod enemy-method-96 enemy ((obj enemy) (arg0 float) (arg1 symbol)) + (let ((a0-2 (handle->process (-> obj focus handle)))) + (cond + (a0-2 + (let ((s4-1 (vector-! + (new 'stack-no-clear 'vector) + (get-trans (the-as process-focusable a0-2) 0) + (-> obj root-override2 trans) + ) + ) + ) + (enemy-method-94 obj s4-1 arg0) + ) + ) + (else + arg1 + ) + ) + ) + ) + +(defmethod enemy-method-104 enemy ((obj enemy) (arg0 process) (arg1 uint) (arg2 uint)) + (let ((v1-1 (-> obj enemy-info attack-damage))) + (if (and (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) (= v1-1 1)) + (set! v1-1 2) + ) + (let ((a1-2 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-2 from) (process->ppointer self)) + (set! (-> a1-2 num-params) 2) + (set! (-> a1-2 message) 'attack) + (set! (-> a1-2 param 0) arg1) + (let ((a0-10 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id damage knock)))) + (set! (-> a0-10 id) arg2) + (set! (-> a0-10 shove-back) (-> obj enemy-info attack-shove-back)) + (set! (-> a0-10 shove-up) (-> obj enemy-info attack-shove-up)) + (set! (-> a0-10 mode) (-> obj enemy-info attack-mode)) + (set! (-> a0-10 damage) (the float v1-1)) + (set! (-> a0-10 knock) (the-as uint 8)) + (set! (-> a1-2 param 1) (the-as uint a0-10)) + ) + (when (send-event-function arg0 a1-2) + (enemy-method-105 obj arg0) + #t + ) + ) + ) + ) + +(defmethod enemy-method-105 enemy ((obj enemy) (arg0 process)) + (with-pp + (when (logtest? (process-mask target bot) (-> arg0 mask)) + (set! (-> obj root-override2 penetrated-by) (the-as penetrate -1)) + (enemy-method-49 obj) + ) + (let ((s5-0 (if (type? arg0 process-focusable) + arg0 + ) + ) + ) + (when (enemy-method-53 obj (the-as process-focusable s5-0)) + (let ((v1-10 (handle->process (-> obj focus handle)))) + (when (or (= s5-0 v1-10) (and (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (or (not v1-10) (zero? (logand (-> obj focus flags) (enemy-flag lock-focus)))) + ) + ) + (enemy-method-63 obj (the-as process-focusable s5-0) #f) + (set! (-> obj hit-focus-time) (the-as uint (-> pp clock frame-counter))) + (let ((v0-3 (logior (-> obj enemy-flags) (enemy-flag look-at-focus)))) + (set! (-> obj enemy-flags) v0-3) + v0-3 + ) + ) + ) + ) + ) + ) + ) + +(defmethod enemy-method-49 enemy ((obj enemy)) + (logior! (-> obj enemy-flags) (enemy-flag attackable-backup)) + (let ((v0-0 (-> self clock frame-counter))) + (set! (-> obj auto-reset-penetrate-time) (the-as uint v0-0)) + v0-0 + ) + ) + +(defmethod enemy-method-50 enemy ((obj enemy) (arg0 vector)) + (set! (-> arg0 quad) (-> obj incoming attack-direction quad)) + (let ((v1-1 arg0)) + (when (= (+ (* (-> v1-1 x) (-> v1-1 x)) (* (-> v1-1 z) (-> v1-1 z))) 0.0) + (vector-z-quaternion! arg0 (-> obj root-override2 quat)) + (vector-negate-in-place! arg0) + ) + ) + (set! (-> arg0 y) 0.0) + (vector-xz-normalize! arg0 1.0) + ) + +;; WARN: Return type mismatch int vs uint. +(defmethod enemy-method-131 enemy ((obj enemy) (arg0 int)) + (the-as uint (cond + ((logtest? arg0 1024) + 7 + ) + ((logtest? #x1000000 arg0) + 6 + ) + ((logtest? #x4400000 arg0) + 4 + ) + ((logtest? #x800000 arg0) + 5 + ) + ((logtest? #xc0000 arg0) + 3 + ) + ((logtest? #xa200000 arg0) + 2 + ) + ((logtest? arg0 #x4000) + 1 + ) + (else + 0 + ) + ) + ) + ) + +(defmethod enemy-method-106 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 int) (arg3 attack-info)) + (set! (-> obj incoming penetrate-using) (the-as uint arg2)) + (set! (-> obj incoming attack-id) (-> arg3 id)) + (let ((v1-3 (if (logtest? (attack-info-mask knock) (-> arg3 mask)) + (-> arg3 knock) + (enemy-method-131 obj arg2) + ) + ) + ) + (set! (-> obj incoming knocked-type) (the-as knocked-type v1-3)) + (let ((a0-4 (-> self clock frame-counter))) + (cond + ((!= v1-3 6) + (set! (-> obj incoming blue-juggle-count) (the-as uint 0)) + 0 + ) + ((>= (- (-> self clock frame-counter) (-> obj incoming attack-time)) (seconds 1)) + (set! (-> obj incoming blue-juggle-count) (the-as uint 1)) + ) + (else + (set! (-> obj incoming blue-juggle-count) (the-as uint (+ (-> obj incoming blue-juggle-count) 1))) + ) + ) + (set! (-> obj incoming attack-time) a0-4) + ) + (cond + ((= v1-3 7) + (set! (-> obj incoming attack-direction quad) (-> arg3 vector quad)) + ) + (else + (let ((s3-0 (new 'stack-no-clear 'attack-info))) + (attack-info-method-9 arg3 s3-0 (the-as process-drawable arg0) obj) + (set! (-> obj incoming attacker-pos quad) (-> s3-0 intersection quad)) + (set! (-> obj incoming attack-direction quad) (-> s3-0 attacker-velocity quad)) + ) + ) + ) + ) + (set! (-> obj incoming attacker-handle) (process->handle (enemy-method-134 obj arg0 arg3))) + 0 + (none) + ) + +(defmethod enemy-method-109 enemy ((obj enemy) (arg0 int)) + (case arg0 + ((1) + (logclear! (-> obj enemy-flags) (enemy-flag death-start)) + (logior! (-> obj enemy-flags) (enemy-flag lock-focus)) + ) + ((2) + (logclear! (-> obj enemy-flags) (enemy-flag lock-focus)) + (logior! (-> obj enemy-flags) (enemy-flag death-start)) + ) + ) + (if (nonzero? (-> obj neck)) + (mode-set! (-> obj neck) (joint-mod-mode look-at)) + ) + 0 + (none) + ) + +(defmethod enemy-method-110 enemy ((obj enemy)) + (when (nonzero? (-> obj neck)) + (logclear! (-> obj enemy-flags) (enemy-flag lock-focus death-start)) + (shut-down (-> obj neck)) + ) + 0 + (none) + ) + +(defmethod enemy-method-125 enemy ((obj enemy) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float)) + (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4) + (let ((v0-1 (-> arg0 best-other-tri pat))) + (set! (-> obj root-override2 ground-pat) v0-1) + v0-1 + ) + ) + ) + +(defmethod enemy-method-126 enemy ((obj enemy) (arg0 collide-query) (arg1 vector) (arg2 collide-spec) (arg3 float) (arg4 float) (arg5 float)) + (above-ground? (-> obj root-override2) arg0 arg1 arg2 arg3 arg4 arg5) + ) + +(defmethod enemy-method-127 enemy ((obj enemy) (arg0 float) (arg1 float) (arg2 symbol) (arg3 collide-spec)) + (let ((s4-0 (new 'stack-no-clear 'collide-query))) + (cond + ((enemy-method-125 obj s4-0 arg3 arg0 arg1 1024.0) + (let ((s5-1 (-> obj root-override2))) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (set! (-> s3-0 quad) (-> obj root-override2 trans quad)) + (set! (-> s3-0 y) (-> s4-0 best-other-tri intersect y)) + (move-to-point! s5-1 s3-0) + (let ((a0-3 (-> s4-0 best-other-tri normal)) + (v1-8 (-> s4-0 best-other-tri pat)) + ) + (set! (-> s5-1 grount-touch-point quad) (-> s3-0 quad)) + (set! (-> s5-1 poly-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 surface-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 local-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 ground-poly-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 poly-pat) v1-8) + (set! (-> s5-1 cur-pat) v1-8) + (set! (-> s5-1 ground-pat) v1-8) + ) + ) + (logior! (-> s5-1 status) (collide-status on-surface on-ground touch-surface)) + ) + #t + ) + (else + (let ((v1-11 (-> obj root-override2))) + (logclear! (-> v1-11 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> v1-11 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((a0-12 (-> v1-11 dynam gravity-normal))) + (set! (-> v1-11 local-normal quad) (-> a0-12 quad)) + (set! (-> v1-11 surface-normal quad) (-> a0-12 quad)) + (set! (-> v1-11 poly-normal quad) (-> a0-12 quad)) + ) + (set! (-> v1-11 coverage) 0.0) + (set! (-> v1-11 touch-angle) 0.0) + ) + ) + (if arg2 + (format 0 "WARNING: enemy::move-to-ground: failed to locate ground for ~S!~%" (-> obj name)) + ) + #f + ) + ) + ) + ) + +(defmethod enemy-method-128 enemy ((obj enemy) (arg0 vector) (arg1 move-above-ground-params)) + (let ((gp-0 (-> obj root-override2))) + (set! (-> arg1 on-ground?) #f) + (set! (-> arg1 do-move?) #t) + (set! (-> arg1 old-gspot-pos quad) (-> gp-0 gspot-pos quad)) + (set! (-> arg1 old-gspot-normal quad) (-> gp-0 gspot-normal quad)) + (set! (-> gp-0 trans-old-old-old quad) (-> gp-0 trans-old-old quad)) + (set! (-> gp-0 trans-old-old quad) (-> gp-0 trans-old quad)) + (set! (-> gp-0 trans-old quad) (-> gp-0 trans quad)) + (set! (-> gp-0 prev-status) (-> gp-0 status)) + (vector-v+! (-> gp-0 trans) (-> gp-0 trans) arg0) + (set! (-> arg1 new-pos quad) (-> gp-0 trans quad)) + (let ((s2-0 (new 'stack-no-clear 'collide-query))) + (cond + ((enemy-method-125 obj s2-0 (-> arg1 gnd-collide-with) (-> arg1 popup) 81920.0 1024.0) + (when (>= (-> gp-0 gspot-pos y) (-> arg1 new-pos y)) + (set! (-> arg1 on-ground?) #t) + (set! (-> arg1 pat) (-> s2-0 best-other-tri pat)) + (set! (-> arg1 new-pos y) (-> s2-0 best-other-tri intersect y)) + (set! (-> gp-0 ground-impact-vel) (- (vector-dot arg0 (-> gp-0 dynam gravity-normal)))) + (set! (-> arg0 y) 0.0) + ) + ) + (else + (if (-> arg1 hover-if-no-ground?) + (set! (-> arg1 new-pos y) (-> gp-0 trans-old y)) + ) + ) + ) + ) + (set! (-> gp-0 trans quad) (-> gp-0 trans-old quad)) + (move-to-point! gp-0 (-> arg1 new-pos)) + (when (logtest? (logand (-> arg1 overlaps-params collide-with-filter) + (collide-spec hit-by-player-list hit-by-others-list player-list) + ) + (-> gp-0 root-prim prim-core collide-with) + ) + (when (find-overlapping-shapes gp-0 (-> arg1 overlaps-params)) + (when (-> arg1 dont-move-if-overlaps?) + (set! (-> arg1 do-move?) #f) + (move-to-point! gp-0 (-> gp-0 trans-old)) + (set! (-> gp-0 gspot-pos quad) (-> arg1 old-gspot-pos quad)) + (set! (-> gp-0 gspot-normal quad) (-> arg1 old-gspot-normal quad)) + ) + ) + ) + (when (-> arg1 do-move?) + (cond + ((-> arg1 on-ground?) + (let ((a1-6 (-> gp-0 gspot-pos)) + (a0-21 (-> gp-0 gspot-normal)) + (v1-39 (-> arg1 pat)) + ) + (set! (-> gp-0 grount-touch-point quad) (-> a1-6 quad)) + (set! (-> gp-0 poly-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 surface-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 local-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 ground-poly-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 poly-pat) v1-39) + (set! (-> gp-0 cur-pat) v1-39) + (set! (-> gp-0 ground-pat) v1-39) + ) + (logior! (-> gp-0 status) (collide-status on-surface on-ground touch-surface)) + ) + (else + (logclear! (-> gp-0 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> gp-0 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((v1-49 (-> gp-0 dynam gravity-normal))) + (set! (-> gp-0 local-normal quad) (-> v1-49 quad)) + (set! (-> gp-0 surface-normal quad) (-> v1-49 quad)) + (set! (-> gp-0 poly-normal quad) (-> v1-49 quad)) + ) + (set! (-> gp-0 coverage) 0.0) + (set! (-> gp-0 touch-angle) 0.0) + ) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod enemy-method-111 enemy ((obj enemy)) + (let ((v1-0 (-> obj root-override2))) + (when (logtest? (-> v1-0 status) (collide-status touch-surface)) + (let ((f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> self clock seconds-per-frame) (+ -1.0 (-> obj enemy-info friction))))))) + (vector-float*! (-> v1-0 transv) (-> v1-0 transv) f0-1) + ) + 0 + ) + ) + 0 + (none) + ) + +(defmethod enemy-method-114 enemy ((obj enemy)) + "@abstract" + 0 + (none) + ) + +(defmethod enemy-method-115 enemy ((obj enemy)) + "@abstract" + 0 + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-idle enemy ((obj enemy)) + (go (method-of-object obj idle)) + (none) + ) + +(defmethod enemy-method-112 enemy ((obj enemy) (arg0 enemy-info)) + (set! (-> obj enemy-info) arg0) + (when (and (!= (-> obj enemy-info neck-joint) -1) (zero? (-> obj neck))) + (set! (-> obj neck) (new 'process 'joint-mod (joint-mod-mode flex-blend) obj (-> obj enemy-info neck-joint))) + (set-vector! (-> obj neck twist-max) 8192.0 8192.0 0.0 1.0) + (set! (-> obj neck up) (the-as uint 1)) + (set! (-> obj neck nose) (the-as uint 2)) + (set! (-> obj neck ear) (the-as uint 0)) + (set! (-> obj neck max-dist) 102400.0) + (set! (-> obj neck ignore-angle) 16384.0) + ) + 0 + (none) + ) + +(defmethod enemy-method-113 enemy ((obj enemy) (arg0 enemy-info)) + (local-vars (sv-16 res-tag)) + (when (coin-flip? obj) + (let ((a0-2 (-> obj node-list data 2))) + (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!)) + (set! (-> a0-2 param1) #f) + (set! (-> a0-2 param2) #f) + ) + (set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag dislike-combo) (-> obj enemy-flags)))) + ) + (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask))) + (logior! (-> obj mask) (process-mask actor-pause)) + (logior! (-> obj enemy-flags) (enemy-flag notice)) + (enemy-method-112 obj arg0) + (let ((a1-2 (-> obj enemy-info idle-anim-script))) + (if a1-2 + (idle-control-method-9 (-> obj idle-anim-player) a1-2) + ) + ) + (if (-> obj draw shadow) + (set! (-> obj draw shadow-ctrl) (new + 'process + 'shadow-control + (-> obj enemy-info shadow-min-y) + (-> obj enemy-info shadow-max-y) + (-> obj enemy-info shadow-locus-dist) + (shadow-flags shdf00 shdf04) + 245760.0 + ) + ) + (set! (-> obj draw shadow-ctrl) *enemy-dummy-shadow-control*) + ) + (set! (-> obj water-max-height) 8192.0) + (if (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + (set! (-> obj hit-points) (* (-> obj enemy-info default-hit-points) 2)) + (set! (-> obj hit-points) (-> obj enemy-info default-hit-points)) + ) + (let* ((v1-38 *game-info*) + (a0-10 (+ (-> v1-38 attack-id) 1)) + ) + (set! (-> v1-38 attack-id) a0-10) + (set! (-> obj attack-id) a0-10) + ) + (let* ((v1-39 *game-info*) + (a0-12 (+ (-> v1-39 attack-id) 1)) + ) + (set! (-> v1-39 attack-id) a0-12) + (set! (-> obj persistent-attack-id) a0-12) + ) + (set! (-> obj incoming attacker-handle) (the-as handle #f)) + (enemy-method-124 obj) + (set! (-> obj fact-info-override) (new + 'process + 'fact-info-enemy + obj + (the-as (pointer float) (-> arg0 fact-defaults)) + (pickup-type eco-pill-random) + (-> *FACT-bank* default-eco-pill-green-inc) + ) + ) + (let ((a1-5 (if (logtest? (enemy-option multi-focus) (-> obj fact-info-override enemy-options)) + #x400406 + #x400402 + ) + ) + ) + (reset-to-collide-spec (-> obj focus) (the-as collide-spec a1-5)) + ) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-49 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16)))) + (cond + ((and v1-49 (nonzero? (-> sv-16 elt-count))) + (set! (-> obj actor-group) (the-as actor-group v1-49)) + (set! (-> obj actor-group-count) (the-as int (-> sv-16 elt-count))) + ) + (else + (set! (-> obj actor-group) #f) + (set! (-> obj actor-group-count) 0) + 0 + ) + ) + ) + (set! (-> obj on-notice) (res-lump-struct (-> obj entity) 'on-notice symbol)) + (set! (-> obj on-active) (res-lump-struct (-> obj entity) 'on-active symbol)) + (set! (-> obj on-hostile) (res-lump-struct (-> obj entity) 'on-hostile symbol)) + (set! (-> obj on-death) (res-lump-struct (-> obj entity) 'on-death symbol)) + (if (-> obj on-notice) + (logior! (-> obj enemy-flags) (enemy-flag auto-reset-penetrate)) + ) + (if (-> obj on-active) + (logior! (-> obj enemy-flags) (enemy-flag jump-check-blocked)) + ) + (if (-> obj on-hostile) + (logior! (-> obj enemy-flags) (enemy-flag drawn-mirrored)) + ) + (let ((s4-0 (-> obj root-override2))) + (set! (-> obj penetrated-by-all) (-> s4-0 penetrated-by)) + (set! (-> s4-0 penetrated-by) (enemy-method-59 obj)) + (set! (-> s4-0 event-self) 'touched) + ) + (set! (-> obj penetrated-flinch) (the-as penetrate (-> arg0 penetrate-flinch))) + (set! (-> obj penetrated-knocked) (the-as penetrate (-> arg0 penetrate-knocked))) + (set! (-> obj reaction-time) (the-as uint (get-rand-int-range obj 30 180))) + (let* ((v1-79 (-> obj enemy-flags)) + (a0-28 (-> obj fact-info-override enemy-options)) + (v1-80 (logior (enemy-flag + enable-on-active + checking-water + enable-on-notice + look-at-move-dest + check-water-backup + no-initial-move-to-ground + ) + v1-79 + ) + ) + ) + (if (logtest? (enemy-option multi-focus) a0-28) + (set! v1-80 (logior (enemy-flag trackable) v1-80)) + ) + (if (logtest? (enemy-option has-trigger) a0-28) + (set! v1-80 (logior (enemy-flag called-dying) v1-80)) + ) + (set! (-> obj enemy-flags) v1-80) + ) + (set! (-> obj mask) (logior (process-mask collectable) (-> obj mask))) + (if (and (-> obj enemy-info move-to-ground) + (not (logtest? (enemy-flag vulnerable-backup) (-> obj enemy-flags))) + (zero? (logand (enemy-option ambush) (-> obj fact-info-override enemy-options))) + ) + (enemy-method-127 obj 40960.0 40960.0 #t (the-as collide-spec (-> obj gnd-collide))) + ) + (if (zero? (-> obj draw light-index)) + (set! (-> obj draw light-index) (the-as uint 10)) + ) + 0 + (none) + ) + +(defbehavior enemy-init-by-other enemy ((arg0 process-drawable) (arg1 transformq)) + (let ((a1-1 (-> arg1 scale x))) + (if a1-1 + (process-entity-set! self (the-as entity-actor a1-1)) + ) + ) + (if (-> arg1 scale y) + (set! (-> self enemy-flags) (logior (enemy-flag alert) (-> self enemy-flags))) + ) + (if (-> arg1 scale z) + (set! (-> self enemy-flags) (the-as enemy-flag (logior (enemy-flag vulnerable-backup) (-> self enemy-flags)))) + ) + (enemy-method-114 self) + (set! (-> self root-override2 trans quad) (-> arg1 trans quad)) + (quaternion-copy! (-> self root-override2 quat) (-> arg1 quat)) + (vector-identity! (-> self root-override2 scale)) + (enemy-method-115 self) + (when (> (-> self enemy-info gem-joint) 0) + (cond + ((and (or (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status save))) + (not (-> self entity)) + ) + (not (or (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + ) + (setup-masks + (-> self draw) + (the-as int (-> self enemy-info gem-no-seg)) + (the-as int (-> self enemy-info gem-seg)) + ) + ) + (else + (setup-masks + (-> self draw) + (the-as int (-> self enemy-info gem-seg)) + (the-as int (-> self enemy-info gem-no-seg)) + ) + (add-connection *part-engine* self (-> self enemy-info gem-joint) self 314 (-> self enemy-info gem-offset)) + ) + ) + ) + (let ((v1-43 (-> self fact-info-override enemy-options))) + (cond + (*debug-view-anims* + (go-virtual view-anims) + ) + ((logtest? (enemy-option dormant) v1-43) + (enemy-method-64 self) + ) + ((logtest? (enemy-flag alert) (-> self enemy-flags)) + (go-directed self) + ) + ((logtest? (enemy-option dormant-aware) v1-43) + (enemy-method-65 self) + ) + ((logtest? (enemy-option ambush) (-> self fact-info-override enemy-options)) + (go-ambush self) + ) + (else + (go-idle self) + ) + ) + ) + (none) + ) + +(defmethod init-from-entity! enemy ((obj enemy) (arg0 entity-actor)) + (enemy-method-114 obj) + (process-drawable-from-entity! obj arg0) + (enemy-method-115 obj) + (when (>= (-> obj enemy-info gem-joint) 0) + (cond + ((and (or (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save))) + (not (-> obj entity)) + ) + (not (or (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + ) + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-no-seg)) + (the-as int (-> obj enemy-info gem-seg)) + ) + ) + (else + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-seg)) + (the-as int (-> obj enemy-info gem-no-seg)) + ) + (add-connection *part-engine* obj (-> obj enemy-info gem-joint) obj 314 (-> obj enemy-info gem-offset)) + ) + ) + ) + (let ((v1-28 (-> obj fact-info-override enemy-options))) + (cond + ((logtest? (enemy-option spawner) v1-28) + (process-entity-status! obj (entity-perm-status dead) #t) + (go (method-of-object obj die-fast)) + ) + (*debug-view-anims* + (go (method-of-object obj view-anims)) + ) + ((logtest? (enemy-option dormant) v1-28) + (enemy-method-64 obj) + ) + ((logtest? (enemy-option dormant-aware) v1-28) + (enemy-method-65 obj) + ) + (else + (go-idle obj) + ) + ) + ) + (none) + ) + +(defmethod enemy-method-98 enemy ((obj enemy) (arg0 process-focusable) (arg1 vector)) + #t + ) + +(defmethod enemy-method-99 enemy ((obj enemy) (arg0 process-focusable)) + #f + ) + +(defmethod reset-to-collide-spec enemy-focus ((obj enemy-focus) (arg0 collide-spec)) + (let ((t9-0 (method-of-type focus reset-to-collide-spec))) + (t9-0 obj arg0) + ) + (set! (-> obj aware) (enemy-aware enemy-aware-0)) + 0 + (none) + ) + +;; WARN: Return type mismatch process vs none. +;; WARN: Function (method 129 enemy) has a return type of none, but the expression builder found a return statement. +(defmethod enemy-method-129 enemy ((obj enemy)) + (let ((gp-0 (-> obj focus))) + (let ((a1-0 (handle->process (-> gp-0 handle)))) + (when a1-0 + (let ((v1-4 (-> obj enemy-flags))) + (cond + ((and a1-0 (zero? (logand (-> (the-as process-focusable a1-0) focus-status) (focus-status disable dead)))) + (when (and (logtest? (enemy-flag trackable) v1-4) + (not (logtest? (enemy-flag actor-pause-backup) v1-4)) + (zero? (logand (-> gp-0 flags) (enemy-flag lock-focus))) + ) + (enemy-method-97 obj) + (return #f) + ) + (let ((v1-14 (enemy-method-61 + obj + (the-as int (enemy-method-57 obj (the-as process-focusable a1-0) (the-as enemy-best-focus #f))) + ) + ) + ) + (set! (-> gp-0 aware) (the-as enemy-aware v1-14)) + (if (>= 1 v1-14) + (logclear! (-> gp-0 flags) (enemy-flag lock-focus)) + ) + ) + (return #f) + ) + (else + (clear-focused gp-0) + ) + ) + ) + ) + ) + (if (!= (-> gp-0 handle) #f) + (clear-focused gp-0) + ) + ) + (if (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (enemy-method-97 obj) + ) + (none) + ) + +(defmethod enemy-method-97 enemy ((obj enemy)) + (let ((s4-0 (-> obj focus collide-with)) + (gp-0 (new 'stack-no-clear 'enemy-best-focus)) + ) + (set! (-> gp-0 proc) #f) + (set! (-> gp-0 rating) 409600000.0) + (set! (-> gp-0 aware) (enemy-aware enemy-aware-0)) + (when (logtest? s4-0 (collide-spec player-list)) + (let ((v1-4 (-> *collide-player-list* alive-list next0))) + *collide-player-list* + (let ((s3-0 (-> v1-4 next0))) + (while (!= v1-4 (-> *collide-player-list* alive-list-end)) + (let ((v1-5 (the-as collide-shape (-> (the-as connection v1-4) param1)))) + (when (logtest? s4-0 (-> v1-5 root-prim prim-core collide-as)) + (let* ((s2-0 (-> v1-5 process)) + (a1-1 (if (type? s2-0 process-focusable) + (the-as process-focusable s2-0) + ) + ) + ) + (if (and a1-1 (and a1-1 (zero? (logand (-> a1-1 focus-status) (focus-status disable dead)))) (!= obj a1-1)) + (enemy-method-57 obj a1-1 gp-0) + ) + ) + ) + ) + (set! v1-4 s3-0) + *collide-player-list* + (set! s3-0 (-> s3-0 next0)) + ) + ) + ) + ) + (when (logtest? s4-0 (collide-spec hit-by-player-list hit-by-others-list)) + (when (logtest? s4-0 (collide-spec hit-by-player-list)) + (let ((v1-19 (-> *collide-hit-by-player-list* alive-list next0))) + *collide-hit-by-player-list* + (let ((s3-1 (-> v1-19 next0))) + (while (!= v1-19 (-> *collide-hit-by-player-list* alive-list-end)) + (let ((v1-20 (the-as collide-shape (-> (the-as connection v1-19) param1)))) + (when (logtest? s4-0 (-> v1-20 root-prim prim-core collide-as)) + (let* ((s2-1 (-> v1-20 process)) + (a1-3 (if (type? s2-1 process-focusable) + (the-as process-focusable s2-1) + ) + ) + ) + (if (and a1-3 (and a1-3 (zero? (logand (-> a1-3 focus-status) (focus-status disable dead)))) (!= obj a1-3)) + (enemy-method-57 obj a1-3 gp-0) + ) + ) + ) + ) + (set! v1-19 s3-1) + *collide-hit-by-player-list* + (set! s3-1 (-> s3-1 next0)) + ) + ) + ) + ) + (when (logtest? s4-0 (collide-spec hit-by-others-list)) + (let ((v1-32 (-> *collide-hit-by-others-list* alive-list next0))) + *collide-hit-by-others-list* + (let ((s3-2 (-> v1-32 next0))) + (while (!= v1-32 (-> *collide-hit-by-others-list* alive-list-end)) + (let ((v1-33 (the-as collide-shape (-> (the-as connection v1-32) param1)))) + (when (logtest? s4-0 (-> v1-33 root-prim prim-core collide-as)) + (let* ((s2-2 (-> v1-33 process)) + (a1-5 (if (type? s2-2 process-focusable) + (the-as process-focusable s2-2) + ) + ) + ) + (if (and a1-5 (and a1-5 (zero? (logand (-> a1-5 focus-status) (focus-status disable dead)))) (!= obj a1-5)) + (enemy-method-57 obj a1-5 gp-0) + ) + ) + ) + ) + (set! v1-32 s3-2) + *collide-hit-by-others-list* + (set! s3-2 (-> s3-2 next0)) + ) + ) + ) + ) + ) + (let ((s4-1 (-> gp-0 proc))) + (when s4-1 + (enemy-method-63 + obj + (the-as process-focusable s4-1) + (the-as symbol (enemy-method-61 obj (the-as int (-> gp-0 aware)))) + ) + s4-1 + ) + ) + ) + ) + +;; WARN: Return type mismatch int vs enemy-aware. +(defmethod enemy-method-57 enemy ((obj enemy) (arg0 process-focusable) (arg1 enemy-best-focus)) + (let ((f30-0 (vector-vector-distance (get-trans arg0 0) (-> obj root-override2 trans))) + (s3-1 #f) + (s2-0 #f) + ) + (cond + ((< f30-0 (-> obj enemy-info proximity-notice-distance)) + (set! s3-1 #t) + (set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f))) + ) + (else + (let ((f0-1 (the-as float (-> obj enemy-info notice-distance)))) + (if (< 1 (the-as int (-> obj focus aware))) + (set! f0-1 (+ (the-as meters f0-1) (-> obj enemy-info notice-distance-delta))) + ) + (when (or (< f30-0 f0-1) (zero? (logand (-> obj enemy-flags) (enemy-flag enable-on-notice)))) + (set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f))) + (if s2-0 + (set! s3-1 #t) + ) + ) + ) + ) + ) + (let ((s3-2 (cond + (s3-1 + (cond + ((enemy-method-99 obj arg0) + 4 + ) + (s2-0 + 3 + ) + (else + 2 + ) + ) + ) + ((< f30-0 (-> obj fact-info-override idle-distance)) + 1 + ) + (else + 0 + ) + ) + ) + ) + (when (and (> s3-2 0) (logtest? (enemy-flag called-dying) (-> obj enemy-flags))) + (cond + ((logtest? (enemy-option idle-til-trigger) (-> obj fact-info-override enemy-options)) + (if (not (enemy-method-130 obj f30-0)) + (set! s3-2 0) + ) + ) + (else + (if (and (< 1 s3-2) (not (enemy-method-130 obj f30-0))) + (set! s3-2 1) + ) + ) + ) + ) + (when arg1 + (when (and (>= s3-2 (the-as int (-> arg1 aware))) (< f30-0 (-> arg1 rating))) + (set! (-> arg1 aware) (the-as enemy-aware s3-2)) + (set! (-> arg1 rating) f30-0) + (set! (-> arg1 proc) arg0) + ) + ) + (the-as enemy-aware s3-2) + ) + ) + ) + +(defmethod enemy-method-130 enemy ((obj enemy) (arg0 float)) + (let* ((v1-0 (-> obj fact-info-override)) + (a2-0 (-> v1-0 trig-mask-count)) + (a3-0 (-> v1-0 trig-mask)) + ) + (dotimes (t0-0 a2-0) + (let ((t1-1 (the-as int (-> a3-0 t0-0)))) + (if (and (logtest? (the-as uint t1-1) 1) (>= (-> v1-0 trig-dist) arg0)) + (set! t1-1 (the-as int (logand -2 (the-as uint t1-1)))) + ) + (when (logtest? (the-as uint t1-1) 2) + (let ((t2-8 (-> v1-0 trig-actor-group 0))) + (countdown (t3-0 (-> t2-8 length)) + (let ((t5-0 (-> t2-8 data t3-0 actor))) + (when (and t5-0 (logtest? (-> t5-0 extra perm status) (entity-perm-status subtask-complete))) + (set! t1-1 (logand -3 t1-1)) + (goto cfg-17) + ) + ) + ) + ) + ) + (label cfg-17) + (when (zero? t1-1) + (logclear! (-> obj enemy-flags) (enemy-flag called-dying)) + (return #t) + ) + ) + ) + ) + #f + ) + +(defmethod enemy-method-61 enemy ((obj enemy) (arg0 int)) + (let ((v1-1 (< 1 arg0))) + (cond + (v1-1 + (when (not (logtest? (-> obj enemy-flags) (enemy-flag spawn-gem))) + (logior! (-> obj enemy-flags) (enemy-flag spawn-gem)) + (set! (-> obj notice-time) (the-as uint (-> self clock frame-counter))) + ) + (if (and (not (logtest? (-> obj enemy-flags) (enemy-flag chase-startup))) + (< (- (-> self clock frame-counter) (the-as int (-> obj notice-time))) + (the-as time-frame (-> obj reaction-time)) + ) + ) + (set! v1-1 #f) + ) + ) + (else + (logclear! (-> obj enemy-flags) (enemy-flag spawn-gem)) + ) + ) + (cond + (v1-1 + arg0 + ) + ((or (zero? arg0) (>= (- (-> self clock frame-counter) (the-as int (-> obj last-draw-time))) (seconds 2))) + 0 + ) + (else + 1 + ) + ) + ) + ) + +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 490] +(defmethod enemy-method-74 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block)) + (local-vars (s5-5 rgbaf) (sv-432 process) (sv-448 event-message-block)) + (with-pp + (cond + ((= arg2 'track) + (and (nonzero? (-> obj hit-points)) + (logtest? (-> obj enemy-flags) (enemy-flag enable-on-active)) + (logtest? (enemy-flag check-water-backup) (-> obj enemy-flags)) + ) + ) + ((= arg2 'combo) + (and (not (logtest? (enemy-flag multi-focus) (-> obj enemy-flags))) (nonzero? (-> obj hit-points))) + ) + ((= arg2 'touch) + (enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3)) + ) + ((= arg2 'touched) + (when (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup)) + (let* ((s3-1 arg0) + (v1-20 (if (type? s3-1 process-drawable) + (the-as process-drawable s3-1) + ) + ) + ) + (when v1-20 + (let* ((s3-2 (-> v1-20 root)) + (a1-4 (if (type? s3-2 collide-shape) + s3-2 + ) + ) + (s3-3 (-> arg3 param 0)) + ) + (if (and a1-4 + s3-3 + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s3-3) + (the-as collide-shape a1-4) + (collide-action solid) + (collide-action) + ) + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s3-3) + (-> obj root-override2) + (collide-action solid) + (collide-action) + ) + ) + (set! (-> obj auto-reset-penetrate-time) (the-as uint (-> pp clock frame-counter))) + ) + ) + ) + ) + ) + (enemy-method-76 obj arg0 arg3) + ) + ((= arg2 'attack-invinc) + (case (-> (the-as attack-info (-> arg3 param 1)) mode) + (('endlessfall) + (let ((v1-31 (-> obj root-override2 root-prim))) + (set! (-> v1-31 prim-core collide-as) (collide-spec)) + (set! (-> v1-31 prim-core collide-with) (collide-spec)) + ) + 0 + (enemy-method-73 obj) + ) + ) + ) + ((= arg2 'attack) + (let ((s2-0 (the-as object (-> arg3 param 1)))) + (when (!= (-> (the-as attack-info s2-0) id) (-> obj incoming attack-id)) + (cond + ((and (logtest? (-> obj enemy-flags) (enemy-flag enable-on-active)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (let* ((s1-0 obj) + (s0-0 (method-of-object s1-0 enemy-method-106)) + ) + (set! sv-432 arg0) + (set! sv-448 arg3) + (let ((a3-3 (get-penetrate-using-from-attack-event (the-as process-drawable arg0) arg3))) + (s0-0 s1-0 sv-432 sv-448 (the-as int a3-3) (the-as attack-info s2-0)) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'child-hit) + 0 + (if (not *debug-unkillable*) + (enemy-method-48 obj arg0 arg3) + ) + (let ((s2-1 (the-as attack-info (enemy-method-58 obj)))) + (when s2-1 + (logclear! (-> obj enemy-flags) (enemy-flag called-dying)) + (enemy-method-108 obj (the-as enemy arg0) arg3) + (let ((a1-13 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-13 from) (process->ppointer arg0)) + (set! (-> a1-13 num-params) (the-as int arg1)) + (set! (-> a1-13 message) (the-as symbol s2-1)) + (set! (-> a1-13 param 0) (-> arg3 param 0)) + (set! (-> a1-13 param 1) (-> arg3 param 1)) + (set! (-> a1-13 param 2) (-> arg3 param 2)) + (set! (-> a1-13 param 3) (-> arg3 param 3)) + (set! (-> a1-13 param 4) (-> arg3 param 4)) + (set! (-> a1-13 param 5) (-> arg3 param 5)) + (send-event-function obj a1-13) + ) + ) + ) + ) + (else + (set! (-> obj incoming attack-id) (-> (the-as attack-info s2-0) id)) + (enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3)) + ) + ) + ) + ) + ) + ((= arg2 'hit-flinch) + (when (zero? (-> obj hit-points)) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (enemy-method-73 obj) + ) + #t + ) + ((= arg2 'hit-knocked) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (when (zero? (-> obj hit-points)) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4) (knocked-type knocked-type-6)) + (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0)) + 0 + ) + ) + ) + (go (method-of-object obj knocked)) + ) + ((= arg2 'hit) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (if (zero? (-> obj hit-points)) + (enemy-method-73 obj) + (go (method-of-object obj hit)) + ) + ) + ((= arg2 'cue-chase) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (let ((v1-162 (logtest? (enemy-flag alert) (-> obj enemy-flags)))) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice alert victory called-dying)) + (set! (-> obj enemy-flags) (logior (enemy-flag dangerous-backup) (-> obj enemy-flags))) + (logclear! (-> obj mask) (process-mask actor-pause)) + (cond + (v1-162 + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (go-hostile obj) + ) + ) + ((and (-> obj next-state) (let ((v1-173 (-> obj next-state name))) + (or (= v1-173 'dormant) (= v1-173 'dormant-aware)) + ) + ) + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (go (method-of-object obj notice)) + ) + ) + ) + ) + #t + ) + ) + ((= arg2 'cue-wake) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (logclear! (-> obj enemy-flags) (enemy-flag alert victory called-dying)) + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (enemy-method-72 obj) + ) + #t + ) + ) + ((= arg2 'jump) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (logclear! (-> obj mask) (process-mask actor-pause)) + (set! (-> obj jump-why) (-> arg3 param 0)) + (set! (-> obj event-param-point quad) (-> (the-as vector (-> arg3 param 1)) quad)) + (go (method-of-object obj jump)) + ) + ) + ((= arg2 'death-start) + (set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag recover) (-> obj enemy-flags)))) + (send-event (ppointer->process (-> obj parent)) 'child-die) + (drop-pickup (-> obj fact-info-override) #t *entity-pool* (-> obj fact-info-override) 0) + (let ((s5-1 (-> obj on-death))) + (if s5-1 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans)) + (the-as pair s5-1) + ) + ) + ) + ) + ((= arg2 'death-end) + (if (-> obj skel effect) + (logior! (-> obj skel effect flags) (effect-control-flag ecf2)) + ) + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag check-water)) + ) + ((= arg2 'instant-death) + (when (and (> (-> obj hit-points) 0) (zero? (-> obj fated-time))) + (set! (-> obj hit-points) 0) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + (let ((s5-2 (enemy-method-50 obj (new 'stack-no-clear 'vector)))) + (vector-z-quaternion! s5-2 (-> obj root-override2 quat)) + (vector-float*! s5-2 s5-2 -1.0) + (vector-normalize! s5-2 1.0) + ) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (enemy-method-73 obj) + ) + ) + ((= arg2 'die-fast) + (logior! (-> obj draw status) (draw-control-status no-draw)) + (enemy-method-132 obj) + (send-event (ppointer->process (-> obj parent)) 'child-die) + (let ((s5-3 (-> obj on-death))) + (if s5-3 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans)) + (the-as pair s5-3) + ) + ) + ) + (cleanup-for-death obj) + (go (method-of-object obj die-fast)) + ) + ((= arg2 'victory) + (if (and (-> obj enemy-info use-victory) + (not (and (-> obj next-state) (= (-> obj next-state name) 'victory))) + (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (go (method-of-object obj victory)) + ) + ) + ((= arg2 'nav-control) + (if (nonzero? (-> obj nav)) + (-> obj nav) + ) + ) + ((= arg2 'push-trans) + (move-by-vector! (-> obj root-override2) (the-as vector (-> arg3 param 0))) + ) + ((= arg2 'move-trans) + (move-to-point! (-> obj root-override2) (the-as vector (-> arg3 param 0))) + ) + ((= arg2 'shadow) + (cond + ((-> arg3 param 0) + (let ((v1-320 (-> obj draw shadow-ctrl))) + (logclear! (-> v1-320 settings flags) (shadow-flags disable-draw)) + ) + 0 + ) + (else + (let ((v1-323 (-> obj draw shadow-ctrl))) + (logior! (-> v1-323 settings flags) (shadow-flags disable-draw)) + ) + 0 + ) + ) + ) + ((= arg2 'color-effect) + (let ((v1-325 (-> arg3 param 0))) + (set! s5-5 + (cond + ((= v1-325 'dark) + (let ((f30-0 (rand-vu-float-range 0.2 1.0))) + (set-vector! (-> obj draw color-mult) (lerp 1.0 1.0 f30-0) (lerp 1.0 0.0 f30-0) (lerp 1.0 1.0 f30-0) 1.0) + (set! s5-5 (-> obj draw color-emissive)) + (set! (-> s5-5 x) (lerp 0.0 0.3 f30-0)) + (set! (-> s5-5 y) (lerp 0.0 0.0 f30-0)) + (set! (-> s5-5 z) (lerp 0.0 0.3 f30-0)) + ) + (set! (-> s5-5 w) 1.0) + s5-5 + ) + ((= v1-325 #f) + (set-vector! (-> obj draw color-mult) 1.0 1.0 1.0 1.0) + (set! s5-5 (-> obj draw color-emissive)) + (set! (-> s5-5 quad) (the-as uint128 0)) + s5-5 + ) + ) + ) + ) + ) + ) + (none) + ) + ) + +(defmethod enemy-method-56 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (let ((v1-0 (the-as attack-info (-> arg1 param 1)))) + (if (logtest? (attack-info-mask damage) (-> v1-0 mask)) + (the int (-> v1-0 damage)) + (penetrate-using->damage (the-as penetrate (-> obj incoming penetrate-using))) + ) + ) + ) + +(defmethod enemy-method-58 enemy ((obj enemy)) + (let ((v1-0 (-> obj incoming penetrate-using))) + (cond + ((logtest? (the-as penetrate v1-0) (-> obj penetrated-flinch)) + 'hit-flinch + ) + ((logtest? (the-as penetrate v1-0) (-> obj penetrated-knocked)) + 'hit-knocked + ) + (else + 'hit + ) + ) + ) + ) + +(defmethod enemy-method-48 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (with-pp + (let* ((v1-1 (enemy-method-56 obj arg0 arg1)) + (s5-0 (-> obj hit-points)) + (s4-1 (max 0 (- s5-0 v1-1))) + ) + (when (and (zero? s4-1) (nonzero? s5-0) (= (-> obj incoming knocked-type) (knocked-type knocked-type-6))) + (cond + ((zero? (-> obj fated-time)) + (set! (-> obj fated-time) (the-as uint (-> pp clock frame-counter))) + (set! s4-1 1) + ) + (else + (if (< (- (-> pp clock frame-counter) (the-as int (-> obj fated-time))) (seconds 1)) + (set! s4-1 1) + ) + ) + ) + ) + (set! (-> obj hit-points) s4-1) + (if (not (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup))) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + ) + (- s5-0 s4-1) + ) + ) + ) + +(defmethod enemy-method-134 enemy ((obj enemy) (arg0 process) (arg1 attack-info)) + (find-offending-process-focusable arg0 arg1) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-75 enemy ((obj enemy) (arg0 process) (arg1 touching-shapes-entry)) + (let* ((s4-0 (-> arg1 handle1)) + (s2-0 arg0) + (s3-0 (if (type? s2-0 process-focusable) + (the-as process-focusable s2-0) + ) + ) + ) + (when (and s4-0 s3-0) + (cond + ((and (logtest? (-> obj focus-status) (focus-status dangerous)) + (and s3-0 (zero? (logand (-> s3-0 focus-status) (focus-status disable dead ignore grabbed)))) + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action deadly) + (collide-action) + ) + ) + (let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action persistent-attack) + (collide-action) + ) + (-> obj persistent-attack-id) + (-> obj attack-id) + ) + ) + ) + (enemy-method-104 obj arg0 (the-as uint s4-0) a3-2) + ) + ) + ((and ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action no-standon) + (collide-action) + ) + (zero? (logand (-> obj root-override2 penetrated-by) (-> s3-0 root-override penetrate-using))) + ) + (if (send-shoves (-> obj root-override2) arg0 (the-as touching-shapes-entry s4-0) 0.7 6144.0 16384.0) + (send-event obj 'bouncing-off arg0) + ) + ) + ) + ) + ) + (none) + ) + +(defmethod enemy-method-76 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (let ((s4-0 (-> arg1 param 0))) + (when s4-0 + (when (or (and (and (-> obj next-state) (= (-> obj next-state name) 'knocked)) + (logtest? (process-mask crate) (-> arg0 mask)) + ) + (and (and (-> obj next-state) (= (-> obj next-state name) 'jump)) + (logtest? (process-mask target sidekick crate bot) (-> arg0 mask)) + ) + ) + (when ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action solid semi-solid deadly) + (collide-action) + ) + (let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action persistent-attack) + (collide-action) + ) + (-> obj persistent-attack-id) + (-> obj attack-id) + ) + ) + ) + (enemy-method-104 obj arg0 s4-0 a3-2) + ) + ) + ) + ) + ) + ) + +;; WARN: Return type mismatch none vs object. +(defbehavior enemy-event-handler enemy ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (the-as object (enemy-method-74 self arg0 arg1 arg2 arg3)) + ) + +(defbehavior enemy-simple-post enemy () + (enemy-method-55 self) + (update-transforms (-> self root-override2)) + 0 + (none) + ) + +(defbehavior enemy-falling-post enemy () + (set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags))) + (let ((gp-0 (-> self root-override2))) + (cond + ((logtest? (-> self focus-status) (focus-status under-water)) + (enemy-method-47 self (-> gp-0 transv)) + ) + (else + (let ((a1-1 (new-stack-vector0))) + (vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 a1-1 (-> self enemy-info slip-factor))) + ) + ) + ) + (let ((a2-1 (new 'stack-no-clear 'collide-query))) + (set! (-> a2-1 collide-with) (-> gp-0 root-prim prim-core collide-with)) + (set! (-> a2-1 ignore-process0) self) + (set! (-> a2-1 ignore-process1) #f) + (set! (-> a2-1 ignore-pat) (logior (new 'static 'pat-surface :noendlessfall #x1) (-> gp-0 pat-ignore-mask))) + (set! (-> a2-1 action-mask) (collide-action solid)) + (fill-cache-integrate-and-collide gp-0 (-> gp-0 transv) a2-1 (meters 0)) + ) + ) + (enemy-method-111 self) + (enemy-method-55 self) + (none) + ) + +(defmethod enemy-method-47 enemy ((obj enemy) (arg0 vector)) + (with-pp + (let* ((f2-0 0.8) + (f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> pp clock seconds-per-frame) (+ -1.0 f2-0))))) + ) + (vector-float*! arg0 arg0 f0-1) + ) + (set! (-> arg0 y) (+ (-> arg0 y) (* -204800.0 (-> pp clock seconds-per-frame)))) + ) + ) + +(defbehavior enemy-die-falling-post enemy () + (set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags))) + (let ((gp-0 (-> self root-override2))) + (if (logtest? (-> self focus-status) (focus-status under-water)) + (enemy-method-47 self (-> gp-0 transv)) + (vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 (new-stack-vector0) 0.0)) + ) + (let ((s4-1 (new 'stack-no-clear 'collide-query)) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-1 quad) (-> gp-0 trans quad)) + (vector-v++! s5-1 (-> gp-0 transv)) + (when (find-ground gp-0 s4-1 (-> self enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (when (>= (-> gp-0 gspot-pos y) (-> s5-1 y)) + (set! (-> s5-1 y) (-> gp-0 gspot-pos y)) + (vector-reset! (-> gp-0 transv)) + ) + ) + (move-to-point! gp-0 s5-1) + ) + ) + (enemy-method-55 self) + 0 + (none) + ) + +(defstate idle (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-110 self) + (logclear! (-> self enemy-flags) (enemy-flag spawn-gem chase-startup use-notice-distance)) + (logior! (-> self enemy-flags) (enemy-flag enable-on-notice)) + (set! (-> self state-timeout) (the-as uint 150)) + (if (-> self on-notice) + (logior! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + ) + (if (-> self on-active) + (logior! (-> self enemy-flags) (enemy-flag jump-check-blocked)) + ) + (if (-> self on-hostile) + (logior! (-> self enemy-flags) (enemy-flag drawn-mirrored)) + ) + (when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags))) + (if (logtest? (-> self enemy-flags) (enemy-flag notice)) + (logior! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self mask) (process-mask actor-pause)) + ) + ) + (none) + ) + :trans (behavior () + (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout))) + (> (the-as int (-> self focus aware)) 0) + ) + (go-virtual active) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (sleep-code) + (none) + ) + :post (behavior () + (idle-control-method-10 (-> self idle-anim-player) self) + (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen))) + (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter))) + ) + (enemy-method-129 self) + (ja-post) + (none) + ) + ) + +(defstate dormant (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + ((-> (method-of-type enemy idle) enter)) + (set! (-> self root-override2 nav-flags) (nav-flags)) + (let ((v1-4 (-> self root-override2 root-prim))) + (set! (-> v1-4 prim-core collide-as) (collide-spec)) + (set! (-> v1-4 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> self draw status) (draw-control-status no-draw)) + (set! (-> self draw origin quad) (-> self root-override2 trans quad)) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + (set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags))) + ) + (logior! (-> self focus-status) (focus-status disable)) + (none) + ) + :exit (behavior () + (logclear! (-> self focus-status) (focus-status disable)) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-3 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (logclear! (-> self enemy-flags) (enemy-flag victory)) + (logior! (-> self root-override2 nav-flags) (nav-flags nav-flags0)) + (none) + ) + :code (the-as (function none :behavior enemy) sleep-code) + ) + +(defstate dormant-aware (enemy) + :virtual #t + :event enemy-event-handler + :enter (-> (method-of-type enemy dormant) enter) + :exit (-> (method-of-type enemy dormant) exit) + :trans (behavior () + (when (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout))) + (> (the-as int (-> self focus aware)) 0) + ) + (if (logtest? (enemy-option ambush) (-> self fact-info-override enemy-options)) + (go-ambush self) + (go-virtual active) + ) + ) + (none) + ) + :code (the-as (function none :behavior enemy) sleep-code) + :post (behavior () + (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen))) + (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter))) + ) + (enemy-method-129 self) + (none) + ) + ) + +(defstate ambush (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (logior! (-> self enemy-flags) (enemy-flag chase-startup)) + (none) + ) + :code (behavior () + (go-virtual notice) + (none) + ) + ) + +(defstate active (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self enemy-flags) (enemy-flag use-notice-distance)) + (when (logtest? (-> self enemy-flags) (enemy-flag jump-check-blocked)) + (logclear! (-> self enemy-flags) (enemy-flag jump-check-blocked)) + (let ((gp-0 (-> self on-active))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags))) + (if (logtest? (-> self enemy-flags) (enemy-flag notice)) + (logior! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self mask) (process-mask actor-pause)) + ) + ) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((v1-3 (-> self focus aware))) + (cond + ((< (the-as int v1-3) 1) + (go-virtual idle) + ) + ((< 1 (the-as int v1-3)) + (go-virtual notice) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (sleep-code) + (none) + ) + :post (behavior () + (idle-control-method-10 (-> self idle-anim-player) self) + (enemy-simple-post) + (none) + ) + ) + +(defstate notice (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((v1-3 (logior (-> self enemy-flags) (enemy-flag use-notice-distance)))) + (set! (-> self enemy-flags) (logclear v1-3 (enemy-flag called-dying))) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (enemy-method-109 self 1) + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (let ((gp-1 (-> self focus aware))) + (when (logtest? (-> self enemy-flags) (enemy-flag chase-startup)) + (cond + ((and (= gp-1 (enemy-aware enemy-aware-3)) (enemy-method-107 self)) + (go-hostile self) + ) + ((= gp-1 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + (else + (go-stare self) + ) + ) + ) + ) + (logior! (-> self enemy-flags) (enemy-flag chase-startup)) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info notice-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info notice-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (vector-! gp-0 (target-pos 0) (-> self root-override2 trans)) + (seek-toward-heading-vec! (-> self root-override2) gp-0 131072.0 (seconds 0.05)) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post enemy-simple-post + ) + +(defstate hostile (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-109 self 1) + (logior! (-> self enemy-flags) (enemy-flag use-notice-distance)) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (logclear! (-> self mask) (process-mask actor-pause)) + (when (logtest? (-> self enemy-flags) (enemy-flag drawn-mirrored)) + (logclear! (-> self enemy-flags) (enemy-flag drawn-mirrored)) + (let ((gp-0 (-> self on-hostile))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (none) + ) + :trans (behavior () + (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory)) + (go-virtual victory) + ) + (let ((gp-0 (-> self focus aware))) + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time))) + (cond + ((or (>= 2 (the-as int gp-0)) (not (enemy-method-107 self))) + (go-stare self) + ) + ((= gp-0 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim))) + (ja :num-func num-func-identity :frame-num 0.0) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +(defstate stare (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((gp-0 (-> self focus aware))) + (cond + ((>= 1 (the-as int gp-0)) + (go-virtual active) + ) + ((and (= gp-0 (enemy-aware enemy-aware-3)) (enemy-method-107 self)) + (go-hostile self) + ) + ((= gp-0 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self enemy-info idle-anim))) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +(defstate victory (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info victory-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info victory-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post enemy-simple-post + ) + +(defstate flee (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-109 self 1) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time))) + (if (!= (-> self focus aware) (enemy-aware enemy-aware-4)) + (go-stare self) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim))) + (ja :num-func num-func-identity :frame-num 0.0) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +(defmethod enemy-method-82 enemy ((obj enemy) (arg0 enemy-jump-info)) + "@abstract" + #f + ) + +(defmethod enemy-method-83 enemy ((obj enemy) (arg0 enemy-jump-info)) + (set! (-> arg0 flags) (the-as uint 1)) + (set! (-> arg0 anim-speed) (get-rand-float-range obj 0.9 1.1)) + (set! (-> arg0 hang-time) 0) + (set! (-> arg0 dest-pos quad) (-> obj event-param-point quad)) + (set! (-> arg0 start-pos quad) (-> obj root-override2 trans quad)) + (let ((s4-0 (new 'stack-no-clear 'collide-query))) + (if (enemy-method-126 + obj + s4-0 + (-> arg0 dest-pos) + (the-as collide-spec (-> obj gnd-collide)) + 8192.0 + 81920.0 + 1024.0 + ) + (set! (-> arg0 dest-pos y) (-> s4-0 best-other-tri intersect y)) + ) + ) + (enemy-method-84 obj arg0) + (none) + ) + +(defmethod enemy-method-84 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let* ((f0-0 (vector-vector-xz-distance (-> arg0 start-pos) (-> arg0 dest-pos))) + (f0-2 (fmax (-> obj enemy-info jump-height-min) (* (-> obj enemy-info jump-height-factor) f0-0))) + ) + (setup-from-to-height! (-> arg0 traj) (-> arg0 start-pos) (-> arg0 dest-pos) f0-2 -4.551111) + ) + (none) + ) + +(defmethod enemy-method-86 enemy ((obj enemy)) + (let ((gp-0 (-> obj root-override2))) + (when (< (-> gp-0 transv y) 0.0) + (let ((a1-0 (new 'stack-no-clear 'collide-query))) + (find-ground (-> obj root-override2) a1-0 (the-as collide-spec (-> obj gnd-collide)) 8192.0 81920.0 1024.0) + ) + (>= (-> gp-0 gspot-pos y) (-> gp-0 trans y)) + ) + ) + ) + +(defmethod enemy-method-85 enemy ((obj enemy)) + (let* ((v1-0 (-> obj root-override2)) + (f0-0 (-> v1-0 gspot-pos y)) + ) + (if (< (-> v1-0 trans y) f0-0) + (set! (-> v1-0 trans y) f0-0) + ) + ) + (set! (-> obj root-override2 transv y) 0.0) + ) + +(defmethod enemy-method-92 enemy ((obj enemy) (arg0 int) (arg1 nav-poly)) + "TODO - nav-poly is a guess + @abstract" + 0 + (none) + ) + +(defmethod enemy-method-91 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info)) + (case arg0 + ((2 3) + (set! (-> obj enemy-flags) (logior (enemy-flag directed) (-> obj enemy-flags))) + (let ((f30-0 (the float (-> arg1 hang-time)))) + (let ((a1-3 (compute-trans-at-time (-> arg1 traj) f30-0 (new 'stack-no-clear 'vector)))) + (move-to-point! (-> obj root-override2) a1-3) + ) + (let ((s5-1 (-> obj root-override2 transv))) + (compute-transv-at-time (-> arg1 traj) f30-0 s5-1) + (vector-float*! s5-1 s5-1 300.0) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod enemy-method-89 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((a0-1 (-> obj skel root-channel 0))) + (set! (-> a0-1 param 0) 1.0) + (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.1)) + (let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim))) + (a0-5 (-> obj skel root-channel 0)) + ) + (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3)) + (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1))) + (set! (-> a0-5 param 1) (-> arg0 anim-speed)) + (set! (-> a0-5 frame-num) 0.0) + (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!) + ) + #t + ) + +(defmethod enemy-method-87 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((s5-0 (-> obj draw art-group data (-> obj enemy-info jump-in-air-anim)))) + (let ((v1-6 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (cond + ((and v1-6 (= v1-6 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim)))) + (ja-channel-push! 1 0) + ) + (else + (let ((a0-10 (-> obj skel root-channel 0))) + (set! (-> a0-10 param 0) 1.0) + (joint-control-channel-group! a0-10 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + ) + (let ((a0-12 (-> obj skel root-channel 0))) + (set! (-> a0-12 frame-group) (the-as art-joint-anim s5-0)) + (set! (-> a0-12 param 0) (the float (+ (-> (the-as art-joint-anim s5-0) frames num-frames) -1))) + (set! (-> a0-12 param 1) (-> arg0 anim-speed)) + (set! (-> a0-12 frame-num) 0.0) + (joint-control-channel-group! a0-12 (the-as art-joint-anim s5-0) num-func-seek!) + ) + ) + #t + ) + +(defmethod enemy-method-88 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((a0-1 (-> obj skel root-channel 0))) + (set! (-> a0-1 param 0) 1.0) + (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.075)) + (let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-land-anim))) + (a0-5 (-> obj skel root-channel 0)) + ) + (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3)) + (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1))) + (set! (-> a0-5 param 1) (-> arg0 anim-speed)) + (set! (-> a0-5 frame-num) 0.0) + (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!) + ) + #t + ) + +(defmethod enemy-method-90 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info)) + (local-vars (s5-0 symbol)) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (not (enemy-method-89 obj arg1)) + ) + ((= v1-0 1) + (set! s5-0 (ja-done? 0)) + (let ((a0-4 (-> obj skel root-channel 0))) + (set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + ((= v1-0 2) + (enemy-method-87 obj arg1) + #f + ) + ((= v1-0 3) + (set! s5-0 (ja-done? 0)) + (let ((a0-9 (-> obj skel root-channel 0))) + (set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1))) + (set! (-> a0-9 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + ((= v1-0 4) + (not (enemy-method-88 obj arg1)) + ) + ((= v1-0 5) + (set! s5-0 (ja-done? 0)) + (let ((a0-14 (-> obj skel root-channel 0))) + (set! (-> a0-14 param 0) (the float (+ (-> a0-14 frame-group frames num-frames) -1))) + (set! (-> a0-14 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-14 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + (else + #t + ) + ) + ) + ) + +(defstate jump (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-6 *game-info*) + (a0-2 (+ (-> v1-6 attack-id) 1)) + ) + (set! (-> v1-6 attack-id) a0-2) + (set! (-> self attack-id) a0-2) + ) + (logclear! (-> self focus-status) (focus-status in-air)) + (none) + ) + :exit (behavior () + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (new 'stack-no-clear 'enemy-jump-info))) + (let ((s5-0 0)) + (enemy-method-83 self gp-0) + (if (and (-> self enemy-info use-jump-blocked) + (logtest? (enemy-flag vulnerable) (-> self enemy-flags)) + (enemy-method-82 self gp-0) + ) + (go-virtual jump-blocked) + ) + (when (logtest? (-> gp-0 flags) 1) + (until #f + (if (enemy-method-90 self s5-0 gp-0) + (goto cfg-12) + ) + (enemy-method-91 self s5-0 gp-0) + (enemy-method-92 self s5-0 (the-as nav-poly gp-0)) + (suspend) + (set! s5-0 1) + ) + #f + ) + ) + (label cfg-12) + (logclear! (-> self root-override2 status) (collide-status on-surface on-ground touch-surface)) + (let ((s5-1 2)) + (logior! (-> self focus-status) (focus-status in-air)) + (until (enemy-method-86 self) + (+! (-> gp-0 hang-time) (- (-> self clock frame-counter) (-> self clock old-frame-counter))) + (enemy-method-90 self s5-1 gp-0) + (enemy-method-91 self s5-1 gp-0) + (enemy-method-92 self s5-1 (the-as nav-poly gp-0)) + (suspend) + (set! s5-1 3) + ) + ) + (logclear! (-> self focus-status) (focus-status in-air)) + (enemy-method-85 self) + (let ((s5-2 4)) + (until #f + (if (enemy-method-90 self s5-2 gp-0) + (goto cfg-19) + ) + (enemy-method-91 self s5-2 gp-0) + (enemy-method-92 self s5-2 (the-as nav-poly gp-0)) + (suspend) + (set! s5-2 5) + ) + ) + #f + (label cfg-19) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + ((lambda :behavior enemy + ((arg0 enemy-jump-info)) + (send-event (ppointer->process (-> self parent)) 'child-jumped) + (none) + ) + gp-0 + ) + ) + ) + (enemy-method-93 self) + (none) + ) + :post (behavior () + (let ((a1-0 (new 'stack-no-clear 'overlaps-others-params))) + (set! (-> a1-0 options) (overlaps-others-options)) + (set! (-> a1-0 collide-with-filter) (-> self enemy-info overlaps-others-collide-with-filter)) + (set! (-> a1-0 tlist) *touching-list*) + (find-overlapping-shapes (-> self root-override2) a1-0) + ) + (enemy-simple-post) + (none) + ) + ) + +(defstate jump-blocked (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + (go-virtual jump) + (enemy-method-93 self) + ) + ) + (none) + ) + :code (behavior () + (let ((v1-2 (ja-group))) + (when (not (and v1-2 (= v1-2 (-> self draw art-group data (-> self enemy-info idle-anim))))) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info idle-anim)) + :num! (identity (rand-vu-float-range 0.0 (the float (+ (-> (ja-group) frames num-frames) -1)))) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.75 1.25))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +(defstate hit (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-110 self) + (logclear! (-> self mask) (process-mask actor-pause)) + (enemy-method-135 self 0) + (none) + ) + :code (behavior () + (local-vars (v1-37 enemy-flag) (v1-45 enemy-flag)) + (ja-channel-push! 1 (seconds 0.2)) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info hit-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info hit-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (let ((v1-36 (-> self enemy-flags))) + (if (logtest? v1-36 (enemy-flag checking-water)) + (set! v1-37 (logior v1-36 (enemy-flag enable-on-active))) + (set! v1-37 (logclear v1-36 (enemy-flag enable-on-active))) + ) + ) + (set! (-> self enemy-flags) v1-37) + (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest)) + (set! (-> self mask) (logior (process-mask collectable) (-> self mask))) + (logclear! (-> self mask) (process-mask collectable)) + ) + (let ((v1-44 (-> self enemy-flags))) + (if (logtest? (enemy-flag no-initial-move-to-ground) v1-44) + (set! v1-45 (logior (enemy-flag check-water-backup) v1-44)) + (set! v1-45 (logclear v1-44 (enemy-flag check-water-backup))) + ) + ) + (set! (-> self enemy-flags) v1-45) + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (logclear! (-> self focus-status) (focus-status hit)) + (go-hostile self) + (none) + ) + :post enemy-simple-post + ) + +;; WARN: Return type mismatch collide-spec vs none. +(defmethod enemy-method-101 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))) + (set! (-> obj enemy-flags) (logior (enemy-flag use-trigger) (-> obj enemy-flags))) + (logclear! (-> obj enemy-flags) (enemy-flag directed)) + (enemy-method-124 obj) + ) + (none) + ) + +(defmethod enemy-method-103 enemy ((obj enemy)) + (when (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (logclear! (-> obj enemy-flags) (enemy-flag use-trigger directed)) + (enemy-method-124 obj) + ) + ) + +(defmethod enemy-method-102 enemy ((obj enemy)) + #f + ) + +;; WARN: Return type mismatch vector vs symbol. +(defmethod enemy-method-100 enemy ((obj enemy)) + (local-vars (v0-1 vector)) + (with-pp + (when (not (-> obj enemy-info move-to-ground)) + (enemy-method-103 obj) + (return (the-as symbol #f)) + ) + (when (not (logtest? (enemy-flag directed) (-> obj enemy-flags))) + (let ((s5-0 (-> obj root-override2))) + (if (logtest? (-> obj focus-status) (focus-status under-water)) + (enemy-method-47 obj (-> s5-0 transv)) + (+! (-> s5-0 transv y) (* (-> obj enemy-info movement-gravity) (-> pp clock seconds-per-frame))) + ) + (let ((a2-0 (new 'stack-no-clear 'move-above-ground-params))) + (let ((v1-16 (-> obj enemy-info))) + (set! (-> a2-0 gnd-collide-with) (-> v1-16 recover-gnd-collide-with)) + (set! (-> a2-0 popup) 8192.0) + (set! (-> a2-0 dont-move-if-overlaps?) #t) + (set! (-> a2-0 hover-if-no-ground?) (-> v1-16 hover-if-no-ground)) + (set! (-> a2-0 overlaps-params options) (overlaps-others-options oo0 oo2)) + (set! (-> a2-0 overlaps-params collide-with-filter) (-> v1-16 overlaps-others-collide-with-filter)) + ) + (set! (-> a2-0 overlaps-params tlist) *touching-list*) + (-> a2-0 overlaps-params) + (enemy-method-128 obj (-> s5-0 transv) a2-0) + ) + ) + ) + (logclear! (-> obj enemy-flags) (enemy-flag directed)) + (if (and (enemy-method-102 obj) (zero? (logand (-> obj focus-status) (focus-status dead)))) + (enemy-method-73 obj) + ) + (let ((s5-1 (-> obj root-override2)) + (a1-2 (new 'stack-no-clear 'collide-query)) + (s3-0 (new 'stack-no-clear 'vector)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s3-0 quad) (-> s5-1 gspot-pos quad)) + (set! (-> s4-0 quad) (-> s5-1 gspot-normal quad)) + (the-as symbol (cond + ((find-ground s5-1 a1-2 (-> obj enemy-info gnd-collide-with) 8192.0 81920.0 1024.0) + (let ((f0-4 (- (-> s5-1 trans y) (-> s5-1 gspot-pos y)))) + (when (>= 409.6 (fabs f0-4)) + (enemy-method-103 obj) + (return (the-as symbol #f)) + v0-1 + ) + ) + ) + (else + (set! (-> s5-1 gspot-pos quad) (-> s3-0 quad)) + (set! v0-1 (-> s5-1 gspot-normal)) + (set! (-> v0-1 quad) (-> s4-0 quad)) + v0-1 + ) + ) + ) + ) + ) + ) + +(defmethod enemy-method-46 enemy ((obj enemy) (arg0 int)) + "@abstract" + 0 + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-52 enemy ((obj enemy) (arg0 vector)) + (enemy-method-50 obj arg0) + (let ((s5-0 (-> obj enemy-info))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-2)) + (let ((f30-0 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-hard-vxz-lo) (-> s5-0 knocked-hard-vxz-hi) f30-0)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-hard-vy-lo) (-> s5-0 knocked-hard-vy-hi) f30-0)) + ) + ) + (((knocked-type knocked-type-1)) + (let ((f30-1 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-medium-vxz-lo) (-> s5-0 knocked-medium-vxz-hi) f30-1)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-medium-vy-lo) (-> s5-0 knocked-medium-vy-hi) f30-1)) + ) + ) + (((knocked-type knocked-type-3)) + (let ((f30-2 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-huge-vxz-lo) (-> s5-0 knocked-huge-vxz-hi) f30-2)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-huge-vy-lo) (-> s5-0 knocked-huge-vy-hi) f30-2)) + ) + ) + (((knocked-type knocked-type-4)) + (vector-rotate90-around-y! arg0 arg0) + (let ((v1-9 (new 'stack-no-clear 'vector))) + (vector-! v1-9 (-> obj incoming attacker-pos) (-> obj root-override2 trans)) + (set! (-> v1-9 y) 0.0) + (if (< 0.0 (vector-dot v1-9 arg0)) + (vector-negate! arg0 arg0) + ) + ) + (let ((f30-3 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-yellow-vxz-lo) (-> s5-0 knocked-yellow-vxz-hi) f30-3)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-yellow-vy-lo) (-> s5-0 knocked-yellow-vy-hi) f30-3)) + ) + ) + (((knocked-type knocked-type-5)) + (let* ((f1-2 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans))) + (f0-26 1.0) + (f2-0 61440.0) + (f1-3 (fmin f1-2 (* f2-0 f2-0))) + (f2-3 61440.0) + (f30-5 (* (- f0-26 (/ f1-3 (* f2-3 f2-3))) (get-rand-float-range obj 0.8 1.0))) + ) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-red-vxz-lo) (-> s5-0 knocked-red-vxz-hi) f30-5)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-red-vy-lo) (-> s5-0 knocked-red-vy-hi) f30-5)) + ) + ) + (((knocked-type knocked-type-6)) + (let* ((f1-5 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans))) + (f0-34 1.0) + (f2-6 122880.0) + (f1-6 (fmin f1-5 (* f2-6 f2-6))) + (f2-9 122880.0) + (f30-7 (* (- f0-34 (/ f1-6 (* f2-9 f2-9))) (get-rand-float-range obj 0.8 1.0))) + ) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-blue-vxz-lo) (-> s5-0 knocked-blue-vxz-hi) f30-7)) + (cond + ((>= (the-as uint 4) (the-as uint (-> obj incoming blue-juggle-count))) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-blue-vy-lo) (-> s5-0 knocked-blue-vy-hi) f30-7)) + ) + (else + (if (zero? (get-rand-int obj 3)) + (set! (-> arg0 y) 40960.0) + ) + ) + ) + ) + ) + (((knocked-type knocked-type-7)) + (set! (-> arg0 quad) (-> obj incoming attack-direction quad)) + ) + (else + (let ((f30-8 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-soft-vxz-lo) (-> s5-0 knocked-soft-vxz-hi) f30-8)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-soft-vy-lo) (-> s5-0 knocked-soft-vy-hi) f30-8)) + ) + ) + ) + ) + (none) + ) + +(defmethod enemy-method-51 enemy ((obj enemy)) + (let ((f30-0 (quaternion-y-angle (-> obj root-override2 quat)))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4) (knocked-type knocked-type-6)) + (let ((a0-5 (handle->process (-> obj focus handle)))) + (when a0-5 + (let ((v1-9 (get-trans (the-as process-focusable a0-5) 0))) + (set! f30-0 + (atan (- (-> v1-9 x) (-> obj root-override2 trans x)) (- (-> v1-9 z) (-> obj root-override2 trans z))) + ) + ) + ) + ) + ) + (else + (let* ((v1-13 (-> obj root-override2 transv)) + (f28-0 (atan (-> v1-13 x) (-> v1-13 z))) + (f1-2 (deg- f30-0 f28-0)) + (f2-0 (fabs f1-2)) + (f0-6 (-> obj enemy-info knocked-seek-ry-clamp)) + ) + (when (and (< f0-6 f2-0) (< f2-0 (- 32768.0 f0-6))) + (set! f30-0 (+ (cond + ((< f2-0 16384.0) + (if (>= f1-2 0.0) + f0-6 + (- f0-6) + ) + ) + ((>= f1-2 0.0) + (- 32768.0 f0-6) + ) + (else + (+ -32768.0 f0-6) + ) + ) + f28-0 + ) + ) + (if (< f30-0 0.0) + (set! f30-0 (+ 65536.0 f30-0)) + ) + ) + ) + ) + ) + f30-0 + ) + ) + +(defmethod enemy-method-77 enemy ((obj enemy) (arg0 (pointer float))) + (ja-channel-push! 1 0) + (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info knocked-anim))) + (a0-4 (-> obj skel root-channel 0)) + ) + (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2)) + (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg0 0)) + (set! (-> a0-4 frame-num) 0.0) + (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!) + ) + #t + ) + +(defmethod enemy-method-78 enemy ((obj enemy) (arg0 (pointer float))) + (let ((v1-4 (-> obj draw art-group data (-> obj enemy-info knocked-land-anim))) + (a0-3 (-> obj skel root-channel 0)) + ) + (set! (-> a0-3 frame-group) (the-as art-joint-anim v1-4)) + (set! (-> a0-3 param 0) (the float (+ (-> (the-as art-joint-anim v1-4) frames num-frames) -1))) + (set! (-> a0-3 param 1) (-> arg0 0)) + (set! (-> a0-3 frame-num) 0.0) + (joint-control-channel-group! a0-3 (the-as art-joint-anim v1-4) num-func-seek!) + ) + #t + ) + +(defmethod enemy-method-80 enemy ((obj enemy) (arg0 enemy-knocked-info)) + (let ((gp-0 (-> obj root-override2))) + (or (>= (-> arg0 on-surface-count) 3) + (and (logtest? (-> gp-0 status) (collide-status on-ground)) (>= 16384.0 (-> gp-0 transv y))) + (and (>= (-> arg0 move-count) 3) + (let ((f0-1 40.96)) + (>= (* f0-1 f0-1) (vector-vector-distance-squared (-> gp-0 trans-old) (-> gp-0 trans-old-old))) + ) + (let ((f0-4 40.96)) + (>= (* f0-4 f0-4) (vector-vector-distance-squared (-> gp-0 trans-old-old) (-> gp-0 trans-old-old-old))) + ) + ) + ) + ) + ) + +(defmethod enemy-method-81 enemy ((obj enemy)) + (let ((s5-0 (-> obj root-override2)) + (a1-0 (new 'stack-no-clear 'collide-query)) + (gp-0 #t) + ) + (when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (let ((f0-1 (- (-> s5-0 trans y) (-> s5-0 gspot-pos y)))) + (if (and (>= f0-1 -1228.8) (>= 6144.0 f0-1)) + (set! gp-0 #f) + ) + ) + ) + gp-0 + ) + ) + +(defmethod enemy-method-79 enemy ((obj enemy) (arg0 int) (arg1 enemy-knocked-info)) + (local-vars (s5-0 symbol)) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (enemy-method-77 obj (the-as (pointer float) arg1)) + (set! s5-0 #f) + ) + ((= v1-0 1) + (set! s5-0 (ja-done? 0)) + (let ((a0-4 (-> obj skel root-channel 0))) + (set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + ((= v1-0 2) + (set! s5-0 (not (enemy-method-78 obj (the-as (pointer float) arg1)))) + (set! (-> obj incoming blue-juggle-count) (the-as uint 0)) + ) + ((= v1-0 3) + (set! s5-0 (ja-done? 0)) + (let ((a0-9 (-> obj skel root-channel 0))) + (set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1))) + (set! (-> a0-9 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + ((= v1-0 4) + (vector-reset! (-> obj root-override2 transv)) + (set! s5-0 #t) + ) + (else + (set! s5-0 #t) + ) + ) + ) + s5-0 + ) + +(defstate knocked (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-110 self) + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (logclear! (-> self mask) (process-mask actor-pause)) + (let* ((v1-8 *game-info*) + (a0-4 (+ (-> v1-8 attack-id) 1)) + ) + (set! (-> v1-8 attack-id) a0-4) + (set! (-> self attack-id) a0-4) + ) + (enemy-method-103 self) + (if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options)) + (set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags))) + ) + (let ((v1-16 (-> self root-override2))) + (logclear! (-> v1-16 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> v1-16 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((a0-16 (-> v1-16 dynam gravity-normal))) + (set! (-> v1-16 local-normal quad) (-> a0-16 quad)) + (set! (-> v1-16 surface-normal quad) (-> a0-16 quad)) + (set! (-> v1-16 poly-normal quad) (-> a0-16 quad)) + ) + (set! (-> v1-16 coverage) 0.0) + (set! (-> v1-16 touch-angle) 0.0) + ) + (enemy-method-52 self (-> v1-16 transv)) + ) + (if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0) + (set! (-> self desired-angle) (enemy-method-51 self)) + ) + (if (zero? (-> self hit-points)) + (enemy-method-132 self) + (enemy-method-135 self 0) + ) + (logclear! (-> self focus-status) (focus-status dangerous)) + (if (= (-> self incoming knocked-type) (knocked-type knocked-type-4)) + (logclear! (-> self enemy-flags) (enemy-flag check-water-backup)) + ) + (set! (-> self root-override2 penetrate-using) (penetrate lunge vehicle knocked)) + (enemy-method-49 self) + (enemy-method-46 self 1) + (none) + ) + :exit (behavior () + (local-vars (v1-1 enemy-flag) (v1-15 enemy-flag) (v1-23 enemy-flag)) + (let ((v1-0 (-> self enemy-flags))) + (if (logtest? (enemy-flag enable-on-hostile) v1-0) + (set! v1-1 (logior (enemy-flag trackable-backup) v1-0)) + (set! v1-1 (logclear v1-0 (enemy-flag trackable-backup))) + ) + ) + (set! (-> self enemy-flags) v1-1) + (when (nonzero? (-> self hit-points)) + (set! (-> self root-override2 penetrate-using) + (the-as penetrate (logclear (-> self root-override2 penetrate-using) (penetrate knocked))) + ) + (enemy-method-46 self 2) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (let ((v1-14 (-> self enemy-flags))) + (if (logtest? v1-14 (enemy-flag checking-water)) + (set! v1-15 (logior v1-14 (enemy-flag enable-on-active))) + (set! v1-15 (logclear v1-14 (enemy-flag enable-on-active))) + ) + ) + (set! (-> self enemy-flags) v1-15) + (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest)) + (set! (-> self mask) (logior (process-mask collectable) (-> self mask))) + (logclear! (-> self mask) (process-mask collectable)) + ) + (let ((v1-22 (-> self enemy-flags))) + (if (logtest? (enemy-flag no-initial-move-to-ground) v1-22) + (set! v1-23 (logior (enemy-flag check-water-backup) v1-22)) + (set! v1-23 (logclear v1-22 (enemy-flag check-water-backup))) + ) + ) + (set! (-> self enemy-flags) v1-23) + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (logclear! (-> self focus-status) (focus-status hit)) + ) + (none) + ) + :trans (behavior () + (if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0) + (seek-toward-yaw-angle! (-> self root-override2) (-> self desired-angle) 138353.78 (seconds 0.1)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (new 'stack-no-clear 'enemy-knocked-info))) + (let ((s5-0 0)) + (set! (-> gp-0 anim-speed) (get-rand-float-range self 0.9 1.1)) + (set! (-> gp-0 on-surface-count) 0) + (set! (-> gp-0 move-count) 0) + (until (enemy-method-80 self gp-0) + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2)) + (enemy-method-73 self) + ) + (if (logtest? (-> self root-override2 status) (collide-status on-surface)) + (+! (-> gp-0 on-surface-count) 1) + ) + (enemy-method-79 self s5-0 gp-0) + (suspend) + (+! (-> gp-0 move-count) 1) + (set! s5-0 1) + ) + ) + (let ((s5-1 2)) + (set! (-> gp-0 land-can-land-time) (-> self clock frame-counter)) + (until #f + (if (logtest? (-> self root-override2 status) (collide-status on-surface)) + (+! (-> gp-0 on-surface-count) 1) + ) + (if (enemy-method-79 self s5-1 gp-0) + (goto cfg-15) + ) + (suspend) + (+! (-> gp-0 move-count) 1) + (set! s5-1 3) + (if (enemy-method-80 self gp-0) + (set! (-> gp-0 land-can-land-time) (-> self clock frame-counter)) + ) + ) + ) + #f + (label cfg-15) + (if (and (not (logtest? (enemy-flag recover) (-> self enemy-flags))) + (or (>= (- (-> self clock frame-counter) (-> gp-0 land-can-land-time)) (seconds 0.1)) + (enemy-method-81 self) + (enemy-method-102 self) + ) + ) + (enemy-method-73 self) + ) + (while (not (enemy-method-79 self 4 gp-0)) + (suspend) + ) + ) + (enemy-method-101 self) + (cond + ((or (zero? (-> self hit-points)) (nonzero? (-> self fated-time))) + (cond + ((logtest? (enemy-flag recover) (-> self enemy-flags)) + (set! (-> self hit-points) 0) + (let ((v1-67 (-> self root-override2 root-prim))) + (set! (-> v1-67 prim-core collide-as) (collide-spec)) + (set! (-> v1-67 prim-core collide-with) (collide-spec)) + ) + 0 + (enemy-method-103 self) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + ) + (else + (enemy-method-73 self) + ) + ) + ) + (else + (go-hostile self) + ) + ) + (none) + ) + :post enemy-falling-post + ) + +(defmethod enemy-method-132 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (set! (-> obj enemy-flags) + (the-as enemy-flag (logior (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + ) + (enemy-method-135 obj 1) + (when (and (>= (-> obj enemy-info gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (or (and (not (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save)))) + (-> obj entity) + ) + (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + (set! (-> obj enemy-flags) (logior (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (remove-from-process *part-engine* obj) + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-no-seg)) + (the-as int (-> obj enemy-info gem-seg)) + ) + (let ((a0-18 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info gem-joint)))) + ) + (birth-pickup-at-point a0-18 (pickup-type gem) 1.0 #t *entity-pool* (-> obj fact-info-override)) + ) + ) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag check-water)) + (logclear! (-> obj mask) (process-mask collectable)) + (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest)) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj enemy-flags) (enemy-flag notice)) + (logior! (-> obj focus-status) (focus-status dead)) + (if (-> obj skel effect) + (logior! (-> obj skel effect flags) (effect-control-flag ecf1)) + ) + (enemy-method-110 obj) + ) + (none) + ) + +(defstate die (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-132 self) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + ) + 0 + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self hit-points) 0) + (enemy-method-103 self) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info die-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info die-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + (none) + ) + :post enemy-simple-post + ) + +(defmethod enemy-method-133 enemy ((obj enemy)) + (let ((s5-0 (-> obj root-override2)) + (a1-0 (new 'stack-no-clear 'collide-query)) + (gp-0 #t) + ) + (when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (if (< (- (-> s5-0 trans y) (-> s5-0 gspot-pos y)) 8192.0) + (set! gp-0 #f) + ) + ) + gp-0 + ) + ) + +(defstate die-falling (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-132 self) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + ) + 0 + (set! (-> self hit-points) 0) + (if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options)) + (set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags))) + ) + (enemy-method-103 self) + (none) + ) + :exit (behavior () + (local-vars (v0-0 enemy-flag)) + (let ((v1-0 (-> self enemy-flags))) + (if (logtest? (enemy-flag enable-on-hostile) v1-0) + (set! v0-0 (logior (enemy-flag trackable-backup) v1-0)) + (set! v0-0 (logclear v1-0 (enemy-flag trackable-backup))) + ) + ) + (set! (-> self enemy-flags) v0-0) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((gp-0 (-> self draw art-group data (if (enemy-method-133 self) + (-> self enemy-info die-falling-anim) + (-> self enemy-info die-anim) + ) + ) + ) + (f30-0 (get-rand-float-range self 0.8 1.2)) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + (none) + ) + :post enemy-die-falling-post + ) + +(defstate directed (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags))) + ((-> (method-of-type enemy idle) enter)) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag victory)) + (none) + ) + :code (-> (method-of-type enemy idle) code) + :post (-> (method-of-type enemy idle) post) + ) + +(defstate die-fast (enemy) + :virtual #t + :code (the-as (function none :behavior enemy) nothing) + ) + +(defstate view-anims (enemy) + :virtual #t + :enter (behavior () + '() + (none) + ) + :trans (behavior () + '() + (none) + ) + :code (behavior () + (let ((gp-0 (-> self draw art-group))) + (until #f + (dotimes (s5-0 (-> gp-0 length)) + (let ((s4-0 (-> gp-0 data s5-0))) + (when (and s4-0 (= (-> s4-0 type) art-joint-anim)) + (ja-channel-set! 1) + (ja-no-eval :group! s4-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + ) + ) + ) + ) + ) + #f + (none) + ) + :post (the-as (function none :behavior enemy) transform-post) + ) + +(defbehavior ja-group-index? enemy ((arg0 int)) + (ja-group? (-> self draw art-group data arg0)) + ) diff --git a/goal_src/jak2/engine/game/fact-h.gc b/goal_src/jak2/engine/game/fact-h.gc index 17abfc46e9..29ce807ed8 100644 --- a/goal_src/jak2/engine/game/fact-h.gc +++ b/goal_src/jak2/engine/game/fact-h.gc @@ -113,6 +113,7 @@ (declare-type entity res-lump) (declare-type entity-actor entity) +(declare-type actor-group inline-array-class) (declare-type target process-focusable) (define-extern process-task-mask (function process task-mask)) @@ -373,18 +374,18 @@ (deftype fact-info-enemy (fact-info) - ((speed float :offset-assert 40) - (idle-distance meters :offset-assert 44) - (notice-top meters :offset-assert 48) - (notice-bottom meters :offset-assert 52) - (cam-horz meters :offset-assert 56) - (cam-vert meters :offset-assert 60) - (cam-notice-dist meters :offset-assert 64) - (enemy-options enemy-option :offset-assert 68) - (trig-dist meters :offset-assert 72) - (trig-actor-group uint32 :offset-assert 76) - (trig-mask-count int8 :offset-assert 80) - (trig-mask uint8 2 :offset-assert 81) + ((speed float :offset-assert 40) + (idle-distance meters :offset-assert 44) + (notice-top meters :offset-assert 48) + (notice-bottom meters :offset-assert 52) + (cam-horz meters :offset-assert 56) + (cam-vert meters :offset-assert 60) + (cam-notice-dist meters :offset-assert 64) + (enemy-options enemy-option :offset-assert 68) + (trig-dist meters :offset-assert 72) + (trig-actor-group (pointer actor-group) :offset-assert 76) + (trig-mask-count int8 :offset-assert 80) + (trig-mask uint8 2 :offset-assert 81) ) :method-count-assert 13 :size-assert #x53 @@ -518,7 +519,7 @@ (set! sv-32 (new 'static 'res-tag)) (let ((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 uint v1-20)) + (set! (-> gp-0 trig-actor-group) (the-as (pointer actor-group) v1-20)) (clear-mask-bits gp-0 2) ) ) diff --git a/goal_src/jak2/engine/nav/nav-enemy-h.gc b/goal_src/jak2/engine/nav/nav-enemy-h.gc index 8b2fdc4c21..8ff5231cdd 100644 --- a/goal_src/jak2/engine/nav/nav-enemy-h.gc +++ b/goal_src/jak2/engine/nav/nav-enemy-h.gc @@ -5,15 +5,27 @@ ;; name in dgo: nav-enemy-h ;; dgos: GAME, COMMON +;; grunt +(declare-type nav-enemy enemy) +(define-extern nav-enemy-falling-post (function none :behavior nav-enemy)) +(define-extern nav-enemy-chase-post (function none :behavior nav-enemy)) +(define-extern nav-enemy-simple-post (function none :behavior nav-enemy)) + +(declare-type nav-callback-info structure) +(define-extern *nav-enemy-null-callback-info* nav-callback-info) + +;; flitter +(define-extern nav-enemy-travel-post (function none :behavior nav-enemy)) + ;; DECOMP BEGINS (deftype nav-enemy-info (enemy-info) ((callback-info nav-callback-info :offset-assert 384) (use-momentum symbol :offset-assert 388) - (use-frustration basic :offset-assert 392) - (use-stop-chase basic :offset-assert 396) - (use-circling basic :offset-assert 400) - (use-pacing basic :offset-assert 404) + (use-frustration symbol :offset-assert 392) + (use-stop-chase symbol :offset-assert 396) + (use-circling symbol :offset-assert 400) + (use-pacing symbol :offset-assert 404) (walk-anim int32 :offset-assert 408) (turn-anim int32 :offset-assert 412) (run-anim int32 :offset-assert 416) @@ -31,7 +43,7 @@ (blocked-time time-frame :offset-assert 472) (circle-dist-lo float :offset-assert 480) (circle-dist-hi float :offset-assert 484) - (nav-mesh basic :offset-assert 488) + (nav-mesh nav-mesh :offset-assert 488) ) :method-count-assert 11 :size-assert #x1ec @@ -84,7 +96,7 @@ (nav-enemy-method-160 (_type_) none 160) (nav-enemy-method-161 (_type_) none 161) (nav-enemy-method-162 (_type_) none 162) - (nav-enemy-method-163 (_type_) none 163) + (nav-enemy-method-163 (_type_) symbol 163) (nav-enemy-method-164 (_type_) none 164) (nav-enemy-method-165 (_type_) none 165) (nav-enemy-method-166 (_type_) none 166) diff --git a/goal_src/jak2/levels/common/flitter.gc b/goal_src/jak2/levels/common/flitter.gc index 8d65f8ba58..0de96cfae6 100644 --- a/goal_src/jak2/levels/common/flitter.gc +++ b/goal_src/jak2/levels/common/flitter.gc @@ -7,3 +7,1445 @@ ;; DECOMP BEGINS +(defpartgroup group-flitter-dust-puff + :id 144 + :duration (seconds 0.017) + :flags (use-local-clock) + :bounds (static-bspherem 0 0 0 8) + :parts ((sp-item 641)) + ) + +(defpart 641 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-flt spt-num 6.0) + (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.4) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-rnd-flt spt-r 32.0 8.0 1.0) + (sp-rnd-flt spt-g 16.0 8.0 1.0) + (sp-rnd-flt spt-b 16.0 8.0 1.0) + (sp-rnd-flt spt-a 32.0 32.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.0026666666) 1.0) + (sp-flt spt-scalevel-x (meters 0.0016666667)) + (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-r -0.35555556) + (sp-flt spt-fade-g -0.35555556) + (sp-flt spt-fade-b -0.35555556) + (sp-flt spt-fade-a -0.30476192) + (sp-flt spt-accel-y -1.3653333) + (sp-int spt-timer 120) + (sp-cpuinfo-flags sp-cpuinfo-flag-2) + (sp-int spt-next-time 60) + (sp-launcher-by-id spt-next-launcher 642) + (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 30.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0) + ) + ) + +(defpartgroup group-flitter-birth + :id 145 + :duration (seconds 7.335) + :linger-duration (seconds 4) + :flags (use-local-clock) + :bounds (static-bspherem 0 3 0 8) + :parts ((sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 250 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 200 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 150 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 100 :binding 643) + (sp-item 646 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 120 :binding 644) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 647 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 320) + ) + ) + +(defpart 647 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 1.0 1.0 1.0) + (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 48.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-fade-a -0.053333335 -0.053333335 1.0) + (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0) + (sp-rnd-flt spt-friction 0.85 0.05 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 90.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.5) 1.0) + ) + ) + +(defun check-drop-level-flitter-dirt-rubble ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector)) + (let ((f30-0 (-> arg1 key origin trans y))) + (when (< (-> arg2 y) f30-0) + (let ((gp-0 (new 'stack-no-clear 'vector))) + (sp-kill-particle arg0 arg1) + (set-vector! gp-0 (-> arg2 x) f30-0 (-> arg2 z) 1.0) + (let ((t9-1 sp-launch-particles-var) + (a0-2 *sp-particle-system-2d*) + (a1-1 (-> *part-id-table* 648)) + (a2-1 *launch-matrix*) + ) + (set! (-> a2-1 trans quad) (-> gp-0 quad)) + (t9-1 a0-2 a1-1 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + (let ((t9-2 sp-launch-particles-var) + (a0-3 *sp-particle-system-2d*) + (a1-2 (-> *part-id-table* 649)) + (a2-2 *launch-matrix*) + ) + (set! (-> a2-2 trans quad) (-> gp-0 quad)) + (t9-2 a0-3 a1-2 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + (let ((t9-3 sp-launch-particles-var) + (a0-4 *sp-particle-system-2d*) + (a1-3 (-> *part-id-table* 650)) + (a2-3 *launch-matrix*) + ) + (set! (-> a2-3 trans quad) (-> gp-0 quad)) + (t9-3 a0-4 a1-3 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + ) + ) + ) + (none) + ) + +(defpart 644 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 0.0 0.2 1.0) + (sp-sound (static-sound-spec "debris-fall" :num 0.01 :volume 100.0)) + (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 16.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0) + (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0) + (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0) + (sp-int spt-timer 250) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-func spt-func 'check-drop-group-center) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +(defpart 643 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 0.0 0.2 1.0) + (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 16.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0) + (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0) + (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0) + (sp-int spt-timer 750) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-func spt-func 'check-drop-group-center) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +(defpart 646 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 0.5 0.5 1.0) + (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0) + (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.033333335) (meters 0.033333335) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0) + (sp-flt spt-friction 0.98) + (sp-int spt-timer 350) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-func spt-func 'check-drop-level-flitter-dirt-rubble) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 45.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-radius (meters 0.5)) + ) + ) + +(defpart 645 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 0.1 0.5 1.0) + (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0) + (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.033333335) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0) + (sp-flt spt-friction 0.98) + (sp-int spt-timer 350) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-func spt-func 'check-drop-level-flitter-dirt-rubble-ruins) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 15.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-radius (meters 0.1)) + ) + ) + +(defpart 648 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 1.0 2.0 1.0) + (sp-rnd-flt spt-scale-x (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-fade-a -0.42666668 -0.85333335 1.0) + (sp-flt spt-accel-y -2.7306666) + (sp-int spt-timer 600) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-rnd-flt spt-conerot-x (degrees 10.0) (degrees 60.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +(defpart 649 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 1.0 1.0 1.0) + (sp-rnd-flt spt-scale-x (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters 0.04) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-friction 0.94 0.02 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-int-plain-rnd spt-next-time 450 149 1) + (sp-launcher-by-id spt-next-launcher 651) + (sp-flt spt-conerot-x (degrees 90.0)) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +(defpart 651 + :init-specs ((sp-flt spt-rotvel-z (degrees 0.0)) (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)) + ) + +(defpart 650 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-flt spt-num 1.0) + (sp-sound (static-sound-spec "debris-ground" :num 0.01 :volume 100.0)) + (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.5) (meters 0.5) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 32.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-fade-a -0.026666667 -0.026666667 1.0) + (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0) + (sp-rnd-flt spt-friction 0.9 0.05 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-rnd-flt spt-conerot-x (degrees 70.0) (degrees 20.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +(deftype flitter (nav-enemy) + ((move-angle float :offset-assert 604) + (heading basic :offset-assert 608) + (change-dir-time time-frame :offset-assert 616) + (last-change-dir uint64 :offset-assert 624) + (off-screen-timer uint64 :offset-assert 632) + (amb-sound-timer uint64 :offset-assert 640) + (attack-time time-frame :offset-assert 648) + (target-pos vector :inline :offset-assert 656) + (attack-pos vector :inline :offset-assert 672) + (base-height float :offset-assert 688) + (minimap connection-minimap :offset-assert 692) + ) + :heap-base #x240 + :method-count-assert 184 + :size-assert #x2b8 + :flag-assert #xb8024002b8 + (:methods + (attack () _type_ :state 178) + (ambush-jumping () _type_ :state 179) + (flitter-method-180 (_type_) none 180) + (flitter-method-181 (_type_) none 181) + (flitter-method-182 (_type_ process-focusable) symbol 182) + (flitter-method-183 (_type_) float 183) + ) + ) + + +(defskelgroup skel-flitter flitter 0 -1 + ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999))) + :bounds (static-spherem 0 0 0 5.5) + :shadow 4 + :origin-joint-index 3 + ) + +(define *flitter-nav-enemy-info* (new 'static 'nav-enemy-info + :use-die-falling #t + :use-victory #f + :use-jump-blocked #f + :debug-draw-neck #f + :jump-debug-draw #f + :move-to-ground #t + :hover-if-no-ground #f + :idle-anim-script (new 'static 'array uint32 16 + #x1e0002 + #x6030501 + #x1e0002 + #x1010601 + #x1e0f0701 + #x1e0002 + #x4020501 + #x1e0002 + #x1010801 + #x140a0901 + #x1e0002 + #x2010501 + #x1e0002 + #x1010801 + #x1e0f0901 + #x0 + ) + :idle-anim 5 + :notice-anim 12 + :hostile-anim 14 + :hit-anim 5 + :knocked-anim 20 + :knocked-land-anim 21 + :die-anim 19 + :die-falling-anim 18 + :victory-anim 5 + :jump-wind-up-anim 5 + :jump-in-air-anim 5 + :jump-land-anim 5 + :neck-joint -1 + :look-at-joint 28 + :bullseye-joint 3 + :sound-hit (static-sound-name "flitter-hit") + :sound-die (static-sound-name "flitter-die") + :notice-distance (meters 40) + :notice-distance-delta (meters 10) + :proximity-notice-distance (meters 20) + :default-hit-points 1 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :penetrate-knocked #x11fffdffa + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 6) + :attack-shove-up (meters 3) + :attack-mode 'generic + :attack-damage 1 + :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher) + :jump-height-min (meters 3) + :jump-height-factor 0.5 + :knocked-seek-ry-clamp 2730.6667 + :knocked-soft-vxz-lo 72089.6 + :knocked-soft-vxz-hi 108134.4 + :knocked-soft-vy-lo 81920.0 + :knocked-soft-vy-hi 122880.0 + :knocked-medium-vxz-lo 147456.0 + :knocked-medium-vxz-hi 196608.0 + :knocked-medium-vy-lo 135168.0 + :knocked-medium-vy-hi 151552.0 + :knocked-hard-vxz-lo 78643.2 + :knocked-hard-vxz-hi 117964.8 + :knocked-hard-vy-lo 183500.8 + :knocked-hard-vy-hi 275251.2 + :knocked-huge-vxz-lo 164659.2 + :knocked-huge-vxz-hi 249036.8 + :knocked-huge-vy-lo 183500.8 + :knocked-huge-vy-hi 217907.2 + :knocked-yellow-vxz-lo 40960.0 + :knocked-yellow-vxz-hi 49152.0 + :knocked-yellow-vy-lo 57344.0 + :knocked-yellow-vy-hi 81920.0 + :knocked-red-vxz-lo 24576.0 + :knocked-red-vxz-hi 196608.0 + :knocked-red-vy-lo 94208.0 + :knocked-red-vy-hi 151552.0 + :knocked-blue-vxz-lo 40960.0 + :knocked-blue-vxz-hi 49152.0 + :knocked-blue-vy-lo 24576.0 + :knocked-blue-vy-hi 81920.0 + :shadow-size (meters 2) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint 28 + :gem-seg #x2 + :gem-no-seg #x4 + :gem-offset (new 'static 'sphere :y 696.32 :z 1843.2 :r 163840.0) + :callback-info #f + :use-momentum #f + :use-frustration #t + :use-stop-chase #f + :use-circling #t + :use-pacing #t + :walk-anim 13 + :turn-anim 15 + :run-anim 14 + :taunt-anim -1 + :run-travel-speed (meters 12) + :run-acceleration (meters 8) + :run-turning-acceleration (meters 120) + :walk-travel-speed (meters 4) + :walk-acceleration (meters 1) + :walk-turning-acceleration (meters 5) + :maximum-rotation-rate (degrees 720.0) + :notice-nav-radius (meters 5) + :frustration-distance (meters 12) + :frustration-time (seconds 4) + :blocked-time (seconds 0.3) + :circle-dist-lo 20480.0 + :circle-dist-hi 61440.0 + :nav-mesh #f + ) + ) + +(set! (-> *flitter-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +(defmethod flitter-method-182 flitter ((obj flitter) (arg0 process-focusable)) + (and (logtest? (-> obj draw status) (draw-control-status on-screen)) + (let ((s4-0 (camera-matrix))) + (camera-pos) + (let* ((s3-0 (get-trans arg0 0)) + (s5-1 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s4-0 vector 2) 1.0)) + (v1-7 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) s3-0) 1.0)) + ) + (< 0.0 (vector-dot s5-1 v1-7)) + ) + ) + ) + ) + +(defmethod enemy-method-77 flitter ((obj flitter) (arg0 (pointer float))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4)) + (let ((a0-2 (-> obj skel root-channel 0))) + (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 20))) + (set! (-> a0-2 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 20)) frames num-frames) -1)) + ) + (set! (-> a0-2 param 1) (-> arg0 0)) + (set! (-> a0-2 frame-num) 0.0) + (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 20)) num-func-seek!) + ) + #t + ) + (((knocked-type knocked-type-6)) + (let ((v1-17 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and v1-17 (= v1-17 (-> obj draw art-group data 21))) + (ja-channel-push! 1 (seconds 0.17)) + (ja-channel-push! 1 (seconds 0.02)) + ) + ) + (let ((a0-10 (-> obj skel root-channel 0))) + (set! (-> a0-10 frame-group) (the-as art-joint-anim (-> obj draw art-group data 23))) + (set! (-> a0-10 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 23)) frames num-frames) -1)) + ) + (set! (-> a0-10 param 1) 1.0) + (set! (-> a0-10 frame-num) 0.0) + (joint-control-channel-group! a0-10 (the-as art-joint-anim (-> obj draw art-group data 23)) num-func-seek!) + ) + #t + ) + (else + ((method-of-type nav-enemy enemy-method-77) obj arg0) + ) + ) + ) + +(defmethod enemy-method-78 flitter ((obj flitter) (arg0 (pointer float))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-6)) + (when (>= (the-as uint (-> obj incoming blue-juggle-count)) (the-as uint 2)) + (let ((v1-4 (-> obj skel root-channel 0))) + (set! (-> v1-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 22))) + (set! (-> v1-4 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 22)) frames num-frames) -1)) + ) + (set! (-> v1-4 param 1) 1.0) + (set! (-> v1-4 frame-num) 0.0) + (joint-control-channel-group! v1-4 (the-as art-joint-anim (-> obj draw art-group data 22)) num-func-seek!) + ) + #t + ) + ) + (else + ((method-of-type nav-enemy enemy-method-78) obj arg0) + ) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod go-stare2 flitter ((obj flitter)) + (if (and (= (-> obj focus aware) (enemy-aware enemy-aware-2)) + (not (nav-enemy-method-163 obj)) + (not (and (-> obj next-state) (= (-> obj next-state name) 'pacing))) + ) + (go (method-of-object obj pacing)) + (go (method-of-object obj stare)) + ) + (none) + ) + +(defstate ambush (flitter) + :virtual #t + :enter (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (set! (-> self base-height) (-> self root-override2 trans y)) + (let ((v1-13 (-> self root-override2 root-prim))) + (set! (-> v1-13 prim-core collide-as) (collide-spec)) + (set! (-> v1-13 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> self draw status) (draw-control-status no-draw)) + (none) + ) + :code (behavior () + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-1 (method-of-type part-tracker activate))) + (t9-1 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-2 run-function-in-process) + (a0-2 gp-0) + (a1-2 part-tracker-init) + (a2-4 (-> *part-group-id-table* 145)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> self root-override2 trans quad)) + ((the-as (function object object object object object object object object none) t9-2) + a0-2 + a1-2 + a2-4 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> gp-0 ppointer) + ) + ) + (let ((gp-1 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.6)) + (suspend) + ) + ) + (set! (-> self root-override2 trans y) (+ -8192.0 (-> self root-override2 trans y))) + (enemy-method-129 self) + (let ((a0-5 (handle->process (-> self focus handle)))) + (when a0-5 + (let* ((gp-2 (-> self root-override2)) + (s3-0 + (vector-normalize! + (vector-! (new 'stack-no-clear 'vector) (get-trans (the-as process-focusable a0-5) 0) (-> gp-2 trans)) + 1.0 + ) + ) + (f0-2 (deg-diff (quaternion-y-angle (-> gp-2 quat)) (vector-y-angle s3-0))) + ) + (quaternion-rotate-y! (-> gp-2 quat) (-> gp-2 quat) f0-2) + ) + ) + ) + (let ((gp-3 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-3) (the int (* 300.0 (get-rand-float-range self 0.0 0.6)))) + (suspend) + ) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (go-virtual ambush-jumping) + (none) + ) + ) + +(defstate ambush-jumping (flitter) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior flitter) enemy-event-handler) + :enter (behavior () + (let ((v1-0 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-0 enemy-flags))) + (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-0 enemy-flags)))) + ) + (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-0 enemy-flags)))) + (set! (-> v1-0 nav callback-info) (-> v1-0 enemy-info-override callback-info)) + ) + 0 + (let ((v1-3 self)) + (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-3 enemy-flags)))) + ) + 0 + (enemy-method-109 self 1) + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((gp-0 (-> self root-override2))) + (vector-reset! (-> gp-0 transv)) + (set! (-> gp-0 transv y) (* 4096.0 (get-rand-float-range self 34.0 38.0))) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (ja-no-eval :group! (-> self draw art-group data 10) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 10)) frames num-frames) -1))) + ) + (until #f + (when (< (-> self base-height) (-> self root-override2 trans y)) + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-3 (method-of-type part-tracker activate))) + (t9-3 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-4 run-function-in-process) + (a0-4 gp-0) + (a1-4 part-tracker-init) + (a2-5 (-> *part-group-id-table* 144)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> self root-override2 trans quad)) + ((the-as (function object object object object object object object object none) t9-4) + a0-4 + a1-4 + a2-5 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> gp-0 ppointer) + ) + ) + (goto cfg-10) + ) + (suspend) + (ja :num! (seek!)) + ) + #f + (until #f + (when (< (+ 204.8 (-> self base-height)) (-> self root-override2 trans y)) + (let ((v1-40 (-> self root-override2 root-prim))) + (set! (-> v1-40 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-40 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (goto cfg-11) + ) + (label cfg-10) + (suspend) + (ja :num! (seek!)) + ) + #f + (until #f + (label cfg-11) + (if (or (and (>= 0.0 (-> self root-override2 transv y)) + (>= (+ 1638.4 (-> self base-height)) (-> self root-override2 trans y)) + ) + (logtest? (-> self root-override2 status) (collide-status on-ground)) + ) + (goto cfg-26) + ) + (suspend) + (if (not (ja-done? 0)) + (ja :num! (seek!)) + ) + ) + #f + (label cfg-26) + (ja-no-eval :group! (-> self draw art-group data 11) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 11)) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + (until #f + (if (logtest? (-> self root-override2 status) (collide-status on-ground)) + (goto cfg-33) + ) + (suspend) + ) + #f + (label cfg-33) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior flitter) nav-enemy-falling-post) + ) + +(defmethod enemy-method-99 flitter ((obj flitter) (arg0 process-focusable)) + (logtest? (focus-status mech) (-> arg0 focus-status)) + ) + +(defmethod flitter-method-180 flitter ((obj flitter)) + (with-pp + (let* ((s5-0 (handle->process (-> obj focus handle))) + (s3-0 (if (type? s5-0 process-focusable) + (the-as process-focusable s5-0) + ) + ) + ) + (when s3-0 + (let* ((s5-1 (get-trans s3-0 0)) + (s4-1 (vector-! (new 'stack-no-clear 'vector) s5-1 (-> obj root-override2 trans))) + (f30-0 (vector-length s4-1)) + ) + (cond + ((enemy-method-99 obj s3-0) + (go-flee obj) + ) + ((and (< f30-0 32768.0) (not (flitter-method-182 obj s3-0))) + (go (method-of-object obj circling)) + ) + ((< f30-0 (-> obj enemy-info-override notice-nav-radius)) + (set! (-> obj target-pos quad) (-> s5-1 quad)) + (let ((s3-1 (new 'stack-no-clear 'vector))) + (set! (-> s3-1 quad) (-> s4-1 quad)) + (let ((s5-2 (new 'stack-no-clear 'vector))) + (set! (-> s5-2 quad) (-> obj root-override2 transv quad)) + (vector-normalize! s5-2 f30-0) + (if (>= (vector-dot s3-1 s5-2) 0.98) + (go (method-of-object obj attack)) + ) + ) + ) + ) + ((< f30-0 32768.0) + (set! (-> obj target-pos quad) (-> s5-1 quad)) + ) + ((or (>= (- (-> pp clock frame-counter) (the-as int (-> obj last-change-dir))) (-> obj change-dir-time)) + (< (vector-vector-distance-squared (-> obj root-override2 trans) (-> obj target-pos)) 0.1) + ) + (set! (-> obj last-change-dir) (the-as uint (-> pp clock frame-counter))) + (set! (-> obj change-dir-time) (rand-vu-int-range (seconds 0.5) (seconds 0.7))) + (let ((s3-2 (new 'stack-no-clear 'vector)) + (f0-9 (* 0.5 f30-0 (tan (-> obj move-angle)))) + (s2-0 (new 'stack-no-clear 'vector)) + ) + (if (-> obj heading) + (set-vector! s3-2 (-> s4-1 z) (-> s4-1 y) (- (-> s4-1 x)) 1.0) + (set-vector! s3-2 (- (-> s4-1 z)) (-> s4-1 y) (-> s4-1 x) 1.0) + ) + (set! (-> obj heading) (the-as basic (not (-> obj heading)))) + (let ((f28-1 (rand-vu-float-range (* 0.75 f0-9) f0-9)) + (s4-2 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-1 (* -0.6 f30-0))) + ) + (vector-normalize! s3-2 f28-1) + (vector+! s3-2 s3-2 s4-2) + ) + (nav-state-method-41 (-> obj nav state) s3-2) + (vector+! s2-0 s5-1 s3-2) + (set! (-> obj target-pos quad) (-> s2-0 quad)) + ) + ) + ) + ) + 0 + ) + ) + 0 + (none) + ) + ) + +;; WARN: Return type mismatch time-frame vs none. +(defmethod flitter-method-181 flitter ((obj flitter)) + (with-pp + (when (>= (- (-> pp clock frame-counter) (the-as int (-> obj amb-sound-timer))) + (the int (* 300.0 (rand-vu-float-range 1.5 3.0))) + ) + (sound-play "flitter-amb" :position (-> obj root-override2 trans)) + (set! (-> obj amb-sound-timer) (the-as uint (-> pp clock frame-counter))) + ) + (none) + ) + ) + +(defbehavior flitter-fall-and-play-death-anim flitter ((arg0 art-joint-anim) (arg1 float) (arg2 time-frame)) + (local-vars (v1-29 symbol)) + (enemy-method-110 self) + (set! (-> self skel root-channel 0 frame-group) arg0) + (let ((s4-1 (enemy-method-50 self (new 'stack-no-clear 'vector))) + (s3-0 (-> self root-override2)) + ) + (when (if (type? s3-0 collide-shape-moving) + s3-0 + ) + (set! (-> self root-override2 transv y) 33775.48) + (ja :num-func num-func-identity :frame-num 0.0) + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self root-override2 status) (collide-status on-surface on-ground touch-surface)) + (until v1-29 + (let ((f0-2 102400.0)) + (set! (-> self root-override2 transv x) (* (-> s4-1 x) f0-2)) + (set! (-> self root-override2 transv z) (* (-> s4-1 z) f0-2)) + ) + (suspend) + (ja :num! (seek! max arg1)) + (set! v1-29 (or (ja-done? 0) (>= (- (-> self clock frame-counter) (-> self state-time)) arg2))) + ) + ) + ) + 0 + (none) + ) + +(defstate active (flitter) + :virtual #t + :post (behavior () + (flitter-method-181 self) + (let ((t9-1 (-> (method-of-type nav-enemy active) post))) + (if t9-1 + ((the-as (function none) t9-1)) + ) + ) + (none) + ) + ) + +(defstate stare (flitter) + :virtual #t + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (until #f + (when (not (enemy-method-96 self 2730.6667 #t)) + (let ((v1-5 self)) + (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags)))) + ) + 0 + (ja-no-eval :num! (loop!)) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 15)) + (ja :num-func num-func-identity :frame-num 0.0) + (until (enemy-method-96 self 1820.4445 #t) + (ja-blend-eval) + (suspend) + (ja :num! (loop! 0.75)) + ) + (let ((v1-25 self)) + (set! (-> v1-25 enemy-flags) (the-as enemy-flag (logclear (-> v1-25 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + ) + (let ((v1-29 (ja-group))) + (if (not (and v1-29 (= v1-29 (-> self draw art-group data (-> self enemy-info-override idle-anim))))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post (behavior () + (flitter-method-181 self) + (let ((t9-1 (-> (method-of-type nav-enemy stare) post))) + (if t9-1 + ((the-as (function none) t9-1)) + ) + ) + (none) + ) + ) + +(defstate circling (flitter) + :virtual #t + :enter (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy circling) enter))) + (if t9-0 + (t9-0) + ) + ) + (set! (-> self off-screen-timer) (the-as uint (-> self clock frame-counter))) + (none) + ) + :trans (behavior () + (let ((gp-0 (handle->process (-> self focus handle)))) + (if gp-0 + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad)) + ) + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((v1-11 (-> self focus aware))) + (cond + ((= v1-11 (enemy-aware enemy-aware-3)) + (cond + ((when gp-0 + (let* ((gp-1 self) + (s5-1 (method-of-object gp-1 flitter-method-182)) + (s4-0 (handle->process (-> self focus handle))) + ) + (s5-1 gp-1 (the-as process-focusable (if (type? s4-0 process-focusable) + s4-0 + ) + ) + ) + ) + ) + (if (and (enemy-method-107 self) + (>= (- (-> self clock frame-counter) (the-as int (-> self off-screen-timer))) (seconds 0.3)) + ) + (go-hostile self) + ) + ) + (else + (set! (-> self off-screen-timer) (the-as uint (-> self clock frame-counter))) + ) + ) + ) + ((= v1-11 (enemy-aware enemy-aware-2)) + (go-stare self) + ) + ((>= 1 (the-as int v1-11)) + (go-virtual active) + ) + ) + ) + (if (or (nav-enemy-method-163 self) (logtest? (enemy-flag enemy-flag41) (-> self enemy-flags))) + (go-stare2 self) + ) + ) + ) + (none) + ) + :code (behavior () + (nav-enemy-method-166 self) + (ja-channel-push! 1 (seconds 0.2)) + (until #f + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override run-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override run-anim))) + frames + num-frames + ) + -1 + ) + ) + (get-rand-float-range self 0.9 1.1) + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max (get-rand-float-range self 0.9 1.1))) + ) + ) + #f + (none) + ) + ) + +(defstate hostile (flitter) + :virtual #t + :enter (behavior () + (set! (-> self last-change-dir) (the-as uint (-> self clock frame-counter))) + (set! (-> self change-dir-time) 0) + (set! (-> self attack-time) (+ (-> self clock frame-counter) (seconds 0.35))) + (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter))) + (if t9-0 + (t9-0) + ) + ) + (none) + ) + :trans (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans))) + (if t9-0 + (t9-0) + ) + ) + (flitter-method-180 self) + (none) + ) + :post (behavior () + (let ((a0-0 (-> self nav state)) + (v1-1 (-> self target-pos)) + ) + (logclear! (-> a0-0 flags) (nav-state-flag directional-mode)) + (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty)) + (set! (-> a0-0 target-post quad) (-> v1-1 quad)) + ) + 0 + (nav-enemy-travel-post) + (none) + ) + ) + +(defstate die (flitter) + :virtual #t + :enter (behavior () + (sound-play "flitter-die") + (let ((t9-2 (-> (method-of-type nav-enemy die) enter))) + (if t9-2 + (t9-2) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (flitter-fall-and-play-death-anim + (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override die-anim))) + 1.0 + (seconds 2) + ) + (send-event self 'death-end) + (cleanup-for-death self) + (none) + ) + ) + +(defmethod flitter-method-183 flitter ((obj flitter)) + (lerp-scale 0.0 1.0 (- (-> obj attack-pos y) (-> obj root-override2 trans y)) 13926.4 25600.0) + ) + +(defstate attack (flitter) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior flitter) enemy-event-handler) + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((v1-2 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags)))) + ) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))) + (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info)) + ) + 0 + (sound-play "flitter-attack") + (set! (-> self amb-sound-timer) (the-as uint 0)) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-8 *game-info*) + (v0-2 (+ (-> v1-8 attack-id) 1)) + ) + (set! (-> v1-8 attack-id) v0-2) + (set! (-> self attack-id) v0-2) + ) + (none) + ) + :exit (behavior () + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (local-vars (s5-2 none)) + (let* ((s5-0 (handle->process (-> self focus handle))) + (gp-0 (if (type? s5-0 process-focusable) + (the-as process-focusable s5-0) + ) + ) + ) + (set! s5-2 (cond + ((and gp-0 + (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.5)) + gp-0 + (zero? (logand (-> gp-0 focus-status) (focus-status disable dead ignore grabbed))) + ) + (let ((s5-1 (-> self nav state)) + (v1-10 (get-trans gp-0 0)) + ) + (logclear! (-> s5-1 flags) (nav-state-flag directional-mode)) + (logior! (-> s5-1 flags) (nav-state-flag target-poly-dirty)) + (set! (-> s5-1 target-post quad) (-> v1-10 quad)) + ) + 0 + (set! s5-2 (the-as none (-> self attack-pos))) + (set! (-> (the-as vector s5-2) quad) (-> (get-trans gp-0 3) quad)) + s5-2 + ) + (else + (go-stare self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 2 (seconds 0.1)) + (let ((f30-0 (flitter-method-183 self))) + (ja-no-eval :group! (-> self draw art-group data 16) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 16)) frames num-frames) -1)) 0.8) + :frame-num 0.0 + ) + (let ((a0-3 (-> self skel root-channel 1))) + (set! (-> a0-3 frame-interp 1) f30-0) + (set! (-> a0-3 frame-interp 0) f30-0) + (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> self draw art-group data 17))) + (set! (-> a0-3 param 0) 0.0) + (set! (-> a0-3 frame-num) 0.0) + (joint-control-channel-group! a0-3 (the-as art-joint-anim (-> self draw art-group data 17)) num-func-chan) + ) + (until (ja-done? 0) + (suspend) + (set! f30-0 (seek f30-0 (flitter-method-183 self) (* 0.2 (-> self clock seconds-per-frame)))) + (ja :num! (seek! max 0.8)) + (let ((a0-7 (-> self skel root-channel 1))) + (set! (-> a0-7 frame-interp 1) f30-0) + (set! (-> a0-7 frame-interp 0) f30-0) + (set! (-> a0-7 param 0) 0.0) + (joint-control-channel-group-eval! a0-7 (the-as art-joint-anim #f) num-func-chan) + ) + ) + ) + (let ((v1-40 self)) + (set! (-> v1-40 enemy-flags) (the-as enemy-flag (logclear (-> v1-40 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-40 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (ja-channel-push! 1 (seconds 0.1)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (dotimes (gp-1 (get-rand-int self 3)) + (ja-no-eval :group! (-> self draw art-group data 5) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post (the-as (function none :behavior flitter) nav-enemy-travel-post) + ) + +(defstate victory (flitter) + :virtual #t + :post (behavior () + (flitter-method-181 self) + (nav-enemy-simple-post) + (none) + ) + ) + +(defmethod enemy-method-132 flitter ((obj flitter)) + (when (-> obj minimap) + (logior! (-> obj minimap flags) (minimap-flag fade-out)) + (set! (-> obj minimap) #f) + ) + ((the-as (function nav-enemy none) (find-parent-method flitter 132)) obj) + (none) + ) + +(defmethod enemy-method-114 flitter ((obj flitter)) + "@abstract" + (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s5-0 reaction) cshape-reaction-default) + (set! (-> s5-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 3) 0))) + (set! (-> s5-0 total-prims) (the-as uint 4)) + (set! (-> s4-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s4-0 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> s4-0 local-sphere) 0.0 10240.0 0.0 15360.0) + (set! (-> s5-0 root-prim) s4-0) + ) + (let ((v1-12 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-12 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-12 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> v1-12 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> v1-12 local-sphere) 0.0 5734.4 0.0 5734.4) + ) + (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-14 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-14 prim-core action) (collide-action deadly)) + (set! (-> v1-14 transform-index) 34) + (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 3481.6) + ) + (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-16 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-16 prim-core action) (collide-action deadly)) + (set! (-> v1-16 transform-index) 35) + (set-vector! (-> v1-16 local-sphere) 0.0 0.0 0.0 3481.6) + ) + (set! (-> s5-0 nav-radius) 3686.4) + (let ((v1-18 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-18 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-18 prim-core collide-with)) + ) + (set! (-> s5-0 max-iteration-count) (the-as uint 3)) + (set! (-> obj root-override2) s5-0) + ) + 0 + (none) + ) + +;; WARN: Return type mismatch connection-minimap vs none. +(defmethod enemy-method-115 flitter ((obj flitter)) + "@abstract" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-flitter" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (enemy-method-113 obj *flitter-nav-enemy-info*) + (set! (-> obj move-angle) 10922.667) + (set! (-> obj heading) (the-as basic (if (= (rand-vu-int-range 0 1) 1) + #t + #f + ) + ) + ) + (set! (-> obj change-dir-time) 0) + (set! (-> obj off-screen-timer) (the-as uint 0)) + (set! (-> obj amb-sound-timer) (the-as uint 0)) + (add-connection + *part-engine* + obj + 28 + obj + 318 + (new 'static 'vector :x 942.08 :y -860.16 :z 1269.76 :w 163840.0) + ) + (add-connection + *part-engine* + obj + 28 + obj + 318 + (new 'static 'vector :x -942.08 :y -860.16 :z 1269.76 :w 163840.0) + ) + (set-gravity-length (-> obj root-override2 dynam) 491520.0) + (let* ((s4-1 "pebble1-ruins") + (v1-15 (-> obj level name)) + (s5-2 + (cond + ((= v1-15 'strip) + (set! s4-1 "pebble1-strip") + (new 'static 'boxed-array :type int32 40 1 0 #x4f800500 #x4f800600 #x4f800700 #x4f800800 #x4f800900) + ) + ((= v1-15 'dig3a) + (set! s4-1 "pebble1-dig") + (new 'static 'boxed-array :type int32 40 1 0 -1377828352 -1377828096 -1377827840 -1377827584 -1377827328) + ) + ((= v1-15 'stadblmp) + (set! s4-1 "pebble1-dig") + (new 'static 'boxed-array :type int32 40 1 0 -670040064 -670039808 -670039552 -670039296 -670039040) + ) + (else + (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + ) + ) + ) + (setup-user-array (-> *part-id-table* 646) s4-1) + (setup-user-array (-> *part-id-table* 645) s4-1) + (setup-user-array (-> *part-id-table* 648) s4-1) + (setup-user-array (-> *part-id-table* 649) s4-1) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 646) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 645) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 648) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 649) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + ) + (set! (-> obj minimap) + (minimap-method-12 *minimap* obj (the-as uint 70) (the-as int #f) (the-as vector #t) 0) + ) + (none) + ) diff --git a/goal_src/jak2/levels/common/grunt.gc b/goal_src/jak2/levels/common/grunt.gc index dc401a4a8c..db031c152c 100644 --- a/goal_src/jak2/levels/common/grunt.gc +++ b/goal_src/jak2/levels/common/grunt.gc @@ -7,3 +7,1628 @@ ;; DECOMP BEGINS +(defskelgroup skel-grunt grunt 0 -1 + ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999))) + :bounds (static-spherem 0 0 0 5) + :shadow 4 + :origin-joint-index 18 + ) + +(deftype grunt-anim-info (structure) + ((anim-index int32 :offset-assert 0) + (travel-speed meters :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + + +(deftype grunt-global-info (basic) + ((prev-knocked-anim-index int32 :offset-assert 4) + (prev-yellow-hit-anim-index int32 :offset-assert 8) + (prev-blue-hit-anim-index int32 :offset-assert 12) + (patrol-anim grunt-anim-info 4 :inline :offset-assert 16) + (charge-anim grunt-anim-info 3 :inline :offset-assert 48) + (attack-anim grunt-anim-info 2 :inline :offset-assert 72) + (knocked-anim grunt-anim-info 4 :inline :offset-assert 88) + (knocked-land-anim grunt-anim-info 4 :inline :offset-assert 120) + (yellow-hit-anim grunt-anim-info 4 :inline :offset-assert 152) + (blue-hit-anim grunt-anim-info 6 :inline :offset-assert 184) + ) + :method-count-assert 9 + :size-assert #xe8 + :flag-assert #x9000000e8 + ) + + +(deftype grunt (nav-enemy) + ((patrol-anim grunt-anim-info :offset-assert 604) + (charge-anim grunt-anim-info :offset-assert 608) + (attack-anim grunt-anim-info :offset-assert 612) + (knocked-anim grunt-anim-info :offset-assert 616) + (yellow-hit-anim grunt-anim-info :offset-assert 620) + (blue-hit-anim grunt-anim-info :offset-assert 624) + (intro-path path-control :offset-assert 628) + (use-charge-anim-index int8 :offset-assert 632) + (knocked-anim-index int8 :offset-assert 633) + (jumping-ambush-path-pt int8 :offset-assert 634) + (grunt-flags uint8 :offset-assert 635) + (unknown-byte-n1k2n3 int8 :offset 636) + (unknown-byte-m2j342 int8 :offset 637) + (unknown-byte-1ji2n3 int8 :offset 638) + (unknown-byte-n123n int8 :offset 639) + (state-timeout2 uint64 :offset-assert 640) + (next-warn-time time-frame :offset-assert 648) + (dest vector :inline :offset-assert 656) + (minimap connection-minimap :offset 688) + ) + :heap-base #x240 + :method-count-assert 186 + :size-assert #x2b4 + :flag-assert #xba024002b4 + (:methods + (attack () _type_ :state 178) + (falling-ambush () _type_ :state 179) + (jumping-ambush () _type_ :state 180) + (jumping-ambush-cont () _type_ :state 181) + (wait-for-focus () _type_ :state 182) + (spin-attack () _type_ :state 183) + (grunt-method-184 (_type_ float) process-focusable 184) + (grunt-method-185 () none 185) + ) + ) + + +(define *grunt-global-info* (new 'static 'grunt-global-info + :patrol-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 11 :travel-speed (meters 4)) + (new 'static 'grunt-anim-info :anim-index 12 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 14 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 15 :travel-speed (meters 7)) + ) + :charge-anim (new 'static 'inline-array grunt-anim-info 3 + (new 'static 'grunt-anim-info :anim-index 14 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 15 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 16 :travel-speed (meters 7)) + ) + :attack-anim (new 'static 'inline-array grunt-anim-info 2 + (new 'static 'grunt-anim-info :anim-index 17 :travel-speed (meters 12)) + (new 'static 'grunt-anim-info :anim-index 18 :travel-speed (meters 12)) + ) + :knocked-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 22) + (new 'static 'grunt-anim-info :anim-index 24) + (new 'static 'grunt-anim-info :anim-index 26) + (new 'static 'grunt-anim-info :anim-index 28) + ) + :knocked-land-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 23) + (new 'static 'grunt-anim-info :anim-index 25) + (new 'static 'grunt-anim-info :anim-index 27) + (new 'static 'grunt-anim-info :anim-index 29) + ) + :yellow-hit-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 34) + (new 'static 'grunt-anim-info :anim-index 35) + (new 'static 'grunt-anim-info :anim-index 36) + (new 'static 'grunt-anim-info :anim-index 37) + ) + :blue-hit-anim (new 'static 'inline-array grunt-anim-info 6 + (new 'static 'grunt-anim-info :anim-index 38) + (new 'static 'grunt-anim-info :anim-index 39) + (new 'static 'grunt-anim-info :anim-index 40) + (new 'static 'grunt-anim-info :anim-index 41) + (new 'static 'grunt-anim-info :anim-index 42) + (new 'static 'grunt-anim-info :anim-index 43) + ) + ) + ) + +(define *grunt-nav-enemy-info* (new 'static 'nav-enemy-info + :use-die-falling #t + :use-victory #f + :use-jump-blocked #t + :debug-draw-neck #f + :jump-debug-draw #f + :move-to-ground #t + :hover-if-no-ground #f + :idle-anim-script (new 'static 'array uint32 36 + #x1e0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x3c0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1011e01 + #x3c0002 + #x1010501 + #x0 + ) + :idle-anim 5 + :notice-anim 13 + :hostile-anim -1 + :hit-anim 34 + :knocked-anim -1 + :knocked-land-anim -1 + :die-anim 19 + :die-falling-anim 32 + :victory-anim -1 + :jump-wind-up-anim 45 + :jump-in-air-anim 46 + :jump-land-anim 47 + :neck-joint 5 + :look-at-joint 6 + :bullseye-joint 18 + :sound-hit (static-sound-name "grunt-hit") + :sound-die (static-sound-name "grunt-die") + :notice-distance (meters 40) + :notice-distance-delta (meters 10) + :proximity-notice-distance (meters 20) + :default-hit-points 5 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :penetrate-knocked #xffffffffffffffff + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 5) + :attack-shove-up (meters 3) + :attack-mode 'generic + :attack-damage 2 + :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher) + :jump-height-min (meters 3) + :jump-height-factor 0.5 + :knocked-seek-ry-clamp 6371.5557 + :knocked-soft-vxz-lo 72089.6 + :knocked-soft-vxz-hi 108134.4 + :knocked-soft-vy-lo 81920.0 + :knocked-soft-vy-hi 122880.0 + :knocked-medium-vxz-lo 147456.0 + :knocked-medium-vxz-hi 196608.0 + :knocked-medium-vy-lo 135168.0 + :knocked-medium-vy-hi 151552.0 + :knocked-hard-vxz-lo 78643.2 + :knocked-hard-vxz-hi 117964.8 + :knocked-hard-vy-lo 183500.8 + :knocked-hard-vy-hi 209715.2 + :knocked-huge-vxz-lo 164659.2 + :knocked-huge-vxz-hi 249036.8 + :knocked-huge-vy-lo 183500.8 + :knocked-huge-vy-hi 217907.2 + :knocked-yellow-vxz-lo 40960.0 + :knocked-yellow-vxz-hi 49152.0 + :knocked-yellow-vy-lo 57344.0 + :knocked-yellow-vy-hi 81920.0 + :knocked-red-vxz-lo 24576.0 + :knocked-red-vxz-hi 196608.0 + :knocked-red-vy-lo 94208.0 + :knocked-red-vy-hi 151552.0 + :knocked-blue-vxz-lo 40960.0 + :knocked-blue-vxz-hi 49152.0 + :knocked-blue-vy-lo 24576.0 + :knocked-blue-vy-hi 81920.0 + :shadow-size (meters 2) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint 6 + :gem-seg #x2 + :gem-no-seg #x4 + :gem-offset (new 'static 'sphere :y 614.4 :z -3276.8 :r 327680.0) + :callback-info #f + :use-momentum #t + :use-frustration #t + :use-stop-chase #t + :use-circling #t + :use-pacing #t + :walk-anim 11 + :turn-anim -1 + :run-anim 14 + :taunt-anim 20 + :run-travel-speed (meters 7) + :run-acceleration (meters 6) + :run-turning-acceleration (meters 50) + :walk-travel-speed (meters 4) + :walk-acceleration (meters 6) + :walk-turning-acceleration (meters 3) + :maximum-rotation-rate (degrees 360.0) + :notice-nav-radius (meters 2) + :frustration-distance (meters 8) + :frustration-time (seconds 4) + :blocked-time (seconds 0.3) + :circle-dist-lo 20480.0 + :circle-dist-hi 61440.0 + :nav-mesh #f + ) + ) + +(set! (-> *grunt-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +(defmethod enemy-method-74 grunt ((obj grunt) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('hit 'hit-knocked) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (cond + ((zero? (-> obj hit-points)) + (let ((s5-1 (-> obj incoming knocked-type))) + (cond + ((and (= s5-1 (knocked-type knocked-type-4)) + (not (and (-> obj next-state) (let ((v1-33 (-> obj next-state name))) + (or (= v1-33 'knocked) (= v1-33 'jump) (= v1-33 'jump-land)) + ) + ) + ) + (zero? (get-rand-int obj 3)) + (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0))) + (f1-0 32768.0) + ) + (>= f0-0 (* f1-0 f1-0)) + ) + ) + (enemy-method-73 obj) + ) + ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6))) + (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0)) + (go (method-of-object obj knocked)) + ) + (else + (go (method-of-object obj knocked)) + ) + ) + ) + ) + (else + (go (method-of-object obj knocked)) + ) + ) + #t + ) + (else + ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3) + ) + ) + (none) + ) + +(defmethod go-ambush grunt ((obj grunt)) + (cond + ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user10)) + (go (method-of-object obj falling-ambush)) + ) + ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user11)) + (go (method-of-object obj jumping-ambush)) + ) + (else + (format 0 "ERROR: ~A doesn't specify which ambush behavior to use.~%" (-> obj name)) + (go-hostile obj) + ) + ) + (none) + ) + +(defstate falling-ambush (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (let* ((gp-1 *target*) + (a0-4 (if (type? gp-1 process-focusable) + gp-1 + ) + ) + ) + (when a0-4 + (let* ((gp-2 (-> self root-override2)) + (s3-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (get-trans a0-4 0) (-> gp-2 trans)) 1.0)) + (f0-0 (deg-diff (quaternion-y-angle (-> gp-2 quat)) (vector-y-angle s3-0))) + ) + (quaternion-rotate-y! (-> gp-2 quat) (-> gp-2 quat) f0-0) + ) + ) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (let* ((v1-17 *game-info*) + (a0-15 (+ (-> v1-17 attack-id) 1)) + ) + (set! (-> v1-17 attack-id) a0-15) + (set! (-> self attack-id) a0-15) + ) + (let ((v1-19 (-> self root-override2 root-prim))) + (set! (-> v1-19 prim-core collide-as) (collide-spec)) + (set! (-> v1-19 prim-core collide-with) (collide-spec)) + ) + 0 + (none) + ) + :exit (behavior () + (let ((v1-1 (-> self root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-1 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.2)) + (suspend) + ) + ) + (let ((v1-6 (-> self root-override2 root-prim))) + (set! (-> v1-6 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-6 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (sound-play "grunt-notice") + (ja-channel-push! 1 0) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override notice-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override notice-anim))) + frames + num-frames + ) + -1 + ) + ) + 1.8 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max 1.8)) + ) + (until (logtest? (-> self root-override2 status) (collide-status on-ground touch-surface touch-wall)) + (suspend) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-falling-post) + ) + +(defmethod enemy-method-93 grunt ((obj grunt)) + (case (-> obj jump-why) + ((2) + (go (method-of-object obj jumping-ambush-cont)) + ) + (else + ((method-of-type nav-enemy enemy-method-93) obj) + ) + ) + (none) + ) + +(defstate jumping-ambush (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + ((-> (method-of-type nav-enemy ambush) enter)) + (when (zero? (-> self intro-path)) + (format 0 "ERROR: ~A has no intro path, skipping jumping-ambush~%" (-> self name)) + (go-virtual notice) + ) + (get-point-in-path! (-> self intro-path) (-> self root-override2 trans) 0.0 'interp) + (none) + ) + :code (behavior () + (set! (-> self unknown-byte-1ji2n3) 1) + (until #f + (let ((gp-0 (new 'stack-no-clear 'vector))) + (get-point-in-path! (-> self intro-path) gp-0 1.0 'interp) + (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable)))) + (let ((a1-1 (new 'stack-no-clear 'event-message-block))) + (let ((v1-5 (process->ppointer self))) + (set! (-> a1-1 from) v1-5) + ) + (set! (-> a1-1 num-params) 2) + (set! (-> a1-1 message) 'jump) + (set! (-> a1-1 param 0) (the-as uint 2)) + (set! (-> a1-1 param 1) (the-as uint gp-0)) + (send-event-function self a1-1) + ) + ) + (suspend) + ) + #f + (none) + ) + ) + +(defstate jumping-ambush-cont (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :code (behavior () + (let ((a0-0 (-> self intro-path)) + (v1-1 (+ (-> self unknown-byte-1ji2n3) 1)) + ) + (if (< v1-1 (-> a0-0 curve num-cverts)) + (set! (-> self unknown-byte-1ji2n3) v1-1) + (enemy-method-72 self) + ) + ) + (until #f + (let ((gp-0 (new 'stack-no-clear 'vector))) + (get-point-in-path! (-> self intro-path) gp-0 (the float (-> self unknown-byte-1ji2n3)) 'interp) + (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable)))) + (let ((a1-1 (new 'stack-no-clear 'event-message-block))) + (let ((v1-9 (process->ppointer self))) + (set! (-> a1-1 from) v1-9) + ) + (set! (-> a1-1 num-params) 2) + (set! (-> a1-1 message) 'jump) + (set! (-> a1-1 param 0) (the-as uint 2)) + (set! (-> a1-1 param 1) (the-as uint gp-0)) + (send-event-function self a1-1) + ) + ) + (suspend) + ) + #f + (none) + ) + ) + +(defstate active (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (or (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-8 (ja-group))) + (and v1-8 (or (= v1-8 (-> self draw art-group data 11)) + (= v1-8 (-> self draw art-group data 12)) + (= v1-8 (-> self draw art-group data 14)) + (= v1-8 (-> self draw art-group data 15)) + ) + ) + ) + ) + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((v1-28 (-> self nav))) + (set! (-> v1-28 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + (s5-0 (get-rand-int-range self 1 8)) + ) + (let ((v1-37 (ja-group))) + (if (not (and v1-37 (= v1-37 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (dotimes (s4-0 s5-0) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + (when (nonzero? (-> self patrol-anim anim-index)) + (ja-no-eval :num! (loop!)) + (ja-channel-push! 1 (seconds 0.2)) + (set! (-> self patrol-anim) (the-as grunt-anim-info (-> *grunt-global-info* patrol-anim))) + (let ((v1-67 (-> self nav))) + (set! (-> v1-67 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((gp-1 (-> self draw art-group data (-> self patrol-anim anim-index))) + (s5-1 (get-rand-int-range self 2 5)) + ) + (ja-no-eval :group! gp-1 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (ja-blend-eval) + (suspend) + (ja :num! (seek! max f30-0)) + ) + (dotimes (s4-1 s5-1) + (ja-no-eval :group! gp-1 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + ) + (when (zero? (get-rand-int self 3)) + (let ((v1-107 self)) + (set! (-> v1-107 enemy-flags) + (the-as enemy-flag (logclear (-> v1-107 enemy-flags) (enemy-flag enemy-flag36))) + ) + (set! (-> v1-107 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (ja-channel-push! 1 (seconds 0.3)) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + (until (not (enemy-method-123 self 0.2)) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((v1-171 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-171 enemy-flags))) + (set! (-> v1-171 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-171 enemy-flags)))) + ) + (set! (-> v1-171 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-171 enemy-flags)))) + (set! (-> v1-171 nav callback-info) (-> v1-171 enemy-info-override callback-info)) + ) + 0 + ) + ) + ) + #f + (none) + ) + ) + +(defmethod grunt-method-184 grunt ((obj grunt) (arg0 float)) + (local-vars (v1-5 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (enemy-method-107 obj))) + (when gp-0 + (let ((v1-3 (get-trans gp-0 0)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (vector-! s4-0 v1-3 (-> obj root-override2 trans)) + (.lvf vf1 (&-> s4-0 quad)) + (.add.w.vf vf2 vf0 vf0 :mask #b1) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf2 vf1 :mask #b1) + (.add.mul.y.vf acc vf2 vf1 acc :mask #b1) + (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1) + (.mov v1-5 vf1) + (let* ((f30-0 v1-5) + (f0-0 arg0) + (f28-0 (* f0-0 f0-0)) + (f0-2 12288.0) + ) + (when (or (>= (* f0-2 f0-2) f30-0) (>= f28-0 f30-0)) + (let ((f26-0 (quaternion-y-angle (-> obj root-override2 quat))) + (f0-7 (atan (-> s4-0 x) (-> s4-0 z))) + (f1-0 1228.8) + ) + (cond + ((and (< (* f1-0 f1-0) f30-0) (>= f28-0 f30-0) (>= 8192.0 (fabs (deg- f26-0 f0-7)))) + (go (method-of-object obj attack)) + ) + ((let ((f0-10 12288.0)) + (< f30-0 (* f0-10 f0-10)) + ) + (go (method-of-object obj spin-attack)) + ) + ) + ) + ) + ) + ) + ) + gp-0 + ) + ) + ) + +(defstate hostile (grunt) + :virtual #t + :trans (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans))) + (if t9-0 + (t9-0) + ) + ) + (let ((a0-1 (grunt-method-184 self 13312.0)) + (gp-0 (-> self clock frame-counter)) + ) + (when (and (>= gp-0 (-> self next-warn-time)) + (zero? (logand (-> self draw status) (draw-control-status on-screen))) + ) + (when (and a0-1 + (let ((f0-0 65536.0)) + (>= (* f0-0 f0-0) (vector-vector-xz-distance-squared (get-trans a0-1 0) (-> self root-override2 trans))) + ) + ) + (sound-play "grunt-warn") + (set! (-> self next-warn-time) (+ gp-0 (get-rand-int-range self 300 360))) + ) + ) + ) + (none) + ) + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (let ((v1-19 (-> self unknown-byte-n1k2n3))) + (cond + ((>= v1-19 0) + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim v1-19)) + (set! (-> self unknown-byte-n1k2n3) -1) + ) + (else + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim (get-rand-int self 3))) + ) + ) + ) + (until #f + (grunt-method-184 self 22528.0) + (let ((gp-0 (-> self draw art-group data (-> self charge-anim anim-index)))) + (let ((v1-37 (ja-group))) + (when (not (and v1-37 (= v1-37 gp-0))) + (ja-channel-push! 1 (seconds 0.1)) + (let ((v1-41 (-> self nav))) + (set! (-> v1-41 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-chase-post) + ) + +(defstate attack (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (let ((v1-1 (-> self nav state))) + (set! (-> v1-1 speed) (-> self enemy-info-override run-travel-speed)) + ) + 0 + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (logior! (-> self focus-status) (focus-status dangerous)) + (set! (-> self root-override2 penetrate-using) (penetrate generic-attack lunge)) + (enemy-method-49 self) + (let* ((v1-10 *game-info*) + (v0-1 (+ (-> v1-10 attack-id) 1)) + ) + (set! (-> v1-10 attack-id) v0-1) + (set! (-> self attack-id) v0-1) + ) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (enemy-method-49 self) + (when (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (sound-play "grunt-hit") + ) + (none) + ) + :code (behavior () + (set! (-> self attack-anim) (-> *grunt-global-info* attack-anim (get-rand-int self 2))) + (let ((v1-5 (-> self nav))) + (set! (-> v1-5 target-speed) (-> self attack-anim travel-speed)) + ) + 0 + (let ((v1-7 (-> self nav))) + (set! (-> v1-7 turning-acceleration) 49152.0) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self attack-anim anim-index))) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (let ((v1-17 (ja-group))) + (if (not (and v1-17 (= v1-17 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((v1-36 (-> self nav))) + (set! (-> v1-36 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (let ((v1-38 (-> self nav))) + (set! (-> v1-38 turning-acceleration) (-> self enemy-info-override run-turning-acceleration)) + ) + 0 + (let ((gp-1 (-> self draw art-group data (-> self charge-anim anim-index)))) + (ja-channel-push! 1 (seconds 0.1)) + (set! (-> self skel root-channel 0 frame-group) (the-as art-joint-anim gp-1)) + ) + (ja :num-func num-func-identity :frame-num (ja-aframe 3.0 0)) + (let ((gp-3 (-> self focus aware))) + (if (or (not (enemy-method-107 self)) (!= gp-3 3)) + (go-stare self) + ) + ) + (let ((v1-57 0)) + (let ((a0-22 (the-as object (-> *grunt-global-info* charge-anim))) + (a1-7 (-> self charge-anim)) + ) + (dotimes (a2-3 3) + (when (= a0-22 a1-7) + (set! v1-57 a2-3) + (goto cfg-21) + ) + (set! a0-22 (&+ (the-as grunt-anim-info a0-22) 8)) + ) + ) + (label cfg-21) + (set! (-> self unknown-byte-n1k2n3) v1-57) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-chase-post) + ) + +(defstate spin-attack (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (let ((v1-2 self)) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (let ((v1-7 self)) + (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + (let ((gp-0 (handle->process (-> self focus handle)))) + (if (not gp-0) + (go-stare self) + ) + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad)) + ) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-21 *game-info*) + (v0-3 (+ (-> v1-21 attack-id) 1)) + ) + (set! (-> v1-21 attack-id) v0-3) + (set! (-> self attack-id) v0-3) + ) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (sound-play "grunt-hit") + ) + (none) + ) + :code (behavior () + (set! (-> self attack-anim) (-> *grunt-global-info* attack-anim (get-rand-int self 2))) + (let ((gp-0 (-> self draw art-group data (-> self attack-anim anim-index))) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (let ((v1-13 (ja-group))) + (if (not (and v1-13 (= v1-13 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (let ((a0-9 (handle->process (-> self focus handle)))) + (if a0-9 + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable a0-9) 0) quad)) + ) + ) + (seek-to-point-toward-point! (-> self root-override2) (-> self focus-pos) 546133.3 (seconds 0.1)) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((gp-3 (-> self focus aware))) + (if (or (not (enemy-method-107 self)) (!= gp-3 3)) + (go-stare self) + ) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-simple-post) + ) + +(defstate circling (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (until #f + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim (get-rand-int self 3))) + (let ((v1-22 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-22 enemy-flags))) + (set! (-> v1-22 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-22 enemy-flags)))) + ) + (set! (-> v1-22 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-22 enemy-flags)))) + (set! (-> v1-22 nav callback-info) (-> v1-22 enemy-info-override callback-info)) + ) + 0 + (let ((v1-25 self)) + (set! (-> v1-25 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-25 enemy-flags)))) + ) + 0 + (let ((v1-27 (-> self nav))) + (set! (-> v1-27 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (let ((v1-29 (-> self nav))) + (set! (-> v1-29 acceleration) (-> self enemy-info-override run-acceleration)) + ) + 0 + (let ((v1-31 (-> self nav))) + (set! (-> v1-31 turning-acceleration) (-> self enemy-info-override run-turning-acceleration)) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self charge-anim anim-index)))) + (let ((v1-39 (ja-group))) + (if (not (and v1-39 (= v1-39 gp-0))) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + (let ((s5-0 (get-rand-int self 8)) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (while (nonzero? s5-0) + (+! s5-0 -1) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + ) + (when (< 20480.0 (vector-vector-xz-distance (-> self focus-pos) (-> self root-override2 trans))) + (let ((v1-66 self)) + (set! (-> v1-66 enemy-flags) (the-as enemy-flag (logclear (-> v1-66 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-66 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (let ((v1-71 self)) + (set! (-> v1-71 enemy-flags) (the-as enemy-flag (logclear (-> v1-71 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + (vector-reset! (-> self root-override2 transv)) + (let ((v1-77 (ja-group))) + (if (not (and v1-77 (= v1-77 (-> self draw art-group data 30)))) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + (let ((f30-2 (get-rand-float-range self 0.9 1.1))) + (ja-no-eval :group! (-> self draw art-group data 30) + :num! (seek! + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 30)) frames num-frames) -1)) + f30-2 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-2)) + ) + (ja-no-eval :group! (-> self draw art-group data 31) + :num! (seek! + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 31)) frames num-frames) -1)) + f30-2 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-2)) + ) + ) + ) + ) + #f + (none) + ) + ) + +(defstate pacing (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + ) + (let ((v1-28 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-28 enemy-flags))) + (set! (-> v1-28 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-28 enemy-flags)))) + ) + (set! (-> v1-28 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-28 enemy-flags)))) + (set! (-> v1-28 nav callback-info) (-> v1-28 enemy-info-override callback-info)) + ) + 0 + (let ((v1-31 self)) + (set! (-> v1-31 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-31 enemy-flags)))) + ) + 0 + (let ((v1-33 (-> self nav))) + (set! (-> v1-33 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((v1-35 (-> self nav))) + (set! (-> v1-35 acceleration) (-> self enemy-info-override walk-acceleration)) + ) + 0 + (let ((v1-37 (-> self nav))) + (set! (-> v1-37 turning-acceleration) (-> self enemy-info-override walk-turning-acceleration)) + ) + 0 + (let ((v1-41 (ja-group))) + (if (not (and v1-41 (= v1-41 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + ) + +(defstate stop-chase (grunt) + :virtual #t + :code (behavior () + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((v1-14 (-> self nav))) + (set! (-> v1-14 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + ) + (let ((v1-24 (ja-group))) + (if (not (and v1-24 (= v1-24 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + ) + +(defmethod enemy-method-77 grunt ((obj grunt) (arg0 (pointer float))) + (local-vars (v1-72 int) (a2-3 int) (a2-5 int)) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4)) + (let ((v1-2 (ash 1 (-> *grunt-global-info* prev-yellow-hit-anim-index))) + (a0-7 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and a0-7 (or (= a0-7 (-> obj draw art-group data 16)) + (= a0-7 (-> obj draw art-group data 38)) + (= a0-7 (-> obj draw art-group data 39)) + (= a0-7 (-> obj draw art-group data 40)) + ) + ) + (set! a2-3 (logior v1-2 4)) + (set! a2-3 (logior v1-2 8)) + ) + ) + (let ((s4-0 (enemy-method-120 obj 4 a2-3))) + (set! (-> *grunt-global-info* prev-yellow-hit-anim-index) s4-0) + (set! (-> obj yellow-hit-anim) (-> *grunt-global-info* yellow-hit-anim s4-0)) + (let ((v1-11 (get-rand-int obj 3))) + (if (= s4-0 3) + (set! v1-11 2) + ) + (set! (-> obj unknown-byte-n1k2n3) v1-11) + ) + ) + (let ((s4-1 (-> obj draw art-group data (-> obj yellow-hit-anim anim-index)))) + (ja-channel-push! 1 0) + (let ((a0-19 (-> obj skel root-channel 0))) + (set! (-> a0-19 frame-group) (the-as art-joint-anim s4-1)) + (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1))) + (set! (-> a0-19 param 1) (-> arg0 0)) + (set! (-> a0-19 frame-num) 0.0) + (joint-control-channel-group! a0-19 (the-as art-joint-anim s4-1) num-func-seek!) + ) + ) + #t + ) + (((knocked-type knocked-type-6)) + (let* ((v1-24 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + (s4-2 (and v1-24 (or (= v1-24 (-> obj draw art-group data 16)) + (= v1-24 (-> obj draw art-group data 38)) + (= v1-24 (-> obj draw art-group data 39)) + (= v1-24 (-> obj draw art-group data 40)) + ) + ) + ) + ) + (if (>= (the-as uint (-> obj incoming blue-juggle-count)) (the-as uint 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 2))) + ) + (cond + ((and (not s4-2) (logtest? (-> obj stack 511) 2)) + (set! s4-2 #t) + (ja-channel-push! 1 (seconds 0.17)) + ) + (else + (let ((v1-36 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and v1-36 (= v1-36 (-> obj draw art-group data 44))) + (ja-channel-push! 1 (seconds 0.17)) + (ja-channel-push! 1 (seconds 0.02)) + ) + ) + ) + ) + (let ((v1-42 (ash 1 (-> *grunt-global-info* prev-blue-hit-anim-index)))) + (if s4-2 + (set! a2-5 (logior v1-42 56)) + (set! a2-5 (logior v1-42 7)) + ) + ) + (let ((v1-46 (enemy-method-120 obj 6 a2-5))) + (set! (-> *grunt-global-info* prev-blue-hit-anim-index) v1-46) + (set! (-> obj blue-hit-anim) (-> *grunt-global-info* blue-hit-anim v1-46)) + ) + (let ((a2-6 0)) + (when (not (logtest? (-> obj stack 511) 2)) + (if s4-2 + (set! a2-6 (logior a2-6 3)) + (set! a2-6 (logior a2-6 4)) + ) + ) + (set! (-> obj unknown-byte-n1k2n3) (enemy-method-120 obj 3 a2-6)) + ) + ) + (let ((a1-26 (-> obj draw art-group data (-> obj blue-hit-anim anim-index))) + (a0-51 (-> obj skel root-channel 0)) + ) + (set! (-> a0-51 frame-group) (the-as art-joint-anim a1-26)) + (set! (-> a0-51 param 0) (the float (+ (-> (the-as art-joint-anim a1-26) frames num-frames) -1))) + (set! (-> a0-51 param 1) (-> arg0 0)) + (set! (-> a0-51 frame-num) 0.0) + (joint-control-channel-group! a0-51 (the-as art-joint-anim a1-26) num-func-seek!) + ) + #t + ) + (else + 0 + (cond + ((or (= (-> obj incoming knocked-type) (knocked-type knocked-type-2)) + (= (-> obj incoming knocked-type) (knocked-type knocked-type-3)) + ) + (set! v1-72 3) + ) + (else + (let ((s4-3 (ash 1 (-> *grunt-global-info* prev-knocked-anim-index)))) + (let ((s3-0 (-> obj root-override2))) + (if (>= 16384.0 (fabs (deg- (quaternion-y-angle (-> s3-0 quat)) (atan (-> s3-0 transv x) (-> s3-0 transv z))))) + (set! s4-3 (logior s4-3 4)) + ) + ) + (set! v1-72 (enemy-method-120 obj 3 s4-3)) + ) + ) + ) + (set! (-> *grunt-global-info* prev-knocked-anim-index) v1-72) + (set! (-> obj unknown-byte-m2j342) v1-72) + (set! (-> obj knocked-anim) (-> *grunt-global-info* knocked-anim v1-72)) + (let ((s4-4 (-> obj draw art-group data (-> obj knocked-anim anim-index)))) + (ja-channel-push! 1 0) + (let ((a0-68 (-> obj skel root-channel 0))) + (set! (-> a0-68 frame-group) (the-as art-joint-anim s4-4)) + (set! (-> a0-68 param 0) (the float (+ (-> (the-as art-joint-anim s4-4) frames num-frames) -1))) + (set! (-> a0-68 param 1) (-> arg0 0)) + (set! (-> a0-68 frame-num) 0.0) + (joint-control-channel-group! a0-68 (the-as art-joint-anim s4-4) num-func-seek!) + ) + ) + #t + ) + ) + ) + +(defmethod enemy-method-78 grunt ((obj grunt) (arg0 (pointer float))) + (cond + ((= (-> obj incoming knocked-type) (knocked-type knocked-type-6)) + (when (or (logtest? (-> obj stack 511) 2) (let ((v1-7 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (not (and v1-7 (or (= v1-7 (-> obj draw art-group data 16)) + (= v1-7 (-> obj draw art-group data 38)) + (= v1-7 (-> obj draw art-group data 39)) + (= v1-7 (-> obj draw art-group data 40)) + ) + ) + ) + ) + ) + (let ((s4-0 (-> obj draw art-group data 44))) + (ja-channel-push! 1 (seconds 0.17)) + (let ((a0-16 (-> obj skel root-channel 0))) + (set! (-> a0-16 frame-group) (the-as art-joint-anim s4-0)) + (set! (-> a0-16 param 0) (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1))) + (set! (-> a0-16 param 1) (-> arg0 0)) + (set! (-> a0-16 frame-num) 0.0) + (joint-control-channel-group! a0-16 (the-as art-joint-anim s4-0) num-func-seek!) + ) + ) + (set! (-> obj unknown-byte-n123n) (the-as int (logand -3 (-> obj stack 511)))) + #t + ) + ) + ((!= (-> obj incoming knocked-type) (knocked-type knocked-type-4)) + (let ((a1-6 (-> obj + draw + art-group + data + (-> *grunt-global-info* knocked-land-anim (-> obj unknown-byte-m2j342) anim-index) + ) + ) + (a0-23 (-> obj skel root-channel 0)) + ) + (set! (-> a0-23 frame-group) (the-as art-joint-anim a1-6)) + (set! (-> a0-23 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1))) + (set! (-> a0-23 param 1) (-> arg0 0)) + (set! (-> a0-23 frame-num) 0.0) + (joint-control-channel-group! a0-23 (the-as art-joint-anim a1-6) num-func-seek!) + ) + #t + ) + ) + ) + +(defstate wait-for-focus (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (-> (method-of-type nav-enemy idle) enter) + :trans (behavior () + (let ((s5-0 (handle->process (-> self focus handle)))) + (when s5-0 + (let ((gp-0 (get-trans (the-as process-focusable s5-0) 0))) + (when (and (or (not (logtest? (-> self enemy-flags) (enemy-flag enable-on-notice))) + (>= 163840.0 (vector-vector-distance (-> self root-override2 trans) gp-0)) + ) + (or (not (logtest? (-> self fact-info-override enemy-options) (enemy-option user8))) + (and (not (logtest? (-> (the-as process-focusable s5-0) focus-status) (focus-status in-air))) + (>= 4096.0 (fabs (- (-> gp-0 y) (-> self root-override2 trans y)))) + ) + ) + ) + (cond + ((and (logtest? (-> self fact-info-override enemy-options) (enemy-option user9)) + (logtest? (-> self enemy-flags) (enemy-flag enable-on-notice)) + ) + (let ((s5-1 (new 'stack-no-clear 'vector))) + (vector-! s5-1 gp-0 (-> self root-override2 trans)) + (let ((f0-2 32768.0) + (v1-26 s5-1) + ) + (if (or (>= f0-2 (sqrtf (+ (* (-> v1-26 x) (-> v1-26 x)) (* (-> v1-26 z) (-> v1-26 z))))) + (>= 20024.889 (fabs (deg- (y-angle (-> self root-override2)) (atan (-> s5-1 x) (-> s5-1 z))))) + ) + (go-virtual notice) + ) + ) + ) + ) + (else + (go-virtual notice) + ) + ) + ) + ) + ) + ) + (none) + ) + :code (-> (method-of-type nav-enemy idle) code) + :post (-> (method-of-type nav-enemy idle) post) + ) + +(defmethod enemy-method-132 grunt ((obj grunt)) + (when (-> obj minimap) + (logior! (-> obj minimap flags) (minimap-flag fade-out)) + (set! (-> obj minimap) #f) + ) + ((the-as (function nav-enemy none) (find-parent-method grunt 132)) obj) + (none) + ) + +;; WARN: Return type mismatch nav-enemy vs grunt. +(defmethod relocate grunt ((obj grunt) (arg0 int)) + (if (nonzero? (-> obj intro-path)) + (&+! (-> obj intro-path) arg0) + ) + (the-as grunt ((method-of-type nav-enemy relocate) obj arg0)) + ) + +(defmethod enemy-method-114 grunt ((obj grunt)) + "@abstract" + (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s5-0 reaction) cshape-reaction-default) + (set! (-> s5-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (set! (-> s5-0 penetrated-by) (penetrate + generic-attack + lunge + flop + punch + spin + roll + uppercut + bonk + tube + vehicle + flut-attack + board + mech-punch + dark-punch + dark-giant + ) + ) + (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 7) 0))) + (set! (-> s5-0 total-prims) (the-as uint 8)) + (set! (-> s4-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s4-0 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 17408.0) + (set! (-> s5-0 root-prim) s4-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> v1-13 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> v1-13 local-sphere) 0.0 4915.2 0.0 4915.2) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-with) (collide-spec backgnd crate obstacle hit-by-others-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set-vector! (-> v1-15 local-sphere) 0.0 9830.4 0.0 4915.2) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-17 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-17 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-17 transform-index) 4) + (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 4915.2) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-19 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-19 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-19 transform-index) 18) + (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 2252.8) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-21 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-21 prim-core action) (collide-action deadly)) + (set! (-> v1-21 transform-index) 16) + (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-23 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-23 prim-core action) (collide-action deadly)) + (set! (-> v1-23 transform-index) 12) + (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-25 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-25 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-25 transform-index) 6) + (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (set! (-> s5-0 nav-radius) 8192.0) + (let ((v1-27 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-27 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-27 prim-core collide-with)) + ) + (set! (-> s5-0 max-iteration-count) (the-as uint 3)) + (set! (-> obj root-override2) s5-0) + ) + 0 + (none) + ) + +;; WARN: Return type mismatch nav-enemy-info vs none. +(defmethod grunt-method-185 grunt () + *grunt-nav-enemy-info* + (none) + ) + +(defmethod enemy-method-115 grunt ((obj grunt)) + "@abstract" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-grunt" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (enemy-method-113 obj (the-as nav-enemy-info ((method-of-object obj grunt-method-185)))) + (let ((v1-6 (-> obj neck))) + (set! (-> v1-6 up) (the-as uint 1)) + (set! (-> v1-6 nose) (the-as uint 2)) + (set! (-> v1-6 ear) (the-as uint 0)) + (set-vector! (-> v1-6 twist-max) 11832.889 11832.889 0.0 1.0) + (set! (-> v1-6 ignore-angle) 30947.555) + ) + (let ((v1-8 (-> obj nav))) + (set! (-> v1-8 speed-scale) 1.0) + ) + 0 + (set-gravity-length (-> obj root-override2 dynam) 573440.0) + (let ((s5-2 *grunt-global-info*)) + (set! (-> obj patrol-anim) (-> s5-2 patrol-anim (get-rand-int obj 4))) + (set! (-> obj charge-anim) (-> s5-2 charge-anim (get-rand-int obj 3))) + (set! (-> obj attack-anim) (-> s5-2 attack-anim (get-rand-int obj 2))) + ) + (set! (-> obj unknown-byte-n1k2n3) -1) + (if (zero? (get-rand-int obj 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 1))) + ) + (if (zero? (get-rand-int obj 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 4))) + ) + (set! (-> obj intro-path) (new 'process 'path-control obj 'intro 0.0 (the-as entity #f) #t)) + (add-connection + *part-engine* + obj + 6 + obj + 318 + (new 'static 'vector :x 1433.6 :y 2785.28 :z -1761.28 :w 163840.0) + ) + (add-connection + *part-engine* + obj + 6 + obj + 318 + (new 'static 'vector :x -1433.6 :y 2785.28 :z -1761.28 :w 163840.0) + ) + (set! (-> obj minimap) + (minimap-method-12 *minimap* obj (the-as uint 70) (the-as int #f) (the-as vector #t) 0) + ) + 0 + (none) + ) + +(defmethod go-idle grunt ((obj grunt)) + (if (logtest? (-> obj fact-info-override enemy-options) (enemy-option user9)) + (go (method-of-object obj wait-for-focus)) + (go (method-of-object obj idle)) + ) + 0 + (none) + ) diff --git a/test/decompiler/reference/jak2/engine/ai/enemy-h_REF.gc b/test/decompiler/reference/jak2/engine/ai/enemy-h_REF.gc new file mode 100644 index 0000000000..d767a5042b --- /dev/null +++ b/test/decompiler/reference/jak2/engine/ai/enemy-h_REF.gc @@ -0,0 +1,753 @@ +;;-*-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 ((obj enemy-focus)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-focus) + (format #t "~1Thandle: ~D~%" (-> obj handle)) + (format #t "~1Tcollide-with: ~D~%" (-> obj collide-with)) + (format #t "~1Taware: ~D~%" (-> obj aware)) + (format #t "~1Tflags: ~D~%" (-> obj flags)) + (label cfg-4) + obj + ) + +;; 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 uint32) :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 uint64 :offset-assert 168) + (penetrate-knocked uint64 :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 ((obj enemy-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tfact-defaults: ~A~%" (-> obj fact-defaults)) + (format #t "~1Tuse-die-falling: ~A~%" (-> obj use-die-falling)) + (format #t "~1Tuse-victory: ~A~%" (-> obj use-victory)) + (format #t "~1Tuse-jump-blocked: ~A~%" (-> obj use-jump-blocked)) + (format #t "~1Tdebug-draw-neck: ~A~%" (-> obj debug-draw-neck)) + (format #t "~1Tjump-debug-draw: ~A~%" (-> obj jump-debug-draw)) + (format #t "~1Tmove-to-ground: ~A~%" (-> obj move-to-ground)) + (format #t "~1Thover-if-no-ground: ~A~%" (-> obj hover-if-no-ground)) + (format #t "~1Tidle-anim-script: #x~X~%" (-> obj idle-anim-script)) + (format #t "~1Tidle-anim: ~D~%" (-> obj idle-anim)) + (format #t "~1Tnotice-anim: ~D~%" (-> obj notice-anim)) + (format #t "~1Thostile-anim: ~D~%" (-> obj hostile-anim)) + (format #t "~1Thit-anim: ~D~%" (-> obj hit-anim)) + (format #t "~1Tknocked-anim: ~D~%" (-> obj knocked-anim)) + (format #t "~1Tknocked-land-anim: ~D~%" (-> obj knocked-land-anim)) + (format #t "~1Tdie-anim: ~D~%" (-> obj die-anim)) + (format #t "~1Tdie-falling-anim: ~D~%" (-> obj die-falling-anim)) + (format #t "~1Tvictory-anim: ~D~%" (-> obj victory-anim)) + (format #t "~1Tjump-wind-up-anim: ~D~%" (-> obj jump-wind-up-anim)) + (format #t "~1Tjump-in-air-anim: ~D~%" (-> obj jump-in-air-anim)) + (format #t "~1Tjump-land-anim: ~D~%" (-> obj jump-land-anim)) + (format #t "~1Tneck-joint: ~D~%" (-> obj neck-joint)) + (format #t "~1Tlook-at-joint: ~D~%" (-> obj look-at-joint)) + (format #t "~1Tbullseye-joint: ~D~%" (-> obj bullseye-joint)) + (format #t "~1Tsound-hit: ~D~%" (-> obj sound-hit)) + (format #t "~1Tsound-die: ~D~%" (-> obj sound-die)) + (format #t "~1Tnotice-distance: (meters ~m)~%" (-> obj notice-distance)) + (format #t "~1Tnotice-distance-delta: (meters ~m)~%" (-> obj notice-distance-delta)) + (format #t "~1Tproximity-notice-distance: (meters ~m)~%" (-> obj proximity-notice-distance)) + (format #t "~1Tdefault-hit-points: ~D~%" (-> obj default-hit-points)) + (format #t "~1Tgnd-collide-with: ~D~%" (-> obj gnd-collide-with)) + (format #t "~1Toverlaps-others-collide-with-filter: ~D~%" (-> obj overlaps-others-collide-with-filter)) + (format #t "~1Tpenetrate-flinch: ~D~%" (-> obj penetrate-flinch)) + (format #t "~1Tpenetrate-knocked: ~D~%" (-> obj penetrate-knocked)) + (format #t "~1Tmovement-gravity: (meters ~m)~%" (-> obj movement-gravity)) + (format #t "~1Tfriction: ~f~%" (-> obj friction)) + (format #t "~1Tslip-factor: ~f~%" (-> obj slip-factor)) + (format #t "~1Tattack-shove-back: (meters ~m)~%" (-> obj attack-shove-back)) + (format #t "~1Tattack-shove-up: (meters ~m)~%" (-> obj attack-shove-up)) + (format #t "~1Tattack-mode: ~A~%" (-> obj attack-mode)) + (format #t "~1Tattack-damage: ~D~%" (-> obj attack-damage)) + (format #t "~1Trecover-gnd-collide-with: ~D~%" (-> obj recover-gnd-collide-with)) + (format #t "~1Tjump-height-min: (meters ~m)~%" (-> obj jump-height-min)) + (format #t "~1Tjump-height-factor: ~f~%" (-> obj jump-height-factor)) + (format #t "~1Tknocked-seek-ry-clamp: ~f~%" (-> obj knocked-seek-ry-clamp)) + (format #t "~1Tknocked-soft-vxz-lo: ~f~%" (-> obj knocked-soft-vxz-lo)) + (format #t "~1Tknocked-soft-vxz-hi: ~f~%" (-> obj knocked-soft-vxz-hi)) + (format #t "~1Tknocked-soft-vy-lo: ~f~%" (-> obj knocked-soft-vy-lo)) + (format #t "~1Tknocked-soft-vy-hi: ~f~%" (-> obj knocked-soft-vy-hi)) + (format #t "~1Tknocked-medium-vxz-lo: ~f~%" (-> obj knocked-medium-vxz-lo)) + (format #t "~1Tknocked-medium-vxz-hi: ~f~%" (-> obj knocked-medium-vxz-hi)) + (format #t "~1Tknocked-medium-vy-lo: ~f~%" (-> obj knocked-medium-vy-lo)) + (format #t "~1Tknocked-medium-vy-hi: ~f~%" (-> obj knocked-medium-vy-hi)) + (format #t "~1Tknocked-hard-vxz-lo: ~f~%" (-> obj knocked-hard-vxz-lo)) + (format #t "~1Tknocked-hard-vxz-hi: ~f~%" (-> obj knocked-hard-vxz-hi)) + (format #t "~1Tknocked-hard-vy-lo: ~f~%" (-> obj knocked-hard-vy-lo)) + (format #t "~1Tknocked-hard-vy-hi: ~f~%" (-> obj knocked-hard-vy-hi)) + (format #t "~1Tknocked-huge-vxz-lo: ~f~%" (-> obj knocked-huge-vxz-lo)) + (format #t "~1Tknocked-huge-vxz-hi: ~f~%" (-> obj knocked-huge-vxz-hi)) + (format #t "~1Tknocked-huge-vy-lo: ~f~%" (-> obj knocked-huge-vy-lo)) + (format #t "~1Tknocked-huge-vy-hi: ~f~%" (-> obj knocked-huge-vy-hi)) + (format #t "~1Tknocked-yellow-vxz-lo: ~f~%" (-> obj knocked-yellow-vxz-lo)) + (format #t "~1Tknocked-yellow-vxz-hi: ~f~%" (-> obj knocked-yellow-vxz-hi)) + (format #t "~1Tknocked-yellow-vy-lo: ~f~%" (-> obj knocked-yellow-vy-lo)) + (format #t "~1Tknocked-yellow-vy-hi: ~f~%" (-> obj knocked-yellow-vy-hi)) + (format #t "~1Tknocked-red-vxz-lo: ~f~%" (-> obj knocked-red-vxz-lo)) + (format #t "~1Tknocked-red-vxz-hi: ~f~%" (-> obj knocked-red-vxz-hi)) + (format #t "~1Tknocked-red-vy-lo: ~f~%" (-> obj knocked-red-vy-lo)) + (format #t "~1Tknocked-red-vy-hi: ~f~%" (-> obj knocked-red-vy-hi)) + (format #t "~1Tknocked-blue-vxz-lo: ~f~%" (-> obj knocked-blue-vxz-lo)) + (format #t "~1Tknocked-blue-vxz-hi: ~f~%" (-> obj knocked-blue-vxz-hi)) + (format #t "~1Tknocked-blue-vy-lo: ~f~%" (-> obj knocked-blue-vy-lo)) + (format #t "~1Tknocked-blue-vy-hi: ~f~%" (-> obj knocked-blue-vy-hi)) + (format #t "~1Tshadow-size: (meters ~m)~%" (-> obj shadow-size)) + (format #t "~1Tshadow-max-y: (meters ~m)~%" (-> obj shadow-max-y)) + (format #t "~1Tshadow-min-y: (meters ~m)~%" (-> obj shadow-min-y)) + (format #t "~1Tshadow-locus-dist: (meters ~m)~%" (-> obj shadow-locus-dist)) + (format #t "~1Tgem-joint: ~D~%" (-> obj gem-joint)) + (format #t "~1Tgem-seg: ~D~%" (-> obj gem-seg)) + (format #t "~1Tgem-no-seg: ~D~%" (-> obj gem-no-seg)) + (format #t "~1Tgem-offset: #~%" (-> obj gem-offset)) + (label cfg-4) + obj + ) + +;; 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 ((obj enemy-knocked-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-knocked-info) + (format #t "~1Tanim-speed: ~f~%" (-> obj anim-speed)) + (format #t "~1Ton-surface-count: ~D~%" (-> obj on-surface-count)) + (format #t "~1Tmove-count: ~D~%" (-> obj move-count)) + (format #t "~1Tland-can-land-time: ~D~%" (-> obj land-can-land-time)) + (label cfg-4) + obj + ) + +;; 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 ((obj enemy-jump-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-jump-info) + (format #t "~1Tflags: ~D~%" (-> obj flags)) + (format #t "~1Tanim-speed: ~f~%" (-> obj anim-speed)) + (format #t "~1Thang-time: ~D~%" (-> obj hang-time)) + (format #t "~1Tstart-pos: #~%" (-> obj start-pos)) + (format #t "~1Tdest-pos: #~%" (-> obj dest-pos)) + (format #t "~1Ttraj: #~%" (-> obj traj)) + (label cfg-4) + obj + ) + +;; 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 ((obj enemy-init-by-other-params)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-init-by-other-params) + (format #t "~1Ttrans: #~%" (-> obj trans)) + (format #t "~1Tquat: #~%" (-> obj quat)) + (format #t "~1Tentity: ~A~%" (-> obj entity)) + (format #t "~1Tdirected?: ~A~%" (-> obj directed?)) + (format #t "~1Tno-initial-move-to-ground?: ~A~%" (-> obj no-initial-move-to-ground?)) + (label cfg-4) + obj + ) + +;; 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 ((obj enemy-attack-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-attack-info) + (format #t "~1Tattack-id: ~D~%" (-> obj attack-id)) + (format #t "~1Tknocked-type: ~D~%" (-> obj knocked-type)) + (format #t "~1Tblue-juggle-count: ~D~%" (-> obj blue-juggle-count)) + (format #t "~1Tattacker-handle: ~D~%" (-> obj attacker-handle)) + (format #t "~1Tattack-time: ~D~%" (-> obj attack-time)) + (format #t "~1Tpenetrate-using: ~D~%" (-> obj penetrate-using)) + (format #t "~1Tattacker-pos: ~`vector`P~%" (-> obj attacker-pos)) + (format #t "~1Tattack-direction: ~`vector`P~%" (-> obj attack-direction)) + (label cfg-4) + obj + ) + +;; 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 ((obj enemy-best-focus)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'enemy-best-focus) + (format #t "~1Tproc: ~A~%" (-> obj proc)) + (format #t "~1Trating: ~f~%" (-> obj rating)) + (format #t "~1Taware: ~D~%" (-> obj aware)) + (label cfg-4) + obj + ) + +;; definition of type enemy +(deftype enemy (process-focusable) + ((root-override2 collide-shape-moving :offset 128) + (fact-info-override fact-info-enemy :offset 160) + (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 uint64 :offset-assert 280) + (notice-time uint64 :offset-assert 288) + (state-timeout uint64 :offset-assert 296) + (auto-reset-penetrate-time uint64 :offset-assert 304) + (hit-focus-time uint64 :offset-assert 312) + (last-draw-time uint64 :offset-assert 320) + (starting-time uint64 :offset-assert 328) + (fated-time uint64 :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 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) + (enemy-method-48 (_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) + (enemy-method-55 (_type_) none 55) + (enemy-method-56 (_type_ process event-message-block) int 56) + (enemy-method-57 (_type_ process-focusable enemy-best-focus) enemy-aware 57) + (enemy-method-58 (_type_) symbol 58) + (enemy-method-59 (_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 symbol) none 63) + (enemy-method-64 (_type_) none 64) + (enemy-method-65 (_type_) none 65) + (go-ambush (_type_) none 66) + (go-stare (_type_) none 67) + (go-stare2 (_type_) none 68) + (go-directed (_type_) none 69) + (go-hostile (_type_) none 70) + (go-flee (_type_) none 71) + (enemy-method-72 (_type_) none 72) + (enemy-method-73 (_type_) none 73) + (enemy-method-74 (_type_ process object symbol event-message-block) none 74) + (enemy-method-75 (_type_ process touching-shapes-entry) none 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) + (enemy-method-98 (_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 uint 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) + (enemy-method-107 (_type_) process-focusable 107) + (enemy-method-108 (_type_ enemy event-message-block) int 108) + (enemy-method-109 (_type_ int) none 109) + (enemy-method-110 (_type_) none 110) + (enemy-method-111 (_type_) none :behavior enemy 111) + (enemy-method-112 (_type_ enemy-info) none 112) + (enemy-method-113 (_type_ enemy-info) none 113) + (enemy-method-114 (_type_) none 114) + (enemy-method-115 (_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-method-126 (_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) + (enemy-method-132 (_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 ((obj enemy)) + (when (not obj) + (set! obj obj) + (goto cfg-79) + ) + (let ((t9-0 (method-of-type process-focusable inspect))) + (t9-0 obj) + ) + (format #t "~2Tenemy-flags: #x~X : (enemy-flag " (-> obj enemy-flags)) + (let ((s5-0 (-> obj 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~%" (-> obj enemy-info)) + (format #t "~2Thit-points: ~D~%" (-> obj hit-points)) + (format #t "~2Tgnd-collide-with: ~D~%" (-> obj gnd-collide)) + (format #t "~2Tattack-id: ~D~%" (-> obj attack-id)) + (format #t "~2Tpersistent-attack-id: ~D~%" (-> obj persistent-attack-id)) + (format #t "~2Twater-max-height: ~f~%" (-> obj water-max-height)) + (format #t "~2Twater-surface-height: ~f~%" (-> obj water-surface-height)) + (format #t "~2Tdesired-angle: ~f~%" (-> obj desired-angle)) + (format #t "~2Tjump-why: ~D~%" (-> obj jump-why)) + (format #t "~2Tpenetrated-by-all: ~D~%" (-> obj penetrated-by-all)) + (format #t "~2Tpenetrate-flinch: ~D~%" (-> obj penetrated-flinch)) + (format #t "~2Tpenetrate-knocked: ~D~%" (-> obj penetrated-knocked)) + (format #t "~2Treaction-time: ~D~%" (-> obj reaction-time)) + (format #t "~2Tnotice-time: ~D~%" (-> obj notice-time)) + (format #t "~2Tstate-timeout: ~D~%" (-> obj state-timeout)) + (format #t "~2Tauto-reset-penetrate-time: ~D~%" (-> obj auto-reset-penetrate-time)) + (format #t "~2Thit-focus-time: ~D~%" (-> obj hit-focus-time)) + (format #t "~2Tlast-draw-time: ~D~%" (-> obj last-draw-time)) + (format #t "~2Tstarting-time: ~D~%" (-> obj starting-time)) + (format #t "~2Tfated-time: ~D~%" (-> obj fated-time)) + (format #t "~2Tfocus-pos: ~`vector`P~%" (-> obj focus-pos)) + (format #t "~2Tevent-param-point: ~`vector`P~%" (-> obj event-param-point)) + (format #t "~2Tjump-dest: ~`vector`P~%" (-> obj event-param-point)) + (format #t "~2Tfocus: #~%" (-> obj focus)) + (format #t "~2Tincoming: #~%" (-> obj incoming)) + (format #t "~2Tactor-group: #x~X~%" (-> obj actor-group)) + (dotimes (s5-1 (-> obj actor-group-count)) + (format + #t + "~T [~D]~2Tactor-group: ~`actor-group`P~%" + s5-1 + (-> (the-as (pointer uint32) (+ (the-as uint (-> obj actor-group)) (* s5-1 4)))) + ) + ) + (format #t "~2Tactor-group-count: ~D~%" (-> obj actor-group-count)) + (format #t "~2Tneck: ~A~%" (-> obj neck)) + (format #t "~2Ton-notice: ~A~%" (-> obj on-notice)) + (format #t "~2Ton-active: ~A~%" (-> obj on-active)) + (format #t "~2Ton-hostile: ~A~%" (-> obj on-hostile)) + (format #t "~2Ton-death: ~A~%" (-> obj on-death)) + (format #t "~2Tidle-anim-player: #~%" (-> obj idle-anim-player)) + (format #t "~2Trand-gen: ~A~%" (-> obj rand-gen)) + (label cfg-79) + obj + ) + +;; 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 ((obj anim-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'anim-info) + (format #t "~1Tanim-index: ~D~%" (-> obj anim-index)) + (format #t "~1Ttravel-speed: (meters ~m)~%" (-> obj travel-speed)) + (label cfg-4) + obj + ) + +;; definition for method 12 of type enemy-focus +(defmethod try-update-focus enemy-focus ((obj enemy-focus) (arg0 process-focusable) (arg1 enemy)) + (let* ((t9-0 (method-of-type focus try-update-focus)) + (s3-0 (t9-0 obj arg0)) + ) + (when (not s3-0) + (logclear! (-> obj flags) (enemy-flag lock-focus)) + (set! (-> obj aware) + (the-as + enemy-aware + (enemy-method-61 arg1 (the-as int (enemy-method-57 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 ((obj enemy-focus) (arg0 process-focusable) (arg1 enemy-aware)) + (let* ((t9-0 (method-of-type focus try-update-focus)) + (v0-0 (t9-0 obj arg0)) + ) + (set! (-> obj aware) arg1) + (if (not v0-0) + (logclear! (-> obj 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 ((obj enemy-focus)) + (let ((t9-0 (method-of-type focus clear-focused))) + (t9-0 obj) + ) + (set! (-> obj aware) (enemy-aware enemy-aware-0)) + (logclear! (-> obj flags) (enemy-flag lock-focus)) + (none) + ) diff --git a/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc b/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc new file mode 100644 index 0000000000..c957659d70 --- /dev/null +++ b/test/decompiler/reference/jak2/engine/ai/enemy_REF.gc @@ -0,0 +1,3870 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for method 9 of type enemy-info +;; WARN: Return type mismatch int vs none. +(defmethod copy-enemy-info! enemy-info ((obj enemy-info) (obj-to-copy enemy-info)) + "Copies the given [[enemy-info]] into the current [[enemy-info]]" + (mem-copy! (&-> obj type) (&-> obj-to-copy type) 384) + 0 + (none) + ) + +;; definition for symbol *enemy-dummy-shadow-control*, type shadow-control +(define *enemy-dummy-shadow-control* + (new 'static 'shadow-control :settings (new 'static 'shadow-settings + :flags (shadow-flags shdf03 disable-draw) + :shadow-dir (new 'static 'vector :y -1.0 :w 614400.0) + :bot-plane (new 'static 'plane :y 1.0 :w 4096.0) + :top-plane (new 'static 'plane :y 1.0 :w -4096.0) + ) + ) + ) + +;; definition for method 7 of type enemy +;; WARN: Return type mismatch process-focusable vs enemy. +(defmethod relocate enemy ((obj enemy) (arg0 int)) + (if (nonzero? (-> obj neck)) + (&+! (-> obj neck) arg0) + ) + (the-as + enemy + ((the-as (function process-focusable int process-focusable) (find-parent-method enemy 7)) obj arg0) + ) + ) + +;; definition for method 117 of type enemy +(defmethod get-rand-float enemy ((obj enemy)) + "@returns the result of calling [[rand-vu]]" + (rand-vu) + ) + +;; definition for method 118 of type enemy +(defmethod get-rand-float-range enemy ((obj enemy) (low float) (high float)) + "@param low The lower bound of the range (inclusive) + @param high The upper bound of the range (exclusive) + @returns A random float in the specified range" + (+ low (* (rand-vu) (- high low))) + ) + +;; definition for method 119 of type enemy +(defmethod get-rand-int enemy ((obj enemy) (high int)) + "@param high The upper bound of the range (exclusive) + @returns a random integer in the range 0 to `high` + @see [[rand-vu]]" + (the int (* (rand-vu) (the float high))) + ) + +;; definition for method 121 of type enemy +(defmethod get-rand-int-range enemy ((obj enemy) (low int) (high int)) + "@param low The lower bound of the range (inclusive) + @param high The upper bound of the range (exclusive) + @returns A random integer in the specified range" + (+ low (the int (* (rand-vu) (the float (+ (- 1 low) high))))) + ) + +;; definition for method 122 of type enemy +(defmethod rng-hit? enemy ((obj enemy) (chance float)) + "TODO - not the best name + @param chance The value to compare ([[>=]]) with the result from [[rand-vu]]. + @returns If `chance` is greater than the random draw" + (>= chance (rand-vu)) + ) + +;; definition for method 120 of type enemy +;; WARN: new jak 2 until loop case, check carefully +(defmethod enemy-method-120 enemy ((obj enemy) (arg0 int) (arg1 int)) + "TODO" + (let ((v1-0 0) + (s5-0 0) + ) + (let ((a2-1 1)) + (while (nonzero? arg0) + (+! arg0 -1) + (if (not (logtest? arg1 a2-1)) + (+! v1-0 1) + ) + (set! a2-1 (* a2-1 2)) + ) + ) + (when (> v1-0 0) + (let ((v1-1 (get-rand-int obj v1-0)) + (a0-1 1) + ) + (until #f + (while (logtest? arg1 a0-1) + (nop!) + (nop!) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + (if (zero? v1-1) + (goto cfg-14) + ) + (+! v1-1 -1) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + ) + #f + ) + (label cfg-14) + s5-0 + ) + ) + +;; definition for method 123 of type enemy +(defmethod enemy-method-123 enemy ((obj enemy) (arg0 float)) + "TODO" + (let* ((v1-5 (-> *display* frames (-> *display* last-screen) run-time)) + (f1-2 (fmax 0.0 (fmin 1.0 (* 0.001 (+ -7000.0 (the float v1-5)))))) + ) + (>= (+ arg0 (* f1-2 (- 1.0 arg0))) (rand-vu)) + ) + ) + +;; definition for method 60 of type enemy +(defmethod coin-flip? enemy ((obj enemy)) + "@returns The result of a 50/50 RNG roll" + (zero? (get-rand-int obj 2)) + ) + +;; definition for method 12 of type enemy +;; WARN: disable def twice: 40. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare. +(defmethod run-logic? enemy ((obj enemy)) + (cond + ((logtest? (-> obj mask) (process-mask actor-pause)) + (let ((draw (-> obj draw))) + (or (and (nonzero? draw) + (>= (+ (-> *ACTOR-bank* pause-dist) (-> obj root-override2 pause-adjust-distance)) + (vector-vector-distance (-> obj root-override2 trans) (camera-pos)) + ) + (or (logtest? (-> draw status) (draw-control-status on-screen)) + (not (and (-> obj next-state) (= (-> obj next-state name) 'idle))) + ) + ) + (and (nonzero? (-> obj skel)) (!= (-> obj skel root-channel 0) (-> obj skel channel))) + (and (nonzero? draw) (logtest? (-> draw status) (draw-control-status uninited))) + ) + ) + ) + (else + #t + ) + ) + ) + +;; definition for method 53 of type enemy +;; WARN: Return type mismatch object vs symbol. +(defmethod enemy-method-53 enemy ((obj enemy) (proc-focus process-focusable)) + "TODO" + (the-as symbol (and proc-focus (!= obj proc-focus) (collide-check? (-> obj focus) proc-focus))) + ) + +;; definition for method 20 of type enemy +(defmethod get-trans enemy ((obj enemy) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (let ((s4-0 (-> obj root-override2))) + (cond + ((zero? arg0) + (-> s4-0 trans) + ) + ((and (= arg0 1) (type? s4-0 collide-shape-moving)) + (-> s4-0 gspot-pos) + ) + ((= arg0 2) + (vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info look-at-joint))) + ) + ((= arg0 3) + (let ((v0-0 (vector<-cspace! (new 'static 'vector) (-> obj node-list data (-> obj enemy-info bullseye-joint))))) + (set! (-> v0-0 w) (-> obj root-override2 root-prim prim-core world-sphere w)) + v0-0 + ) + ) + (else + (-> s4-0 trans) + ) + ) + ) + ) + +;; definition for method 124 of type enemy +(defmethod enemy-method-124 enemy ((obj enemy)) + "TODO" + (let* ((v1-0 (-> obj enemy-info)) + (v0-0 (if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (-> v1-0 recover-gnd-collide-with) + (-> v1-0 gnd-collide-with) + ) + ) + ) + (set! (-> obj gnd-collide) (the-as uint v0-0)) + v0-0 + ) + ) + +;; definition for method 59 of type enemy +(defmethod enemy-method-59 enemy ((obj enemy)) + (penetrated-by-all&hit-points->penetrated-by (-> obj penetrated-by-all) (-> obj hit-points)) + ) + +;; definition for method 24 of type enemy +(defmethod get-water-height enemy ((obj enemy)) + (-> obj water-surface-height) + ) + +;; definition for method 54 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-54 enemy ((obj enemy)) + (let ((s4-0 (-> obj root-override2))) + (when (>= (-> obj water-max-height) (-> s4-0 trans y)) + (let ((s5-0 (new 'stack-no-clear 'water-info))) + (water-info-init! s4-0 s5-0 (collide-action solid semi-solid)) + (let ((s3-0 (-> s5-0 flags))) + (when (logtest? (water-flags touch-water) s3-0) + (set! (-> obj enemy-flags) (logior (enemy-flag directed-ready) (-> obj enemy-flags))) + (set! (-> obj water-surface-height) (-> s5-0 trans y)) + (when (not (logtest? (-> obj focus-status) (focus-status touch-water under-water))) + (let ((s2-0 (new 'stack-no-clear 'vector))) + (set! (-> s2-0 quad) (-> obj root-override2 trans quad)) + (set! (-> s2-0 y) (+ 409.6 (-> s5-0 trans y))) + (let ((s1-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when s1-0 + (let ((t9-2 (method-of-type part-tracker activate))) + (t9-2 + (the-as part-tracker s1-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-3 run-function-in-process) + (a0-8 s1-0) + (a1-3 part-tracker-init) + (a2-5 (-> *part-group-id-table* 121)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> s2-0 quad)) + ((the-as (function object object object object object object object object none) t9-3) + a0-8 + a1-3 + a2-5 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> s1-0 ppointer) + ) + ) + ) + (cond + ((logtest? s3-0 (water-flags dark-eco)) + (sound-play "eco-splash") + (send-event obj 'instant-death) + ) + (else + (sound-play "splash") + ) + ) + ) + (logior! (-> obj focus-status) (focus-status touch-water)) + (let* ((v1-32 (-> s4-0 root-prim prim-core)) + (f0-5 (+ (-> v1-32 world-sphere y) (-> v1-32 world-sphere w))) + ) + (if (logtest? (-> obj focus-status) (focus-status under-water)) + (set! f0-5 (+ -819.2 f0-5)) + ) + (if (< f0-5 (-> s5-0 trans y)) + (logior! (-> obj focus-status) (focus-status under-water)) + (logclear! (-> obj focus-status) (focus-status under-water)) + ) + ) + (return (the-as enemy-flag #f)) + ) + ) + ) + ) + ) + (logclear! (-> obj focus-status) (focus-status touch-water under-water)) + (when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))) + (let ((v0-9 (logclear (-> obj enemy-flags) (enemy-flag directed-ready)))) + (set! (-> obj enemy-flags) v0-9) + v0-9 + ) + ) + ) + +;; definition for method 55 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-55 enemy ((obj enemy)) + (with-pp + (if (and (nonzero? (-> obj draw)) (logtest? (-> obj draw status) (draw-control-status on-screen))) + (set! (-> obj last-draw-time) (the-as uint (-> pp clock frame-counter))) + ) + (enemy-method-129 obj) + (if (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (enemy-method-100 obj) + ) + (when *target* + (if *target* + (look-at! + (-> *target* neck) + (the-as vector (-> obj root-override2 root-prim prim-core)) + (if (logtest? (-> obj enemy-flags) (enemy-flag use-notice-distance)) + 'attacking + ) + obj + ) + ) + ) + (when (nonzero? (-> obj neck)) + (when (logtest? (-> obj enemy-flags) (enemy-flag lock-focus)) + (let ((a0-9 (handle->process (-> obj focus handle)))) + (if a0-9 + (target-set! (-> obj neck) (get-trans (the-as process-focusable a0-9) 2)) + ) + ) + ) + ) + (when (and (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup)) + (>= (- (-> pp clock frame-counter) (the-as int (-> obj auto-reset-penetrate-time))) (seconds 0.1)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag attackable-backup)) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + (let ((v1-48 0)) + (if (logtest? (penetrate knocked) (-> obj root-override2 penetrate-using)) + (set! v1-48 (logior (shl 1 32) v1-48)) + ) + (set! (-> obj root-override2 penetrate-using) (the-as penetrate v1-48)) + ) + ) + (if (logtest? (-> obj enemy-flags) (enemy-flag look-at-focus)) + (enemy-method-136 obj) + ) + (if (logtest? (enemy-flag trackable-backup directed-ready) (-> obj enemy-flags)) + (enemy-method-54 obj) + ) + (if (and *debug-segment* (-> obj enemy-info debug-draw-neck) (nonzero? (-> obj neck))) + (joint-mod-debug-draw (-> obj neck)) + ) + (ja-post) + 0 + (none) + ) + ) + +;; definition for method 136 of type enemy +(defmethod enemy-method-136 enemy ((obj enemy)) + (with-pp + (when (or (>= (- (-> pp clock frame-counter) (the-as int (-> obj hit-focus-time))) (seconds 2)) + (and (handle->process (-> obj focus handle)) + (zero? (logand (-> (the-as process-focusable (handle->process (-> obj focus handle))) focus-status) + (focus-status disable dead ignore grabbed) + ) + ) + ) + ) + (let ((v0-0 (logclear (-> obj enemy-flags) (enemy-flag look-at-focus)))) + (set! (-> obj enemy-flags) v0-0) + v0-0 + ) + ) + ) + ) + +;; definition for function get-penetrate-using-from-attack-event +;; WARN: Return type mismatch int vs penetrate. +(defun get-penetrate-using-from-attack-event ((arg0 process-drawable) (arg1 event-message-block)) + (let ((v1-0 (the-as attack-info (-> arg1 param 1)))) + (if (logtest? (attack-info-mask penetrate-using) (-> v1-0 mask)) + (return (the-as penetrate (-> v1-0 penetrate-using))) + ) + ) + (let* ((gp-0 arg0) + (v1-3 (if (type? gp-0 process-drawable) + gp-0 + ) + ) + ) + (when v1-3 + (let* ((gp-1 (-> v1-3 root)) + (v1-4 (if (type? gp-1 collide-shape) + (the-as collide-shape gp-1) + ) + ) + ) + (if v1-4 + (return (the-as penetrate (logior (-> v1-4 penetrate-using) (penetrate generic-attack)))) + ) + ) + ) + ) + (the-as penetrate 2) + ) + +;; definition for method 107 of type enemy +;; WARN: Return type mismatch process vs process-focusable. +(defmethod enemy-method-107 enemy ((obj enemy)) + (let ((v0-0 (handle->process (-> obj focus handle)))) + (if (and v0-0 + (not (and v0-0 + (zero? (logand (-> (the-as process-focusable v0-0) focus-status) (focus-status disable dead ignore grabbed))) + ) + ) + ) + (set! v0-0 (the-as process #f)) + ) + (the-as process-focusable v0-0) + ) + ) + +;; definition for method 63 of type enemy +;; WARN: Return type mismatch symbol vs none. +(defmethod enemy-method-63 enemy ((obj enemy) (arg0 process-focusable) (arg1 symbol)) + (if arg1 + (enemy-focus-method-13 (-> obj focus) arg0 (the-as enemy-aware arg1)) + (try-update-focus (-> obj focus) arg0 obj) + ) + (none) + ) + +;; definition for method 62 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-62 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (let* ((s4-0 (handle->process (-> obj incoming attacker-handle))) + (s5-0 (if (type? s4-0 process-focusable) + s4-0 + ) + ) + ) + (when (enemy-method-53 obj (the-as process-focusable s5-0)) + (enemy-method-63 obj (the-as process-focusable s5-0) #f) + (logior! (-> obj focus flags) (enemy-flag lock-focus)) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 108 of type enemy +(defmethod enemy-method-108 enemy ((obj enemy) (arg0 enemy) (arg1 event-message-block)) + (let ((s4-0 (the-as touching-shapes-entry (-> arg1 param 0)))) + (when (and s4-0 + (and (logtest? (-> obj incoming penetrate-using) 4096) (zero? (logand (-> obj incoming penetrate-using) 32))) + (begin + (let ((s3-0 (-> s4-0 head))) + (while s3-0 + (let ((s2-0 (get-touched-prim s3-0 (-> arg0 root-override2) s4-0))) + (get-touched-prim s3-0 (-> obj root-override2) s4-0) + (when (logtest? (-> s2-0 prim-core action) (collide-action solid semi-solid deadly)) + (let* ((a0-5 obj) + (t9-2 (method-of-object a0-5 enemy-method-104)) + (a1-3 arg0) + (a2-3 s4-0) + (v1-13 *game-info*) + (a3-1 (+ (-> v1-13 attack-id) 1)) + ) + (set! (-> v1-13 attack-id) a3-1) + (if (t9-2 a0-5 a1-3 (the-as uint a2-3) a3-1) + (return 0) + ) + ) + ) + ) + (set! s3-0 (-> s3-0 next)) + ) + ) + #f + ) + ) + ) + ) + 0 + ) + +;; definition for method 64 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-64 enemy ((obj enemy)) + (let ((v1-1 (-> obj root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (collide-spec)) + (set! (-> v1-1 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logior! (-> obj focus-status) (focus-status disable)) + (go (method-of-object obj dormant)) + (none) + ) + +;; definition for method 65 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-65 enemy ((obj enemy)) + (let ((v1-1 (-> obj root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (collide-spec)) + (set! (-> v1-1 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logior! (-> obj focus-status) (focus-status disable)) + (go (method-of-object obj dormant-aware)) + (none) + ) + +;; definition for method 67 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-stare enemy ((obj enemy)) + (go (method-of-object obj stare)) + (none) + ) + +;; definition for method 68 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-stare2 enemy ((obj enemy)) + (go (method-of-object obj stare)) + (none) + ) + +;; definition for method 70 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-hostile enemy ((obj enemy)) + (go (method-of-object obj hostile)) + (none) + ) + +;; definition for method 66 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-ambush enemy ((obj enemy)) + (go (method-of-object obj ambush)) + (none) + ) + +;; definition for method 71 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-flee enemy ((obj enemy)) + (go (method-of-object obj flee)) + (none) + ) + +;; definition for method 69 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-directed enemy ((obj enemy)) + (go (method-of-object obj directed)) + (none) + ) + +;; definition for method 72 of type enemy +(defmethod enemy-method-72 enemy ((obj enemy)) + (let ((s5-0 (-> obj focus aware))) + (cond + ((and (= s5-0 (enemy-aware enemy-aware-3)) (enemy-method-107 obj)) + (go-hostile obj) + ) + ((<= (the-as int s5-0) 0) + (go (method-of-object obj idle)) + ) + ((>= 1 (the-as int s5-0)) + (go (method-of-object obj active)) + ) + ((= s5-0 (enemy-aware enemy-aware-4)) + (go-flee obj) + ) + (else + (go-stare obj) + ) + ) + ) + (none) + ) + +;; definition for method 93 of type enemy +(defmethod enemy-method-93 enemy ((obj enemy)) + (if (logtest? (enemy-flag alert) (-> obj enemy-flags)) + (go-directed obj) + (enemy-method-72 obj) + ) + (none) + ) + +;; definition for method 73 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-73 enemy ((obj enemy)) + (if (-> obj enemy-info use-die-falling) + (go (method-of-object obj die-falling)) + (go (method-of-object obj die)) + ) + (none) + ) + +;; definition for method 135 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-135 enemy ((obj enemy) (arg0 int)) + (let ((gp-0 (make-u128 0 0))) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (set! gp-0 (the-as uint (-> obj enemy-info sound-hit))) + ) + ((= v1-0 1) + (set! gp-0 (the-as uint (-> obj enemy-info sound-die))) + ) + ) + ) + (if (nonzero? gp-0) + (sound-play-by-name (the-as sound-name gp-0) (new-sound-id) 1024 0 0 (sound-group sfx) #t) + ) + ) + ) + +;; definition for method 94 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-94 enemy ((obj enemy) (arg0 vector) (arg1 float)) + (let ((s4-0 (vector-z-quaternion! (new 'stack-no-clear 'vector) (-> obj root-override2 quat))) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-0 quad) (-> arg0 quad)) + (set! (-> s4-0 y) 0.0) + (vector-normalize! s4-0 1.0) + (set! (-> s5-0 y) 0.0) + (vector-normalize! s5-0 1.0) + (>= (vector-dot s4-0 s5-0) (cos arg1)) + ) + ) + +;; definition for method 95 of type enemy +(defmethod enemy-method-95 enemy ((obj enemy) (arg0 vector) (arg1 float)) + (let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj root-override2 trans)))) + (enemy-method-94 obj v1-1 arg1) + ) + ) + +;; definition for method 96 of type enemy +(defmethod enemy-method-96 enemy ((obj enemy) (arg0 float) (arg1 symbol)) + (let ((a0-2 (handle->process (-> obj focus handle)))) + (cond + (a0-2 + (let ((s4-1 (vector-! + (new 'stack-no-clear 'vector) + (get-trans (the-as process-focusable a0-2) 0) + (-> obj root-override2 trans) + ) + ) + ) + (enemy-method-94 obj s4-1 arg0) + ) + ) + (else + arg1 + ) + ) + ) + ) + +;; definition for method 104 of type enemy +(defmethod enemy-method-104 enemy ((obj enemy) (arg0 process) (arg1 uint) (arg2 uint)) + (let ((v1-1 (-> obj enemy-info attack-damage))) + (if (and (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) (= v1-1 1)) + (set! v1-1 2) + ) + (let ((a1-2 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-2 from) (process->ppointer self)) + (set! (-> a1-2 num-params) 2) + (set! (-> a1-2 message) 'attack) + (set! (-> a1-2 param 0) arg1) + (let ((a0-10 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id damage knock)))) + (set! (-> a0-10 id) arg2) + (set! (-> a0-10 shove-back) (-> obj enemy-info attack-shove-back)) + (set! (-> a0-10 shove-up) (-> obj enemy-info attack-shove-up)) + (set! (-> a0-10 mode) (-> obj enemy-info attack-mode)) + (set! (-> a0-10 damage) (the float v1-1)) + (set! (-> a0-10 knock) (the-as uint 8)) + (set! (-> a1-2 param 1) (the-as uint a0-10)) + ) + (when (send-event-function arg0 a1-2) + (enemy-method-105 obj arg0) + #t + ) + ) + ) + ) + +;; definition for method 105 of type enemy +(defmethod enemy-method-105 enemy ((obj enemy) (arg0 process)) + (with-pp + (when (logtest? (process-mask target bot) (-> arg0 mask)) + (set! (-> obj root-override2 penetrated-by) (the-as penetrate -1)) + (enemy-method-49 obj) + ) + (let ((s5-0 (if (type? arg0 process-focusable) + arg0 + ) + ) + ) + (when (enemy-method-53 obj (the-as process-focusable s5-0)) + (let ((v1-10 (handle->process (-> obj focus handle)))) + (when (or (= s5-0 v1-10) (and (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (or (not v1-10) (zero? (logand (-> obj focus flags) (enemy-flag lock-focus)))) + ) + ) + (enemy-method-63 obj (the-as process-focusable s5-0) #f) + (set! (-> obj hit-focus-time) (the-as uint (-> pp clock frame-counter))) + (let ((v0-3 (logior (-> obj enemy-flags) (enemy-flag look-at-focus)))) + (set! (-> obj enemy-flags) v0-3) + v0-3 + ) + ) + ) + ) + ) + ) + ) + +;; definition for method 49 of type enemy +(defmethod enemy-method-49 enemy ((obj enemy)) + (logior! (-> obj enemy-flags) (enemy-flag attackable-backup)) + (let ((v0-0 (-> self clock frame-counter))) + (set! (-> obj auto-reset-penetrate-time) (the-as uint v0-0)) + v0-0 + ) + ) + +;; definition for method 50 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-50 enemy ((obj enemy) (arg0 vector)) + (set! (-> arg0 quad) (-> obj incoming attack-direction quad)) + (let ((v1-1 arg0)) + (when (= (+ (* (-> v1-1 x) (-> v1-1 x)) (* (-> v1-1 z) (-> v1-1 z))) 0.0) + (vector-z-quaternion! arg0 (-> obj root-override2 quat)) + (vector-negate-in-place! arg0) + ) + ) + (set! (-> arg0 y) 0.0) + (vector-xz-normalize! arg0 1.0) + ) + +;; definition for method 131 of type enemy +;; WARN: Return type mismatch int vs uint. +(defmethod enemy-method-131 enemy ((obj enemy) (arg0 int)) + (the-as uint (cond + ((logtest? arg0 1024) + 7 + ) + ((logtest? #x1000000 arg0) + 6 + ) + ((logtest? #x4400000 arg0) + 4 + ) + ((logtest? #x800000 arg0) + 5 + ) + ((logtest? #xc0000 arg0) + 3 + ) + ((logtest? #xa200000 arg0) + 2 + ) + ((logtest? arg0 #x4000) + 1 + ) + (else + 0 + ) + ) + ) + ) + +;; definition for method 106 of type enemy +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-106 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 int) (arg3 attack-info)) + (set! (-> obj incoming penetrate-using) (the-as uint arg2)) + (set! (-> obj incoming attack-id) (-> arg3 id)) + (let ((v1-3 (if (logtest? (attack-info-mask knock) (-> arg3 mask)) + (-> arg3 knock) + (enemy-method-131 obj arg2) + ) + ) + ) + (set! (-> obj incoming knocked-type) (the-as knocked-type v1-3)) + (let ((a0-4 (-> self clock frame-counter))) + (cond + ((!= v1-3 6) + (set! (-> obj incoming blue-juggle-count) (the-as uint 0)) + 0 + ) + ((>= (- (-> self clock frame-counter) (-> obj incoming attack-time)) (seconds 1)) + (set! (-> obj incoming blue-juggle-count) (the-as uint 1)) + ) + (else + (set! (-> obj incoming blue-juggle-count) (the-as uint (+ (-> obj incoming blue-juggle-count) 1))) + ) + ) + (set! (-> obj incoming attack-time) a0-4) + ) + (cond + ((= v1-3 7) + (set! (-> obj incoming attack-direction quad) (-> arg3 vector quad)) + ) + (else + (let ((s3-0 (new 'stack-no-clear 'attack-info))) + (attack-info-method-9 arg3 s3-0 (the-as process-drawable arg0) obj) + (set! (-> obj incoming attacker-pos quad) (-> s3-0 intersection quad)) + (set! (-> obj incoming attack-direction quad) (-> s3-0 attacker-velocity quad)) + ) + ) + ) + ) + (set! (-> obj incoming attacker-handle) (process->handle (enemy-method-134 obj arg0 arg3))) + 0 + (none) + ) + +;; definition for method 109 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-109 enemy ((obj enemy) (arg0 int)) + (case arg0 + ((1) + (logclear! (-> obj enemy-flags) (enemy-flag death-start)) + (logior! (-> obj enemy-flags) (enemy-flag lock-focus)) + ) + ((2) + (logclear! (-> obj enemy-flags) (enemy-flag lock-focus)) + (logior! (-> obj enemy-flags) (enemy-flag death-start)) + ) + ) + (if (nonzero? (-> obj neck)) + (mode-set! (-> obj neck) (joint-mod-mode look-at)) + ) + 0 + (none) + ) + +;; definition for method 110 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-110 enemy ((obj enemy)) + (when (nonzero? (-> obj neck)) + (logclear! (-> obj enemy-flags) (enemy-flag lock-focus death-start)) + (shut-down (-> obj neck)) + ) + 0 + (none) + ) + +;; definition for method 125 of type enemy +(defmethod enemy-method-125 enemy ((obj enemy) (arg0 collide-query) (arg1 collide-spec) (arg2 float) (arg3 float) (arg4 float)) + (when (find-ground (-> obj root-override2) arg0 arg1 arg2 arg3 arg4) + (let ((v0-1 (-> arg0 best-other-tri pat))) + (set! (-> obj root-override2 ground-pat) v0-1) + v0-1 + ) + ) + ) + +;; definition for method 126 of type enemy +(defmethod enemy-method-126 enemy ((obj enemy) (arg0 collide-query) (arg1 vector) (arg2 collide-spec) (arg3 float) (arg4 float) (arg5 float)) + (above-ground? (-> obj root-override2) arg0 arg1 arg2 arg3 arg4 arg5) + ) + +;; definition for method 127 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-127 enemy ((obj enemy) (arg0 float) (arg1 float) (arg2 symbol) (arg3 collide-spec)) + (let ((s4-0 (new 'stack-no-clear 'collide-query))) + (cond + ((enemy-method-125 obj s4-0 arg3 arg0 arg1 1024.0) + (let ((s5-1 (-> obj root-override2))) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (set! (-> s3-0 quad) (-> obj root-override2 trans quad)) + (set! (-> s3-0 y) (-> s4-0 best-other-tri intersect y)) + (move-to-point! s5-1 s3-0) + (let ((a0-3 (-> s4-0 best-other-tri normal)) + (v1-8 (-> s4-0 best-other-tri pat)) + ) + (set! (-> s5-1 grount-touch-point quad) (-> s3-0 quad)) + (set! (-> s5-1 poly-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 surface-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 local-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 ground-poly-normal quad) (-> a0-3 quad)) + (set! (-> s5-1 poly-pat) v1-8) + (set! (-> s5-1 cur-pat) v1-8) + (set! (-> s5-1 ground-pat) v1-8) + ) + ) + (logior! (-> s5-1 status) (collide-status on-surface on-ground touch-surface)) + ) + #t + ) + (else + (let ((v1-11 (-> obj root-override2))) + (logclear! (-> v1-11 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> v1-11 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((a0-12 (-> v1-11 dynam gravity-normal))) + (set! (-> v1-11 local-normal quad) (-> a0-12 quad)) + (set! (-> v1-11 surface-normal quad) (-> a0-12 quad)) + (set! (-> v1-11 poly-normal quad) (-> a0-12 quad)) + ) + (set! (-> v1-11 coverage) 0.0) + (set! (-> v1-11 touch-angle) 0.0) + ) + ) + (if arg2 + (format 0 "WARNING: enemy::move-to-ground: failed to locate ground for ~S!~%" (-> obj name)) + ) + #f + ) + ) + ) + ) + +;; definition for method 128 of type enemy +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-128 enemy ((obj enemy) (arg0 vector) (arg1 move-above-ground-params)) + (let ((gp-0 (-> obj root-override2))) + (set! (-> arg1 on-ground?) #f) + (set! (-> arg1 do-move?) #t) + (set! (-> arg1 old-gspot-pos quad) (-> gp-0 gspot-pos quad)) + (set! (-> arg1 old-gspot-normal quad) (-> gp-0 gspot-normal quad)) + (set! (-> gp-0 trans-old-old-old quad) (-> gp-0 trans-old-old quad)) + (set! (-> gp-0 trans-old-old quad) (-> gp-0 trans-old quad)) + (set! (-> gp-0 trans-old quad) (-> gp-0 trans quad)) + (set! (-> gp-0 prev-status) (-> gp-0 status)) + (vector-v+! (-> gp-0 trans) (-> gp-0 trans) arg0) + (set! (-> arg1 new-pos quad) (-> gp-0 trans quad)) + (let ((s2-0 (new 'stack-no-clear 'collide-query))) + (cond + ((enemy-method-125 obj s2-0 (-> arg1 gnd-collide-with) (-> arg1 popup) 81920.0 1024.0) + (when (>= (-> gp-0 gspot-pos y) (-> arg1 new-pos y)) + (set! (-> arg1 on-ground?) #t) + (set! (-> arg1 pat) (-> s2-0 best-other-tri pat)) + (set! (-> arg1 new-pos y) (-> s2-0 best-other-tri intersect y)) + (set! (-> gp-0 ground-impact-vel) (- (vector-dot arg0 (-> gp-0 dynam gravity-normal)))) + (set! (-> arg0 y) 0.0) + ) + ) + (else + (if (-> arg1 hover-if-no-ground?) + (set! (-> arg1 new-pos y) (-> gp-0 trans-old y)) + ) + ) + ) + ) + (set! (-> gp-0 trans quad) (-> gp-0 trans-old quad)) + (move-to-point! gp-0 (-> arg1 new-pos)) + (when (logtest? (logand (-> arg1 overlaps-params collide-with-filter) + (collide-spec hit-by-player-list hit-by-others-list player-list) + ) + (-> gp-0 root-prim prim-core collide-with) + ) + (when (find-overlapping-shapes gp-0 (-> arg1 overlaps-params)) + (when (-> arg1 dont-move-if-overlaps?) + (set! (-> arg1 do-move?) #f) + (move-to-point! gp-0 (-> gp-0 trans-old)) + (set! (-> gp-0 gspot-pos quad) (-> arg1 old-gspot-pos quad)) + (set! (-> gp-0 gspot-normal quad) (-> arg1 old-gspot-normal quad)) + ) + ) + ) + (when (-> arg1 do-move?) + (cond + ((-> arg1 on-ground?) + (let ((a1-6 (-> gp-0 gspot-pos)) + (a0-21 (-> gp-0 gspot-normal)) + (v1-39 (-> arg1 pat)) + ) + (set! (-> gp-0 grount-touch-point quad) (-> a1-6 quad)) + (set! (-> gp-0 poly-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 surface-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 local-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 ground-poly-normal quad) (-> a0-21 quad)) + (set! (-> gp-0 poly-pat) v1-39) + (set! (-> gp-0 cur-pat) v1-39) + (set! (-> gp-0 ground-pat) v1-39) + ) + (logior! (-> gp-0 status) (collide-status on-surface on-ground touch-surface)) + ) + (else + (logclear! (-> gp-0 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> gp-0 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((v1-49 (-> gp-0 dynam gravity-normal))) + (set! (-> gp-0 local-normal quad) (-> v1-49 quad)) + (set! (-> gp-0 surface-normal quad) (-> v1-49 quad)) + (set! (-> gp-0 poly-normal quad) (-> v1-49 quad)) + ) + (set! (-> gp-0 coverage) 0.0) + (set! (-> gp-0 touch-angle) 0.0) + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 111 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-111 enemy ((obj enemy)) + (let ((v1-0 (-> obj root-override2))) + (when (logtest? (-> v1-0 status) (collide-status touch-surface)) + (let ((f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> self clock seconds-per-frame) (+ -1.0 (-> obj enemy-info friction))))))) + (vector-float*! (-> v1-0 transv) (-> v1-0 transv) f0-1) + ) + 0 + ) + ) + 0 + (none) + ) + +;; definition for method 114 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-114 enemy ((obj enemy)) + "@abstract" + 0 + (none) + ) + +;; definition for method 115 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-115 enemy ((obj enemy)) + "@abstract" + 0 + (none) + ) + +;; definition for method 116 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod go-idle enemy ((obj enemy)) + (go (method-of-object obj idle)) + (none) + ) + +;; definition for method 112 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-112 enemy ((obj enemy) (arg0 enemy-info)) + (set! (-> obj enemy-info) arg0) + (when (and (!= (-> obj enemy-info neck-joint) -1) (zero? (-> obj neck))) + (set! (-> obj neck) (new 'process 'joint-mod (joint-mod-mode flex-blend) obj (-> obj enemy-info neck-joint))) + (set-vector! (-> obj neck twist-max) 8192.0 8192.0 0.0 1.0) + (set! (-> obj neck up) (the-as uint 1)) + (set! (-> obj neck nose) (the-as uint 2)) + (set! (-> obj neck ear) (the-as uint 0)) + (set! (-> obj neck max-dist) 102400.0) + (set! (-> obj neck ignore-angle) 16384.0) + ) + 0 + (none) + ) + +;; definition for method 113 of type enemy +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-113 enemy ((obj enemy) (arg0 enemy-info)) + (local-vars (sv-16 res-tag)) + (when (coin-flip? obj) + (let ((a0-2 (-> obj node-list data 2))) + (set! (-> a0-2 param0) (the-as (function cspace matrix none) cspace<-parented-matrix-joint-flip-z!)) + (set! (-> a0-2 param1) #f) + (set! (-> a0-2 param2) #f) + ) + (set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag dislike-combo) (-> obj enemy-flags)))) + ) + (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask))) + (logior! (-> obj mask) (process-mask actor-pause)) + (logior! (-> obj enemy-flags) (enemy-flag notice)) + (enemy-method-112 obj arg0) + (let ((a1-2 (-> obj enemy-info idle-anim-script))) + (if a1-2 + (idle-control-method-9 (-> obj idle-anim-player) a1-2) + ) + ) + (if (-> obj draw shadow) + (set! (-> obj draw shadow-ctrl) (new + 'process + 'shadow-control + (-> obj enemy-info shadow-min-y) + (-> obj enemy-info shadow-max-y) + (-> obj enemy-info shadow-locus-dist) + (shadow-flags shdf00 shdf04) + 245760.0 + ) + ) + (set! (-> obj draw shadow-ctrl) *enemy-dummy-shadow-control*) + ) + (set! (-> obj water-max-height) 8192.0) + (if (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + (set! (-> obj hit-points) (* (-> obj enemy-info default-hit-points) 2)) + (set! (-> obj hit-points) (-> obj enemy-info default-hit-points)) + ) + (let* ((v1-38 *game-info*) + (a0-10 (+ (-> v1-38 attack-id) 1)) + ) + (set! (-> v1-38 attack-id) a0-10) + (set! (-> obj attack-id) a0-10) + ) + (let* ((v1-39 *game-info*) + (a0-12 (+ (-> v1-39 attack-id) 1)) + ) + (set! (-> v1-39 attack-id) a0-12) + (set! (-> obj persistent-attack-id) a0-12) + ) + (set! (-> obj incoming attacker-handle) (the-as handle #f)) + (enemy-method-124 obj) + (set! (-> obj fact-info-override) (new + 'process + 'fact-info-enemy + obj + (the-as (pointer float) (-> arg0 fact-defaults)) + (pickup-type eco-pill-random) + (-> *FACT-bank* default-eco-pill-green-inc) + ) + ) + (let ((a1-5 (if (logtest? (enemy-option multi-focus) (-> obj fact-info-override enemy-options)) + #x400406 + #x400402 + ) + ) + ) + (reset-to-collide-spec (-> obj focus) (the-as collide-spec a1-5)) + ) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-49 (res-lump-data (-> obj entity) 'actor-groups pointer :tag-ptr (& sv-16)))) + (cond + ((and v1-49 (nonzero? (-> sv-16 elt-count))) + (set! (-> obj actor-group) (the-as actor-group v1-49)) + (set! (-> obj actor-group-count) (the-as int (-> sv-16 elt-count))) + ) + (else + (set! (-> obj actor-group) #f) + (set! (-> obj actor-group-count) 0) + 0 + ) + ) + ) + (set! (-> obj on-notice) (res-lump-struct (-> obj entity) 'on-notice symbol)) + (set! (-> obj on-active) (res-lump-struct (-> obj entity) 'on-active symbol)) + (set! (-> obj on-hostile) (res-lump-struct (-> obj entity) 'on-hostile symbol)) + (set! (-> obj on-death) (res-lump-struct (-> obj entity) 'on-death symbol)) + (if (-> obj on-notice) + (logior! (-> obj enemy-flags) (enemy-flag auto-reset-penetrate)) + ) + (if (-> obj on-active) + (logior! (-> obj enemy-flags) (enemy-flag jump-check-blocked)) + ) + (if (-> obj on-hostile) + (logior! (-> obj enemy-flags) (enemy-flag drawn-mirrored)) + ) + (let ((s4-0 (-> obj root-override2))) + (set! (-> obj penetrated-by-all) (-> s4-0 penetrated-by)) + (set! (-> s4-0 penetrated-by) (enemy-method-59 obj)) + (set! (-> s4-0 event-self) 'touched) + ) + (set! (-> obj penetrated-flinch) (the-as penetrate (-> arg0 penetrate-flinch))) + (set! (-> obj penetrated-knocked) (the-as penetrate (-> arg0 penetrate-knocked))) + (set! (-> obj reaction-time) (the-as uint (get-rand-int-range obj 30 180))) + (let* ((v1-79 (-> obj enemy-flags)) + (a0-28 (-> obj fact-info-override enemy-options)) + (v1-80 (logior (enemy-flag + enable-on-active + checking-water + enable-on-notice + look-at-move-dest + check-water-backup + no-initial-move-to-ground + ) + v1-79 + ) + ) + ) + (if (logtest? (enemy-option multi-focus) a0-28) + (set! v1-80 (logior (enemy-flag trackable) v1-80)) + ) + (if (logtest? (enemy-option has-trigger) a0-28) + (set! v1-80 (logior (enemy-flag called-dying) v1-80)) + ) + (set! (-> obj enemy-flags) v1-80) + ) + (set! (-> obj mask) (logior (process-mask collectable) (-> obj mask))) + (if (and (-> obj enemy-info move-to-ground) + (not (logtest? (enemy-flag vulnerable-backup) (-> obj enemy-flags))) + (zero? (logand (enemy-option ambush) (-> obj fact-info-override enemy-options))) + ) + (enemy-method-127 obj 40960.0 40960.0 #t (the-as collide-spec (-> obj gnd-collide))) + ) + (if (zero? (-> obj draw light-index)) + (set! (-> obj draw light-index) (the-as uint 10)) + ) + 0 + (none) + ) + +;; definition for function enemy-init-by-other +;; INFO: Used lq/sq +(defbehavior enemy-init-by-other enemy ((arg0 process-drawable) (arg1 transformq)) + (let ((a1-1 (-> arg1 scale x))) + (if a1-1 + (process-entity-set! self (the-as entity-actor a1-1)) + ) + ) + (if (-> arg1 scale y) + (set! (-> self enemy-flags) (logior (enemy-flag alert) (-> self enemy-flags))) + ) + (if (-> arg1 scale z) + (set! (-> self enemy-flags) (the-as enemy-flag (logior (enemy-flag vulnerable-backup) (-> self enemy-flags)))) + ) + (enemy-method-114 self) + (set! (-> self root-override2 trans quad) (-> arg1 trans quad)) + (quaternion-copy! (-> self root-override2 quat) (-> arg1 quat)) + (vector-identity! (-> self root-override2 scale)) + (enemy-method-115 self) + (when (> (-> self enemy-info gem-joint) 0) + (cond + ((and (or (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status save))) + (not (-> self entity)) + ) + (not (or (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + ) + (setup-masks + (-> self draw) + (the-as int (-> self enemy-info gem-no-seg)) + (the-as int (-> self enemy-info gem-seg)) + ) + ) + (else + (setup-masks + (-> self draw) + (the-as int (-> self enemy-info gem-seg)) + (the-as int (-> self enemy-info gem-no-seg)) + ) + (add-connection *part-engine* self (-> self enemy-info gem-joint) self 314 (-> self enemy-info gem-offset)) + ) + ) + ) + (let ((v1-43 (-> self fact-info-override enemy-options))) + (cond + (*debug-view-anims* + (go-virtual view-anims) + ) + ((logtest? (enemy-option dormant) v1-43) + (enemy-method-64 self) + ) + ((logtest? (enemy-flag alert) (-> self enemy-flags)) + (go-directed self) + ) + ((logtest? (enemy-option dormant-aware) v1-43) + (enemy-method-65 self) + ) + ((logtest? (enemy-option ambush) (-> self fact-info-override enemy-options)) + (go-ambush self) + ) + (else + (go-idle self) + ) + ) + ) + (none) + ) + +;; definition for method 11 of type enemy +(defmethod init-from-entity! enemy ((obj enemy) (arg0 entity-actor)) + (enemy-method-114 obj) + (process-drawable-from-entity! obj arg0) + (enemy-method-115 obj) + (when (>= (-> obj enemy-info gem-joint) 0) + (cond + ((and (or (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save))) + (not (-> obj entity)) + ) + (not (or (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + ) + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-no-seg)) + (the-as int (-> obj enemy-info gem-seg)) + ) + ) + (else + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-seg)) + (the-as int (-> obj enemy-info gem-no-seg)) + ) + (add-connection *part-engine* obj (-> obj enemy-info gem-joint) obj 314 (-> obj enemy-info gem-offset)) + ) + ) + ) + (let ((v1-28 (-> obj fact-info-override enemy-options))) + (cond + ((logtest? (enemy-option spawner) v1-28) + (process-entity-status! obj (entity-perm-status dead) #t) + (go (method-of-object obj die-fast)) + ) + (*debug-view-anims* + (go (method-of-object obj view-anims)) + ) + ((logtest? (enemy-option dormant) v1-28) + (enemy-method-64 obj) + ) + ((logtest? (enemy-option dormant-aware) v1-28) + (enemy-method-65 obj) + ) + (else + (go-idle obj) + ) + ) + ) + (none) + ) + +;; definition for method 98 of type enemy +(defmethod enemy-method-98 enemy ((obj enemy) (arg0 process-focusable) (arg1 vector)) + #t + ) + +;; definition for method 99 of type enemy +(defmethod enemy-method-99 enemy ((obj enemy) (arg0 process-focusable)) + #f + ) + +;; definition for method 11 of type enemy-focus +;; WARN: Return type mismatch int vs none. +(defmethod reset-to-collide-spec enemy-focus ((obj enemy-focus) (arg0 collide-spec)) + (let ((t9-0 (method-of-type focus reset-to-collide-spec))) + (t9-0 obj arg0) + ) + (set! (-> obj aware) (enemy-aware enemy-aware-0)) + 0 + (none) + ) + +;; definition for method 129 of type enemy +;; WARN: Return type mismatch process vs none. +;; WARN: Function (method 129 enemy) has a return type of none, but the expression builder found a return statement. +(defmethod enemy-method-129 enemy ((obj enemy)) + (let ((gp-0 (-> obj focus))) + (let ((a1-0 (handle->process (-> gp-0 handle)))) + (when a1-0 + (let ((v1-4 (-> obj enemy-flags))) + (cond + ((and a1-0 (zero? (logand (-> (the-as process-focusable a1-0) focus-status) (focus-status disable dead)))) + (when (and (logtest? (enemy-flag trackable) v1-4) + (not (logtest? (enemy-flag actor-pause-backup) v1-4)) + (zero? (logand (-> gp-0 flags) (enemy-flag lock-focus))) + ) + (enemy-method-97 obj) + (return #f) + ) + (let ((v1-14 (enemy-method-61 + obj + (the-as int (enemy-method-57 obj (the-as process-focusable a1-0) (the-as enemy-best-focus #f))) + ) + ) + ) + (set! (-> gp-0 aware) (the-as enemy-aware v1-14)) + (if (>= 1 v1-14) + (logclear! (-> gp-0 flags) (enemy-flag lock-focus)) + ) + ) + (return #f) + ) + (else + (clear-focused gp-0) + ) + ) + ) + ) + ) + (if (!= (-> gp-0 handle) #f) + (clear-focused gp-0) + ) + ) + (if (not (logtest? (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (enemy-method-97 obj) + ) + (none) + ) + +;; definition for method 97 of type enemy +(defmethod enemy-method-97 enemy ((obj enemy)) + (let ((s4-0 (-> obj focus collide-with)) + (gp-0 (new 'stack-no-clear 'enemy-best-focus)) + ) + (set! (-> gp-0 proc) #f) + (set! (-> gp-0 rating) 409600000.0) + (set! (-> gp-0 aware) (enemy-aware enemy-aware-0)) + (when (logtest? s4-0 (collide-spec player-list)) + (let ((v1-4 (-> *collide-player-list* alive-list next0))) + *collide-player-list* + (let ((s3-0 (-> v1-4 next0))) + (while (!= v1-4 (-> *collide-player-list* alive-list-end)) + (let ((v1-5 (the-as collide-shape (-> (the-as connection v1-4) param1)))) + (when (logtest? s4-0 (-> v1-5 root-prim prim-core collide-as)) + (let* ((s2-0 (-> v1-5 process)) + (a1-1 (if (type? s2-0 process-focusable) + (the-as process-focusable s2-0) + ) + ) + ) + (if (and a1-1 (and a1-1 (zero? (logand (-> a1-1 focus-status) (focus-status disable dead)))) (!= obj a1-1)) + (enemy-method-57 obj a1-1 gp-0) + ) + ) + ) + ) + (set! v1-4 s3-0) + *collide-player-list* + (set! s3-0 (-> s3-0 next0)) + ) + ) + ) + ) + (when (logtest? s4-0 (collide-spec hit-by-player-list hit-by-others-list)) + (when (logtest? s4-0 (collide-spec hit-by-player-list)) + (let ((v1-19 (-> *collide-hit-by-player-list* alive-list next0))) + *collide-hit-by-player-list* + (let ((s3-1 (-> v1-19 next0))) + (while (!= v1-19 (-> *collide-hit-by-player-list* alive-list-end)) + (let ((v1-20 (the-as collide-shape (-> (the-as connection v1-19) param1)))) + (when (logtest? s4-0 (-> v1-20 root-prim prim-core collide-as)) + (let* ((s2-1 (-> v1-20 process)) + (a1-3 (if (type? s2-1 process-focusable) + (the-as process-focusable s2-1) + ) + ) + ) + (if (and a1-3 (and a1-3 (zero? (logand (-> a1-3 focus-status) (focus-status disable dead)))) (!= obj a1-3)) + (enemy-method-57 obj a1-3 gp-0) + ) + ) + ) + ) + (set! v1-19 s3-1) + *collide-hit-by-player-list* + (set! s3-1 (-> s3-1 next0)) + ) + ) + ) + ) + (when (logtest? s4-0 (collide-spec hit-by-others-list)) + (let ((v1-32 (-> *collide-hit-by-others-list* alive-list next0))) + *collide-hit-by-others-list* + (let ((s3-2 (-> v1-32 next0))) + (while (!= v1-32 (-> *collide-hit-by-others-list* alive-list-end)) + (let ((v1-33 (the-as collide-shape (-> (the-as connection v1-32) param1)))) + (when (logtest? s4-0 (-> v1-33 root-prim prim-core collide-as)) + (let* ((s2-2 (-> v1-33 process)) + (a1-5 (if (type? s2-2 process-focusable) + (the-as process-focusable s2-2) + ) + ) + ) + (if (and a1-5 (and a1-5 (zero? (logand (-> a1-5 focus-status) (focus-status disable dead)))) (!= obj a1-5)) + (enemy-method-57 obj a1-5 gp-0) + ) + ) + ) + ) + (set! v1-32 s3-2) + *collide-hit-by-others-list* + (set! s3-2 (-> s3-2 next0)) + ) + ) + ) + ) + ) + (let ((s4-1 (-> gp-0 proc))) + (when s4-1 + (enemy-method-63 + obj + (the-as process-focusable s4-1) + (the-as symbol (enemy-method-61 obj (the-as int (-> gp-0 aware)))) + ) + s4-1 + ) + ) + ) + ) + +;; definition for method 57 of type enemy +;; WARN: Return type mismatch int vs enemy-aware. +(defmethod enemy-method-57 enemy ((obj enemy) (arg0 process-focusable) (arg1 enemy-best-focus)) + (let ((f30-0 (vector-vector-distance (get-trans arg0 0) (-> obj root-override2 trans))) + (s3-1 #f) + (s2-0 #f) + ) + (cond + ((< f30-0 (-> obj enemy-info proximity-notice-distance)) + (set! s3-1 #t) + (set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f))) + ) + (else + (let ((f0-1 (the-as float (-> obj enemy-info notice-distance)))) + (if (< 1 (the-as int (-> obj focus aware))) + (set! f0-1 (+ (the-as meters f0-1) (-> obj enemy-info notice-distance-delta))) + ) + (when (or (< f30-0 f0-1) (zero? (logand (-> obj enemy-flags) (enemy-flag enable-on-notice)))) + (set! s2-0 (enemy-method-98 obj arg0 (the-as vector #f))) + (if s2-0 + (set! s3-1 #t) + ) + ) + ) + ) + ) + (let ((s3-2 (cond + (s3-1 + (cond + ((enemy-method-99 obj arg0) + 4 + ) + (s2-0 + 3 + ) + (else + 2 + ) + ) + ) + ((< f30-0 (-> obj fact-info-override idle-distance)) + 1 + ) + (else + 0 + ) + ) + ) + ) + (when (and (> s3-2 0) (logtest? (enemy-flag called-dying) (-> obj enemy-flags))) + (cond + ((logtest? (enemy-option idle-til-trigger) (-> obj fact-info-override enemy-options)) + (if (not (enemy-method-130 obj f30-0)) + (set! s3-2 0) + ) + ) + (else + (if (and (< 1 s3-2) (not (enemy-method-130 obj f30-0))) + (set! s3-2 1) + ) + ) + ) + ) + (when arg1 + (when (and (>= s3-2 (the-as int (-> arg1 aware))) (< f30-0 (-> arg1 rating))) + (set! (-> arg1 aware) (the-as enemy-aware s3-2)) + (set! (-> arg1 rating) f30-0) + (set! (-> arg1 proc) arg0) + ) + ) + (the-as enemy-aware s3-2) + ) + ) + ) + +;; definition for method 130 of type enemy +(defmethod enemy-method-130 enemy ((obj enemy) (arg0 float)) + (let* ((v1-0 (-> obj fact-info-override)) + (a2-0 (-> v1-0 trig-mask-count)) + (a3-0 (-> v1-0 trig-mask)) + ) + (dotimes (t0-0 a2-0) + (let ((t1-1 (the-as int (-> a3-0 t0-0)))) + (if (and (logtest? (the-as uint t1-1) 1) (>= (-> v1-0 trig-dist) arg0)) + (set! t1-1 (the-as int (logand -2 (the-as uint t1-1)))) + ) + (when (logtest? (the-as uint t1-1) 2) + (let ((t2-8 (-> v1-0 trig-actor-group 0))) + (countdown (t3-0 (-> t2-8 length)) + (let ((t5-0 (-> t2-8 data t3-0 actor))) + (when (and t5-0 (logtest? (-> t5-0 extra perm status) (entity-perm-status subtask-complete))) + (set! t1-1 (logand -3 t1-1)) + (goto cfg-17) + ) + ) + ) + ) + ) + (label cfg-17) + (when (zero? t1-1) + (logclear! (-> obj enemy-flags) (enemy-flag called-dying)) + (return #t) + ) + ) + ) + ) + #f + ) + +;; definition for method 61 of type enemy +(defmethod enemy-method-61 enemy ((obj enemy) (arg0 int)) + (let ((v1-1 (< 1 arg0))) + (cond + (v1-1 + (when (not (logtest? (-> obj enemy-flags) (enemy-flag spawn-gem))) + (logior! (-> obj enemy-flags) (enemy-flag spawn-gem)) + (set! (-> obj notice-time) (the-as uint (-> self clock frame-counter))) + ) + (if (and (not (logtest? (-> obj enemy-flags) (enemy-flag chase-startup))) + (< (- (-> self clock frame-counter) (the-as int (-> obj notice-time))) + (the-as time-frame (-> obj reaction-time)) + ) + ) + (set! v1-1 #f) + ) + ) + (else + (logclear! (-> obj enemy-flags) (enemy-flag spawn-gem)) + ) + ) + (cond + (v1-1 + arg0 + ) + ((or (zero? arg0) (>= (- (-> self clock frame-counter) (the-as int (-> obj last-draw-time))) (seconds 2))) + 0 + ) + (else + 1 + ) + ) + ) + ) + +;; definition for method 74 of type enemy +;; INFO: Used lq/sq +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 490] +(defmethod enemy-method-74 enemy ((obj enemy) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block)) + (local-vars (s5-5 rgbaf) (sv-432 process) (sv-448 event-message-block)) + (with-pp + (cond + ((= arg2 'track) + (and (nonzero? (-> obj hit-points)) + (logtest? (-> obj enemy-flags) (enemy-flag enable-on-active)) + (logtest? (enemy-flag check-water-backup) (-> obj enemy-flags)) + ) + ) + ((= arg2 'combo) + (and (not (logtest? (enemy-flag multi-focus) (-> obj enemy-flags))) (nonzero? (-> obj hit-points))) + ) + ((= arg2 'touch) + (enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3)) + ) + ((= arg2 'touched) + (when (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup)) + (let* ((s3-1 arg0) + (v1-20 (if (type? s3-1 process-drawable) + (the-as process-drawable s3-1) + ) + ) + ) + (when v1-20 + (let* ((s3-2 (-> v1-20 root)) + (a1-4 (if (type? s3-2 collide-shape) + s3-2 + ) + ) + (s3-3 (-> arg3 param 0)) + ) + (if (and a1-4 + s3-3 + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s3-3) + (the-as collide-shape a1-4) + (collide-action solid) + (collide-action) + ) + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s3-3) + (-> obj root-override2) + (collide-action solid) + (collide-action) + ) + ) + (set! (-> obj auto-reset-penetrate-time) (the-as uint (-> pp clock frame-counter))) + ) + ) + ) + ) + ) + (enemy-method-76 obj arg0 arg3) + ) + ((= arg2 'attack-invinc) + (case (-> (the-as attack-info (-> arg3 param 1)) mode) + (('endlessfall) + (let ((v1-31 (-> obj root-override2 root-prim))) + (set! (-> v1-31 prim-core collide-as) (collide-spec)) + (set! (-> v1-31 prim-core collide-with) (collide-spec)) + ) + 0 + (enemy-method-73 obj) + ) + ) + ) + ((= arg2 'attack) + (let ((s2-0 (the-as object (-> arg3 param 1)))) + (when (!= (-> (the-as attack-info s2-0) id) (-> obj incoming attack-id)) + (cond + ((and (logtest? (-> obj enemy-flags) (enemy-flag enable-on-active)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (let* ((s1-0 obj) + (s0-0 (method-of-object s1-0 enemy-method-106)) + ) + (set! sv-432 arg0) + (set! sv-448 arg3) + (let ((a3-3 (get-penetrate-using-from-attack-event (the-as process-drawable arg0) arg3))) + (s0-0 s1-0 sv-432 sv-448 (the-as int a3-3) (the-as attack-info s2-0)) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'child-hit) + 0 + (if (not *debug-unkillable*) + (enemy-method-48 obj arg0 arg3) + ) + (let ((s2-1 (the-as attack-info (enemy-method-58 obj)))) + (when s2-1 + (logclear! (-> obj enemy-flags) (enemy-flag called-dying)) + (enemy-method-108 obj (the-as enemy arg0) arg3) + (let ((a1-13 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-13 from) (process->ppointer arg0)) + (set! (-> a1-13 num-params) (the-as int arg1)) + (set! (-> a1-13 message) (the-as symbol s2-1)) + (set! (-> a1-13 param 0) (-> arg3 param 0)) + (set! (-> a1-13 param 1) (-> arg3 param 1)) + (set! (-> a1-13 param 2) (-> arg3 param 2)) + (set! (-> a1-13 param 3) (-> arg3 param 3)) + (set! (-> a1-13 param 4) (-> arg3 param 4)) + (set! (-> a1-13 param 5) (-> arg3 param 5)) + (send-event-function obj a1-13) + ) + ) + ) + ) + (else + (set! (-> obj incoming attack-id) (-> (the-as attack-info s2-0) id)) + (enemy-method-75 obj arg0 (the-as touching-shapes-entry arg3)) + ) + ) + ) + ) + ) + ((= arg2 'hit-flinch) + (when (zero? (-> obj hit-points)) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (enemy-method-73 obj) + ) + #t + ) + ((= arg2 'hit-knocked) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (when (zero? (-> obj hit-points)) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4) (knocked-type knocked-type-6)) + (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0)) + 0 + ) + ) + ) + (go (method-of-object obj knocked)) + ) + ((= arg2 'hit) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (if (zero? (-> obj hit-points)) + (enemy-method-73 obj) + (go (method-of-object obj hit)) + ) + ) + ((= arg2 'cue-chase) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (let ((v1-162 (logtest? (enemy-flag alert) (-> obj enemy-flags)))) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice alert victory called-dying)) + (set! (-> obj enemy-flags) (logior (enemy-flag dangerous-backup) (-> obj enemy-flags))) + (logclear! (-> obj mask) (process-mask actor-pause)) + (cond + (v1-162 + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (go-hostile obj) + ) + ) + ((and (-> obj next-state) (let ((v1-173 (-> obj next-state name))) + (or (= v1-173 'dormant) (= v1-173 'dormant-aware)) + ) + ) + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (go (method-of-object obj notice)) + ) + ) + ) + ) + #t + ) + ) + ((= arg2 'cue-wake) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (logclear! (-> obj enemy-flags) (enemy-flag alert victory called-dying)) + (if (logtest? (enemy-option ambush) (-> obj fact-info-override enemy-options)) + (go-ambush obj) + (enemy-method-72 obj) + ) + #t + ) + ) + ((= arg2 'jump) + (when (and (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (logclear! (-> obj mask) (process-mask actor-pause)) + (set! (-> obj jump-why) (-> arg3 param 0)) + (set! (-> obj event-param-point quad) (-> (the-as vector (-> arg3 param 1)) quad)) + (go (method-of-object obj jump)) + ) + ) + ((= arg2 'death-start) + (set! (-> obj enemy-flags) (the-as enemy-flag (logior (enemy-flag recover) (-> obj enemy-flags)))) + (send-event (ppointer->process (-> obj parent)) 'child-die) + (drop-pickup (-> obj fact-info-override) #t *entity-pool* (-> obj fact-info-override) 0) + (let ((s5-1 (-> obj on-death))) + (if s5-1 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans)) + (the-as pair s5-1) + ) + ) + ) + ) + ((= arg2 'death-end) + (if (-> obj skel effect) + (logior! (-> obj skel effect flags) (effect-control-flag ecf2)) + ) + (logior! (-> obj draw status) (draw-control-status no-draw)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag check-water)) + ) + ((= arg2 'instant-death) + (when (and (> (-> obj hit-points) 0) (zero? (-> obj fated-time))) + (set! (-> obj hit-points) 0) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + (let ((s5-2 (enemy-method-50 obj (new 'stack-no-clear 'vector)))) + (vector-z-quaternion! s5-2 (-> obj root-override2 quat)) + (vector-float*! s5-2 s5-2 -1.0) + (vector-normalize! s5-2 1.0) + ) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (enemy-method-73 obj) + ) + ) + ((= arg2 'die-fast) + (logior! (-> obj draw status) (draw-control-status no-draw)) + (enemy-method-132 obj) + (send-event (ppointer->process (-> obj parent)) 'child-die) + (let ((s5-3 (-> obj on-death))) + (if s5-3 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer pp)) pp (-> obj root-override2 trans)) + (the-as pair s5-3) + ) + ) + ) + (cleanup-for-death obj) + (go (method-of-object obj die-fast)) + ) + ((= arg2 'victory) + (if (and (-> obj enemy-info use-victory) + (not (and (-> obj next-state) (= (-> obj next-state name) 'victory))) + (> (-> obj hit-points) 0) + (zero? (-> obj fated-time)) + (zero? (logand (-> obj focus-status) (focus-status grabbed))) + ) + (go (method-of-object obj victory)) + ) + ) + ((= arg2 'nav-control) + (if (nonzero? (-> obj nav)) + (-> obj nav) + ) + ) + ((= arg2 'push-trans) + (move-by-vector! (-> obj root-override2) (the-as vector (-> arg3 param 0))) + ) + ((= arg2 'move-trans) + (move-to-point! (-> obj root-override2) (the-as vector (-> arg3 param 0))) + ) + ((= arg2 'shadow) + (cond + ((-> arg3 param 0) + (let ((v1-320 (-> obj draw shadow-ctrl))) + (logclear! (-> v1-320 settings flags) (shadow-flags disable-draw)) + ) + 0 + ) + (else + (let ((v1-323 (-> obj draw shadow-ctrl))) + (logior! (-> v1-323 settings flags) (shadow-flags disable-draw)) + ) + 0 + ) + ) + ) + ((= arg2 'color-effect) + (let ((v1-325 (-> arg3 param 0))) + (set! s5-5 + (cond + ((= v1-325 'dark) + (let ((f30-0 (rand-vu-float-range 0.2 1.0))) + (set-vector! (-> obj draw color-mult) (lerp 1.0 1.0 f30-0) (lerp 1.0 0.0 f30-0) (lerp 1.0 1.0 f30-0) 1.0) + (set! s5-5 (-> obj draw color-emissive)) + (set! (-> s5-5 x) (lerp 0.0 0.3 f30-0)) + (set! (-> s5-5 y) (lerp 0.0 0.0 f30-0)) + (set! (-> s5-5 z) (lerp 0.0 0.3 f30-0)) + ) + (set! (-> s5-5 w) 1.0) + s5-5 + ) + ((= v1-325 #f) + (set-vector! (-> obj draw color-mult) 1.0 1.0 1.0 1.0) + (set! s5-5 (-> obj draw color-emissive)) + (set! (-> s5-5 quad) (the-as uint128 0)) + s5-5 + ) + ) + ) + ) + ) + ) + (none) + ) + ) + +;; definition for method 56 of type enemy +(defmethod enemy-method-56 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (let ((v1-0 (the-as attack-info (-> arg1 param 1)))) + (if (logtest? (attack-info-mask damage) (-> v1-0 mask)) + (the int (-> v1-0 damage)) + (penetrate-using->damage (the-as penetrate (-> obj incoming penetrate-using))) + ) + ) + ) + +;; definition for method 58 of type enemy +(defmethod enemy-method-58 enemy ((obj enemy)) + (let ((v1-0 (-> obj incoming penetrate-using))) + (cond + ((logtest? (the-as penetrate v1-0) (-> obj penetrated-flinch)) + 'hit-flinch + ) + ((logtest? (the-as penetrate v1-0) (-> obj penetrated-knocked)) + 'hit-knocked + ) + (else + 'hit + ) + ) + ) + ) + +;; definition for method 48 of type enemy +(defmethod enemy-method-48 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (with-pp + (let* ((v1-1 (enemy-method-56 obj arg0 arg1)) + (s5-0 (-> obj hit-points)) + (s4-1 (max 0 (- s5-0 v1-1))) + ) + (when (and (zero? s4-1) (nonzero? s5-0) (= (-> obj incoming knocked-type) (knocked-type knocked-type-6))) + (cond + ((zero? (-> obj fated-time)) + (set! (-> obj fated-time) (the-as uint (-> pp clock frame-counter))) + (set! s4-1 1) + ) + (else + (if (< (- (-> pp clock frame-counter) (the-as int (-> obj fated-time))) (seconds 1)) + (set! s4-1 1) + ) + ) + ) + ) + (set! (-> obj hit-points) s4-1) + (if (not (logtest? (-> obj enemy-flags) (enemy-flag attackable-backup))) + (set! (-> obj root-override2 penetrated-by) (enemy-method-59 obj)) + ) + (- s5-0 s4-1) + ) + ) + ) + +;; definition for method 134 of type enemy +(defmethod enemy-method-134 enemy ((obj enemy) (arg0 process) (arg1 attack-info)) + (find-offending-process-focusable arg0 arg1) + ) + +;; definition for method 75 of type enemy +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-75 enemy ((obj enemy) (arg0 process) (arg1 touching-shapes-entry)) + (let* ((s4-0 (-> arg1 handle1)) + (s2-0 arg0) + (s3-0 (if (type? s2-0 process-focusable) + (the-as process-focusable s2-0) + ) + ) + ) + (when (and s4-0 s3-0) + (cond + ((and (logtest? (-> obj focus-status) (focus-status dangerous)) + (and s3-0 (zero? (logand (-> s3-0 focus-status) (focus-status disable dead ignore grabbed)))) + ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action deadly) + (collide-action) + ) + ) + (let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action persistent-attack) + (collide-action) + ) + (-> obj persistent-attack-id) + (-> obj attack-id) + ) + ) + ) + (enemy-method-104 obj arg0 (the-as uint s4-0) a3-2) + ) + ) + ((and ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action no-standon) + (collide-action) + ) + (zero? (logand (-> obj root-override2 penetrated-by) (-> s3-0 root-override penetrate-using))) + ) + (if (send-shoves (-> obj root-override2) arg0 (the-as touching-shapes-entry s4-0) 0.7 6144.0 16384.0) + (send-event obj 'bouncing-off arg0) + ) + ) + ) + ) + ) + (none) + ) + +;; definition for method 76 of type enemy +(defmethod enemy-method-76 enemy ((obj enemy) (arg0 process) (arg1 event-message-block)) + (let ((s4-0 (-> arg1 param 0))) + (when s4-0 + (when (or (and (and (-> obj next-state) (= (-> obj next-state name) 'knocked)) + (logtest? (process-mask crate) (-> arg0 mask)) + ) + (and (and (-> obj next-state) (= (-> obj next-state name) 'jump)) + (logtest? (process-mask target sidekick crate bot) (-> arg0 mask)) + ) + ) + (when ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action solid semi-solid deadly) + (collide-action) + ) + (let ((a3-2 (if ((method-of-type touching-shapes-entry prims-touching-action?) + (the-as touching-shapes-entry s4-0) + (-> obj root-override2) + (collide-action persistent-attack) + (collide-action) + ) + (-> obj persistent-attack-id) + (-> obj attack-id) + ) + ) + ) + (enemy-method-104 obj arg0 s4-0 a3-2) + ) + ) + ) + ) + ) + ) + +;; definition for function enemy-event-handler +;; WARN: Return type mismatch none vs object. +(defbehavior enemy-event-handler enemy ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (the-as object (enemy-method-74 self arg0 arg1 arg2 arg3)) + ) + +;; definition for function enemy-simple-post +;; WARN: Return type mismatch int vs none. +(defbehavior enemy-simple-post enemy () + (enemy-method-55 self) + (update-transforms (-> self root-override2)) + 0 + (none) + ) + +;; definition for function enemy-falling-post +;; INFO: Used lq/sq +(defbehavior enemy-falling-post enemy () + (set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags))) + (let ((gp-0 (-> self root-override2))) + (cond + ((logtest? (-> self focus-status) (focus-status under-water)) + (enemy-method-47 self (-> gp-0 transv)) + ) + (else + (let ((a1-1 (new-stack-vector0))) + (vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 a1-1 (-> self enemy-info slip-factor))) + ) + ) + ) + (let ((a2-1 (new 'stack-no-clear 'collide-query))) + (set! (-> a2-1 collide-with) (-> gp-0 root-prim prim-core collide-with)) + (set! (-> a2-1 ignore-process0) self) + (set! (-> a2-1 ignore-process1) #f) + (set! (-> a2-1 ignore-pat) (logior (new 'static 'pat-surface :noendlessfall #x1) (-> gp-0 pat-ignore-mask))) + (set! (-> a2-1 action-mask) (collide-action solid)) + (fill-cache-integrate-and-collide gp-0 (-> gp-0 transv) a2-1 (meters 0)) + ) + ) + (enemy-method-111 self) + (enemy-method-55 self) + (none) + ) + +;; definition for method 47 of type enemy +(defmethod enemy-method-47 enemy ((obj enemy) (arg0 vector)) + (with-pp + (let* ((f2-0 0.8) + (f0-1 (fmax 0.0 (+ 1.0 (* 60.0 (-> pp clock seconds-per-frame) (+ -1.0 f2-0))))) + ) + (vector-float*! arg0 arg0 f0-1) + ) + (set! (-> arg0 y) (+ (-> arg0 y) (* -204800.0 (-> pp clock seconds-per-frame)))) + ) + ) + +;; definition for function enemy-die-falling-post +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defbehavior enemy-die-falling-post enemy () + (set! (-> self enemy-flags) (logior (enemy-flag directed) (-> self enemy-flags))) + (let ((gp-0 (-> self root-override2))) + (if (logtest? (-> self focus-status) (focus-status under-water)) + (enemy-method-47 self (-> gp-0 transv)) + (vector-v++! (-> gp-0 transv) (compute-acc-due-to-gravity gp-0 (new-stack-vector0) 0.0)) + ) + (let ((s4-1 (new 'stack-no-clear 'collide-query)) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-1 quad) (-> gp-0 trans quad)) + (vector-v++! s5-1 (-> gp-0 transv)) + (when (find-ground gp-0 s4-1 (-> self enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (when (>= (-> gp-0 gspot-pos y) (-> s5-1 y)) + (set! (-> s5-1 y) (-> gp-0 gspot-pos y)) + (vector-reset! (-> gp-0 transv)) + ) + ) + (move-to-point! gp-0 s5-1) + ) + ) + (enemy-method-55 self) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate idle (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-110 self) + (logclear! (-> self enemy-flags) (enemy-flag spawn-gem chase-startup use-notice-distance)) + (logior! (-> self enemy-flags) (enemy-flag enable-on-notice)) + (set! (-> self state-timeout) (the-as uint 150)) + (if (-> self on-notice) + (logior! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + ) + (if (-> self on-active) + (logior! (-> self enemy-flags) (enemy-flag jump-check-blocked)) + ) + (if (-> self on-hostile) + (logior! (-> self enemy-flags) (enemy-flag drawn-mirrored)) + ) + (when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags))) + (if (logtest? (-> self enemy-flags) (enemy-flag notice)) + (logior! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self mask) (process-mask actor-pause)) + ) + ) + (none) + ) + :trans (behavior () + (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout))) + (> (the-as int (-> self focus aware)) 0) + ) + (go-virtual active) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (sleep-code) + (none) + ) + :post (behavior () + (idle-control-method-10 (-> self idle-anim-player) self) + (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen))) + (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter))) + ) + (enemy-method-129 self) + (ja-post) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate dormant (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + ((-> (method-of-type enemy idle) enter)) + (set! (-> self root-override2 nav-flags) (nav-flags)) + (let ((v1-4 (-> self root-override2 root-prim))) + (set! (-> v1-4 prim-core collide-as) (collide-spec)) + (set! (-> v1-4 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> self draw status) (draw-control-status no-draw)) + (set! (-> self draw origin quad) (-> self root-override2 trans quad)) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + (set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags))) + ) + (logior! (-> self focus-status) (focus-status disable)) + (none) + ) + :exit (behavior () + (logclear! (-> self focus-status) (focus-status disable)) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-3 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (logclear! (-> self enemy-flags) (enemy-flag victory)) + (logior! (-> self root-override2 nav-flags) (nav-flags nav-flags0)) + (none) + ) + :code (the-as (function none :behavior enemy) sleep-code) + ) + +;; failed to figure out what this is: +(defstate dormant-aware (enemy) + :virtual #t + :event enemy-event-handler + :enter (-> (method-of-type enemy dormant) enter) + :exit (-> (method-of-type enemy dormant) exit) + :trans (behavior () + (when (and (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self state-timeout))) + (> (the-as int (-> self focus aware)) 0) + ) + (if (logtest? (enemy-option ambush) (-> self fact-info-override enemy-options)) + (go-ambush self) + (go-virtual active) + ) + ) + (none) + ) + :code (the-as (function none :behavior enemy) sleep-code) + :post (behavior () + (if (and (nonzero? (-> self draw)) (logtest? (-> self draw status) (draw-control-status on-screen))) + (set! (-> self last-draw-time) (the-as uint (-> self clock frame-counter))) + ) + (enemy-method-129 self) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate ambush (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (logior! (-> self enemy-flags) (enemy-flag chase-startup)) + (none) + ) + :code (behavior () + (go-virtual notice) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate active (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self enemy-flags) (enemy-flag use-notice-distance)) + (when (logtest? (-> self enemy-flags) (enemy-flag jump-check-blocked)) + (logclear! (-> self enemy-flags) (enemy-flag jump-check-blocked)) + (let ((gp-0 (-> self on-active))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (when (not (logtest? (enemy-flag dangerous-backup) (-> self enemy-flags))) + (if (logtest? (-> self enemy-flags) (enemy-flag notice)) + (logior! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self mask) (process-mask actor-pause)) + ) + ) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((v1-3 (-> self focus aware))) + (cond + ((< (the-as int v1-3) 1) + (go-virtual idle) + ) + ((< 1 (the-as int v1-3)) + (go-virtual notice) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (sleep-code) + (none) + ) + :post (behavior () + (idle-control-method-10 (-> self idle-anim-player) self) + (enemy-simple-post) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate notice (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((v1-3 (logior (-> self enemy-flags) (enemy-flag use-notice-distance)))) + (set! (-> self enemy-flags) (logclear v1-3 (enemy-flag called-dying))) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (enemy-method-109 self 1) + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (let ((gp-1 (-> self focus aware))) + (when (logtest? (-> self enemy-flags) (enemy-flag chase-startup)) + (cond + ((and (= gp-1 (enemy-aware enemy-aware-3)) (enemy-method-107 self)) + (go-hostile self) + ) + ((= gp-1 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + (else + (go-stare self) + ) + ) + ) + ) + (logior! (-> self enemy-flags) (enemy-flag chase-startup)) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info notice-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info notice-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (vector-! gp-0 (target-pos 0) (-> self root-override2 trans)) + (seek-toward-heading-vec! (-> self root-override2) gp-0 131072.0 (seconds 0.05)) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post enemy-simple-post + ) + +;; failed to figure out what this is: +(defstate hostile (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-109 self 1) + (logior! (-> self enemy-flags) (enemy-flag use-notice-distance)) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (logclear! (-> self mask) (process-mask actor-pause)) + (when (logtest? (-> self enemy-flags) (enemy-flag drawn-mirrored)) + (logclear! (-> self enemy-flags) (enemy-flag drawn-mirrored)) + (let ((gp-0 (-> self on-hostile))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (none) + ) + :trans (behavior () + (if (and (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) (-> self enemy-info use-victory)) + (go-virtual victory) + ) + (let ((gp-0 (-> self focus aware))) + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time))) + (cond + ((or (>= 2 (the-as int gp-0)) (not (enemy-method-107 self))) + (go-stare self) + ) + ((= gp-0 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim))) + (ja :num-func num-func-identity :frame-num 0.0) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +;; failed to figure out what this is: +(defstate stare (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((gp-0 (-> self focus aware))) + (cond + ((>= 1 (the-as int gp-0)) + (go-virtual active) + ) + ((and (= gp-0 (enemy-aware enemy-aware-3)) (enemy-method-107 self)) + (go-hostile self) + ) + ((= gp-0 (enemy-aware enemy-aware-4)) + (go-flee self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self enemy-info idle-anim))) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +;; failed to figure out what this is: +(defstate victory (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info victory-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info victory-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post enemy-simple-post + ) + +;; failed to figure out what this is: +(defstate flee (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-109 self 1) + (logclear! (-> self enemy-flags) (enemy-flag dangerous-backup)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (the-as time-frame (-> self reaction-time))) + (if (!= (-> self focus aware) (enemy-aware enemy-aware-4)) + (go-stare self) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info hostile-anim))) + (ja :num-func num-func-identity :frame-num 0.0) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +;; definition for method 82 of type enemy +(defmethod enemy-method-82 enemy ((obj enemy) (arg0 enemy-jump-info)) + "@abstract" + #f + ) + +;; definition for method 83 of type enemy +;; INFO: Used lq/sq +(defmethod enemy-method-83 enemy ((obj enemy) (arg0 enemy-jump-info)) + (set! (-> arg0 flags) (the-as uint 1)) + (set! (-> arg0 anim-speed) (get-rand-float-range obj 0.9 1.1)) + (set! (-> arg0 hang-time) 0) + (set! (-> arg0 dest-pos quad) (-> obj event-param-point quad)) + (set! (-> arg0 start-pos quad) (-> obj root-override2 trans quad)) + (let ((s4-0 (new 'stack-no-clear 'collide-query))) + (if (enemy-method-126 + obj + s4-0 + (-> arg0 dest-pos) + (the-as collide-spec (-> obj gnd-collide)) + 8192.0 + 81920.0 + 1024.0 + ) + (set! (-> arg0 dest-pos y) (-> s4-0 best-other-tri intersect y)) + ) + ) + (enemy-method-84 obj arg0) + (none) + ) + +;; definition for method 84 of type enemy +(defmethod enemy-method-84 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let* ((f0-0 (vector-vector-xz-distance (-> arg0 start-pos) (-> arg0 dest-pos))) + (f0-2 (fmax (-> obj enemy-info jump-height-min) (* (-> obj enemy-info jump-height-factor) f0-0))) + ) + (setup-from-to-height! (-> arg0 traj) (-> arg0 start-pos) (-> arg0 dest-pos) f0-2 -4.551111) + ) + (none) + ) + +;; definition for method 86 of type enemy +(defmethod enemy-method-86 enemy ((obj enemy)) + (let ((gp-0 (-> obj root-override2))) + (when (< (-> gp-0 transv y) 0.0) + (let ((a1-0 (new 'stack-no-clear 'collide-query))) + (find-ground (-> obj root-override2) a1-0 (the-as collide-spec (-> obj gnd-collide)) 8192.0 81920.0 1024.0) + ) + (>= (-> gp-0 gspot-pos y) (-> gp-0 trans y)) + ) + ) + ) + +;; definition for method 85 of type enemy +(defmethod enemy-method-85 enemy ((obj enemy)) + (let* ((v1-0 (-> obj root-override2)) + (f0-0 (-> v1-0 gspot-pos y)) + ) + (if (< (-> v1-0 trans y) f0-0) + (set! (-> v1-0 trans y) f0-0) + ) + ) + (set! (-> obj root-override2 transv y) 0.0) + ) + +;; definition for method 92 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-92 enemy ((obj enemy) (arg0 int) (arg1 nav-poly)) + "TODO - nav-poly is a guess + @abstract" + 0 + (none) + ) + +;; definition for method 91 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-91 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info)) + (case arg0 + ((2 3) + (set! (-> obj enemy-flags) (logior (enemy-flag directed) (-> obj enemy-flags))) + (let ((f30-0 (the float (-> arg1 hang-time)))) + (let ((a1-3 (compute-trans-at-time (-> arg1 traj) f30-0 (new 'stack-no-clear 'vector)))) + (move-to-point! (-> obj root-override2) a1-3) + ) + (let ((s5-1 (-> obj root-override2 transv))) + (compute-transv-at-time (-> arg1 traj) f30-0 s5-1) + (vector-float*! s5-1 s5-1 300.0) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 89 of type enemy +(defmethod enemy-method-89 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((a0-1 (-> obj skel root-channel 0))) + (set! (-> a0-1 param 0) 1.0) + (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.1)) + (let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim))) + (a0-5 (-> obj skel root-channel 0)) + ) + (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3)) + (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1))) + (set! (-> a0-5 param 1) (-> arg0 anim-speed)) + (set! (-> a0-5 frame-num) 0.0) + (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!) + ) + #t + ) + +;; definition for method 87 of type enemy +(defmethod enemy-method-87 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((s5-0 (-> obj draw art-group data (-> obj enemy-info jump-in-air-anim)))) + (let ((v1-6 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (cond + ((and v1-6 (= v1-6 (-> obj draw art-group data (-> obj enemy-info jump-wind-up-anim)))) + (ja-channel-push! 1 0) + ) + (else + (let ((a0-10 (-> obj skel root-channel 0))) + (set! (-> a0-10 param 0) 1.0) + (joint-control-channel-group! a0-10 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + ) + (let ((a0-12 (-> obj skel root-channel 0))) + (set! (-> a0-12 frame-group) (the-as art-joint-anim s5-0)) + (set! (-> a0-12 param 0) (the float (+ (-> (the-as art-joint-anim s5-0) frames num-frames) -1))) + (set! (-> a0-12 param 1) (-> arg0 anim-speed)) + (set! (-> a0-12 frame-num) 0.0) + (joint-control-channel-group! a0-12 (the-as art-joint-anim s5-0) num-func-seek!) + ) + ) + #t + ) + +;; definition for method 88 of type enemy +(defmethod enemy-method-88 enemy ((obj enemy) (arg0 enemy-jump-info)) + (let ((a0-1 (-> obj skel root-channel 0))) + (set! (-> a0-1 param 0) 1.0) + (joint-control-channel-group! a0-1 (the-as art-joint-anim #f) num-func-loop!) + ) + (ja-channel-push! 1 (seconds 0.075)) + (let ((a1-3 (-> obj draw art-group data (-> obj enemy-info jump-land-anim))) + (a0-5 (-> obj skel root-channel 0)) + ) + (set! (-> a0-5 frame-group) (the-as art-joint-anim a1-3)) + (set! (-> a0-5 param 0) (the float (+ (-> (the-as art-joint-anim a1-3) frames num-frames) -1))) + (set! (-> a0-5 param 1) (-> arg0 anim-speed)) + (set! (-> a0-5 frame-num) 0.0) + (joint-control-channel-group! a0-5 (the-as art-joint-anim a1-3) num-func-seek!) + ) + #t + ) + +;; definition for method 90 of type enemy +(defmethod enemy-method-90 enemy ((obj enemy) (arg0 int) (arg1 enemy-jump-info)) + (local-vars (s5-0 symbol)) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (not (enemy-method-89 obj arg1)) + ) + ((= v1-0 1) + (set! s5-0 (ja-done? 0)) + (let ((a0-4 (-> obj skel root-channel 0))) + (set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + ((= v1-0 2) + (enemy-method-87 obj arg1) + #f + ) + ((= v1-0 3) + (set! s5-0 (ja-done? 0)) + (let ((a0-9 (-> obj skel root-channel 0))) + (set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1))) + (set! (-> a0-9 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + ((= v1-0 4) + (not (enemy-method-88 obj arg1)) + ) + ((= v1-0 5) + (set! s5-0 (ja-done? 0)) + (let ((a0-14 (-> obj skel root-channel 0))) + (set! (-> a0-14 param 0) (the float (+ (-> a0-14 frame-group frames num-frames) -1))) + (set! (-> a0-14 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-14 (the-as art-joint-anim #f) num-func-seek!) + ) + (ja-blend-eval) + s5-0 + ) + (else + #t + ) + ) + ) + ) + +;; failed to figure out what this is: +(defstate jump (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-6 *game-info*) + (a0-2 (+ (-> v1-6 attack-id) 1)) + ) + (set! (-> v1-6 attack-id) a0-2) + (set! (-> self attack-id) a0-2) + ) + (logclear! (-> self focus-status) (focus-status in-air)) + (none) + ) + :exit (behavior () + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (new 'stack-no-clear 'enemy-jump-info))) + (let ((s5-0 0)) + (enemy-method-83 self gp-0) + (if (and (-> self enemy-info use-jump-blocked) + (logtest? (enemy-flag vulnerable) (-> self enemy-flags)) + (enemy-method-82 self gp-0) + ) + (go-virtual jump-blocked) + ) + (when (logtest? (-> gp-0 flags) 1) + (until #f + (if (enemy-method-90 self s5-0 gp-0) + (goto cfg-12) + ) + (enemy-method-91 self s5-0 gp-0) + (enemy-method-92 self s5-0 (the-as nav-poly gp-0)) + (suspend) + (set! s5-0 1) + ) + #f + ) + ) + (label cfg-12) + (logclear! (-> self root-override2 status) (collide-status on-surface on-ground touch-surface)) + (let ((s5-1 2)) + (logior! (-> self focus-status) (focus-status in-air)) + (until (enemy-method-86 self) + (+! (-> gp-0 hang-time) (- (-> self clock frame-counter) (-> self clock old-frame-counter))) + (enemy-method-90 self s5-1 gp-0) + (enemy-method-91 self s5-1 gp-0) + (enemy-method-92 self s5-1 (the-as nav-poly gp-0)) + (suspend) + (set! s5-1 3) + ) + ) + (logclear! (-> self focus-status) (focus-status in-air)) + (enemy-method-85 self) + (let ((s5-2 4)) + (until #f + (if (enemy-method-90 self s5-2 gp-0) + (goto cfg-19) + ) + (enemy-method-91 self s5-2 gp-0) + (enemy-method-92 self s5-2 (the-as nav-poly gp-0)) + (suspend) + (set! s5-2 5) + ) + ) + #f + (label cfg-19) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + ((lambda :behavior enemy + ((arg0 enemy-jump-info)) + (send-event (ppointer->process (-> self parent)) 'child-jumped) + (none) + ) + gp-0 + ) + ) + ) + (enemy-method-93 self) + (none) + ) + :post (behavior () + (let ((a1-0 (new 'stack-no-clear 'overlaps-others-params))) + (set! (-> a1-0 options) (overlaps-others-options)) + (set! (-> a1-0 collide-with-filter) (-> self enemy-info overlaps-others-collide-with-filter)) + (set! (-> a1-0 tlist) *touching-list*) + (find-overlapping-shapes (-> self root-override2) a1-0) + ) + (enemy-simple-post) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate jump-blocked (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self mask) (process-mask actor-pause)) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) + (if (logtest? (enemy-flag alert) (-> self enemy-flags)) + (go-virtual jump) + (enemy-method-93 self) + ) + ) + (none) + ) + :code (behavior () + (let ((v1-2 (ja-group))) + (when (not (and v1-2 (= v1-2 (-> self draw art-group data (-> self enemy-info idle-anim))))) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data (-> self enemy-info idle-anim)) + :num! (identity (rand-vu-float-range 0.0 (the float (+ (-> (ja-group) frames num-frames) -1)))) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.75 1.25))) + (until #f + (suspend) + (ja :num! (loop! f30-0)) + ) + ) + #f + (none) + ) + :post enemy-simple-post + ) + +;; failed to figure out what this is: +(defstate hit (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-110 self) + (logclear! (-> self mask) (process-mask actor-pause)) + (enemy-method-135 self 0) + (none) + ) + :code (behavior () + (local-vars (v1-37 enemy-flag) (v1-45 enemy-flag)) + (ja-channel-push! 1 (seconds 0.2)) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info hit-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info hit-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (let ((v1-36 (-> self enemy-flags))) + (if (logtest? v1-36 (enemy-flag checking-water)) + (set! v1-37 (logior v1-36 (enemy-flag enable-on-active))) + (set! v1-37 (logclear v1-36 (enemy-flag enable-on-active))) + ) + ) + (set! (-> self enemy-flags) v1-37) + (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest)) + (set! (-> self mask) (logior (process-mask collectable) (-> self mask))) + (logclear! (-> self mask) (process-mask collectable)) + ) + (let ((v1-44 (-> self enemy-flags))) + (if (logtest? (enemy-flag no-initial-move-to-ground) v1-44) + (set! v1-45 (logior (enemy-flag check-water-backup) v1-44)) + (set! v1-45 (logclear v1-44 (enemy-flag check-water-backup))) + ) + ) + (set! (-> self enemy-flags) v1-45) + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (logclear! (-> self focus-status) (focus-status hit)) + (go-hostile self) + (none) + ) + :post enemy-simple-post + ) + +;; definition for method 101 of type enemy +;; WARN: Return type mismatch collide-spec vs none. +(defmethod enemy-method-101 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag use-trigger) (-> obj enemy-flags))) + (set! (-> obj enemy-flags) (logior (enemy-flag use-trigger) (-> obj enemy-flags))) + (logclear! (-> obj enemy-flags) (enemy-flag directed)) + (enemy-method-124 obj) + ) + (none) + ) + +;; definition for method 103 of type enemy +(defmethod enemy-method-103 enemy ((obj enemy)) + (when (logtest? (enemy-flag use-trigger) (-> obj enemy-flags)) + (logclear! (-> obj enemy-flags) (enemy-flag use-trigger directed)) + (enemy-method-124 obj) + ) + ) + +;; definition for method 102 of type enemy +(defmethod enemy-method-102 enemy ((obj enemy)) + #f + ) + +;; definition for method 100 of type enemy +;; INFO: Used lq/sq +;; WARN: Return type mismatch vector vs symbol. +(defmethod enemy-method-100 enemy ((obj enemy)) + (local-vars (v0-1 vector)) + (with-pp + (when (not (-> obj enemy-info move-to-ground)) + (enemy-method-103 obj) + (return (the-as symbol #f)) + ) + (when (not (logtest? (enemy-flag directed) (-> obj enemy-flags))) + (let ((s5-0 (-> obj root-override2))) + (if (logtest? (-> obj focus-status) (focus-status under-water)) + (enemy-method-47 obj (-> s5-0 transv)) + (+! (-> s5-0 transv y) (* (-> obj enemy-info movement-gravity) (-> pp clock seconds-per-frame))) + ) + (let ((a2-0 (new 'stack-no-clear 'move-above-ground-params))) + (let ((v1-16 (-> obj enemy-info))) + (set! (-> a2-0 gnd-collide-with) (-> v1-16 recover-gnd-collide-with)) + (set! (-> a2-0 popup) 8192.0) + (set! (-> a2-0 dont-move-if-overlaps?) #t) + (set! (-> a2-0 hover-if-no-ground?) (-> v1-16 hover-if-no-ground)) + (set! (-> a2-0 overlaps-params options) (overlaps-others-options oo0 oo2)) + (set! (-> a2-0 overlaps-params collide-with-filter) (-> v1-16 overlaps-others-collide-with-filter)) + ) + (set! (-> a2-0 overlaps-params tlist) *touching-list*) + (-> a2-0 overlaps-params) + (enemy-method-128 obj (-> s5-0 transv) a2-0) + ) + ) + ) + (logclear! (-> obj enemy-flags) (enemy-flag directed)) + (if (and (enemy-method-102 obj) (zero? (logand (-> obj focus-status) (focus-status dead)))) + (enemy-method-73 obj) + ) + (let ((s5-1 (-> obj root-override2)) + (a1-2 (new 'stack-no-clear 'collide-query)) + (s3-0 (new 'stack-no-clear 'vector)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s3-0 quad) (-> s5-1 gspot-pos quad)) + (set! (-> s4-0 quad) (-> s5-1 gspot-normal quad)) + (the-as symbol (cond + ((find-ground s5-1 a1-2 (-> obj enemy-info gnd-collide-with) 8192.0 81920.0 1024.0) + (let ((f0-4 (- (-> s5-1 trans y) (-> s5-1 gspot-pos y)))) + (when (>= 409.6 (fabs f0-4)) + (enemy-method-103 obj) + (return (the-as symbol #f)) + v0-1 + ) + ) + ) + (else + (set! (-> s5-1 gspot-pos quad) (-> s3-0 quad)) + (set! v0-1 (-> s5-1 gspot-normal)) + (set! (-> v0-1 quad) (-> s4-0 quad)) + v0-1 + ) + ) + ) + ) + ) + ) + +;; definition for method 46 of type enemy +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-46 enemy ((obj enemy) (arg0 int)) + "@abstract" + 0 + (none) + ) + +;; definition for method 52 of type enemy +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defmethod enemy-method-52 enemy ((obj enemy) (arg0 vector)) + (enemy-method-50 obj arg0) + (let ((s5-0 (-> obj enemy-info))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-2)) + (let ((f30-0 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-hard-vxz-lo) (-> s5-0 knocked-hard-vxz-hi) f30-0)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-hard-vy-lo) (-> s5-0 knocked-hard-vy-hi) f30-0)) + ) + ) + (((knocked-type knocked-type-1)) + (let ((f30-1 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-medium-vxz-lo) (-> s5-0 knocked-medium-vxz-hi) f30-1)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-medium-vy-lo) (-> s5-0 knocked-medium-vy-hi) f30-1)) + ) + ) + (((knocked-type knocked-type-3)) + (let ((f30-2 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-huge-vxz-lo) (-> s5-0 knocked-huge-vxz-hi) f30-2)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-huge-vy-lo) (-> s5-0 knocked-huge-vy-hi) f30-2)) + ) + ) + (((knocked-type knocked-type-4)) + (vector-rotate90-around-y! arg0 arg0) + (let ((v1-9 (new 'stack-no-clear 'vector))) + (vector-! v1-9 (-> obj incoming attacker-pos) (-> obj root-override2 trans)) + (set! (-> v1-9 y) 0.0) + (if (< 0.0 (vector-dot v1-9 arg0)) + (vector-negate! arg0 arg0) + ) + ) + (let ((f30-3 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-yellow-vxz-lo) (-> s5-0 knocked-yellow-vxz-hi) f30-3)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-yellow-vy-lo) (-> s5-0 knocked-yellow-vy-hi) f30-3)) + ) + ) + (((knocked-type knocked-type-5)) + (let* ((f1-2 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans))) + (f0-26 1.0) + (f2-0 61440.0) + (f1-3 (fmin f1-2 (* f2-0 f2-0))) + (f2-3 61440.0) + (f30-5 (* (- f0-26 (/ f1-3 (* f2-3 f2-3))) (get-rand-float-range obj 0.8 1.0))) + ) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-red-vxz-lo) (-> s5-0 knocked-red-vxz-hi) f30-5)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-red-vy-lo) (-> s5-0 knocked-red-vy-hi) f30-5)) + ) + ) + (((knocked-type knocked-type-6)) + (let* ((f1-5 (vector-vector-xz-distance-squared (target-pos 0) (-> obj root-override2 trans))) + (f0-34 1.0) + (f2-6 122880.0) + (f1-6 (fmin f1-5 (* f2-6 f2-6))) + (f2-9 122880.0) + (f30-7 (* (- f0-34 (/ f1-6 (* f2-9 f2-9))) (get-rand-float-range obj 0.8 1.0))) + ) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-blue-vxz-lo) (-> s5-0 knocked-blue-vxz-hi) f30-7)) + (cond + ((>= (the-as uint 4) (the-as uint (-> obj incoming blue-juggle-count))) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-blue-vy-lo) (-> s5-0 knocked-blue-vy-hi) f30-7)) + ) + (else + (if (zero? (get-rand-int obj 3)) + (set! (-> arg0 y) 40960.0) + ) + ) + ) + ) + ) + (((knocked-type knocked-type-7)) + (set! (-> arg0 quad) (-> obj incoming attack-direction quad)) + ) + (else + (let ((f30-8 (get-rand-float-range obj 0.0 1.0))) + (vector-float*! arg0 arg0 (lerp (-> s5-0 knocked-soft-vxz-lo) (-> s5-0 knocked-soft-vxz-hi) f30-8)) + (set! (-> arg0 y) (lerp (-> s5-0 knocked-soft-vy-lo) (-> s5-0 knocked-soft-vy-hi) f30-8)) + ) + ) + ) + ) + (none) + ) + +;; definition for method 51 of type enemy +(defmethod enemy-method-51 enemy ((obj enemy)) + (let ((f30-0 (quaternion-y-angle (-> obj root-override2 quat)))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4) (knocked-type knocked-type-6)) + (let ((a0-5 (handle->process (-> obj focus handle)))) + (when a0-5 + (let ((v1-9 (get-trans (the-as process-focusable a0-5) 0))) + (set! f30-0 + (atan (- (-> v1-9 x) (-> obj root-override2 trans x)) (- (-> v1-9 z) (-> obj root-override2 trans z))) + ) + ) + ) + ) + ) + (else + (let* ((v1-13 (-> obj root-override2 transv)) + (f28-0 (atan (-> v1-13 x) (-> v1-13 z))) + (f1-2 (deg- f30-0 f28-0)) + (f2-0 (fabs f1-2)) + (f0-6 (-> obj enemy-info knocked-seek-ry-clamp)) + ) + (when (and (< f0-6 f2-0) (< f2-0 (- 32768.0 f0-6))) + (set! f30-0 (+ (cond + ((< f2-0 16384.0) + (if (>= f1-2 0.0) + f0-6 + (- f0-6) + ) + ) + ((>= f1-2 0.0) + (- 32768.0 f0-6) + ) + (else + (+ -32768.0 f0-6) + ) + ) + f28-0 + ) + ) + (if (< f30-0 0.0) + (set! f30-0 (+ 65536.0 f30-0)) + ) + ) + ) + ) + ) + f30-0 + ) + ) + +;; definition for method 77 of type enemy +(defmethod enemy-method-77 enemy ((obj enemy) (arg0 (pointer float))) + (ja-channel-push! 1 0) + (let ((a1-2 (-> obj draw art-group data (-> obj enemy-info knocked-anim))) + (a0-4 (-> obj skel root-channel 0)) + ) + (set! (-> a0-4 frame-group) (the-as art-joint-anim a1-2)) + (set! (-> a0-4 param 0) (the float (+ (-> (the-as art-joint-anim a1-2) frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg0 0)) + (set! (-> a0-4 frame-num) 0.0) + (joint-control-channel-group! a0-4 (the-as art-joint-anim a1-2) num-func-seek!) + ) + #t + ) + +;; definition for method 78 of type enemy +(defmethod enemy-method-78 enemy ((obj enemy) (arg0 (pointer float))) + (let ((v1-4 (-> obj draw art-group data (-> obj enemy-info knocked-land-anim))) + (a0-3 (-> obj skel root-channel 0)) + ) + (set! (-> a0-3 frame-group) (the-as art-joint-anim v1-4)) + (set! (-> a0-3 param 0) (the float (+ (-> (the-as art-joint-anim v1-4) frames num-frames) -1))) + (set! (-> a0-3 param 1) (-> arg0 0)) + (set! (-> a0-3 frame-num) 0.0) + (joint-control-channel-group! a0-3 (the-as art-joint-anim v1-4) num-func-seek!) + ) + #t + ) + +;; definition for method 80 of type enemy +(defmethod enemy-method-80 enemy ((obj enemy) (arg0 enemy-knocked-info)) + (let ((gp-0 (-> obj root-override2))) + (or (>= (-> arg0 on-surface-count) 3) + (and (logtest? (-> gp-0 status) (collide-status on-ground)) (>= 16384.0 (-> gp-0 transv y))) + (and (>= (-> arg0 move-count) 3) + (let ((f0-1 40.96)) + (>= (* f0-1 f0-1) (vector-vector-distance-squared (-> gp-0 trans-old) (-> gp-0 trans-old-old))) + ) + (let ((f0-4 40.96)) + (>= (* f0-4 f0-4) (vector-vector-distance-squared (-> gp-0 trans-old-old) (-> gp-0 trans-old-old-old))) + ) + ) + ) + ) + ) + +;; definition for method 81 of type enemy +(defmethod enemy-method-81 enemy ((obj enemy)) + (let ((s5-0 (-> obj root-override2)) + (a1-0 (new 'stack-no-clear 'collide-query)) + (gp-0 #t) + ) + (when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (let ((f0-1 (- (-> s5-0 trans y) (-> s5-0 gspot-pos y)))) + (if (and (>= f0-1 -1228.8) (>= 6144.0 f0-1)) + (set! gp-0 #f) + ) + ) + ) + gp-0 + ) + ) + +;; definition for method 79 of type enemy +(defmethod enemy-method-79 enemy ((obj enemy) (arg0 int) (arg1 enemy-knocked-info)) + (local-vars (s5-0 symbol)) + (let ((v1-0 arg0)) + (cond + ((zero? v1-0) + (enemy-method-77 obj (the-as (pointer float) arg1)) + (set! s5-0 #f) + ) + ((= v1-0 1) + (set! s5-0 (ja-done? 0)) + (let ((a0-4 (-> obj skel root-channel 0))) + (set! (-> a0-4 param 0) (the float (+ (-> a0-4 frame-group frames num-frames) -1))) + (set! (-> a0-4 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-4 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + ((= v1-0 2) + (set! s5-0 (not (enemy-method-78 obj (the-as (pointer float) arg1)))) + (set! (-> obj incoming blue-juggle-count) (the-as uint 0)) + ) + ((= v1-0 3) + (set! s5-0 (ja-done? 0)) + (let ((a0-9 (-> obj skel root-channel 0))) + (set! (-> a0-9 param 0) (the float (+ (-> a0-9 frame-group frames num-frames) -1))) + (set! (-> a0-9 param 1) (-> arg1 anim-speed)) + (joint-control-channel-group-eval! a0-9 (the-as art-joint-anim #f) num-func-seek!) + ) + ) + ((= v1-0 4) + (vector-reset! (-> obj root-override2 transv)) + (set! s5-0 #t) + ) + (else + (set! s5-0 #t) + ) + ) + ) + s5-0 + ) + +;; failed to figure out what this is: +(defstate knocked (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (enemy-method-110 self) + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (logclear! (-> self mask) (process-mask actor-pause)) + (let* ((v1-8 *game-info*) + (a0-4 (+ (-> v1-8 attack-id) 1)) + ) + (set! (-> v1-8 attack-id) a0-4) + (set! (-> self attack-id) a0-4) + ) + (enemy-method-103 self) + (if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options)) + (set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags))) + ) + (let ((v1-16 (-> self root-override2))) + (logclear! (-> v1-16 status) (collide-status + on-surface + on-ground + touch-surface + touch-wall + touch-ceiling + touch-actor + on-special-surface + touch-edge + blocked + on-water + impact-surface + touch-background + stuck + glance + ) + ) + (when (not (logtest? (-> v1-16 root-prim prim-core action) (collide-action no-normal-reset))) + (let ((a0-16 (-> v1-16 dynam gravity-normal))) + (set! (-> v1-16 local-normal quad) (-> a0-16 quad)) + (set! (-> v1-16 surface-normal quad) (-> a0-16 quad)) + (set! (-> v1-16 poly-normal quad) (-> a0-16 quad)) + ) + (set! (-> v1-16 coverage) 0.0) + (set! (-> v1-16 touch-angle) 0.0) + ) + (enemy-method-52 self (-> v1-16 transv)) + ) + (if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0) + (set! (-> self desired-angle) (enemy-method-51 self)) + ) + (if (zero? (-> self hit-points)) + (enemy-method-132 self) + (enemy-method-135 self 0) + ) + (logclear! (-> self focus-status) (focus-status dangerous)) + (if (= (-> self incoming knocked-type) (knocked-type knocked-type-4)) + (logclear! (-> self enemy-flags) (enemy-flag check-water-backup)) + ) + (set! (-> self root-override2 penetrate-using) (penetrate lunge vehicle knocked)) + (enemy-method-49 self) + (enemy-method-46 self 1) + (none) + ) + :exit (behavior () + (local-vars (v1-1 enemy-flag) (v1-15 enemy-flag) (v1-23 enemy-flag)) + (let ((v1-0 (-> self enemy-flags))) + (if (logtest? (enemy-flag enable-on-hostile) v1-0) + (set! v1-1 (logior (enemy-flag trackable-backup) v1-0)) + (set! v1-1 (logclear v1-0 (enemy-flag trackable-backup))) + ) + ) + (set! (-> self enemy-flags) v1-1) + (when (nonzero? (-> self hit-points)) + (set! (-> self root-override2 penetrate-using) + (the-as penetrate (logclear (-> self root-override2 penetrate-using) (penetrate knocked))) + ) + (enemy-method-46 self 2) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (let ((v1-14 (-> self enemy-flags))) + (if (logtest? v1-14 (enemy-flag checking-water)) + (set! v1-15 (logior v1-14 (enemy-flag enable-on-active))) + (set! v1-15 (logclear v1-14 (enemy-flag enable-on-active))) + ) + ) + (set! (-> self enemy-flags) v1-15) + (if (logtest? (-> self enemy-flags) (enemy-flag look-at-move-dest)) + (set! (-> self mask) (logior (process-mask collectable) (-> self mask))) + (logclear! (-> self mask) (process-mask collectable)) + ) + (let ((v1-22 (-> self enemy-flags))) + (if (logtest? (enemy-flag no-initial-move-to-ground) v1-22) + (set! v1-23 (logior (enemy-flag check-water-backup) v1-22)) + (set! v1-23 (logclear v1-22 (enemy-flag check-water-backup))) + ) + ) + (set! (-> self enemy-flags) v1-23) + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (logclear! (-> self focus-status) (focus-status hit)) + ) + (none) + ) + :trans (behavior () + (if (>= (-> self enemy-info knocked-seek-ry-clamp) 0.0) + (seek-toward-yaw-angle! (-> self root-override2) (-> self desired-angle) 138353.78 (seconds 0.1)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (new 'stack-no-clear 'enemy-knocked-info))) + (let ((s5-0 0)) + (set! (-> gp-0 anim-speed) (get-rand-float-range self 0.9 1.1)) + (set! (-> gp-0 on-surface-count) 0) + (set! (-> gp-0 move-count) 0) + (until (enemy-method-80 self gp-0) + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 2)) + (enemy-method-73 self) + ) + (if (logtest? (-> self root-override2 status) (collide-status on-surface)) + (+! (-> gp-0 on-surface-count) 1) + ) + (enemy-method-79 self s5-0 gp-0) + (suspend) + (+! (-> gp-0 move-count) 1) + (set! s5-0 1) + ) + ) + (let ((s5-1 2)) + (set! (-> gp-0 land-can-land-time) (-> self clock frame-counter)) + (until #f + (if (logtest? (-> self root-override2 status) (collide-status on-surface)) + (+! (-> gp-0 on-surface-count) 1) + ) + (if (enemy-method-79 self s5-1 gp-0) + (goto cfg-15) + ) + (suspend) + (+! (-> gp-0 move-count) 1) + (set! s5-1 3) + (if (enemy-method-80 self gp-0) + (set! (-> gp-0 land-can-land-time) (-> self clock frame-counter)) + ) + ) + ) + #f + (label cfg-15) + (if (and (not (logtest? (enemy-flag recover) (-> self enemy-flags))) + (or (>= (- (-> self clock frame-counter) (-> gp-0 land-can-land-time)) (seconds 0.1)) + (enemy-method-81 self) + (enemy-method-102 self) + ) + ) + (enemy-method-73 self) + ) + (while (not (enemy-method-79 self 4 gp-0)) + (suspend) + ) + ) + (enemy-method-101 self) + (cond + ((or (zero? (-> self hit-points)) (nonzero? (-> self fated-time))) + (cond + ((logtest? (enemy-flag recover) (-> self enemy-flags)) + (set! (-> self hit-points) 0) + (let ((v1-67 (-> self root-override2 root-prim))) + (set! (-> v1-67 prim-core collide-as) (collide-spec)) + (set! (-> v1-67 prim-core collide-with) (collide-spec)) + ) + 0 + (enemy-method-103 self) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + ) + (else + (enemy-method-73 self) + ) + ) + ) + (else + (go-hostile self) + ) + ) + (none) + ) + :post enemy-falling-post + ) + +;; definition for method 132 of type enemy +(defmethod enemy-method-132 enemy ((obj enemy)) + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (set! (-> obj enemy-flags) + (the-as enemy-flag (logior (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + ) + (enemy-method-135 obj 1) + (when (and (>= (-> obj enemy-info gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (or (and (not (and (-> obj entity) (logtest? (-> obj entity extra perm status) (entity-perm-status save)))) + (-> obj entity) + ) + (task-node-closed? (game-task-node city-win-introduction)) + (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + ) + ) + (set! (-> obj enemy-flags) (logior (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (remove-from-process *part-engine* obj) + (setup-masks + (-> obj draw) + (the-as int (-> obj enemy-info gem-no-seg)) + (the-as int (-> obj enemy-info gem-seg)) + ) + (let ((a0-18 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info gem-joint)))) + ) + (birth-pickup-at-point a0-18 (pickup-type gem) 1.0 #t *entity-pool* (-> obj fact-info-override)) + ) + ) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-active checking-water)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag check-water)) + (logclear! (-> obj mask) (process-mask collectable)) + (logclear! (-> obj enemy-flags) (enemy-flag look-at-move-dest)) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj enemy-flags) (enemy-flag notice)) + (logior! (-> obj focus-status) (focus-status dead)) + (if (-> obj skel effect) + (logior! (-> obj skel effect flags) (effect-control-flag ecf1)) + ) + (enemy-method-110 obj) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate die (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-132 self) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + ) + 0 + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self hit-points) 0) + (enemy-method-103 self) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.075)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info die-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info die-anim))) frames num-frames) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + (none) + ) + :post enemy-simple-post + ) + +;; definition for method 133 of type enemy +(defmethod enemy-method-133 enemy ((obj enemy)) + (let ((s5-0 (-> obj root-override2)) + (a1-0 (new 'stack-no-clear 'collide-query)) + (gp-0 #t) + ) + (when (find-ground s5-0 a1-0 (-> obj enemy-info recover-gnd-collide-with) 8192.0 81920.0 1024.0) + (if (< (- (-> s5-0 trans y) (-> s5-0 gspot-pos y)) 8192.0) + (set! gp-0 #f) + ) + ) + gp-0 + ) + ) + +;; failed to figure out what this is: +(defstate die-falling (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (enemy-method-132 self) + (let ((v1-3 (-> self root-override2 root-prim))) + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + ) + 0 + (set! (-> self hit-points) 0) + (if (logtest? (enemy-option knocked-into-water) (-> self fact-info-override enemy-options)) + (set! (-> self enemy-flags) (logior (enemy-flag trackable-backup) (-> self enemy-flags))) + ) + (enemy-method-103 self) + (none) + ) + :exit (behavior () + (local-vars (v0-0 enemy-flag)) + (let ((v1-0 (-> self enemy-flags))) + (if (logtest? (enemy-flag enable-on-hostile) v1-0) + (set! v0-0 (logior (enemy-flag trackable-backup) v1-0)) + (set! v0-0 (logclear v1-0 (enemy-flag trackable-backup))) + ) + ) + (set! (-> self enemy-flags) v0-0) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((gp-0 (-> self draw art-group data (if (enemy-method-133 self) + (-> self enemy-info die-falling-anim) + (-> self enemy-info die-anim) + ) + ) + ) + (f30-0 (get-rand-float-range self 0.8 1.2)) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (send-event self 'death-end) + (while (-> self child) + (suspend) + ) + (cleanup-for-death self) + (none) + ) + :post enemy-die-falling-post + ) + +;; failed to figure out what this is: +(defstate directed (enemy) + :virtual #t + :event enemy-event-handler + :enter (behavior () + (set! (-> self enemy-flags) (logior (enemy-flag victory) (-> self enemy-flags))) + ((-> (method-of-type enemy idle) enter)) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag victory)) + (none) + ) + :code (-> (method-of-type enemy idle) code) + :post (-> (method-of-type enemy idle) post) + ) + +;; failed to figure out what this is: +(defstate die-fast (enemy) + :virtual #t + :code (the-as (function none :behavior enemy) nothing) + ) + +;; failed to figure out what this is: +(defstate view-anims (enemy) + :virtual #t + :enter (behavior () + '() + (none) + ) + :trans (behavior () + '() + (none) + ) + :code (behavior () + (let ((gp-0 (-> self draw art-group))) + (until #f + (dotimes (s5-0 (-> gp-0 length)) + (let ((s4-0 (-> gp-0 data s5-0))) + (when (and s4-0 (= (-> s4-0 type) art-joint-anim)) + (ja-channel-set! 1) + (ja-no-eval :group! s4-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + ) + ) + ) + ) + ) + #f + (none) + ) + :post (the-as (function none :behavior enemy) transform-post) + ) + +;; definition for function ja-group-index? +(defbehavior ja-group-index? enemy ((arg0 int)) + (ja-group? (-> self draw art-group data arg0)) + ) diff --git a/test/decompiler/reference/jak2/engine/camera/cam-layout_REF.gc b/test/decompiler/reference/jak2/engine/camera/cam-layout_REF.gc index e471583851..9e854a2dcb 100644 --- a/test/decompiler/reference/jak2/engine/camera/cam-layout_REF.gc +++ b/test/decompiler/reference/jak2/engine/camera/cam-layout_REF.gc @@ -1,9 +1,13 @@ +;;-*-Lisp-*- (in-package goal) +;; this file is debug only (declare-file (debug)) (when *debug-segment* +;; definition for symbol *camera-layout-blink*, type symbol (define *camera-layout-blink* #f) +;; definition of type cam-layout-bank (deftype cam-layout-bank (basic) ((spline-t float :offset-assert 4) (spline-step float :offset-assert 8) @@ -17,6 +21,7 @@ :flag-assert #x90000001c ) +;; definition for method 3 of type cam-layout-bank (defmethod inspect cam-layout-bank ((obj cam-layout-bank)) (when (not obj) (set! obj obj) @@ -33,6 +38,7 @@ obj ) +;; definition for symbol *CAM_LAYOUT-bank*, type cam-layout-bank (define *CAM_LAYOUT-bank* (new 'static 'cam-layout-bank :spline-t 0.01 :spline-step 0.0016666667 @@ -43,8 +49,10 @@ ) ) +;; definition for symbol *camera-layout-message-ypos*, type int (define *camera-layout-message-ypos* 30) +;; definition of type clm-basic (deftype clm-basic (basic) () :method-count-assert 9 @@ -52,6 +60,7 @@ :flag-assert #x900000004 ) +;; definition for method 3 of type clm-basic (defmethod inspect clm-basic ((obj clm-basic)) (when (not obj) (set! obj obj) @@ -62,6 +71,7 @@ obj ) +;; definition of type clm-item-action (deftype clm-item-action (structure) ((button uint64 :offset-assert 0) (options uint64 :offset-assert 8) @@ -77,6 +87,7 @@ :flag-assert #x90000001c ) +;; definition for method 3 of type clm-item-action (defmethod inspect clm-item-action ((obj clm-item-action)) (when (not obj) (set! obj obj) @@ -92,6 +103,7 @@ obj ) +;; definition of type clm-item (deftype clm-item (clm-basic) ((description string :offset-assert 4) (button-symbol symbol :offset-assert 8) @@ -102,6 +114,7 @@ :flag-assert #x90000002c ) +;; definition for method 3 of type clm-item (defmethod inspect clm-item ((obj clm-item)) (when (not obj) (set! obj obj) @@ -115,6 +128,7 @@ obj ) +;; definition of type clm-list-item (deftype clm-list-item (basic) ((description string :offset-assert 4) (track-val symbol :offset-assert 8) @@ -131,6 +145,7 @@ :flag-assert #x90000001c ) +;; definition for method 3 of type clm-list-item (defmethod inspect clm-list-item ((obj clm-list-item)) (when (not obj) (set! obj obj) @@ -147,6 +162,7 @@ obj ) +;; definition of type clm-list (deftype clm-list (clm-basic) ((tracker symbol :offset-assert 4) (cur-list-item int32 :offset-assert 8) @@ -157,6 +173,7 @@ :flag-assert #x900000010 ) +;; definition for method 3 of type clm-list (defmethod inspect clm-list ((obj clm-list)) (when (not obj) (set! obj obj) @@ -170,6 +187,7 @@ obj ) +;; definition of type clm (deftype clm (basic) ((title string :offset-assert 4) (items (array clm-basic) :offset-assert 8) @@ -179,6 +197,7 @@ :flag-assert #x90000000c ) +;; definition for method 3 of type clm (defmethod inspect clm ((obj clm)) (when (not obj) (set! obj obj) @@ -191,14 +210,19 @@ obj ) +;; definition for symbol *volume-point-current*, type int (define *volume-point-current* 0) +;; definition for symbol *volume-point*, type vector-array (define *volume-point* (new 'debug 'vector-array 1000)) +;; definition for symbol *volume-normal-current*, type int (define *volume-normal-current* 0) +;; definition for symbol *volume-normal*, type vector-array (define *volume-normal* (new 'debug 'vector-array 600)) +;; definition of type volume-descriptor-array (deftype volume-descriptor-array (inline-array-class) ((data plane-volume :inline :dynamic :offset 16) ) @@ -207,6 +231,7 @@ :flag-assert #x900000010 ) +;; definition for method 3 of type volume-descriptor-array (defmethod inspect volume-descriptor-array ((obj volume-descriptor-array)) (when (not obj) (set! obj obj) @@ -220,12 +245,16 @@ obj ) +;; failed to figure out what this is: (set! (-> volume-descriptor-array heap-base) (the-as uint 24)) +;; definition for symbol *volume-descriptor-current*, type int (define *volume-descriptor-current* 0) +;; definition for symbol *volume-descriptor*, type vol-control (define *volume-descriptor* (the-as vol-control (new 'debug 'volume-descriptor-array 100))) +;; definition of type cam-layout (deftype cam-layout (process) ((cam-entity entity-camera :offset-assert 128) (num-entities int32 :offset-assert 132) @@ -245,6 +274,7 @@ ) ) +;; definition for method 3 of type cam-layout (defmethod inspect cam-layout ((obj cam-layout)) (when (not obj) (set! obj obj) @@ -265,6 +295,9 @@ obj ) +;; definition for function cam-layout-print +;; WARN: Failed store: (s.w! (+ v1-6 8) 0) at op 22 +;; WARN: Failed store: (s.w! (+ v1-6 12) 0) at op 23 (defun cam-layout-print ((arg0 int) (arg1 int) (arg2 string)) (with-dma-buffer-add-bucket ((s5-0 (-> *display* frames (-> *display* on-screen) debug-buf)) (bucket-id debug2) @@ -273,6 +306,7 @@ ) ) +;; definition for function cam-layout-intersect-dist (defun cam-layout-intersect-dist ((arg0 vector) (arg1 vector) (arg2 vector)) (let ((f0-1 (vector-dot arg1 arg0)) (f1-1 (vector-dot arg2 arg0)) @@ -284,6 +318,44 @@ ) ) +;; definition for function cam-layout-entity-volume-info-create +;; INFO: Used lq/sq +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: Stack slot offset 164 signed mismatch +;; WARN: new jak 2 until loop case, check carefully (defbehavior cam-layout-entity-volume-info-create cam-layout ((arg0 entity-camera) (arg1 symbol)) (local-vars (sv-16 res-tag) @@ -460,6 +532,7 @@ #f ) +;; definition for function cam-layout-entity-volume-info (defbehavior cam-layout-entity-volume-info cam-layout () (dotimes (gp-0 (-> self num-volumes)) (cond @@ -505,6 +578,8 @@ #f ) +;; definition for function v-slrp! +;; INFO: Used lq/sq (defun v-slrp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) (let ((s2-0 (new-stack-vector0)) (s1-0 (new-stack-vector0)) @@ -534,6 +609,7 @@ ) ) +;; definition of type interp-test-info (deftype interp-test-info (structure) ((from vector :inline :offset-assert 0) (to vector :inline :offset-assert 16) @@ -547,6 +623,7 @@ :flag-assert #x90000003c ) +;; definition for method 3 of type interp-test-info (defmethod inspect interp-test-info ((obj interp-test-info)) (when (not obj) (set! obj obj) @@ -563,6 +640,8 @@ obj ) +;; definition for function interp-test +;; INFO: Used lq/sq (defun interp-test ((arg0 (function vector vector vector float vector float none)) (arg1 interp-test-info)) (let ((s3-0 (new-stack-vector0)) (s5-0 (new-stack-vector0)) @@ -584,6 +663,8 @@ (none) ) +;; definition for function interp-test-deg +;; INFO: Used lq/sq (defun interp-test-deg ((arg0 (function vector vector vector vector float none)) (arg1 interp-test-info)) (let ((s3-0 (new-stack-vector0)) (s5-0 (new-stack-vector0)) @@ -605,6 +686,9 @@ (none) ) +;; definition for function cam-layout-entity-info +;; INFO: Used lq/sq +;; WARN: Function cam-layout-entity-info has a return type of none, but the expression builder found a return statement. (defun cam-layout-entity-info ((arg0 entity-actor)) (if (not arg0) (return #f) @@ -865,6 +949,7 @@ (none) ) +;; definition for function clmf-button-test (defun clmf-button-test () "Displays the message `button test`" (cam-layout-print 16 *camera-layout-message-ypos* "button test") @@ -873,6 +958,7 @@ #f ) +;; definition for function clmf-bna (defun clmf-bna () "Displays the message `button not available`" (cam-layout-print 16 *camera-layout-message-ypos* "button not applicable") @@ -881,6 +967,7 @@ #t ) +;; definition for function clmf-implement (defun clmf-implement () "Displays the message `button not implemented yet`" (cam-layout-print 16 *camera-layout-message-ypos* "button not implemented yet") @@ -889,6 +976,8 @@ #t ) +;; definition for function clmf-input +;; INFO: Used lq/sq (defun clmf-input ((arg0 vector) (arg1 vector) (arg2 int)) (vector-reset! arg0) (vector-reset! arg1) @@ -935,6 +1024,8 @@ arg1 ) +;; definition for function clmf-pos-rot +;; INFO: Used lq/sq (defbehavior clmf-pos-rot cam-layout ((arg0 symbol) (arg1 symbol)) (local-vars (s2-0 structure) (s3-1 vector) (sv-192 matrix)) (cam-layout-print 16 *camera-layout-message-ypos* "x/z pos: left stick, down: l1, up: r1") @@ -1043,6 +1134,7 @@ #t ) +;; definition for function clmf-next-volume (defbehavior clmf-next-volume cam-layout ((arg0 int)) (if (zero? (-> self num-volumes)) (return #f) @@ -1054,6 +1146,7 @@ #t ) +;; definition for function clmf-next-vol-dpad (defun clmf-next-vol-dpad () (local-vars (a0-1 int)) (cam-layout-print 16 *camera-layout-message-ypos* "dpad selects volume") @@ -1080,14 +1173,17 @@ #t ) +;; definition for function clmf-to-edit-cam (defun clmf-to-edit-cam () (clmf-next-volume 0) (set! *clm* *clm-edit*) #t ) +;; definition for symbol *last-cur-entity*, type int (define *last-cur-entity* -1) +;; definition for function clmf-next-entity (defbehavior clmf-next-entity cam-layout ((arg0 int)) (let ((v1-0 (/ arg0 8))) (when (zero? (-> self num-entities)) @@ -1142,38 +1238,46 @@ #t ) +;; definition for function clmf-to-spline-attr (defun clmf-to-spline-attr () (set! *clm* *clm-spline-attr*) #t ) +;; definition for function clmf-to-intro-attr (defun clmf-to-intro-attr () (set! *clm* *clm-intro-attr*) #t ) +;; definition for function clmf-to-index-attr (defun clmf-to-index-attr () (set! *clm* *clm-index-attr*) #t ) +;; definition for function clmf-to-focalpull-attr (defun clmf-to-focalpull-attr () (set! *clm* *clm-focalpull-attr*) #t ) +;; definition for function clmf-to-edit (defbehavior clmf-to-edit cam-layout () (set! (-> self res-key) -1000000000.0) (set! *clm* *clm-edit*) #t ) +;; definition for function clmf-to-select (defun clmf-to-select () (set! *camera-layout-blink* #f) (set! *clm* *clm-select*) #t ) +;; definition for function clmf-look-through +;; INFO: Used lq/sq (defbehavior clmf-look-through cam-layout () (set! (-> *camera-other-fov* data) (cam-slave-get-fov (-> self cam-entity))) (cam-slave-get-vector-with-offset (the-as entity-actor (-> self cam-entity)) *camera-other-trans* 'trans) @@ -1184,6 +1288,7 @@ #f ) +;; definition for function fov->maya (defun fov->maya ((arg0 float)) (if (= arg0 0.0) 0.0 @@ -1191,6 +1296,8 @@ ) ) +;; definition for function cam-layout-save-cam-rot +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-cam-rot ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s3-0 (-> arg2 quat)) (s5-0 (res-lump-struct arg2 'rot-offset vector)) @@ -1215,6 +1322,9 @@ (none) ) +;; definition for function cam-layout-save-cam-trans +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-cam-trans ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s1-0 (-> arg2 trans)) (s5-0 (method-of-type res-lump get-property-struct)) @@ -1284,6 +1394,9 @@ (none) ) +;; definition for function cam-layout-save-pivot +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-pivot ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s2-0 (res-lump-struct arg2 'pivot vector)) (s4-0 (method-of-type res-lump get-property-struct)) @@ -1329,6 +1442,9 @@ (none) ) +;; definition for function cam-layout-save-align +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-align ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s2-0 (res-lump-struct arg2 'align vector)) (s4-0 (method-of-type res-lump get-property-struct)) @@ -1374,6 +1490,9 @@ (none) ) +;; definition for function cam-layout-save-interesting +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-interesting ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s2-0 (res-lump-struct arg2 'interesting vector)) (s4-0 (method-of-type res-lump get-property-struct)) @@ -1419,6 +1538,8 @@ (none) ) +;; definition for function cam-layout-save-fov +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-fov ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f28-0 (res-lump-float arg2 'fov)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1458,6 +1579,8 @@ (none) ) +;; definition for function cam-layout-save-focalpull +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-focalpull ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'focalPull)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1489,6 +1612,8 @@ (none) ) +;; definition for function cam-layout-save-flags +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s4-0 (res-lump-value arg2 'flags uint128 :time -1000000000.0)) (s5-0 (method-of-type res-lump get-property-value)) @@ -1543,6 +1668,8 @@ (none) ) +;; definition for function cam-layout-save-focalpull-flags +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-focalpull-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s4-0 (res-lump-value arg2 'focalpull-flags uint128 :time -1000000000.0)) (s5-0 (method-of-type res-lump get-property-value)) @@ -1597,6 +1724,8 @@ (none) ) +;; definition for function cam-layout-save-campoints-flags +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-campoints-flags ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s4-0 (res-lump-value arg2 'campoints-flags uint128 :time -1000000000.0)) (s5-0 (method-of-type res-lump get-property-value)) @@ -1651,6 +1780,8 @@ (none) ) +;; definition for function cam-layout-save-introsplinetime +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-introsplinetime ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f28-0 (res-lump-float arg2 'intro-time)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1690,6 +1821,8 @@ (none) ) +;; definition for function cam-layout-save-introsplineexitval +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-introsplineexitval ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'intro-exitValue)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1724,6 +1857,8 @@ (none) ) +;; definition for function cam-layout-save-interptime +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-interptime ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'interpTime)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1755,6 +1890,8 @@ (none) ) +;; definition for function cam-layout-save-splineoffset +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-splineoffset ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (when (and (not (res-lump-struct arg2 'pivot structure)) (res-lump-struct arg2 'spline-offset structure)) (let ((s5-1 (res-lump-struct arg2 'spline-offset vector))) @@ -1775,6 +1912,8 @@ (none) ) +;; definition for function cam-layout-save-spline-follow-dist-offset +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-spline-follow-dist-offset ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'spline-follow-dist-offset))) (when (the int f30-0) @@ -1787,6 +1926,8 @@ (none) ) +;; definition for function cam-layout-save-campointsoffset +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-campointsoffset ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((s5-0 (res-lump-struct arg2 'campoints-offset vector))) (when s5-0 @@ -1805,6 +1946,8 @@ (none) ) +;; definition for function cam-layout-save-tiltAdjust +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-tiltAdjust ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'tiltAdjust)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1836,6 +1979,8 @@ (none) ) +;; definition for function cam-layout-save-stringMinLength +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-stringMinLength ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'stringMinLength)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1867,6 +2012,8 @@ (none) ) +;; definition for function cam-layout-save-stringMaxLength +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-stringMaxLength ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'stringMaxLength)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1898,6 +2045,8 @@ (none) ) +;; definition for function cam-layout-save-stringMinHeight +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-stringMinHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'stringMinHeight)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1929,6 +2078,8 @@ (none) ) +;; definition for function cam-layout-save-stringMaxHeight +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-stringMaxHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'stringMaxHeight)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1960,6 +2111,8 @@ (none) ) +;; definition for function cam-layout-save-stringCliffHeight +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-stringCliffHeight ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'stringCliffHeight)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -1991,6 +2144,8 @@ (none) ) +;; definition for function cam-layout-save-maxAngle +;; WARN: Return type mismatch object vs none. (defun cam-layout-save-maxAngle ((arg0 symbol) (arg1 string) (arg2 entity-actor)) (let ((f30-0 (res-lump-float arg2 'maxAngle)) (s3-0 (method-of-type res-lump get-property-value-float)) @@ -2022,6 +2177,7 @@ (none) ) +;; definition for function clmf-save-single (defbehavior clmf-save-single cam-layout ((arg0 entity-camera) (arg1 symbol) (arg2 symbol)) (clear *temp-string*) (if arg2 @@ -2062,6 +2218,7 @@ ) ) +;; definition for function clmf-save-one (defbehavior clmf-save-one cam-layout ((arg0 symbol)) (let ((s5-1 (logtest? (the-as int arg0) 8)) (gp-1 (logtest? (the-as int arg0) 16)) @@ -2080,6 +2237,7 @@ #t ) +;; definition for function clmf-save-all (defbehavior clmf-save-all cam-layout ((arg0 symbol)) (let ((s5-1 (logtest? (the-as int arg0) 8)) (gp-1 (logtest? (the-as int arg0) 16)) @@ -2110,6 +2268,7 @@ #t ) +;; definition of type clmf-cam-flag-toggle-info (deftype clmf-cam-flag-toggle-info (structure) ((key float :offset-assert 0) (force-on int32 :offset-assert 4) @@ -2120,6 +2279,7 @@ :flag-assert #x90000000c ) +;; definition for method 3 of type clmf-cam-flag-toggle-info (defmethod inspect clmf-cam-flag-toggle-info ((obj clmf-cam-flag-toggle-info)) (when (not obj) (set! obj obj) @@ -2133,6 +2293,7 @@ obj ) +;; definition for function clmf-cam-flag-toggle (defbehavior clmf-cam-flag-toggle cam-layout ((arg0 int) (arg1 int)) (let ((s4-0 (/ arg0 8)) (gp-0 (new 'stack 'clmf-cam-flag-toggle-info)) @@ -2256,6 +2417,7 @@ #t ) +;; definition for function clmf-cam-flag (defbehavior clmf-cam-flag cam-layout ((arg0 string) (arg1 uint) (arg2 uint)) (let ((s5-0 (/ (the-as int arg1) 8)) (f30-0 (-> self res-key)) @@ -2329,6 +2491,7 @@ #t ) +;; definition for function clmf-cam-float-adjust (defbehavior clmf-cam-float-adjust cam-layout ((arg0 symbol) (arg1 (pointer float))) (cam-layout-print 16 *camera-layout-message-ypos* "left stick adjusts value") (set! *camera-layout-message-ypos* (+ *camera-layout-message-ypos* 14)) @@ -2354,6 +2517,7 @@ #t ) +;; definition for function clmf-cam-meters (defbehavior clmf-cam-meters cam-layout ((arg0 meters) (arg1 symbol)) (let ((f0-0 (cam-slave-get-float (-> self cam-entity) arg1 0.0))) (format arg0 ": ~M" f0-0) @@ -2361,16 +2525,19 @@ #t ) +;; definition for function clmf-cam-fov (defbehavior clmf-cam-fov cam-layout ((arg0 degrees) (arg1 symbol)) (format arg0 ": ~R" (cam-slave-get-fov (-> self cam-entity))) #t ) +;; definition for function clmf-cam-deg (defbehavior clmf-cam-deg cam-layout ((arg0 degrees) (arg1 symbol)) (format arg0 ": ~R" (cam-slave-get-float (-> self cam-entity) arg1 0.0)) #t ) +;; definition for function clmf-cam-intro-time (defbehavior clmf-cam-intro-time cam-layout ((arg0 float) (arg1 symbol)) (let ((f30-0 (cam-slave-get-intro-step (-> self cam-entity)))) (format arg0 ": ~f" (/ 0.016666668 f30-0)) @@ -2379,16 +2546,20 @@ #t ) +;; definition for function clmf-cam-interp-time (defbehavior clmf-cam-interp-time cam-layout ((arg0 float) (arg1 symbol)) (format arg0 ": ~f" (cam-slave-get-interp-time (-> self cam-entity))) #t ) +;; definition for function clmf-cam-float (defbehavior clmf-cam-float cam-layout ((arg0 float) (arg1 symbol)) (format arg0 ": ~f" (cam-slave-get-float (-> self cam-entity) arg1 0.0)) #t ) +;; definition for function clmf-cam-string +;; INFO: Used lq/sq (defbehavior clmf-cam-string cam-layout ((arg0 string) (arg1 symbol)) (local-vars (r0-0 uint128) (v1-5 uint128) (sv-16 int)) (format arg0 ":") @@ -2411,6 +2582,7 @@ #t ) +;; definition for symbol *clm-focalpull-attr*, type clm (define *clm-focalpull-attr* (new 'static 'clm :title "---focalpull attributes--" @@ -2465,6 +2637,7 @@ ) ) +;; definition for symbol *clm-index-attr*, type clm (define *clm-index-attr* (new 'static 'clm :title "---index attributes--" @@ -2519,6 +2692,7 @@ ) ) +;; definition for symbol *clm-intro-attr*, type clm (define *clm-intro-attr* (new 'static 'clm :title "---intro attributes--" @@ -2569,6 +2743,7 @@ ) ) +;; definition for symbol *clm-spline-attr*, type clm (define *clm-spline-attr* (new 'static 'clm :title "---spline attributes--" @@ -2605,6 +2780,7 @@ ) ) +;; definition for symbol *clm-cam-attr*, type clm (define *clm-cam-attr* (new 'static 'clm :title "---camera attributes--" @@ -2906,6 +3082,7 @@ ) ) +;; definition for symbol *clm-cam-lookthrough*, type clm (define *clm-cam-lookthrough* (new 'static 'clm :title "---cam-lookthrough---" @@ -2958,6 +3135,7 @@ ) ) +;; definition for symbol *clm-edit*, type clm (define *clm-edit* (new 'static 'clm :title "---edit---" @@ -3089,6 +3267,7 @@ ) ) +;; definition for symbol *clm-save-all*, type clm (define *clm-save-all* (new 'static 'clm :title "---save all?---" @@ -3112,6 +3291,7 @@ ) ) +;; definition for symbol *clm-save-one*, type clm (define *clm-save-one* (new 'static 'clm :title "---single save?---" @@ -3135,6 +3315,7 @@ ) ) +;; definition for symbol *clm-select*, type clm (define *clm-select* (new 'static 'clm :title "---camera---" @@ -3178,8 +3359,10 @@ ) ) +;; definition for symbol *clm*, type clm (define *clm* *clm-select*) +;; definition for function cam-layout-do-action (defbehavior cam-layout-do-action cam-layout ((arg0 clm-item-action)) (let ((s5-0 (-> arg0 func value))) (cond @@ -3224,6 +3407,7 @@ ) ) +;; definition for function cam-layout-function-call (defbehavior cam-layout-function-call cam-layout ((arg0 symbol) (arg1 string) (arg2 int) (arg3 basic)) (let ((gp-0 (-> arg0 value))) (cond @@ -3239,6 +3423,7 @@ #f ) +;; definition for function cam-layout-do-menu (defbehavior cam-layout-do-menu cam-layout ((arg0 clm)) (set! *camera-layout-message-ypos* 30) (+! (-> *CAM_LAYOUT-bank* spline-t) (-> *CAM_LAYOUT-bank* spline-step)) @@ -3384,6 +3569,7 @@ #f ) +;; failed to figure out what this is: (defstate cam-layout-active (cam-layout) :code (behavior () (until #f @@ -3396,6 +3582,7 @@ ) ) +;; definition for function cam-layout-init (defbehavior cam-layout-init cam-layout () (set! (-> self res-key) -1000000000.0) (set! (-> self num-entities) 0) @@ -3417,11 +3604,13 @@ (go cam-layout-active) ) +;; definition for function cam-layout-stop (defun cam-layout-stop () (set! *cam-layout* #f) (kill-by-name "cam-layout" *active-pool*) ) +;; definition for function cam-layout-start (defun cam-layout-start () (let ((a0-1 (new 'global 'file-stream "dd_next/caminfo/garbage" 'read))) (file-stream-close a0-1) @@ -3448,6 +3637,7 @@ *cam-layout* ) +;; definition for function cam-layout-restart (defun cam-layout-restart () (cam-layout-stop) (cam-layout-start) diff --git a/test/decompiler/reference/jak2/engine/game/fact-h_REF.gc b/test/decompiler/reference/jak2/engine/game/fact-h_REF.gc index acc80b3148..2e2371b842 100644 --- a/test/decompiler/reference/jak2/engine/game/fact-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/game/fact-h_REF.gc @@ -1,5 +1,7 @@ +;;-*-Lisp-*- (in-package goal) +;; definition of type fact-bank (deftype fact-bank (basic) ((eco-level-max float :offset-assert 4) (eco-single-inc float :offset-assert 8) @@ -41,6 +43,7 @@ :flag-assert #x9000000a0 ) +;; definition for method 3 of type fact-bank (defmethod inspect fact-bank ((obj fact-bank)) (when (not obj) (set! obj obj) @@ -85,6 +88,7 @@ obj ) +;; 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 @@ -121,6 +125,7 @@ ) ) +;; definition for function pickup-type->string (defun pickup-type->string ((arg0 pickup-type)) (case arg0 (((pickup-type eco-pill-dark)) @@ -231,6 +236,7 @@ ) ) +;; definition of type fact-info (deftype fact-info (basic) ((process process :offset-assert 4) (pickup-type pickup-type :offset-assert 8) @@ -250,6 +256,7 @@ ) ) +;; definition for method 3 of type fact-info (defmethod inspect fact-info ((obj fact-info)) (when (not obj) (set! obj obj) @@ -467,6 +474,7 @@ obj ) +;; definition of type fact-info-target (deftype fact-info-target (fact-info) ((eco-type int32 :offset-assert 40) (eco-level float :offset-assert 44) @@ -512,6 +520,7 @@ ) ) +;; definition for method 3 of type fact-info-target (defmethod inspect fact-info-target ((obj fact-info-target)) (when (not obj) (set! obj obj) @@ -763,19 +772,20 @@ obj ) +;; definition of type fact-info-enemy (deftype fact-info-enemy (fact-info) - ((speed float :offset-assert 40) - (idle-distance meters :offset-assert 44) - (notice-top meters :offset-assert 48) - (notice-bottom meters :offset-assert 52) - (cam-horz meters :offset-assert 56) - (cam-vert meters :offset-assert 60) - (cam-notice-dist meters :offset-assert 64) - (enemy-options enemy-option :offset-assert 68) - (trig-dist meters :offset-assert 72) - (trig-actor-group uint32 :offset-assert 76) - (trig-mask-count int8 :offset-assert 80) - (trig-mask uint8 2 :offset-assert 81) + ((speed float :offset-assert 40) + (idle-distance meters :offset-assert 44) + (notice-top meters :offset-assert 48) + (notice-bottom meters :offset-assert 52) + (cam-horz meters :offset-assert 56) + (cam-vert meters :offset-assert 60) + (cam-notice-dist meters :offset-assert 64) + (enemy-options enemy-option :offset-assert 68) + (trig-dist meters :offset-assert 72) + (trig-actor-group (pointer actor-group) :offset-assert 76) + (trig-mask-count int8 :offset-assert 80) + (trig-mask uint8 2 :offset-assert 81) ) :method-count-assert 13 :size-assert #x53 @@ -786,6 +796,7 @@ ) ) +;; definition for method 3 of type fact-info-enemy (defmethod inspect fact-info-enemy ((obj fact-info-enemy)) (when (not obj) (set! obj obj) @@ -1096,6 +1107,7 @@ obj ) +;; definition of type fact-info-crate (deftype fact-info-crate (fact-info) ((suck-count int32 :offset-assert 40) ) @@ -1107,6 +1119,7 @@ ) ) +;; definition for method 3 of type fact-info-crate (defmethod inspect fact-info-crate ((obj fact-info-crate)) (when (not obj) (set! obj obj) @@ -1325,6 +1338,9 @@ obj ) +;; 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)) (local-vars (sv-16 fact-info) (sv-20 res-lump) (sv-24 task-mask)) (set! sv-16 (object-new allocation type-to-make (the-as int (-> type-to-make size)))) @@ -1373,10 +1389,12 @@ (the-as fact-info sv-16) ) +;; definition for method 11 of type fact-info (defmethod pickup-collectable! fact-info ((obj 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 :offset-assert 4) ) @@ -1385,6 +1403,7 @@ :flag-assert #x900000008 ) +;; definition for method 3 of type fact-info-enemy-defaults (defmethod inspect fact-info-enemy-defaults ((obj fact-info-enemy-defaults)) (when (not obj) (set! obj obj) @@ -1396,8 +1415,11 @@ obj ) +;; 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))) +;; 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) @@ -1444,7 +1466,7 @@ (set! sv-32 (new 'static 'res-tag)) (let ((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 uint v1-20)) + (set! (-> gp-0 trig-actor-group) (the-as (pointer actor-group) v1-20)) (clear-mask-bits gp-0 2) ) ) @@ -1455,6 +1477,8 @@ ) ) +;; definition for method 12 of type fact-info-enemy +;; WARN: Return type mismatch int vs none. (defmethod clear-mask-bits fact-info-enemy ((obj fact-info-enemy) (arg0 int)) (let ((v1-0 (lognot arg0))) (dotimes (a1-1 (-> obj trig-mask-count)) @@ -1465,6 +1489,7 @@ (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 (the-as res-lump (-> gp-0 process entity)))) @@ -1474,6 +1499,7 @@ ) ) +;; definition for method 0 of type fact-info-target (defmethod new fact-info-target ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 pickup-type) (arg2 float)) (let ((gp-0 (the-as fact-info-target ((method-of-type fact-info new) allocation type-to-make arg0 arg1 arg2)))) (set! (-> gp-0 eco-source) (the-as handle #f)) diff --git a/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc index 7e32a619d8..c3316c154e 100644 --- a/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc +++ b/test/decompiler/reference/jak2/engine/gfx/tfrag/tfrag-near_REF.gc @@ -70,7 +70,3 @@ ) (none) ) - - - - diff --git a/test/decompiler/reference/jak2/engine/nav/nav-enemy-h_REF.gc b/test/decompiler/reference/jak2/engine/nav/nav-enemy-h_REF.gc index 188577c19b..af363844ca 100644 --- a/test/decompiler/reference/jak2/engine/nav/nav-enemy-h_REF.gc +++ b/test/decompiler/reference/jak2/engine/nav/nav-enemy-h_REF.gc @@ -1,12 +1,14 @@ +;;-*-Lisp-*- (in-package goal) +;; definition of type nav-enemy-info (deftype nav-enemy-info (enemy-info) ((callback-info nav-callback-info :offset-assert 384) (use-momentum symbol :offset-assert 388) - (use-frustration basic :offset-assert 392) - (use-stop-chase basic :offset-assert 396) - (use-circling basic :offset-assert 400) - (use-pacing basic :offset-assert 404) + (use-frustration symbol :offset-assert 392) + (use-stop-chase symbol :offset-assert 396) + (use-circling symbol :offset-assert 400) + (use-pacing symbol :offset-assert 404) (walk-anim int32 :offset-assert 408) (turn-anim int32 :offset-assert 412) (run-anim int32 :offset-assert 416) @@ -24,7 +26,7 @@ (blocked-time time-frame :offset-assert 472) (circle-dist-lo float :offset-assert 480) (circle-dist-hi float :offset-assert 484) - (nav-mesh basic :offset-assert 488) + (nav-mesh nav-mesh :offset-assert 488) ) :method-count-assert 11 :size-assert #x1ec @@ -34,6 +36,8 @@ ) ) +;; definition for method 3 of type nav-enemy-info +;; INFO: Used lq/sq (defmethod inspect nav-enemy-info ((obj nav-enemy-info)) (when (not obj) (set! obj obj) @@ -149,6 +153,7 @@ obj ) +;; definition of type nav-enemy (deftype nav-enemy (enemy) ((enemy-info-override nav-enemy-info :offset 216) (frustration-point vector :inline :offset-assert 544) @@ -191,7 +196,7 @@ (nav-enemy-method-160 (_type_) none 160) (nav-enemy-method-161 (_type_) none 161) (nav-enemy-method-162 (_type_) none 162) - (nav-enemy-method-163 (_type_) none 163) + (nav-enemy-method-163 (_type_) symbol 163) (nav-enemy-method-164 (_type_) none 164) (nav-enemy-method-165 (_type_) none 165) (nav-enemy-method-166 (_type_) none 166) @@ -209,6 +214,7 @@ ) ) +;; definition for method 3 of type nav-enemy (defmethod inspect nav-enemy ((obj nav-enemy)) (when (not obj) (set! obj obj) @@ -228,6 +234,7 @@ obj ) +;; definition of type nav-enemy-debug-control-info (deftype nav-enemy-debug-control-info (basic) ((enable basic :offset-assert 4) (steering float :offset-assert 8) @@ -238,6 +245,7 @@ :flag-assert #x900000010 ) +;; definition for method 3 of type nav-enemy-debug-control-info (defmethod inspect nav-enemy-debug-control-info ((obj nav-enemy-debug-control-info)) (when (not obj) (set! obj obj) @@ -251,4 +259,5 @@ obj ) +;; failed to figure out what this is: 0 diff --git a/test/decompiler/reference/jak2/engine/target/gun/gun-part_REF.gc b/test/decompiler/reference/jak2/engine/target/gun/gun-part_REF.gc index fe4ce2ca79..123360754a 100644 --- a/test/decompiler/reference/jak2/engine/target/gun/gun-part_REF.gc +++ b/test/decompiler/reference/jak2/engine/target/gun/gun-part_REF.gc @@ -1825,7 +1825,3 @@ (sp-cpuinfo-flags sp-cpuinfo-flag-2) ) ) - - - - diff --git a/test/decompiler/reference/jak2/levels/common/flitter_REF.gc b/test/decompiler/reference/jak2/levels/common/flitter_REF.gc new file mode 100644 index 0000000000..ec67574dbd --- /dev/null +++ b/test/decompiler/reference/jak2/levels/common/flitter_REF.gc @@ -0,0 +1,1515 @@ +;;-*-Lisp-*- +(in-package goal) + +;; failed to figure out what this is: +(defpartgroup group-flitter-dust-puff + :id 144 + :duration (seconds 0.017) + :flags (use-local-clock) + :bounds (static-bspherem 0 0 0 8) + :parts ((sp-item 641)) + ) + +;; failed to figure out what this is: +(defpart 641 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-flt spt-num 6.0) + (sp-rnd-flt spt-scale-x (meters 0.6) (meters 0.4) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-copy-from-other spt-scale-y -4) + (sp-rnd-flt spt-r 32.0 8.0 1.0) + (sp-rnd-flt spt-g 16.0 8.0 1.0) + (sp-rnd-flt spt-b 16.0 8.0 1.0) + (sp-rnd-flt spt-a 32.0 32.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.01) (meters 0.0026666666) 1.0) + (sp-flt spt-scalevel-x (meters 0.0016666667)) + (sp-rnd-flt spt-rotvel-z (degrees -0.2) (degrees 0.4) 1.0) + (sp-copy-from-other spt-scalevel-y -4) + (sp-flt spt-fade-r -0.35555556) + (sp-flt spt-fade-g -0.35555556) + (sp-flt spt-fade-b -0.35555556) + (sp-flt spt-fade-a -0.30476192) + (sp-flt spt-accel-y -1.3653333) + (sp-int spt-timer 120) + (sp-cpuinfo-flags sp-cpuinfo-flag-2) + (sp-int spt-next-time 60) + (sp-launcher-by-id spt-next-launcher 642) + (sp-rnd-flt spt-conerot-x (degrees 60.0) (degrees 30.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 180.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpartgroup group-flitter-birth + :id 145 + :duration (seconds 7.335) + :linger-duration (seconds 4) + :flags (use-local-clock) + :bounds (static-bspherem 0 3 0 8) + :parts ((sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 250 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 200 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 150 :binding 643) + (sp-item 645 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 100 :binding 643) + (sp-item 646 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 120 :binding 644) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 644 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 643 :flags (bit1 start-dead)) + (sp-item 647 :fade-after (meters 100) :falloff-to (meters 100) :period 2200 :length 320) + ) + ) + +;; failed to figure out what this is: +(defpart 647 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 1.0 1.0 1.0) + (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 48.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.026666667) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.006666667) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-fade-a -0.053333335 -0.053333335 1.0) + (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0) + (sp-rnd-flt spt-friction 0.85 0.05 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 90.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-conerot-radius (meters 0) (meters 0.5) 1.0) + ) + ) + +;; definition for function check-drop-level-flitter-dirt-rubble +;; INFO: Used lq/sq +(defun check-drop-level-flitter-dirt-rubble ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector)) + (let ((f30-0 (-> arg1 key origin trans y))) + (when (< (-> arg2 y) f30-0) + (let ((gp-0 (new 'stack-no-clear 'vector))) + (sp-kill-particle arg0 arg1) + (set-vector! gp-0 (-> arg2 x) f30-0 (-> arg2 z) 1.0) + (let ((t9-1 sp-launch-particles-var) + (a0-2 *sp-particle-system-2d*) + (a1-1 (-> *part-id-table* 648)) + (a2-1 *launch-matrix*) + ) + (set! (-> a2-1 trans quad) (-> gp-0 quad)) + (t9-1 a0-2 a1-1 a2-1 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + (let ((t9-2 sp-launch-particles-var) + (a0-3 *sp-particle-system-2d*) + (a1-2 (-> *part-id-table* 649)) + (a2-2 *launch-matrix*) + ) + (set! (-> a2-2 trans quad) (-> gp-0 quad)) + (t9-2 a0-3 a1-2 a2-2 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + (let ((t9-3 sp-launch-particles-var) + (a0-4 *sp-particle-system-2d*) + (a1-3 (-> *part-id-table* 650)) + (a2-3 *launch-matrix*) + ) + (set! (-> a2-3 trans quad) (-> gp-0 quad)) + (t9-3 a0-4 a1-3 a2-3 (the-as sparticle-launch-state #f) (the-as sparticle-launch-control #f) 1.0) + ) + ) + ) + ) + (none) + ) + +;; failed to figure out what this is: +(defpart 644 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 0.0 0.2 1.0) + (sp-sound (static-sound-spec "debris-fall" :num 0.01 :volume 100.0)) + (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 16.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0) + (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0) + (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0) + (sp-int spt-timer 250) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-func spt-func 'check-drop-group-center) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 643 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-rnd-flt spt-num 0.0 0.2 1.0) + (sp-rnd-flt spt-scale-x (meters 0.3) (meters 0.1) 1.0) + (sp-rnd-flt spt-scale-y (meters 1) (meters 0.2) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 16.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters -0.0033333334) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0) (meters 0.00033333333) 1.0) + (sp-rnd-flt spt-fade-a -0.042666666 -0.064 1.0) + (sp-rnd-flt spt-accel-y -1.3653333 -1.3653333 1.0) + (sp-int spt-timer 750) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-func spt-func 'check-drop-group-center) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 646 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 0.5 0.5 1.0) + (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0) + (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.033333335) (meters 0.033333335) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0) + (sp-flt spt-friction 0.98) + (sp-int spt-timer 350) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-func spt-func 'check-drop-level-flitter-dirt-rubble) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 45.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-radius (meters 0.5)) + ) + ) + +;; failed to figure out what this is: +(defpart 645 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 0.1 0.5 1.0) + (sp-rnd-flt spt-x (meters 0) (meters 1) 1.0) + (sp-rnd-flt spt-scale-x (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.1) (meters 0.1) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.033333335) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-accel-y -8.192 -8.192 1.0) + (sp-flt spt-friction 0.98) + (sp-int spt-timer 350) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-func spt-func 'check-drop-level-flitter-dirt-rubble-ruins) + (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 15.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 360.0) 1.0) + (sp-flt spt-conerot-radius (meters 0.1)) + ) + ) + +;; failed to figure out what this is: +(defpart 648 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 1.0 2.0 1.0) + (sp-rnd-flt spt-scale-x (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0.006666667) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-fade-a -0.42666668 -0.85333335 1.0) + (sp-flt spt-accel-y -2.7306666) + (sp-int spt-timer 600) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-rnd-flt spt-conerot-x (degrees 10.0) (degrees 60.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 649 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x7 :page #x3e8)) + (sp-func spt-birth-func 'birth-func-texture-group) + (sp-rnd-flt spt-num 1.0 1.0 1.0) + (sp-rnd-flt spt-scale-x (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-rot-z (degrees 0.0) (degrees 360.0) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.05) (meters 0.15) 1.0) + (sp-rnd-flt spt-r 200.0 55.0 1.0) + (sp-copy-from-other spt-g -1) + (sp-copy-from-other spt-b -1) + (sp-flt spt-a 128.0) + (sp-rnd-flt spt-vel-y (meters 0) (meters 0.04) 1.0) + (sp-rnd-flt spt-rotvel-z (degrees -1.2) (degrees 2.4) 1.0) + (sp-rnd-flt spt-friction 0.94 0.02 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (new 'static 'sp-field-init-spec + :field (sp-field-id spt-userdata) + :flags (sp-flag plain-v2) + :object (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + (sp-int-plain-rnd spt-next-time 450 149 1) + (sp-launcher-by-id spt-next-launcher 651) + (sp-flt spt-conerot-x (degrees 90.0)) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; failed to figure out what this is: +(defpart 651 + :init-specs ((sp-flt spt-rotvel-z (degrees 0.0)) (sp-rnd-flt spt-fade-a -0.10666667 -0.10666667 1.0)) + ) + +;; failed to figure out what this is: +(defpart 650 + :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xc)) + (sp-flt spt-num 1.0) + (sp-sound (static-sound-spec "debris-ground" :num 0.01 :volume 100.0)) + (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0) + (sp-rnd-flt spt-scale-y (meters 0.5) (meters 0.5) 1.0) + (sp-rnd-flt spt-r 160.0 16.0 1.0) + (sp-rnd-flt spt-g 130.0 32.0 1.0) + (sp-rnd-flt spt-b 110.0 16.0 1.0) + (sp-rnd-flt spt-a 16.0 32.0 1.0) + (sp-rnd-flt spt-vel-y (meters 0.013333334) (meters 0.026666667) 1.0) + (sp-rnd-flt spt-scalevel-x (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-scalevel-y (meters 0.0033333334) (meters 0.0016666667) 1.0) + (sp-rnd-flt spt-fade-a -0.026666667 -0.026666667 1.0) + (sp-rnd-flt spt-accel-y 0.0 1.3653333 1.0) + (sp-rnd-flt spt-friction 0.9 0.05 1.0) + (sp-int spt-timer 2400) + (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-12) + (sp-rnd-flt spt-conerot-x (degrees 70.0) (degrees 20.0) 1.0) + (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 360.0) 1.0) + ) + ) + +;; definition of type flitter +(deftype flitter (nav-enemy) + ((move-angle float :offset-assert 604) + (heading basic :offset-assert 608) + (change-dir-time time-frame :offset-assert 616) + (last-change-dir uint64 :offset-assert 624) + (off-screen-timer uint64 :offset-assert 632) + (amb-sound-timer uint64 :offset-assert 640) + (attack-time time-frame :offset-assert 648) + (target-pos vector :inline :offset-assert 656) + (attack-pos vector :inline :offset-assert 672) + (base-height float :offset-assert 688) + (minimap connection-minimap :offset-assert 692) + ) + :heap-base #x240 + :method-count-assert 184 + :size-assert #x2b8 + :flag-assert #xb8024002b8 + (:methods + (attack () _type_ :state 178) + (ambush-jumping () _type_ :state 179) + (flitter-method-180 (_type_) none 180) + (flitter-method-181 (_type_) none 181) + (flitter-method-182 (_type_ process-focusable) symbol 182) + (flitter-method-183 (_type_) float 183) + ) + ) + +;; definition for method 3 of type flitter +(defmethod inspect flitter ((obj flitter)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type nav-enemy inspect))) + (t9-0 obj) + ) + (format #t "~2Tmove-angle: ~f~%" (-> obj move-angle)) + (format #t "~2Theading: ~A~%" (-> obj heading)) + (format #t "~2Tchange-dir-time: ~D~%" (-> obj change-dir-time)) + (format #t "~2Tlast-change-dir: ~D~%" (-> obj last-change-dir)) + (format #t "~2Toff-screen-timer: ~D~%" (-> obj off-screen-timer)) + (format #t "~2Tamb-sound-timer: ~D~%" (-> obj amb-sound-timer)) + (format #t "~2Tattack-time: ~D~%" (-> obj attack-time)) + (format #t "~2Ttarget-pos: #~%" (-> obj target-pos)) + (format #t "~2Tattack-pos: #~%" (-> obj attack-pos)) + (format #t "~2Tbase-height: ~f~%" (-> obj base-height)) + (format #t "~2Tminimap: #~%" (-> obj minimap)) + (label cfg-4) + obj + ) + +;; failed to figure out what this is: +(defskelgroup skel-flitter flitter 0 -1 + ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999))) + :bounds (static-spherem 0 0 0 5.5) + :shadow 4 + :origin-joint-index 3 + ) + +;; definition for symbol *flitter-nav-enemy-info*, type nav-enemy-info +(define *flitter-nav-enemy-info* (new 'static 'nav-enemy-info + :use-die-falling #t + :use-victory #f + :use-jump-blocked #f + :debug-draw-neck #f + :jump-debug-draw #f + :move-to-ground #t + :hover-if-no-ground #f + :idle-anim-script (new 'static 'array uint32 16 + #x1e0002 + #x6030501 + #x1e0002 + #x1010601 + #x1e0f0701 + #x1e0002 + #x4020501 + #x1e0002 + #x1010801 + #x140a0901 + #x1e0002 + #x2010501 + #x1e0002 + #x1010801 + #x1e0f0901 + #x0 + ) + :idle-anim 5 + :notice-anim 12 + :hostile-anim 14 + :hit-anim 5 + :knocked-anim 20 + :knocked-land-anim 21 + :die-anim 19 + :die-falling-anim 18 + :victory-anim 5 + :jump-wind-up-anim 5 + :jump-in-air-anim 5 + :jump-land-anim 5 + :neck-joint -1 + :look-at-joint 28 + :bullseye-joint 3 + :sound-hit (static-sound-name "flitter-hit") + :sound-die (static-sound-name "flitter-die") + :notice-distance (meters 40) + :notice-distance-delta (meters 10) + :proximity-notice-distance (meters 20) + :default-hit-points 1 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :penetrate-knocked #x11fffdffa + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 6) + :attack-shove-up (meters 3) + :attack-mode 'generic + :attack-damage 1 + :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher) + :jump-height-min (meters 3) + :jump-height-factor 0.5 + :knocked-seek-ry-clamp 2730.6667 + :knocked-soft-vxz-lo 72089.6 + :knocked-soft-vxz-hi 108134.4 + :knocked-soft-vy-lo 81920.0 + :knocked-soft-vy-hi 122880.0 + :knocked-medium-vxz-lo 147456.0 + :knocked-medium-vxz-hi 196608.0 + :knocked-medium-vy-lo 135168.0 + :knocked-medium-vy-hi 151552.0 + :knocked-hard-vxz-lo 78643.2 + :knocked-hard-vxz-hi 117964.8 + :knocked-hard-vy-lo 183500.8 + :knocked-hard-vy-hi 275251.2 + :knocked-huge-vxz-lo 164659.2 + :knocked-huge-vxz-hi 249036.8 + :knocked-huge-vy-lo 183500.8 + :knocked-huge-vy-hi 217907.2 + :knocked-yellow-vxz-lo 40960.0 + :knocked-yellow-vxz-hi 49152.0 + :knocked-yellow-vy-lo 57344.0 + :knocked-yellow-vy-hi 81920.0 + :knocked-red-vxz-lo 24576.0 + :knocked-red-vxz-hi 196608.0 + :knocked-red-vy-lo 94208.0 + :knocked-red-vy-hi 151552.0 + :knocked-blue-vxz-lo 40960.0 + :knocked-blue-vxz-hi 49152.0 + :knocked-blue-vy-lo 24576.0 + :knocked-blue-vy-hi 81920.0 + :shadow-size (meters 2) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint 28 + :gem-seg #x2 + :gem-no-seg #x4 + :gem-offset (new 'static 'sphere :y 696.32 :z 1843.2 :r 163840.0) + :callback-info #f + :use-momentum #f + :use-frustration #t + :use-stop-chase #f + :use-circling #t + :use-pacing #t + :walk-anim 13 + :turn-anim 15 + :run-anim 14 + :taunt-anim -1 + :run-travel-speed (meters 12) + :run-acceleration (meters 8) + :run-turning-acceleration (meters 120) + :walk-travel-speed (meters 4) + :walk-acceleration (meters 1) + :walk-turning-acceleration (meters 5) + :maximum-rotation-rate (degrees 720.0) + :notice-nav-radius (meters 5) + :frustration-distance (meters 12) + :frustration-time (seconds 4) + :blocked-time (seconds 0.3) + :circle-dist-lo 20480.0 + :circle-dist-hi 61440.0 + :nav-mesh #f + ) + ) + +;; failed to figure out what this is: +(set! (-> *flitter-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +;; definition for method 182 of type flitter +(defmethod flitter-method-182 flitter ((obj flitter) (arg0 process-focusable)) + (and (logtest? (-> obj draw status) (draw-control-status on-screen)) + (let ((s4-0 (camera-matrix))) + (camera-pos) + (let* ((s3-0 (get-trans arg0 0)) + (s5-1 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s4-0 vector 2) 1.0)) + (v1-7 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj root-override2 trans) s3-0) 1.0)) + ) + (< 0.0 (vector-dot s5-1 v1-7)) + ) + ) + ) + ) + +;; definition for method 77 of type flitter +(defmethod enemy-method-77 flitter ((obj flitter) (arg0 (pointer float))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4)) + (let ((a0-2 (-> obj skel root-channel 0))) + (set! (-> a0-2 frame-group) (the-as art-joint-anim (-> obj draw art-group data 20))) + (set! (-> a0-2 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 20)) frames num-frames) -1)) + ) + (set! (-> a0-2 param 1) (-> arg0 0)) + (set! (-> a0-2 frame-num) 0.0) + (joint-control-channel-group! a0-2 (the-as art-joint-anim (-> obj draw art-group data 20)) num-func-seek!) + ) + #t + ) + (((knocked-type knocked-type-6)) + (let ((v1-17 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and v1-17 (= v1-17 (-> obj draw art-group data 21))) + (ja-channel-push! 1 (seconds 0.17)) + (ja-channel-push! 1 (seconds 0.02)) + ) + ) + (let ((a0-10 (-> obj skel root-channel 0))) + (set! (-> a0-10 frame-group) (the-as art-joint-anim (-> obj draw art-group data 23))) + (set! (-> a0-10 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 23)) frames num-frames) -1)) + ) + (set! (-> a0-10 param 1) 1.0) + (set! (-> a0-10 frame-num) 0.0) + (joint-control-channel-group! a0-10 (the-as art-joint-anim (-> obj draw art-group data 23)) num-func-seek!) + ) + #t + ) + (else + ((method-of-type nav-enemy enemy-method-77) obj arg0) + ) + ) + ) + +;; definition for method 78 of type flitter +(defmethod enemy-method-78 flitter ((obj flitter) (arg0 (pointer float))) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-6)) + (when (>= (the-as uint (-> obj incoming blue-juggle-count)) (the-as uint 2)) + (let ((v1-4 (-> obj skel root-channel 0))) + (set! (-> v1-4 frame-group) (the-as art-joint-anim (-> obj draw art-group data 22))) + (set! (-> v1-4 param 0) + (the float (+ (-> (the-as art-joint-anim (-> obj draw art-group data 22)) frames num-frames) -1)) + ) + (set! (-> v1-4 param 1) 1.0) + (set! (-> v1-4 frame-num) 0.0) + (joint-control-channel-group! v1-4 (the-as art-joint-anim (-> obj draw art-group data 22)) num-func-seek!) + ) + #t + ) + ) + (else + ((method-of-type nav-enemy enemy-method-78) obj arg0) + ) + ) + ) + +;; definition for method 68 of type flitter +;; WARN: Return type mismatch object vs none. +(defmethod go-stare2 flitter ((obj flitter)) + (if (and (= (-> obj focus aware) (enemy-aware enemy-aware-2)) + (not (nav-enemy-method-163 obj)) + (not (and (-> obj next-state) (= (-> obj next-state name) 'pacing))) + ) + (go (method-of-object obj pacing)) + (go (method-of-object obj stare)) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate ambush (flitter) + :virtual #t + :enter (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (set! (-> self base-height) (-> self root-override2 trans y)) + (let ((v1-13 (-> self root-override2 root-prim))) + (set! (-> v1-13 prim-core collide-as) (collide-spec)) + (set! (-> v1-13 prim-core collide-with) (collide-spec)) + ) + 0 + (logior! (-> self draw status) (draw-control-status no-draw)) + (none) + ) + :code (behavior () + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-1 (method-of-type part-tracker activate))) + (t9-1 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-2 run-function-in-process) + (a0-2 gp-0) + (a1-2 part-tracker-init) + (a2-4 (-> *part-group-id-table* 145)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> self root-override2 trans quad)) + ((the-as (function object object object object object object object object none) t9-2) + a0-2 + a1-2 + a2-4 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> gp-0 ppointer) + ) + ) + (let ((gp-1 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-1) (seconds 0.6)) + (suspend) + ) + ) + (set! (-> self root-override2 trans y) (+ -8192.0 (-> self root-override2 trans y))) + (enemy-method-129 self) + (let ((a0-5 (handle->process (-> self focus handle)))) + (when a0-5 + (let* ((gp-2 (-> self root-override2)) + (s3-0 + (vector-normalize! + (vector-! (new 'stack-no-clear 'vector) (get-trans (the-as process-focusable a0-5) 0) (-> gp-2 trans)) + 1.0 + ) + ) + (f0-2 (deg-diff (quaternion-y-angle (-> gp-2 quat)) (vector-y-angle s3-0))) + ) + (quaternion-rotate-y! (-> gp-2 quat) (-> gp-2 quat) f0-2) + ) + ) + ) + (let ((gp-3 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-3) (the int (* 300.0 (get-rand-float-range self 0.0 0.6)))) + (suspend) + ) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (go-virtual ambush-jumping) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate ambush-jumping (flitter) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior flitter) enemy-event-handler) + :enter (behavior () + (let ((v1-0 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-0 enemy-flags))) + (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-0 enemy-flags)))) + ) + (set! (-> v1-0 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-0 enemy-flags)))) + (set! (-> v1-0 nav callback-info) (-> v1-0 enemy-info-override callback-info)) + ) + 0 + (let ((v1-3 self)) + (set! (-> v1-3 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-3 enemy-flags)))) + ) + 0 + (enemy-method-109 self 1) + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((gp-0 (-> self root-override2))) + (vector-reset! (-> gp-0 transv)) + (set! (-> gp-0 transv y) (* 4096.0 (get-rand-float-range self 34.0 38.0))) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (ja-no-eval :group! (-> self draw art-group data 10) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 10)) frames num-frames) -1))) + ) + (until #f + (when (< (-> self base-height) (-> self root-override2 trans y)) + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-3 (method-of-type part-tracker activate))) + (t9-3 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-4 run-function-in-process) + (a0-4 gp-0) + (a1-4 part-tracker-init) + (a2-5 (-> *part-group-id-table* 144)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> self root-override2 trans quad)) + ((the-as (function object object object object object object object object none) t9-4) + a0-4 + a1-4 + a2-5 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> gp-0 ppointer) + ) + ) + (goto cfg-10) + ) + (suspend) + (ja :num! (seek!)) + ) + #f + (until #f + (when (< (+ 204.8 (-> self base-height)) (-> self root-override2 trans y)) + (let ((v1-40 (-> self root-override2 root-prim))) + (set! (-> v1-40 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-40 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (goto cfg-11) + ) + (label cfg-10) + (suspend) + (ja :num! (seek!)) + ) + #f + (until #f + (label cfg-11) + (if (or (and (>= 0.0 (-> self root-override2 transv y)) + (>= (+ 1638.4 (-> self base-height)) (-> self root-override2 trans y)) + ) + (logtest? (-> self root-override2 status) (collide-status on-ground)) + ) + (goto cfg-26) + ) + (suspend) + (if (not (ja-done? 0)) + (ja :num! (seek!)) + ) + ) + #f + (label cfg-26) + (ja-no-eval :group! (-> self draw art-group data 11) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 11)) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + (until #f + (if (logtest? (-> self root-override2 status) (collide-status on-ground)) + (goto cfg-33) + ) + (suspend) + ) + #f + (label cfg-33) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior flitter) nav-enemy-falling-post) + ) + +;; definition for method 99 of type flitter +(defmethod enemy-method-99 flitter ((obj flitter) (arg0 process-focusable)) + (logtest? (focus-status mech) (-> arg0 focus-status)) + ) + +;; definition for method 180 of type flitter +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod flitter-method-180 flitter ((obj flitter)) + (with-pp + (let* ((s5-0 (handle->process (-> obj focus handle))) + (s3-0 (if (type? s5-0 process-focusable) + (the-as process-focusable s5-0) + ) + ) + ) + (when s3-0 + (let* ((s5-1 (get-trans s3-0 0)) + (s4-1 (vector-! (new 'stack-no-clear 'vector) s5-1 (-> obj root-override2 trans))) + (f30-0 (vector-length s4-1)) + ) + (cond + ((enemy-method-99 obj s3-0) + (go-flee obj) + ) + ((and (< f30-0 32768.0) (not (flitter-method-182 obj s3-0))) + (go (method-of-object obj circling)) + ) + ((< f30-0 (-> obj enemy-info-override notice-nav-radius)) + (set! (-> obj target-pos quad) (-> s5-1 quad)) + (let ((s3-1 (new 'stack-no-clear 'vector))) + (set! (-> s3-1 quad) (-> s4-1 quad)) + (let ((s5-2 (new 'stack-no-clear 'vector))) + (set! (-> s5-2 quad) (-> obj root-override2 transv quad)) + (vector-normalize! s5-2 f30-0) + (if (>= (vector-dot s3-1 s5-2) 0.98) + (go (method-of-object obj attack)) + ) + ) + ) + ) + ((< f30-0 32768.0) + (set! (-> obj target-pos quad) (-> s5-1 quad)) + ) + ((or (>= (- (-> pp clock frame-counter) (the-as int (-> obj last-change-dir))) (-> obj change-dir-time)) + (< (vector-vector-distance-squared (-> obj root-override2 trans) (-> obj target-pos)) 0.1) + ) + (set! (-> obj last-change-dir) (the-as uint (-> pp clock frame-counter))) + (set! (-> obj change-dir-time) (rand-vu-int-range (seconds 0.5) (seconds 0.7))) + (let ((s3-2 (new 'stack-no-clear 'vector)) + (f0-9 (* 0.5 f30-0 (tan (-> obj move-angle)))) + (s2-0 (new 'stack-no-clear 'vector)) + ) + (if (-> obj heading) + (set-vector! s3-2 (-> s4-1 z) (-> s4-1 y) (- (-> s4-1 x)) 1.0) + (set-vector! s3-2 (- (-> s4-1 z)) (-> s4-1 y) (-> s4-1 x) 1.0) + ) + (set! (-> obj heading) (the-as basic (not (-> obj heading)))) + (let ((f28-1 (rand-vu-float-range (* 0.75 f0-9) f0-9)) + (s4-2 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-1 (* -0.6 f30-0))) + ) + (vector-normalize! s3-2 f28-1) + (vector+! s3-2 s3-2 s4-2) + ) + (nav-state-method-41 (-> obj nav state) s3-2) + (vector+! s2-0 s5-1 s3-2) + (set! (-> obj target-pos quad) (-> s2-0 quad)) + ) + ) + ) + ) + 0 + ) + ) + 0 + (none) + ) + ) + +;; definition for method 181 of type flitter +;; WARN: Return type mismatch time-frame vs none. +(defmethod flitter-method-181 flitter ((obj flitter)) + (with-pp + (when (>= (- (-> pp clock frame-counter) (the-as int (-> obj amb-sound-timer))) + (the int (* 300.0 (rand-vu-float-range 1.5 3.0))) + ) + (sound-play "flitter-amb" :position (-> obj root-override2 trans)) + (set! (-> obj amb-sound-timer) (the-as uint (-> pp clock frame-counter))) + ) + (none) + ) + ) + +;; definition for function flitter-fall-and-play-death-anim +;; WARN: Return type mismatch int vs none. +(defbehavior flitter-fall-and-play-death-anim flitter ((arg0 art-joint-anim) (arg1 float) (arg2 time-frame)) + (local-vars (v1-29 symbol)) + (enemy-method-110 self) + (set! (-> self skel root-channel 0 frame-group) arg0) + (let ((s4-1 (enemy-method-50 self (new 'stack-no-clear 'vector))) + (s3-0 (-> self root-override2)) + ) + (when (if (type? s3-0 collide-shape-moving) + s3-0 + ) + (set! (-> self root-override2 transv y) 33775.48) + (ja :num-func num-func-identity :frame-num 0.0) + (set! (-> self state-time) (-> self clock frame-counter)) + (logclear! (-> self root-override2 status) (collide-status on-surface on-ground touch-surface)) + (until v1-29 + (let ((f0-2 102400.0)) + (set! (-> self root-override2 transv x) (* (-> s4-1 x) f0-2)) + (set! (-> self root-override2 transv z) (* (-> s4-1 z) f0-2)) + ) + (suspend) + (ja :num! (seek! max arg1)) + (set! v1-29 (or (ja-done? 0) (>= (- (-> self clock frame-counter) (-> self state-time)) arg2))) + ) + ) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate active (flitter) + :virtual #t + :post (behavior () + (flitter-method-181 self) + (let ((t9-1 (-> (method-of-type nav-enemy active) post))) + (if t9-1 + ((the-as (function none) t9-1)) + ) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate stare (flitter) + :virtual #t + :code (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (let ((f30-0 (get-rand-float-range self 0.8 1.2))) + (until #f + (when (not (enemy-method-96 self 2730.6667 #t)) + (let ((v1-5 self)) + (set! (-> v1-5 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-5 enemy-flags)))) + ) + 0 + (ja-no-eval :num! (loop!)) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 15)) + (ja :num-func num-func-identity :frame-num 0.0) + (until (enemy-method-96 self 1820.4445 #t) + (ja-blend-eval) + (suspend) + (ja :num! (loop! 0.75)) + ) + (let ((v1-25 self)) + (set! (-> v1-25 enemy-flags) (the-as enemy-flag (logclear (-> v1-25 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + ) + (let ((v1-29 (ja-group))) + (if (not (and v1-29 (= v1-29 (-> self draw art-group data (-> self enemy-info-override idle-anim))))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post (behavior () + (flitter-method-181 self) + (let ((t9-1 (-> (method-of-type nav-enemy stare) post))) + (if t9-1 + ((the-as (function none) t9-1)) + ) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate circling (flitter) + :virtual #t + :enter (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy circling) enter))) + (if t9-0 + (t9-0) + ) + ) + (set! (-> self off-screen-timer) (the-as uint (-> self clock frame-counter))) + (none) + ) + :trans (behavior () + (let ((gp-0 (handle->process (-> self focus handle)))) + (if gp-0 + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad)) + ) + (when (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.1)) + (let ((v1-11 (-> self focus aware))) + (cond + ((= v1-11 (enemy-aware enemy-aware-3)) + (cond + ((when gp-0 + (let* ((gp-1 self) + (s5-1 (method-of-object gp-1 flitter-method-182)) + (s4-0 (handle->process (-> self focus handle))) + ) + (s5-1 gp-1 (the-as process-focusable (if (type? s4-0 process-focusable) + s4-0 + ) + ) + ) + ) + ) + (if (and (enemy-method-107 self) + (>= (- (-> self clock frame-counter) (the-as int (-> self off-screen-timer))) (seconds 0.3)) + ) + (go-hostile self) + ) + ) + (else + (set! (-> self off-screen-timer) (the-as uint (-> self clock frame-counter))) + ) + ) + ) + ((= v1-11 (enemy-aware enemy-aware-2)) + (go-stare self) + ) + ((>= 1 (the-as int v1-11)) + (go-virtual active) + ) + ) + ) + (if (or (nav-enemy-method-163 self) (logtest? (enemy-flag enemy-flag41) (-> self enemy-flags))) + (go-stare2 self) + ) + ) + ) + (none) + ) + :code (behavior () + (nav-enemy-method-166 self) + (ja-channel-push! 1 (seconds 0.2)) + (until #f + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override run-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override run-anim))) + frames + num-frames + ) + -1 + ) + ) + (get-rand-float-range self 0.9 1.1) + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max (get-rand-float-range self 0.9 1.1))) + ) + ) + #f + (none) + ) + ) + +;; failed to figure out what this is: +(defstate hostile (flitter) + :virtual #t + :enter (behavior () + (set! (-> self last-change-dir) (the-as uint (-> self clock frame-counter))) + (set! (-> self change-dir-time) 0) + (set! (-> self attack-time) (+ (-> self clock frame-counter) (seconds 0.35))) + (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter))) + (if t9-0 + (t9-0) + ) + ) + (none) + ) + :trans (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans))) + (if t9-0 + (t9-0) + ) + ) + (flitter-method-180 self) + (none) + ) + :post (behavior () + (let ((a0-0 (-> self nav state)) + (v1-1 (-> self target-pos)) + ) + (logclear! (-> a0-0 flags) (nav-state-flag directional-mode)) + (logior! (-> a0-0 flags) (nav-state-flag target-poly-dirty)) + (set! (-> a0-0 target-post quad) (-> v1-1 quad)) + ) + 0 + (nav-enemy-travel-post) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate die (flitter) + :virtual #t + :enter (behavior () + (sound-play "flitter-die") + (let ((t9-2 (-> (method-of-type nav-enemy die) enter))) + (if t9-2 + (t9-2) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (flitter-fall-and-play-death-anim + (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override die-anim))) + 1.0 + (seconds 2) + ) + (send-event self 'death-end) + (cleanup-for-death self) + (none) + ) + ) + +;; definition for method 183 of type flitter +(defmethod flitter-method-183 flitter ((obj flitter)) + (lerp-scale 0.0 1.0 (- (-> obj attack-pos y) (-> obj root-override2 trans y)) 13926.4 25600.0) + ) + +;; failed to figure out what this is: +(defstate attack (flitter) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior flitter) enemy-event-handler) + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (let ((v1-2 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-2 enemy-flags))) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-2 enemy-flags)))) + ) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-2 enemy-flags)))) + (set! (-> v1-2 nav callback-info) (-> v1-2 enemy-info-override callback-info)) + ) + 0 + (sound-play "flitter-attack") + (set! (-> self amb-sound-timer) (the-as uint 0)) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-8 *game-info*) + (v0-2 (+ (-> v1-8 attack-id) 1)) + ) + (set! (-> v1-8 attack-id) v0-2) + (set! (-> self attack-id) v0-2) + ) + (none) + ) + :exit (behavior () + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (local-vars (s5-2 none)) + (let* ((s5-0 (handle->process (-> self focus handle))) + (gp-0 (if (type? s5-0 process-focusable) + (the-as process-focusable s5-0) + ) + ) + ) + (set! s5-2 (cond + ((and gp-0 + (< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.5)) + gp-0 + (zero? (logand (-> gp-0 focus-status) (focus-status disable dead ignore grabbed))) + ) + (let ((s5-1 (-> self nav state)) + (v1-10 (get-trans gp-0 0)) + ) + (logclear! (-> s5-1 flags) (nav-state-flag directional-mode)) + (logior! (-> s5-1 flags) (nav-state-flag target-poly-dirty)) + (set! (-> s5-1 target-post quad) (-> v1-10 quad)) + ) + 0 + (set! s5-2 (the-as none (-> self attack-pos))) + (set! (-> (the-as vector s5-2) quad) (-> (get-trans gp-0 3) quad)) + s5-2 + ) + (else + (go-stare self) + ) + ) + ) + ) + (none) + ) + :code (behavior () + (ja-channel-push! 2 (seconds 0.1)) + (let ((f30-0 (flitter-method-183 self))) + (ja-no-eval :group! (-> self draw art-group data 16) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 16)) frames num-frames) -1)) 0.8) + :frame-num 0.0 + ) + (let ((a0-3 (-> self skel root-channel 1))) + (set! (-> a0-3 frame-interp 1) f30-0) + (set! (-> a0-3 frame-interp 0) f30-0) + (set! (-> a0-3 frame-group) (the-as art-joint-anim (-> self draw art-group data 17))) + (set! (-> a0-3 param 0) 0.0) + (set! (-> a0-3 frame-num) 0.0) + (joint-control-channel-group! a0-3 (the-as art-joint-anim (-> self draw art-group data 17)) num-func-chan) + ) + (until (ja-done? 0) + (suspend) + (set! f30-0 (seek f30-0 (flitter-method-183 self) (* 0.2 (-> self clock seconds-per-frame)))) + (ja :num! (seek! max 0.8)) + (let ((a0-7 (-> self skel root-channel 1))) + (set! (-> a0-7 frame-interp 1) f30-0) + (set! (-> a0-7 frame-interp 0) f30-0) + (set! (-> a0-7 param 0) 0.0) + (joint-control-channel-group-eval! a0-7 (the-as art-joint-anim #f) num-func-chan) + ) + ) + ) + (let ((v1-40 self)) + (set! (-> v1-40 enemy-flags) (the-as enemy-flag (logclear (-> v1-40 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-40 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (ja-channel-push! 1 (seconds 0.1)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (dotimes (gp-1 (get-rand-int self 3)) + (ja-no-eval :group! (-> self draw art-group data 5) + :num! (seek! (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames) -1))) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek!)) + ) + ) + (enemy-method-72 self) + (none) + ) + :post (the-as (function none :behavior flitter) nav-enemy-travel-post) + ) + +;; failed to figure out what this is: +(defstate victory (flitter) + :virtual #t + :post (behavior () + (flitter-method-181 self) + (nav-enemy-simple-post) + (none) + ) + ) + +;; definition for method 132 of type flitter +(defmethod enemy-method-132 flitter ((obj flitter)) + (when (-> obj minimap) + (logior! (-> obj minimap flags) (minimap-flag fade-out)) + (set! (-> obj minimap) #f) + ) + ((the-as (function nav-enemy none) (find-parent-method flitter 132)) obj) + (none) + ) + +;; definition for method 114 of type flitter +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-114 flitter ((obj flitter)) + "@abstract" + (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s5-0 reaction) cshape-reaction-default) + (set! (-> s5-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 3) 0))) + (set! (-> s5-0 total-prims) (the-as uint 4)) + (set! (-> s4-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s4-0 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> s4-0 local-sphere) 0.0 10240.0 0.0 15360.0) + (set! (-> s5-0 root-prim) s4-0) + ) + (let ((v1-12 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-12 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-12 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> v1-12 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> v1-12 local-sphere) 0.0 5734.4 0.0 5734.4) + ) + (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-14 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-14 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-14 prim-core action) (collide-action deadly)) + (set! (-> v1-14 transform-index) 34) + (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 3481.6) + ) + (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-16 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-16 prim-core action) (collide-action deadly)) + (set! (-> v1-16 transform-index) 35) + (set-vector! (-> v1-16 local-sphere) 0.0 0.0 0.0 3481.6) + ) + (set! (-> s5-0 nav-radius) 3686.4) + (let ((v1-18 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-18 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-18 prim-core collide-with)) + ) + (set! (-> s5-0 max-iteration-count) (the-as uint 3)) + (set! (-> obj root-override2) s5-0) + ) + 0 + (none) + ) + +;; definition for method 115 of type flitter +;; WARN: Return type mismatch connection-minimap vs none. +(defmethod enemy-method-115 flitter ((obj flitter)) + "@abstract" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-flitter" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (enemy-method-113 obj *flitter-nav-enemy-info*) + (set! (-> obj move-angle) 10922.667) + (set! (-> obj heading) (the-as basic (if (= (rand-vu-int-range 0 1) 1) + #t + #f + ) + ) + ) + (set! (-> obj change-dir-time) 0) + (set! (-> obj off-screen-timer) (the-as uint 0)) + (set! (-> obj amb-sound-timer) (the-as uint 0)) + (add-connection + *part-engine* + obj + 28 + obj + 318 + (new 'static 'vector :x 942.08 :y -860.16 :z 1269.76 :w 163840.0) + ) + (add-connection + *part-engine* + obj + 28 + obj + 318 + (new 'static 'vector :x -942.08 :y -860.16 :z 1269.76 :w 163840.0) + ) + (set-gravity-length (-> obj root-override2 dynam) 491520.0) + (let* ((s4-1 "pebble1-ruins") + (v1-15 (-> obj level name)) + (s5-2 + (cond + ((= v1-15 'strip) + (set! s4-1 "pebble1-strip") + (new 'static 'boxed-array :type int32 40 1 0 #x4f800500 #x4f800600 #x4f800700 #x4f800800 #x4f800900) + ) + ((= v1-15 'dig3a) + (set! s4-1 "pebble1-dig") + (new 'static 'boxed-array :type int32 40 1 0 -1377828352 -1377828096 -1377827840 -1377827584 -1377827328) + ) + ((= v1-15 'stadblmp) + (set! s4-1 "pebble1-dig") + (new 'static 'boxed-array :type int32 40 1 0 -670040064 -670039808 -670039552 -670039296 -670039040) + ) + (else + (new 'static 'boxed-array :type int32 40 1 0 #x3e800700 #x3e800800 #x3e800900 #x3e800a00 #x3e800b00) + ) + ) + ) + ) + (setup-user-array (-> *part-id-table* 646) s4-1) + (setup-user-array (-> *part-id-table* 645) s4-1) + (setup-user-array (-> *part-id-table* 648) s4-1) + (setup-user-array (-> *part-id-table* 649) s4-1) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 646) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 645) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 648) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + (set! (-> (get-field-spec-by-id (-> *part-id-table* 649) (sp-field-id spt-userdata)) initial-valuef) + (the-as float s5-2) + ) + ) + (set! (-> obj minimap) + (minimap-method-12 *minimap* obj (the-as uint 70) (the-as int #f) (the-as vector #t) 0) + ) + (none) + ) + + + + diff --git a/test/decompiler/reference/jak2/levels/common/grunt_REF.gc b/test/decompiler/reference/jak2/levels/common/grunt_REF.gc new file mode 100644 index 0000000000..8b29d5bbcb --- /dev/null +++ b/test/decompiler/reference/jak2/levels/common/grunt_REF.gc @@ -0,0 +1,1722 @@ +;;-*-Lisp-*- +(in-package goal) + +;; failed to figure out what this is: +(defskelgroup skel-grunt grunt 0 -1 + ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999))) + :bounds (static-spherem 0 0 0 5) + :shadow 4 + :origin-joint-index 18 + ) + +;; definition of type grunt-anim-info +(deftype grunt-anim-info (structure) + ((anim-index int32 :offset-assert 0) + (travel-speed meters :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; definition for method 3 of type grunt-anim-info +(defmethod inspect grunt-anim-info ((obj grunt-anim-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'grunt-anim-info) + (format #t "~1Tanim-index: ~D~%" (-> obj anim-index)) + (format #t "~1Ttravel-speed: (meters ~m)~%" (-> obj travel-speed)) + (label cfg-4) + obj + ) + +;; definition of type grunt-global-info +(deftype grunt-global-info (basic) + ((prev-knocked-anim-index int32 :offset-assert 4) + (prev-yellow-hit-anim-index int32 :offset-assert 8) + (prev-blue-hit-anim-index int32 :offset-assert 12) + (patrol-anim grunt-anim-info 4 :inline :offset-assert 16) + (charge-anim grunt-anim-info 3 :inline :offset-assert 48) + (attack-anim grunt-anim-info 2 :inline :offset-assert 72) + (knocked-anim grunt-anim-info 4 :inline :offset-assert 88) + (knocked-land-anim grunt-anim-info 4 :inline :offset-assert 120) + (yellow-hit-anim grunt-anim-info 4 :inline :offset-assert 152) + (blue-hit-anim grunt-anim-info 6 :inline :offset-assert 184) + ) + :method-count-assert 9 + :size-assert #xe8 + :flag-assert #x9000000e8 + ) + +;; definition for method 3 of type grunt-global-info +(defmethod inspect grunt-global-info ((obj grunt-global-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tprev-knocked-anim-index: ~D~%" (-> obj prev-knocked-anim-index)) + (format #t "~1Tprev-yellow-hit-anim-index: ~D~%" (-> obj prev-yellow-hit-anim-index)) + (format #t "~1Tprev-blue-hit-anim-index: ~D~%" (-> obj prev-blue-hit-anim-index)) + (format #t "~1Tpatrol-anim[4] @ #x~X~%" (-> obj patrol-anim)) + (format #t "~1Tcharge-anim[3] @ #x~X~%" (-> obj charge-anim)) + (format #t "~1Tattack-anim[2] @ #x~X~%" (-> obj attack-anim)) + (format #t "~1Tknocked-anim[4] @ #x~X~%" (-> obj knocked-anim)) + (format #t "~1Tknocked-land-anim[4] @ #x~X~%" (-> obj knocked-land-anim)) + (format #t "~1Tyellow-hit-anim[4] @ #x~X~%" (-> obj yellow-hit-anim)) + (format #t "~1Tblue-hit-anim[6] @ #x~X~%" (-> obj blue-hit-anim)) + (label cfg-4) + obj + ) + +;; definition of type grunt +(deftype grunt (nav-enemy) + ((patrol-anim grunt-anim-info :offset-assert 604) + (charge-anim grunt-anim-info :offset-assert 608) + (attack-anim grunt-anim-info :offset-assert 612) + (knocked-anim grunt-anim-info :offset-assert 616) + (yellow-hit-anim grunt-anim-info :offset-assert 620) + (blue-hit-anim grunt-anim-info :offset-assert 624) + (intro-path path-control :offset-assert 628) + (use-charge-anim-index int8 :offset-assert 632) + (knocked-anim-index int8 :offset-assert 633) + (jumping-ambush-path-pt int8 :offset-assert 634) + (grunt-flags uint8 :offset-assert 635) + (unknown-byte-n1k2n3 int8 :offset 636) + (unknown-byte-m2j342 int8 :offset 637) + (unknown-byte-1ji2n3 int8 :offset 638) + (unknown-byte-n123n int8 :offset 639) + (state-timeout2 uint64 :offset-assert 640) + (next-warn-time time-frame :offset-assert 648) + (dest vector :inline :offset-assert 656) + (minimap connection-minimap :offset 688) + ) + :heap-base #x240 + :method-count-assert 186 + :size-assert #x2b4 + :flag-assert #xba024002b4 + (:methods + (attack () _type_ :state 178) + (falling-ambush () _type_ :state 179) + (jumping-ambush () _type_ :state 180) + (jumping-ambush-cont () _type_ :state 181) + (wait-for-focus () _type_ :state 182) + (spin-attack () _type_ :state 183) + (grunt-method-184 (_type_ float) process-focusable 184) + (grunt-method-185 () none 185) + ) + ) + +;; definition for method 3 of type grunt +(defmethod inspect grunt ((obj grunt)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type nav-enemy inspect))) + (t9-0 obj) + ) + (format #t "~2Tpatrol-anim: #~%" (-> obj patrol-anim)) + (format #t "~2Tcharge-anim: #~%" (-> obj charge-anim)) + (format #t "~2Tattack-anim: #~%" (-> obj attack-anim)) + (format #t "~2Tknocked-anim: #~%" (-> obj knocked-anim)) + (format #t "~2Tyellow-hit-anim: #~%" (-> obj yellow-hit-anim)) + (format #t "~2Tblue-hit-anim: #~%" (-> obj blue-hit-anim)) + (format #t "~2Tintro-path: ~A~%" (-> obj intro-path)) + (format #t "~2Tcircle-radial-dist: ~f~%" (-> obj desired-angle)) + (format #t "~2Tuse-charge-anim-index: ~D~%" (-> obj unknown-byte-n1k2n3)) + (format #t "~2Tknocked-anim-index: ~D~%" (-> obj unknown-byte-m2j342)) + (format #t "~2Tjumping-ambush-path-pt: ~D~%" (-> obj unknown-byte-1ji2n3)) + (format #t "~2Tgrunt-flags: ~D~%" (-> obj stack 511)) + (format #t "~2Tstate-timeout2: ~D~%" (-> obj state-timeout2)) + (format #t "~2Tnext-warn-time: ~D~%" (-> obj next-warn-time)) + (format #t "~2Tdest: #~%" (-> obj dest)) + (format #t "~2Tfocus-pos: #~%" (-> obj focus-pos)) + (format #t "~2Tminimap: #~%" (-> obj minimap)) + (label cfg-4) + obj + ) + +;; definition for symbol *grunt-global-info*, type grunt-global-info +(define *grunt-global-info* (new 'static 'grunt-global-info + :patrol-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 11 :travel-speed (meters 4)) + (new 'static 'grunt-anim-info :anim-index 12 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 14 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 15 :travel-speed (meters 7)) + ) + :charge-anim (new 'static 'inline-array grunt-anim-info 3 + (new 'static 'grunt-anim-info :anim-index 14 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 15 :travel-speed (meters 7)) + (new 'static 'grunt-anim-info :anim-index 16 :travel-speed (meters 7)) + ) + :attack-anim (new 'static 'inline-array grunt-anim-info 2 + (new 'static 'grunt-anim-info :anim-index 17 :travel-speed (meters 12)) + (new 'static 'grunt-anim-info :anim-index 18 :travel-speed (meters 12)) + ) + :knocked-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 22) + (new 'static 'grunt-anim-info :anim-index 24) + (new 'static 'grunt-anim-info :anim-index 26) + (new 'static 'grunt-anim-info :anim-index 28) + ) + :knocked-land-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 23) + (new 'static 'grunt-anim-info :anim-index 25) + (new 'static 'grunt-anim-info :anim-index 27) + (new 'static 'grunt-anim-info :anim-index 29) + ) + :yellow-hit-anim (new 'static 'inline-array grunt-anim-info 4 + (new 'static 'grunt-anim-info :anim-index 34) + (new 'static 'grunt-anim-info :anim-index 35) + (new 'static 'grunt-anim-info :anim-index 36) + (new 'static 'grunt-anim-info :anim-index 37) + ) + :blue-hit-anim (new 'static 'inline-array grunt-anim-info 6 + (new 'static 'grunt-anim-info :anim-index 38) + (new 'static 'grunt-anim-info :anim-index 39) + (new 'static 'grunt-anim-info :anim-index 40) + (new 'static 'grunt-anim-info :anim-index 41) + (new 'static 'grunt-anim-info :anim-index 42) + (new 'static 'grunt-anim-info :anim-index 43) + ) + ) + ) + +;; definition for symbol *grunt-nav-enemy-info*, type nav-enemy-info +(define *grunt-nav-enemy-info* (new 'static 'nav-enemy-info + :use-die-falling #t + :use-victory #f + :use-jump-blocked #t + :debug-draw-neck #f + :jump-debug-draw #f + :move-to-ground #t + :hover-if-no-ground #f + :idle-anim-script (new 'static 'array uint32 36 + #x1e0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x3c0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1010601 + #x691e0701 + #x1e0002 + #x1010801 + #x691e0901 + #x1010a01 + #x1e0002 + #x3010501 + #x1e0002 + #x1011e01 + #x3c0002 + #x1010501 + #x0 + ) + :idle-anim 5 + :notice-anim 13 + :hostile-anim -1 + :hit-anim 34 + :knocked-anim -1 + :knocked-land-anim -1 + :die-anim 19 + :die-falling-anim 32 + :victory-anim -1 + :jump-wind-up-anim 45 + :jump-in-air-anim 46 + :jump-land-anim 47 + :neck-joint 5 + :look-at-joint 6 + :bullseye-joint 18 + :sound-hit (static-sound-name "grunt-hit") + :sound-die (static-sound-name "grunt-die") + :notice-distance (meters 40) + :notice-distance-delta (meters 10) + :proximity-notice-distance (meters 20) + :default-hit-points 5 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :penetrate-knocked #xffffffffffffffff + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 5) + :attack-shove-up (meters 3) + :attack-mode 'generic + :attack-damage 2 + :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher) + :jump-height-min (meters 3) + :jump-height-factor 0.5 + :knocked-seek-ry-clamp 6371.5557 + :knocked-soft-vxz-lo 72089.6 + :knocked-soft-vxz-hi 108134.4 + :knocked-soft-vy-lo 81920.0 + :knocked-soft-vy-hi 122880.0 + :knocked-medium-vxz-lo 147456.0 + :knocked-medium-vxz-hi 196608.0 + :knocked-medium-vy-lo 135168.0 + :knocked-medium-vy-hi 151552.0 + :knocked-hard-vxz-lo 78643.2 + :knocked-hard-vxz-hi 117964.8 + :knocked-hard-vy-lo 183500.8 + :knocked-hard-vy-hi 209715.2 + :knocked-huge-vxz-lo 164659.2 + :knocked-huge-vxz-hi 249036.8 + :knocked-huge-vy-lo 183500.8 + :knocked-huge-vy-hi 217907.2 + :knocked-yellow-vxz-lo 40960.0 + :knocked-yellow-vxz-hi 49152.0 + :knocked-yellow-vy-lo 57344.0 + :knocked-yellow-vy-hi 81920.0 + :knocked-red-vxz-lo 24576.0 + :knocked-red-vxz-hi 196608.0 + :knocked-red-vy-lo 94208.0 + :knocked-red-vy-hi 151552.0 + :knocked-blue-vxz-lo 40960.0 + :knocked-blue-vxz-hi 49152.0 + :knocked-blue-vy-lo 24576.0 + :knocked-blue-vy-hi 81920.0 + :shadow-size (meters 2) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint 6 + :gem-seg #x2 + :gem-no-seg #x4 + :gem-offset (new 'static 'sphere :y 614.4 :z -3276.8 :r 327680.0) + :callback-info #f + :use-momentum #t + :use-frustration #t + :use-stop-chase #t + :use-circling #t + :use-pacing #t + :walk-anim 11 + :turn-anim -1 + :run-anim 14 + :taunt-anim 20 + :run-travel-speed (meters 7) + :run-acceleration (meters 6) + :run-turning-acceleration (meters 50) + :walk-travel-speed (meters 4) + :walk-acceleration (meters 6) + :walk-turning-acceleration (meters 3) + :maximum-rotation-rate (degrees 360.0) + :notice-nav-radius (meters 2) + :frustration-distance (meters 8) + :frustration-time (seconds 4) + :blocked-time (seconds 0.3) + :circle-dist-lo 20480.0 + :circle-dist-hi 61440.0 + :nav-mesh #f + ) + ) + +;; failed to figure out what this is: +(set! (-> *grunt-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +;; definition for method 74 of type grunt +(defmethod enemy-method-74 grunt ((obj grunt) (arg0 process) (arg1 object) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('hit 'hit-knocked) + (logclear! (-> obj mask) (process-mask actor-pause)) + (logclear! (-> obj focus-status) (focus-status dangerous)) + (logclear! (-> obj enemy-flags) (enemy-flag enable-on-notice)) + (logior! (-> obj enemy-flags) (enemy-flag chase-startup)) + (logior! (-> obj focus-status) (focus-status hit)) + (if (zero? (-> obj hit-points)) + (logior! (-> obj focus-status) (focus-status dead)) + ) + (logclear! (-> obj enemy-flags) (enemy-flag actor-pause-backup)) + (enemy-method-62 obj) + (set! (-> obj enemy-flags) (logior (enemy-flag actor-pause-backup) (-> obj enemy-flags))) + (process-contact-action arg0) + (send-event arg0 'get-attack-count 1) + (cond + ((zero? (-> obj hit-points)) + (let ((s5-1 (-> obj incoming knocked-type))) + (cond + ((and (= s5-1 (knocked-type knocked-type-4)) + (not (and (-> obj next-state) (let ((v1-33 (-> obj next-state name))) + (or (= v1-33 'knocked) (= v1-33 'jump) (= v1-33 'jump-land)) + ) + ) + ) + (zero? (get-rand-int obj 3)) + (let ((f0-0 (vector-vector-distance-squared (-> obj root-override2 trans) (target-pos 0))) + (f1-0 32768.0) + ) + (>= f0-0 (* f1-0 f1-0)) + ) + ) + (enemy-method-73 obj) + ) + ((or (= s5-1 (knocked-type knocked-type-4)) (= s5-1 (knocked-type knocked-type-6))) + (set! (-> obj incoming knocked-type) (knocked-type knocked-type-0)) + (go (method-of-object obj knocked)) + ) + (else + (go (method-of-object obj knocked)) + ) + ) + ) + ) + (else + (go (method-of-object obj knocked)) + ) + ) + #t + ) + (else + ((method-of-type nav-enemy enemy-method-74) obj arg0 arg1 arg2 arg3) + ) + ) + (none) + ) + +;; definition for method 66 of type grunt +(defmethod go-ambush grunt ((obj grunt)) + (cond + ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user10)) + (go (method-of-object obj falling-ambush)) + ) + ((logtest? (-> obj fact-info-override enemy-options) (enemy-option user11)) + (go (method-of-object obj jumping-ambush)) + ) + (else + (format 0 "ERROR: ~A doesn't specify which ambush behavior to use.~%" (-> obj name)) + (go-hostile obj) + ) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate falling-ambush (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (logclear! (-> self enemy-flags) (enemy-flag auto-reset-penetrate)) + (let ((gp-0 (-> self on-notice))) + (if gp-0 + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (-> self root-override2 trans)) + (the-as pair gp-0) + ) + ) + ) + ) + (let* ((gp-1 *target*) + (a0-4 (if (type? gp-1 process-focusable) + gp-1 + ) + ) + ) + (when a0-4 + (let* ((gp-2 (-> self root-override2)) + (s3-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (get-trans a0-4 0) (-> gp-2 trans)) 1.0)) + (f0-0 (deg-diff (quaternion-y-angle (-> gp-2 quat)) (vector-y-angle s3-0))) + ) + (quaternion-rotate-y! (-> gp-2 quat) (-> gp-2 quat) f0-0) + ) + ) + ) + (logclear! (-> self draw status) (draw-control-status no-draw)) + (let* ((v1-17 *game-info*) + (a0-15 (+ (-> v1-17 attack-id) 1)) + ) + (set! (-> v1-17 attack-id) a0-15) + (set! (-> self attack-id) a0-15) + ) + (let ((v1-19 (-> self root-override2 root-prim))) + (set! (-> v1-19 prim-core collide-as) (collide-spec)) + (set! (-> v1-19 prim-core collide-with) (collide-spec)) + ) + 0 + (none) + ) + :exit (behavior () + (let ((v1-1 (-> self root-override2 root-prim))) + (set! (-> v1-1 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-1 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (none) + ) + :code (behavior () + (let ((gp-0 (-> self clock frame-counter))) + (until (>= (- (-> self clock frame-counter) gp-0) (seconds 0.2)) + (suspend) + ) + ) + (let ((v1-6 (-> self root-override2 root-prim))) + (set! (-> v1-6 prim-core collide-as) (-> self root-override2 backup-collide-as)) + (set! (-> v1-6 prim-core collide-with) (-> self root-override2 backup-collide-with)) + ) + (sound-play "grunt-notice") + (ja-channel-push! 1 0) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override notice-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override notice-anim))) + frames + num-frames + ) + -1 + ) + ) + 1.8 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max 1.8)) + ) + (until (logtest? (-> self root-override2 status) (collide-status on-ground touch-surface touch-wall)) + (suspend) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-falling-post) + ) + +;; definition for method 93 of type grunt +(defmethod enemy-method-93 grunt ((obj grunt)) + (case (-> obj jump-why) + ((2) + (go (method-of-object obj jumping-ambush-cont)) + ) + (else + ((method-of-type nav-enemy enemy-method-93) obj) + ) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate jumping-ambush (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + ((-> (method-of-type nav-enemy ambush) enter)) + (when (zero? (-> self intro-path)) + (format 0 "ERROR: ~A has no intro path, skipping jumping-ambush~%" (-> self name)) + (go-virtual notice) + ) + (get-point-in-path! (-> self intro-path) (-> self root-override2 trans) 0.0 'interp) + (none) + ) + :code (behavior () + (set! (-> self unknown-byte-1ji2n3) 1) + (until #f + (let ((gp-0 (new 'stack-no-clear 'vector))) + (get-point-in-path! (-> self intro-path) gp-0 1.0 'interp) + (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable)))) + (let ((a1-1 (new 'stack-no-clear 'event-message-block))) + (let ((v1-5 (process->ppointer self))) + (set! (-> a1-1 from) v1-5) + ) + (set! (-> a1-1 num-params) 2) + (set! (-> a1-1 message) 'jump) + (set! (-> a1-1 param 0) (the-as uint 2)) + (set! (-> a1-1 param 1) (the-as uint gp-0)) + (send-event-function self a1-1) + ) + ) + (suspend) + ) + #f + (none) + ) + ) + +;; failed to figure out what this is: +(defstate jumping-ambush-cont (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :code (behavior () + (let ((a0-0 (-> self intro-path)) + (v1-1 (+ (-> self unknown-byte-1ji2n3) 1)) + ) + (if (< v1-1 (-> a0-0 curve num-cverts)) + (set! (-> self unknown-byte-1ji2n3) v1-1) + (enemy-method-72 self) + ) + ) + (until #f + (let ((gp-0 (new 'stack-no-clear 'vector))) + (get-point-in-path! (-> self intro-path) gp-0 (the float (-> self unknown-byte-1ji2n3)) 'interp) + (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag vulnerable)))) + (let ((a1-1 (new 'stack-no-clear 'event-message-block))) + (let ((v1-9 (process->ppointer self))) + (set! (-> a1-1 from) v1-9) + ) + (set! (-> a1-1 num-params) 2) + (set! (-> a1-1 message) 'jump) + (set! (-> a1-1 param 0) (the-as uint 2)) + (set! (-> a1-1 param 1) (the-as uint gp-0)) + (send-event-function self a1-1) + ) + ) + (suspend) + ) + #f + (none) + ) + ) + +;; failed to figure out what this is: +(defstate active (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (or (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-8 (ja-group))) + (and v1-8 (or (= v1-8 (-> self draw art-group data 11)) + (= v1-8 (-> self draw art-group data 12)) + (= v1-8 (-> self draw art-group data 14)) + (= v1-8 (-> self draw art-group data 15)) + ) + ) + ) + ) + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (until #f + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((v1-28 (-> self nav))) + (set! (-> v1-28 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + (s5-0 (get-rand-int-range self 1 8)) + ) + (let ((v1-37 (ja-group))) + (if (not (and v1-37 (= v1-37 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (dotimes (s4-0 s5-0) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + (when (nonzero? (-> self patrol-anim anim-index)) + (ja-no-eval :num! (loop!)) + (ja-channel-push! 1 (seconds 0.2)) + (set! (-> self patrol-anim) (the-as grunt-anim-info (-> *grunt-global-info* patrol-anim))) + (let ((v1-67 (-> self nav))) + (set! (-> v1-67 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((gp-1 (-> self draw art-group data (-> self patrol-anim anim-index))) + (s5-1 (get-rand-int-range self 2 5)) + ) + (ja-no-eval :group! gp-1 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (ja-blend-eval) + (suspend) + (ja :num! (seek! max f30-0)) + ) + (dotimes (s4-1 s5-1) + (ja-no-eval :group! gp-1 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-1) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + ) + (when (zero? (get-rand-int self 3)) + (let ((v1-107 self)) + (set! (-> v1-107 enemy-flags) + (the-as enemy-flag (logclear (-> v1-107 enemy-flags) (enemy-flag enemy-flag36))) + ) + (set! (-> v1-107 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (ja-channel-push! 1 (seconds 0.3)) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + (until (not (enemy-method-123 self 0.2)) + (ja-no-eval :group! (-> self draw art-group data (-> self enemy-info-override idle-anim)) + :num! (seek! + (the float + (+ (-> (the-as art-joint-anim (-> self draw art-group data (-> self enemy-info-override idle-anim))) + frames + num-frames + ) + -1 + ) + ) + f30-0 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((v1-171 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-171 enemy-flags))) + (set! (-> v1-171 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-171 enemy-flags)))) + ) + (set! (-> v1-171 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-171 enemy-flags)))) + (set! (-> v1-171 nav callback-info) (-> v1-171 enemy-info-override callback-info)) + ) + 0 + ) + ) + ) + #f + (none) + ) + ) + +;; definition for method 184 of type grunt +(defmethod grunt-method-184 grunt ((obj grunt) (arg0 float)) + (local-vars (v1-5 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (enemy-method-107 obj))) + (when gp-0 + (let ((v1-3 (get-trans gp-0 0)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (vector-! s4-0 v1-3 (-> obj root-override2 trans)) + (.lvf vf1 (&-> s4-0 quad)) + (.add.w.vf vf2 vf0 vf0 :mask #b1) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf2 vf1 :mask #b1) + (.add.mul.y.vf acc vf2 vf1 acc :mask #b1) + (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1) + (.mov v1-5 vf1) + (let* ((f30-0 v1-5) + (f0-0 arg0) + (f28-0 (* f0-0 f0-0)) + (f0-2 12288.0) + ) + (when (or (>= (* f0-2 f0-2) f30-0) (>= f28-0 f30-0)) + (let ((f26-0 (quaternion-y-angle (-> obj root-override2 quat))) + (f0-7 (atan (-> s4-0 x) (-> s4-0 z))) + (f1-0 1228.8) + ) + (cond + ((and (< (* f1-0 f1-0) f30-0) (>= f28-0 f30-0) (>= 8192.0 (fabs (deg- f26-0 f0-7)))) + (go (method-of-object obj attack)) + ) + ((let ((f0-10 12288.0)) + (< f30-0 (* f0-10 f0-10)) + ) + (go (method-of-object obj spin-attack)) + ) + ) + ) + ) + ) + ) + ) + gp-0 + ) + ) + ) + +;; failed to figure out what this is: +(defstate hostile (grunt) + :virtual #t + :trans (behavior () + (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans))) + (if t9-0 + (t9-0) + ) + ) + (let ((a0-1 (grunt-method-184 self 13312.0)) + (gp-0 (-> self clock frame-counter)) + ) + (when (and (>= gp-0 (-> self next-warn-time)) + (zero? (logand (-> self draw status) (draw-control-status on-screen))) + ) + (when (and a0-1 + (let ((f0-0 65536.0)) + (>= (* f0-0 f0-0) (vector-vector-xz-distance-squared (get-trans a0-1 0) (-> self root-override2 trans))) + ) + ) + (sound-play "grunt-warn") + (set! (-> self next-warn-time) (+ gp-0 (get-rand-int-range self 300 360))) + ) + ) + ) + (none) + ) + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (let ((f30-0 (get-rand-float-range self 0.9 1.1))) + (let ((v1-19 (-> self unknown-byte-n1k2n3))) + (cond + ((>= v1-19 0) + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim v1-19)) + (set! (-> self unknown-byte-n1k2n3) -1) + ) + (else + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim (get-rand-int self 3))) + ) + ) + ) + (until #f + (grunt-method-184 self 22528.0) + (let ((gp-0 (-> self draw art-group data (-> self charge-anim anim-index)))) + (let ((v1-37 (ja-group))) + (when (not (and v1-37 (= v1-37 gp-0))) + (ja-channel-push! 1 (seconds 0.1)) + (let ((v1-41 (-> self nav))) + (set! (-> v1-41 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-chase-post) + ) + +;; failed to figure out what this is: +(defstate attack (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (let ((v1-1 (-> self nav state))) + (set! (-> v1-1 speed) (-> self enemy-info-override run-travel-speed)) + ) + 0 + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (logior! (-> self focus-status) (focus-status dangerous)) + (set! (-> self root-override2 penetrate-using) (penetrate generic-attack lunge)) + (enemy-method-49 self) + (let* ((v1-10 *game-info*) + (v0-1 (+ (-> v1-10 attack-id) 1)) + ) + (set! (-> v1-10 attack-id) v0-1) + (set! (-> self attack-id) v0-1) + ) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (enemy-method-49 self) + (when (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (sound-play "grunt-hit") + ) + (none) + ) + :code (behavior () + (set! (-> self attack-anim) (-> *grunt-global-info* attack-anim (get-rand-int self 2))) + (let ((v1-5 (-> self nav))) + (set! (-> v1-5 target-speed) (-> self attack-anim travel-speed)) + ) + 0 + (let ((v1-7 (-> self nav))) + (set! (-> v1-7 turning-acceleration) 49152.0) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self attack-anim anim-index))) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (let ((v1-17 (ja-group))) + (if (not (and v1-17 (= v1-17 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((v1-36 (-> self nav))) + (set! (-> v1-36 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (let ((v1-38 (-> self nav))) + (set! (-> v1-38 turning-acceleration) (-> self enemy-info-override run-turning-acceleration)) + ) + 0 + (let ((gp-1 (-> self draw art-group data (-> self charge-anim anim-index)))) + (ja-channel-push! 1 (seconds 0.1)) + (set! (-> self skel root-channel 0 frame-group) (the-as art-joint-anim gp-1)) + ) + (ja :num-func num-func-identity :frame-num (ja-aframe 3.0 0)) + (let ((gp-3 (-> self focus aware))) + (if (or (not (enemy-method-107 self)) (!= gp-3 3)) + (go-stare self) + ) + ) + (let ((v1-57 0)) + (let ((a0-22 (the-as object (-> *grunt-global-info* charge-anim))) + (a1-7 (-> self charge-anim)) + ) + (dotimes (a2-3 3) + (when (= a0-22 a1-7) + (set! v1-57 a2-3) + (goto cfg-21) + ) + (set! a0-22 (&+ (the-as grunt-anim-info a0-22) 8)) + ) + ) + (label cfg-21) + (set! (-> self unknown-byte-n1k2n3) v1-57) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-chase-post) + ) + +;; failed to figure out what this is: +(defstate spin-attack (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (behavior () + (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags))) + (let ((v1-2 self)) + (set! (-> v1-2 enemy-flags) (the-as enemy-flag (logclear (-> v1-2 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-2 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (let ((v1-7 self)) + (set! (-> v1-7 enemy-flags) (the-as enemy-flag (logclear (-> v1-7 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + (let ((gp-0 (handle->process (-> self focus handle)))) + (if (not gp-0) + (go-stare self) + ) + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable gp-0) 0) quad)) + ) + (logior! (-> self focus-status) (focus-status dangerous)) + (let* ((v1-21 *game-info*) + (v0-3 (+ (-> v1-21 attack-id) 1)) + ) + (set! (-> v1-21 attack-id) v0-3) + (set! (-> self attack-id) v0-3) + ) + (none) + ) + :exit (behavior () + (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup)) + (if (logtest? (-> self enemy-flags) (enemy-flag check-water)) + (logior! (-> self focus-status) (focus-status dangerous)) + (logclear! (-> self focus-status) (focus-status dangerous)) + ) + (none) + ) + :trans (behavior () + (when (logtest? (-> self enemy-flags) (enemy-flag look-at-focus)) + (logclear! (-> self enemy-flags) (enemy-flag look-at-focus)) + (sound-play "grunt-hit") + ) + (none) + ) + :code (behavior () + (set! (-> self attack-anim) (-> *grunt-global-info* attack-anim (get-rand-int self 2))) + (let ((gp-0 (-> self draw art-group data (-> self attack-anim anim-index))) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (let ((v1-13 (ja-group))) + (if (not (and v1-13 (= v1-13 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (let ((a0-9 (handle->process (-> self focus handle)))) + (if a0-9 + (set! (-> self focus-pos quad) (-> (get-trans (the-as process-focusable a0-9) 0) quad)) + ) + ) + (seek-to-point-toward-point! (-> self root-override2) (-> self focus-pos) 546133.3 (seconds 0.1)) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + (let ((gp-3 (-> self focus aware))) + (if (or (not (enemy-method-107 self)) (!= gp-3 3)) + (go-stare self) + ) + ) + (go-virtual hostile) + (none) + ) + :post (the-as (function none :behavior grunt) nav-enemy-simple-post) + ) + +;; failed to figure out what this is: +(defstate circling (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (until #f + (set! (-> self charge-anim) (-> *grunt-global-info* charge-anim (get-rand-int self 3))) + (let ((v1-22 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-22 enemy-flags))) + (set! (-> v1-22 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-22 enemy-flags)))) + ) + (set! (-> v1-22 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-22 enemy-flags)))) + (set! (-> v1-22 nav callback-info) (-> v1-22 enemy-info-override callback-info)) + ) + 0 + (let ((v1-25 self)) + (set! (-> v1-25 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-25 enemy-flags)))) + ) + 0 + (let ((v1-27 (-> self nav))) + (set! (-> v1-27 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (let ((v1-29 (-> self nav))) + (set! (-> v1-29 acceleration) (-> self enemy-info-override run-acceleration)) + ) + 0 + (let ((v1-31 (-> self nav))) + (set! (-> v1-31 turning-acceleration) (-> self enemy-info-override run-turning-acceleration)) + ) + 0 + (let ((gp-0 (-> self draw art-group data (-> self charge-anim anim-index)))) + (let ((v1-39 (ja-group))) + (if (not (and v1-39 (= v1-39 gp-0))) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + (let ((s5-0 (get-rand-int self 8)) + (f30-0 (get-rand-float-range self 0.9 1.1)) + ) + (while (nonzero? s5-0) + (+! s5-0 -1) + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + ) + (when (< 20480.0 (vector-vector-xz-distance (-> self focus-pos) (-> self root-override2 trans))) + (let ((v1-66 self)) + (set! (-> v1-66 enemy-flags) (the-as enemy-flag (logclear (-> v1-66 enemy-flags) (enemy-flag enemy-flag36)))) + (set! (-> v1-66 nav callback-info) *nav-enemy-null-callback-info*) + ) + 0 + (nav-enemy-method-167 self) + (let ((v1-71 self)) + (set! (-> v1-71 enemy-flags) (the-as enemy-flag (logclear (-> v1-71 enemy-flags) (enemy-flag enemy-flag37)))) + ) + 0 + (vector-reset! (-> self root-override2 transv)) + (let ((v1-77 (ja-group))) + (if (not (and v1-77 (= v1-77 (-> self draw art-group data 30)))) + (ja-channel-push! 1 (seconds 0.1)) + ) + ) + (let ((f30-2 (get-rand-float-range self 0.9 1.1))) + (ja-no-eval :group! (-> self draw art-group data 30) + :num! (seek! + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 30)) frames num-frames) -1)) + f30-2 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-2)) + ) + (ja-no-eval :group! (-> self draw art-group data 31) + :num! (seek! + (the float (+ (-> (the-as art-joint-anim (-> self draw art-group data 31)) frames num-frames) -1)) + f30-2 + ) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-2)) + ) + ) + ) + ) + #f + (none) + ) + ) + +;; failed to figure out what this is: +(defstate pacing (grunt) + :virtual #t + :code (behavior () + (let ((v1-2 (ja-group))) + (when (and v1-2 (or (= v1-2 (-> self draw art-group data 14)) + (= v1-2 (-> self draw art-group data 15)) + (= v1-2 (-> self draw art-group data 16)) + ) + ) + (let ((v1-6 (-> self nav))) + (set! (-> v1-6 target-speed) (-> self charge-anim travel-speed)) + ) + 0 + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + ) + ) + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + ) + (let ((v1-28 self)) + (if (not (logtest? (enemy-flag enemy-flag36) (-> v1-28 enemy-flags))) + (set! (-> v1-28 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag38) (-> v1-28 enemy-flags)))) + ) + (set! (-> v1-28 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag36) (-> v1-28 enemy-flags)))) + (set! (-> v1-28 nav callback-info) (-> v1-28 enemy-info-override callback-info)) + ) + 0 + (let ((v1-31 self)) + (set! (-> v1-31 enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag37) (-> v1-31 enemy-flags)))) + ) + 0 + (let ((v1-33 (-> self nav))) + (set! (-> v1-33 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((v1-35 (-> self nav))) + (set! (-> v1-35 acceleration) (-> self enemy-info-override walk-acceleration)) + ) + 0 + (let ((v1-37 (-> self nav))) + (set! (-> v1-37 turning-acceleration) (-> self enemy-info-override walk-turning-acceleration)) + ) + 0 + (let ((v1-41 (ja-group))) + (if (not (and v1-41 (= v1-41 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + ) + +;; failed to figure out what this is: +(defstate stop-chase (grunt) + :virtual #t + :code (behavior () + (ja-no-eval :num! (seek!)) + (while (not (ja-done? 0)) + (suspend) + (ja-eval) + ) + (set! (-> self patrol-anim) (-> *grunt-global-info* patrol-anim (get-rand-int self 4))) + (let ((v1-14 (-> self nav))) + (set! (-> v1-14 target-speed) (-> self patrol-anim travel-speed)) + ) + 0 + (let ((f30-0 (get-rand-float-range self 0.9 1.1)) + (gp-0 (-> self draw art-group data (-> self patrol-anim anim-index))) + ) + (let ((v1-24 (ja-group))) + (if (not (and v1-24 (= v1-24 gp-0))) + (ja-channel-push! 1 (seconds 0.2)) + ) + ) + (until #f + (ja-no-eval :group! gp-0 + :num! (seek! (the float (+ (-> (the-as art-joint-anim gp-0) frames num-frames) -1)) f30-0) + :frame-num 0.0 + ) + (until (ja-done? 0) + (suspend) + (ja :num! (seek! max f30-0)) + ) + ) + ) + #f + (none) + ) + ) + +;; definition for method 77 of type grunt +(defmethod enemy-method-77 grunt ((obj grunt) (arg0 (pointer float))) + (local-vars (v1-72 int) (a2-3 int) (a2-5 int)) + (case (-> obj incoming knocked-type) + (((knocked-type knocked-type-4)) + (let ((v1-2 (ash 1 (-> *grunt-global-info* prev-yellow-hit-anim-index))) + (a0-7 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and a0-7 (or (= a0-7 (-> obj draw art-group data 16)) + (= a0-7 (-> obj draw art-group data 38)) + (= a0-7 (-> obj draw art-group data 39)) + (= a0-7 (-> obj draw art-group data 40)) + ) + ) + (set! a2-3 (logior v1-2 4)) + (set! a2-3 (logior v1-2 8)) + ) + ) + (let ((s4-0 (enemy-method-120 obj 4 a2-3))) + (set! (-> *grunt-global-info* prev-yellow-hit-anim-index) s4-0) + (set! (-> obj yellow-hit-anim) (-> *grunt-global-info* yellow-hit-anim s4-0)) + (let ((v1-11 (get-rand-int obj 3))) + (if (= s4-0 3) + (set! v1-11 2) + ) + (set! (-> obj unknown-byte-n1k2n3) v1-11) + ) + ) + (let ((s4-1 (-> obj draw art-group data (-> obj yellow-hit-anim anim-index)))) + (ja-channel-push! 1 0) + (let ((a0-19 (-> obj skel root-channel 0))) + (set! (-> a0-19 frame-group) (the-as art-joint-anim s4-1)) + (set! (-> a0-19 param 0) (the float (+ (-> (the-as art-joint-anim s4-1) frames num-frames) -1))) + (set! (-> a0-19 param 1) (-> arg0 0)) + (set! (-> a0-19 frame-num) 0.0) + (joint-control-channel-group! a0-19 (the-as art-joint-anim s4-1) num-func-seek!) + ) + ) + #t + ) + (((knocked-type knocked-type-6)) + (let* ((v1-24 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + (s4-2 (and v1-24 (or (= v1-24 (-> obj draw art-group data 16)) + (= v1-24 (-> obj draw art-group data 38)) + (= v1-24 (-> obj draw art-group data 39)) + (= v1-24 (-> obj draw art-group data 40)) + ) + ) + ) + ) + (if (>= (the-as uint (-> obj incoming blue-juggle-count)) (the-as uint 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 2))) + ) + (cond + ((and (not s4-2) (logtest? (-> obj stack 511) 2)) + (set! s4-2 #t) + (ja-channel-push! 1 (seconds 0.17)) + ) + (else + (let ((v1-36 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (if (and v1-36 (= v1-36 (-> obj draw art-group data 44))) + (ja-channel-push! 1 (seconds 0.17)) + (ja-channel-push! 1 (seconds 0.02)) + ) + ) + ) + ) + (let ((v1-42 (ash 1 (-> *grunt-global-info* prev-blue-hit-anim-index)))) + (if s4-2 + (set! a2-5 (logior v1-42 56)) + (set! a2-5 (logior v1-42 7)) + ) + ) + (let ((v1-46 (enemy-method-120 obj 6 a2-5))) + (set! (-> *grunt-global-info* prev-blue-hit-anim-index) v1-46) + (set! (-> obj blue-hit-anim) (-> *grunt-global-info* blue-hit-anim v1-46)) + ) + (let ((a2-6 0)) + (when (not (logtest? (-> obj stack 511) 2)) + (if s4-2 + (set! a2-6 (logior a2-6 3)) + (set! a2-6 (logior a2-6 4)) + ) + ) + (set! (-> obj unknown-byte-n1k2n3) (enemy-method-120 obj 3 a2-6)) + ) + ) + (let ((a1-26 (-> obj draw art-group data (-> obj blue-hit-anim anim-index))) + (a0-51 (-> obj skel root-channel 0)) + ) + (set! (-> a0-51 frame-group) (the-as art-joint-anim a1-26)) + (set! (-> a0-51 param 0) (the float (+ (-> (the-as art-joint-anim a1-26) frames num-frames) -1))) + (set! (-> a0-51 param 1) (-> arg0 0)) + (set! (-> a0-51 frame-num) 0.0) + (joint-control-channel-group! a0-51 (the-as art-joint-anim a1-26) num-func-seek!) + ) + #t + ) + (else + 0 + (cond + ((or (= (-> obj incoming knocked-type) (knocked-type knocked-type-2)) + (= (-> obj incoming knocked-type) (knocked-type knocked-type-3)) + ) + (set! v1-72 3) + ) + (else + (let ((s4-3 (ash 1 (-> *grunt-global-info* prev-knocked-anim-index)))) + (let ((s3-0 (-> obj root-override2))) + (if (>= 16384.0 (fabs (deg- (quaternion-y-angle (-> s3-0 quat)) (atan (-> s3-0 transv x) (-> s3-0 transv z))))) + (set! s4-3 (logior s4-3 4)) + ) + ) + (set! v1-72 (enemy-method-120 obj 3 s4-3)) + ) + ) + ) + (set! (-> *grunt-global-info* prev-knocked-anim-index) v1-72) + (set! (-> obj unknown-byte-m2j342) v1-72) + (set! (-> obj knocked-anim) (-> *grunt-global-info* knocked-anim v1-72)) + (let ((s4-4 (-> obj draw art-group data (-> obj knocked-anim anim-index)))) + (ja-channel-push! 1 0) + (let ((a0-68 (-> obj skel root-channel 0))) + (set! (-> a0-68 frame-group) (the-as art-joint-anim s4-4)) + (set! (-> a0-68 param 0) (the float (+ (-> (the-as art-joint-anim s4-4) frames num-frames) -1))) + (set! (-> a0-68 param 1) (-> arg0 0)) + (set! (-> a0-68 frame-num) 0.0) + (joint-control-channel-group! a0-68 (the-as art-joint-anim s4-4) num-func-seek!) + ) + ) + #t + ) + ) + ) + +;; definition for method 78 of type grunt +(defmethod enemy-method-78 grunt ((obj grunt) (arg0 (pointer float))) + (cond + ((= (-> obj incoming knocked-type) (knocked-type knocked-type-6)) + (when (or (logtest? (-> obj stack 511) 2) (let ((v1-7 (if (> (-> obj skel active-channels) 0) + (-> obj skel root-channel 0 frame-group) + ) + ) + ) + (not (and v1-7 (or (= v1-7 (-> obj draw art-group data 16)) + (= v1-7 (-> obj draw art-group data 38)) + (= v1-7 (-> obj draw art-group data 39)) + (= v1-7 (-> obj draw art-group data 40)) + ) + ) + ) + ) + ) + (let ((s4-0 (-> obj draw art-group data 44))) + (ja-channel-push! 1 (seconds 0.17)) + (let ((a0-16 (-> obj skel root-channel 0))) + (set! (-> a0-16 frame-group) (the-as art-joint-anim s4-0)) + (set! (-> a0-16 param 0) (the float (+ (-> (the-as art-joint-anim s4-0) frames num-frames) -1))) + (set! (-> a0-16 param 1) (-> arg0 0)) + (set! (-> a0-16 frame-num) 0.0) + (joint-control-channel-group! a0-16 (the-as art-joint-anim s4-0) num-func-seek!) + ) + ) + (set! (-> obj unknown-byte-n123n) (the-as int (logand -3 (-> obj stack 511)))) + #t + ) + ) + ((!= (-> obj incoming knocked-type) (knocked-type knocked-type-4)) + (let ((a1-6 (-> obj + draw + art-group + data + (-> *grunt-global-info* knocked-land-anim (-> obj unknown-byte-m2j342) anim-index) + ) + ) + (a0-23 (-> obj skel root-channel 0)) + ) + (set! (-> a0-23 frame-group) (the-as art-joint-anim a1-6)) + (set! (-> a0-23 param 0) (the float (+ (-> (the-as art-joint-anim a1-6) frames num-frames) -1))) + (set! (-> a0-23 param 1) (-> arg0 0)) + (set! (-> a0-23 frame-num) 0.0) + (joint-control-channel-group! a0-23 (the-as art-joint-anim a1-6) num-func-seek!) + ) + #t + ) + ) + ) + +;; failed to figure out what this is: +(defstate wait-for-focus (grunt) + :virtual #t + :event (the-as (function process int symbol event-message-block object :behavior grunt) enemy-event-handler) + :enter (-> (method-of-type nav-enemy idle) enter) + :trans (behavior () + (let ((s5-0 (handle->process (-> self focus handle)))) + (when s5-0 + (let ((gp-0 (get-trans (the-as process-focusable s5-0) 0))) + (when (and (or (not (logtest? (-> self enemy-flags) (enemy-flag enable-on-notice))) + (>= 163840.0 (vector-vector-distance (-> self root-override2 trans) gp-0)) + ) + (or (not (logtest? (-> self fact-info-override enemy-options) (enemy-option user8))) + (and (not (logtest? (-> (the-as process-focusable s5-0) focus-status) (focus-status in-air))) + (>= 4096.0 (fabs (- (-> gp-0 y) (-> self root-override2 trans y)))) + ) + ) + ) + (cond + ((and (logtest? (-> self fact-info-override enemy-options) (enemy-option user9)) + (logtest? (-> self enemy-flags) (enemy-flag enable-on-notice)) + ) + (let ((s5-1 (new 'stack-no-clear 'vector))) + (vector-! s5-1 gp-0 (-> self root-override2 trans)) + (let ((f0-2 32768.0) + (v1-26 s5-1) + ) + (if (or (>= f0-2 (sqrtf (+ (* (-> v1-26 x) (-> v1-26 x)) (* (-> v1-26 z) (-> v1-26 z))))) + (>= 20024.889 (fabs (deg- (y-angle (-> self root-override2)) (atan (-> s5-1 x) (-> s5-1 z))))) + ) + (go-virtual notice) + ) + ) + ) + ) + (else + (go-virtual notice) + ) + ) + ) + ) + ) + ) + (none) + ) + :code (-> (method-of-type nav-enemy idle) code) + :post (-> (method-of-type nav-enemy idle) post) + ) + +;; definition for method 132 of type grunt +(defmethod enemy-method-132 grunt ((obj grunt)) + (when (-> obj minimap) + (logior! (-> obj minimap flags) (minimap-flag fade-out)) + (set! (-> obj minimap) #f) + ) + ((the-as (function nav-enemy none) (find-parent-method grunt 132)) obj) + (none) + ) + +;; definition for method 7 of type grunt +;; WARN: Return type mismatch nav-enemy vs grunt. +(defmethod relocate grunt ((obj grunt) (arg0 int)) + (if (nonzero? (-> obj intro-path)) + (&+! (-> obj intro-path) arg0) + ) + (the-as grunt ((method-of-type nav-enemy relocate) obj arg0)) + ) + +;; definition for method 114 of type grunt +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-114 grunt ((obj grunt)) + "@abstract" + (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s5-0 reaction) cshape-reaction-default) + (set! (-> s5-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (set! (-> s5-0 penetrated-by) (penetrate + generic-attack + lunge + flop + punch + spin + roll + uppercut + bonk + tube + vehicle + flut-attack + board + mech-punch + dark-punch + dark-giant + ) + ) + (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 7) 0))) + (set! (-> s5-0 total-prims) (the-as uint 8)) + (set! (-> s4-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s4-0 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> s4-0 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> s4-0 local-sphere) 0.0 6144.0 0.0 17408.0) + (set! (-> s5-0 root-prim) s4-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) + (collide-spec backgnd jak bot crate obstacle hit-by-others-list player-list) + ) + (set! (-> v1-13 prim-core action) (collide-action solid can-ride deadly no-standon)) + (set-vector! (-> v1-13 local-sphere) 0.0 4915.2 0.0 4915.2) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-with) (collide-spec backgnd crate obstacle hit-by-others-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set-vector! (-> v1-15 local-sphere) 0.0 9830.4 0.0 4915.2) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-17 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-17 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-17 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-17 transform-index) 4) + (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 4915.2) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-19 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-19 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-19 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-19 transform-index) 18) + (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 2252.8) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-21 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-21 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-21 prim-core action) (collide-action deadly)) + (set! (-> v1-21 transform-index) 16) + (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-23 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-23 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-23 prim-core action) (collide-action deadly)) + (set! (-> v1-23 transform-index) 12) + (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-25 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-25 prim-core collide-with) (collide-spec jak bot player-list)) + (set! (-> v1-25 prim-core action) (collide-action semi-solid deadly)) + (set! (-> v1-25 transform-index) 6) + (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 2048.0) + ) + (set! (-> s5-0 nav-radius) 8192.0) + (let ((v1-27 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-27 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-27 prim-core collide-with)) + ) + (set! (-> s5-0 max-iteration-count) (the-as uint 3)) + (set! (-> obj root-override2) s5-0) + ) + 0 + (none) + ) + +;; definition for method 185 of type grunt +;; WARN: Return type mismatch nav-enemy-info vs none. +(defmethod grunt-method-185 grunt () + *grunt-nav-enemy-info* + (none) + ) + +;; definition for method 115 of type grunt +;; WARN: Return type mismatch int vs none. +(defmethod enemy-method-115 grunt ((obj grunt)) + "@abstract" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-grunt" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (enemy-method-113 obj (the-as nav-enemy-info ((method-of-object obj grunt-method-185)))) + (let ((v1-6 (-> obj neck))) + (set! (-> v1-6 up) (the-as uint 1)) + (set! (-> v1-6 nose) (the-as uint 2)) + (set! (-> v1-6 ear) (the-as uint 0)) + (set-vector! (-> v1-6 twist-max) 11832.889 11832.889 0.0 1.0) + (set! (-> v1-6 ignore-angle) 30947.555) + ) + (let ((v1-8 (-> obj nav))) + (set! (-> v1-8 speed-scale) 1.0) + ) + 0 + (set-gravity-length (-> obj root-override2 dynam) 573440.0) + (let ((s5-2 *grunt-global-info*)) + (set! (-> obj patrol-anim) (-> s5-2 patrol-anim (get-rand-int obj 4))) + (set! (-> obj charge-anim) (-> s5-2 charge-anim (get-rand-int obj 3))) + (set! (-> obj attack-anim) (-> s5-2 attack-anim (get-rand-int obj 2))) + ) + (set! (-> obj unknown-byte-n1k2n3) -1) + (if (zero? (get-rand-int obj 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 1))) + ) + (if (zero? (get-rand-int obj 2)) + (set! (-> obj unknown-byte-n123n) (the-as int (logior (-> obj stack 511) 4))) + ) + (set! (-> obj intro-path) (new 'process 'path-control obj 'intro 0.0 (the-as entity #f) #t)) + (add-connection + *part-engine* + obj + 6 + obj + 318 + (new 'static 'vector :x 1433.6 :y 2785.28 :z -1761.28 :w 163840.0) + ) + (add-connection + *part-engine* + obj + 6 + obj + 318 + (new 'static 'vector :x -1433.6 :y 2785.28 :z -1761.28 :w 163840.0) + ) + (set! (-> obj minimap) + (minimap-method-12 *minimap* obj (the-as uint 70) (the-as int #f) (the-as vector #t) 0) + ) + 0 + (none) + ) + +;; definition for method 116 of type grunt +;; WARN: Return type mismatch int vs none. +(defmethod go-idle grunt ((obj grunt)) + (if (logtest? (-> obj fact-info-override enemy-options) (enemy-option user9)) + (go (method-of-object obj wait-for-focus)) + (go (method-of-object obj idle)) + ) + 0 + (none) + )