From 7afa583bff09f9d1d9f50bd1fa8ab20656ad3723 Mon Sep 17 00:00:00 2001 From: Hat Kid <6624576+Hat-Kid@users.noreply.github.com> Date: Sat, 11 Feb 2023 15:34:31 +0100 Subject: [PATCH] decomp: `metalkor-*` files (#2211) Manual patches: - `metalkor-egg-reaction`: Rewrote `(.mula.s)` --------- Co-authored-by: water --- decompiler/config/jak2/all-types.gc | 455 ++- .../jak2/anonymous_function_types.jsonc | 7 +- decompiler/config/jak2/label_types.jsonc | 21 + decompiler/config/jak2/stack_structures.jsonc | 27 +- decompiler/config/jak2/type_casts.jsonc | 155 +- .../jak2/levels/nest/boss/metalkor-extras.gc | 2522 ++++++++++++++ .../jak2/levels/nest/boss/metalkor-setup.gc | 1714 ++++++++++ .../jak2/levels/nest/boss/metalkor-states.gc | 2917 ++++++++++++++++ .../jak2/levels/nest/boss/nestb-scenes.gc | 6 +- .../levels/nest/boss/metalkor-extras_REF.gc | 2669 +++++++++++++++ .../levels/nest/boss/metalkor-setup_REF.gc | 2206 ++++++++++++ .../levels/nest/boss/metalkor-states_REF.gc | 2984 +++++++++++++++++ test/offline/config/jak2/config.jsonc | 3 +- 13 files changed, 15423 insertions(+), 263 deletions(-) create mode 100644 test/decompiler/reference/jak2/levels/nest/boss/metalkor-extras_REF.gc create mode 100644 test/decompiler/reference/jak2/levels/nest/boss/metalkor-setup_REF.gc create mode 100644 test/decompiler/reference/jak2/levels/nest/boss/metalkor-states_REF.gc diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index 12ab6607e0..ab9ae361f0 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -42705,40 +42705,31 @@ ;; metalkor-setup ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype metalkor-bomb (process-drawable) - ((joint-mods UNKNOWN 49 :offset-assert 196) + ((root-override collide-shape-moving :offset 128 :score 1) + (joint-mods joint-mod 49 :offset-assert 200) ) :method-count-assert 21 :size-assert #x18c :flag-assert #x150110018c (:methods - (metalkor-bomb-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype gem-tracker (process) - ((gems UNKNOWN 10 :offset-assert 124) - (gems-collected int8 :offset-assert 204) - (perm-byte-index int8 :offset-assert 205) + ((gems handle 10 :offset-assert 128) + (gems-collected int8 :offset-assert 208) + (perm-byte-index int8 :offset-assert 209) ) :method-count-assert 15 :size-assert #xd2 :flag-assert #xf006000d2 (:methods - (gem-tracker-method-9 () none 9) - (gem-tracker-method-10 () none 10) - (gem-tracker-method-11 () none 11) - (gem-tracker-method-12 () none 12) - (gem-tracker-method-13 () none 13) (idle () _type_ :state 14) ) ) -|# -#| (deftype flitter-gem-tracker (gem-tracker) () :method-count-assert 15 @@ -42747,9 +42738,7 @@ (:methods ) ) -|# -#| (deftype wasp-gem-tracker (gem-tracker) () :method-count-assert 15 @@ -42758,95 +42747,82 @@ (:methods ) ) -|# -#| (deftype rift-occlude (process-drawable) - ((original-trans vector :inline :offset-assert 204) + ((original-trans vector :inline :offset-assert 208) ) :method-count-assert 21 :size-assert #xe0 :flag-assert #x15006000e0 (:methods - (rift-occlude-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype metalkor-distort (process-drawable) - () + ((root-override collide-shape-moving :offset 128 :score 1) + ) :method-count-assert 21 :size-assert #xc8 :flag-assert #x15005000c8 (:methods - (metalkor-distort-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype metalkor-explode (process-drawable) - ((ring uint64 :offset-assert 196) + ((ring handle :offset-assert 200) ) :method-count-assert 21 :size-assert #xd0 :flag-assert #x15005000d0 (:methods - (metalkor-explode-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype metalkor-kid (process-drawable) () :method-count-assert 21 :size-assert #xc8 :flag-assert #x15005000c8 (:methods - (metalkor-kid-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype nestb-tail-bound (process-drawable) () :method-count-assert 21 :size-assert #xc8 :flag-assert #x15005000c8 (:methods - (nestb-tail-bound-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype metalkor-ja-float-info (structure) - ((float-anim basic :offset-assert 0) - (channel-index int8 :offset-assert 4) + ((float-anim art-joint-anim :offset-assert 0) + (channel-index int8 :offset-assert 4) ) + :pack-me :method-count-assert 9 :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype metalkor-spinner-info (structure) ((joint-index int8 :offset-assert 0) (launch-angle float :offset-assert 4) ) + :pack-me :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype metalkor-shot (metalhead-shot) - ((old-transv vector :inline :offset-assert 492) + ((old-transv vector :inline :offset-assert 496) ) :method-count-assert 40 :size-assert #x200 @@ -42854,9 +42830,7 @@ (:methods ) ) -|# -#| (deftype metalkor-flitter (flitter) () :method-count-assert 184 @@ -42865,9 +42839,7 @@ (:methods ) ) -|# -#| (deftype metalkor-wasp (wasp) () :method-count-assert 166 @@ -42876,9 +42848,7 @@ (:methods ) ) -|# -#| (deftype metalkor-spinner-chain-physics (chain-physics) ((gravity-mult float :offset-assert 1392) (velocity-mult float :offset-assert 1396) @@ -42889,87 +42859,75 @@ (:methods ) ) -|# -#| (deftype metalkor-spinner (process-drawable) - ((parent-joint-index int8 :offset-assert 196) - (target-pos vector :inline :offset-assert 204) - (chain basic :offset-assert 220) - (anim-speed float :offset-assert 224) + ((parent-joint-index int8 :offset-assert 200) + (target-pos vector :inline :offset-assert 208) + (chain metalkor-spinner-chain-physics :offset-assert 224) + (anim-speed float :offset-assert 228) ) :method-count-assert 23 :size-assert #xe8 :flag-assert #x17007000e8 (:methods - (metalkor-spinner-method-20 () none 20) - (metalkor-spinner-method-21 () none 21) - (metalkor-spinner-method-22 () none 22) + (break-it () _type_ :state 20) + (idle () _type_ :state 21) + (shoot-out () _type_ :state 22) ) ) -|# -#| (deftype metalkor-egg (process-focusable) - ((last-hit-normal vector :inline :offset-assert 204) - (sticky-time time-frame :offset-assert 220) - (flitter-slot int8 :offset-assert 228) + ((last-hit-normal vector :inline :offset-assert 208) + (sticky-time time-frame :offset-assert 224) + (flitter-slot int8 :offset-assert 232) ) :method-count-assert 31 :size-assert #xe9 :flag-assert #x1f007000e9 (:methods - (metalkor-egg-method-27 () none 27) - (metalkor-egg-method-28 () none 28) - (metalkor-egg-method-29 () none 29) - (metalkor-egg-method-30 () none 30) + (egg-pop () _type_ :state 27) + (fall () _type_ :state 28) + (hatch () _type_ :state 29) + (idle () _type_ :state 30) ) ) -|# -#| (deftype metalkor-wings (process-drawable) - ((prefix basic :offset-assert 196) + ((prefix string :offset-assert 200) ) :method-count-assert 21 :size-assert #xcc :flag-assert #x15005000cc (:methods - (metalkor-wings-method-20 () none 20) + (idle () _type_ :state 20) ) ) -|# -#| (deftype metalkor-foot-lock (structure) ((lock cam-float-seeker :inline :offset-assert 0) (old-position vector :inline :offset-assert 32) - (initialized basic :offset-assert 48) + (initialized symbol :offset-assert 48) ) :method-count-assert 9 :size-assert #x34 :flag-assert #x900000034 ) -|# -#| (deftype metalkor-legs (process-focusable) - ((prefix basic :offset-assert 200) - (trackable basic :offset-assert 204) - (joint-ik UNKNOWN 6 :offset-assert 208) - (ja-float-info UNKNOWN 3 :offset-assert 232) - (foot-locks UNKNOWN 6 :offset-assert 284) + ((prefix string :offset-assert 204) + (trackable symbol :offset-assert 208) + (joint-ik joint-mod-ik 6 :offset-assert 212) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 236) + (foot-locks metalkor-foot-lock 6 :inline :offset 288) ) :method-count-assert 28 :size-assert #x2a0 :flag-assert #x1c022002a0 (:methods - (metalkor-legs-method-27 () none 27) + (idle () _type_ :state 27) ) ) -|# -#| (deftype metalkor-chain-physics (chain-physics) ((prev-rotation float :offset-assert 1392) (prev-y-rotation float :offset-assert 1396) @@ -42977,7 +42935,7 @@ (osc-y oscillating-float :inline :offset-assert 1424) (rand-z delayed-rand-float :inline :offset-assert 1448) (rand-y delayed-rand-float :inline :offset-assert 1480) - (move-with-parent basic :offset-assert 1508) + (move-with-parent symbol :offset-assert 1508) ) :method-count-assert 18 :size-assert #x5e8 @@ -42985,123 +42943,117 @@ (:methods ) ) -|# -#| (deftype metalkor-lowtorso (process-focusable) - ((prefix basic :offset-assert 200) - (tail basic :offset-assert 204) - (tail-initialized basic :offset-assert 208) - (spinners UNKNOWN 4 :offset-assert 212) - (ja-float-info UNKNOWN 3 :offset-assert 244) - (no-collision-timer uint64 :offset-assert 292) - (egg-toss-joint-1 basic :offset-assert 300) - (egg-toss-joint-2 basic :offset-assert 304) - (egg-toss-joint-3 basic :offset-assert 308) - (egg-toss-joint-angle oscillating-float :inline :offset-assert 312) + ((prefix string :offset-assert 204) + (tail metalkor-chain-physics :offset-assert 208) ;; guess + (tail-initialized symbol :offset-assert 212) + (spinners handle 4 :offset-assert 216) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 248) + (no-collision-timer time-frame :offset 296) + (egg-toss-joint-1 joint-mod :offset-assert 304) + (egg-toss-joint-2 joint-mod :offset-assert 308) + (egg-toss-joint-3 joint-mod :offset-assert 312) + (egg-toss-joint-angle oscillating-float :inline :offset-assert 316) ) :method-count-assert 28 :size-assert #x154 :flag-assert #x1c00e00154 (:methods - (metalkor-lowtorso-method-27 () none 27) + (idle () _type_ :state 27) ) ) -|# -#| (deftype metalkor (process-focusable) - ((trackable basic :offset-assert 200) - (flitters UNKNOWN 10 :offset-assert 204) - (flitter-gem-tracker uint64 :offset-assert 284) - (wasps UNKNOWN 3 :offset-assert 292) - (wasp-gem-tracker uint64 :offset-assert 316) - (last-flitter-launched int8 :offset-assert 324) - (last-wasp-launched int8 :offset-assert 325) - (live-flitters int8 :offset-assert 326) - (live-wasps int8 :offset-assert 327) - (shoot-timer uint64 :offset-assert 332) - (target-angle float :offset-assert 340) - (wave-timer uint64 :offset-assert 348) - (in-wave basic :offset-assert 356) - (flitter-timer uint64 :offset-assert 364) - (wasp-timer uint64 :offset-assert 372) - (launching-flitters basic :offset-assert 380) - (launching-wasps basic :offset-assert 384) - (egg-timer uint64 :offset-assert 388) - (last-close-attack int8 :offset-assert 396) - (last-standing-attack int8 :offset-assert 397) - (stage int8 :offset-assert 398) - (next-stage-timer uint64 :offset-assert 404) - (initial-y float :offset-assert 412) - (shots-fired int16 :offset-assert 416) - (stage-hit-points float :offset-assert 420) - (hud uint64 :offset-assert 428) - (lowtorso uint64 :offset-assert 436) - (legs uint64 :offset-assert 444) - (wings uint64 :offset-assert 452) - (kid uint64 :offset-assert 460) - (explode uint64 :offset-assert 468) - (rift-occlude uint64 :offset-assert 476) - (last-attack-id uint32 :offset-assert 484) - (current-nav-poly nav-poly :offset-assert 488) - (shot-anticipate basic :offset-assert 492) - (spinners UNKNOWN 4 :offset-assert 500) - (neck basic :offset-assert 532) - (previous-flat-travel vector :inline :offset-assert 540) - (previous-flat-travel-timer uint64 :offset-assert 556) - (previous-flat-travel-long-timer uint64 :offset-assert 564) - (min-state-hit-points float :offset-assert 572) - (countdown-to-roar int8 :offset-assert 576) - (for-back-interp cam-float-seeker :inline :offset-assert 580) - (run-walk-interp cam-float-seeker :inline :offset-assert 604) - (left-right-interp cam-float-seeker :inline :offset-assert 628) - (walk-turn-interp cam-float-seeker :inline :offset-assert 652) - (idle-interp cam-float-seeker :inline :offset-assert 676) - (tmp-hit-points float :offset-assert 700) - (reps-till-idle-alt int8 :offset-assert 704) - (last-rotation float :offset-assert 708) - (no-collision-timer uint64 :offset-assert 716) - (egg-timer uint64 :offset-assert 388) - (egg-angle float :offset-assert 732) - (arm-frame float :offset-assert 736) - (been-to-entity basic :offset-assert 740) - (flying-speed cam-float-seeker :inline :offset-assert 744) - (wing-sound uint32 :offset-assert 768) - (wing-sound-playing basic :offset-assert 772) - (explode-sound uint32 :offset-assert 776) - (bomb-sound uint32 :offset-assert 780) - (stop-bomb-sound basic :offset-assert 784) - (hit-ring-trans vector :inline :offset-assert 796) - (hit-ring-offset vector :inline :offset-assert 812) - (ring-cam-pos cam-float-seeker :inline :offset-assert 828) - (need-teleport basic :offset-assert 852) + ((trackable symbol :offset-assert 204) + (flitters handle 10 :offset-assert 208) + (flitter-gem-tracker handle :offset-assert 288) + (wasps handle 3 :offset-assert 296) + (wasp-gem-tracker handle :offset-assert 320) + (last-flitter-launched int8 :offset-assert 328) + (last-wasp-launched int8 :offset-assert 329) + (live-flitters int8 :offset-assert 330) + (live-wasps int8 :offset-assert 331) + (shoot-timer time-frame :offset-assert 336) + (target-angle float :offset-assert 344) + (wave-timer time-frame :offset-assert 352) + (in-wave symbol :offset-assert 360) + (flitter-timer time-frame :offset-assert 368) + (wasp-timer time-frame :offset-assert 376) + (launching-flitters symbol :offset-assert 384) + (launching-wasps symbol :offset-assert 388) + (egg-timer time-frame :offset-assert 392) + (last-close-attack int8 :offset-assert 400) + (last-standing-attack int8 :offset-assert 401) + (stage int8 :offset-assert 402) + (next-stage-timer time-frame :offset-assert 408) + (initial-y float :offset-assert 416) + (shots-fired int16 :offset-assert 420) + (stage-hit-points float :offset-assert 424) + (hud handle :offset-assert 432) + (lowtorso handle :offset-assert 440) + (legs handle :offset-assert 448) + (wings handle :offset-assert 456) + (kid handle :offset-assert 464) + (explode handle :offset-assert 472) + (rift-occlude handle :offset-assert 480) + (last-attack-id uint32 :offset-assert 488) + (current-nav-poly nav-poly :offset-assert 492) + (shot-anticipate sparticle-launch-control :offset-assert 496) + (spinners handle 4 :offset-assert 504) + (neck joint-mod :offset-assert 536) + (previous-flat-travel vector :inline :offset-assert 544) + (previous-flat-travel-timer time-frame :offset-assert 560) + (previous-flat-travel-long-timer time-frame :offset-assert 568) + (min-state-hit-points float :offset-assert 576) + (countdown-to-roar int8 :offset-assert 580) + (for-back-interp cam-float-seeker :inline :offset-assert 584) + (run-walk-interp cam-float-seeker :inline :offset-assert 608) + (left-right-interp cam-float-seeker :inline :offset-assert 632) + (walk-turn-interp cam-float-seeker :inline :offset-assert 656) + (idle-interp cam-float-seeker :inline :offset-assert 680) + (tmp-hit-points float :offset-assert 704) + (reps-till-idle-alt int8 :offset-assert 708) + (last-rotation float :offset-assert 712) + (no-collision-timer time-frame :offset-assert 720) + ;; (egg-timer time-frame :offset-assert 392) + (egg-angle float :offset 736) + (arm-frame float :offset-assert 740) + (been-to-entity symbol :offset-assert 744) + (flying-speed cam-float-seeker :inline :offset-assert 748) + (wing-sound sound-id :offset-assert 772) + (wing-sound-playing symbol :offset-assert 776) + (explode-sound sound-id :offset-assert 780) + (bomb-sound sound-id :offset-assert 784) + (stop-bomb-sound symbol :offset-assert 788) + (hit-ring-trans vector :inline :offset-assert 800) + (hit-ring-offset vector :inline :offset-assert 816) + (ring-cam-pos cam-float-seeker :inline :offset-assert 832) + (need-teleport symbol :offset-assert 856) ) :method-count-assert 43 :size-assert #x35c :flag-assert #x2b02e0035c (:methods - (metalkor-method-27 () none 27) - (metalkor-method-28 () none 28) - (metalkor-method-29 () none 29) - (metalkor-method-30 () none 30) - (metalkor-method-31 () none 31) - (metalkor-method-32 () none 32) - (metalkor-method-33 () none 33) - (metalkor-method-34 () none 34) - (metalkor-method-35 () none 35) - (metalkor-method-36 () none 36) - (metalkor-method-37 () none 37) - (metalkor-method-38 () none 38) - (metalkor-method-39 () none 39) - (metalkor-method-40 () none 40) - (metalkor-method-41 () none 41) - (metalkor-method-42 () none 42) + (beaten (symbol) _type_ :state 27) + (explode () _type_ :state 28) + (fly-to-ring () _type_ :state 29) + (last-gasp () _type_ :state 30) + (overload-recover () _type_ :state 31) + (fall-down () _type_ :state 32) + (tail-attack () _type_ :state 33) + (foot-attack () _type_ :state 34) + (get-close () _type_ :state 35) + (standing-shot () _type_ :state 36) + (chase-target () _type_ :state 37) + (play-drop-movie () _type_ :state 38) + (start-second-stage () _type_ :state 39) + (hang-shoot-n-launch () _type_ :state 40) + (hidden () _type_ :state 41) + (test () _type_ :state 42) ) ) -|# -#| (deftype metalkor-ik-setup (structure) ((elbow-index int32 :offset-assert 0) (hand-dist float :offset-assert 4) @@ -43110,65 +43062,63 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -;; (define-extern gem-tracker-get-slot function) -;; (define-extern *metalkor-flitter-nav-enemy-info* nav-enemy-info) -;; (define-extern *metalkor-bomb-probe-joints* array) -;; (define-extern metalkor-bomb-init-by-other function) -;; (define-extern gem-tracker-init-by-other function) -;; (define-extern rift-occlude-init-by-other function) -;; (define-extern metalkor-distort-init-by-other function) -;; (define-extern metalkor-explode-init-by-other function) -;; (define-extern metalkor-kid-init-by-other function) -;; (define-extern *metalkor-spinner-chain-setup* array) -;; (define-extern metalkor-spinner-init-by-other function) -;; (define-extern metalkor-egg-reaction function) -;; (define-extern metalkor-egg-init-by-other function) -;; (define-extern metalkor-wings-init-by-other function) -;; (define-extern *metalkor-ik-setup* array) -;; (define-extern metalkor-legs-init-by-other function) -;; (define-extern *metalkor-lowtorso-chain-setup* array) -;; (define-extern metalkor-lowtorso-init-by-other function) +(define-extern gem-tracker-get-slot (function process int :behavior gem-tracker)) +(define-extern *metalkor-flitter-nav-enemy-info* nav-enemy-info) +(define-extern *metalkor-bomb-probe-joints* (array int8)) +(define-extern metalkor-bomb-init-by-other (function vector entity-actor none :behavior metalkor-bomb)) +(define-extern gem-tracker-init-by-other (function entity-actor int none :behavior gem-tracker)) +(define-extern rift-occlude-init-by-other (function vector none :behavior rift-occlude)) +(define-extern metalkor-distort-init-by-other (function vector quaternion none :behavior metalkor-distort)) +(define-extern metalkor-explode-init-by-other (function vector quaternion handle none :behavior metalkor-explode)) +(define-extern metalkor-kid-init-by-other (function vector none :behavior metalkor-kid)) +(define-extern *metalkor-spinner-chain-setup* (array chain-physics-setup)) +(define-extern metalkor-spinner-init-by-other (function vector int none :behavior metalkor-spinner)) +(define-extern metalkor-egg-reaction (function control-info collide-query vector vector collide-status :behavior metalkor-egg)) +(define-extern metalkor-egg-init-by-other (function vector vector int none :behavior metalkor-egg)) +(define-extern metalkor-wings-init-by-other (function vector vector none :behavior metalkor-wings)) +(define-extern *metalkor-ik-setup* (array metalkor-ik-setup)) +(define-extern metalkor-legs-init-by-other (function string vector none :behavior metalkor-legs)) +(define-extern *metalkor-lowtorso-chain-setup* (array chain-physics-setup)) +(define-extern metalkor-lowtorso-init-by-other (function vector vector none :behavior metalkor-lowtorso)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; metalkor-states ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern *metalkor-spinner-setup* array) -;; (define-extern metalkor-start-spinner function) -;; (define-extern metalkor-spinners-off function) -;; (define-extern metalkor-lowtorso-spinners-off function) -;; (define-extern metalkor-spinner-check function) -;; (define-extern metalkor-lowtorso-spinner-check function) -;; (define-extern metalkor-update-hud function) -;; (define-extern metalkor-all-spinners-on function) -;; (define-extern metalkor-ja-float function) -;; (define-extern metalkor-ja-float-stop function) -;; (define-extern metalkor-ja-float-children function) -;; (define-extern metalkor-ja-float-group? function) -;; (define-extern metalkor-get-ring function) -;; (define-extern metalkor-common function) -;; (define-extern set-countdown-to-roar function) -;; (define-extern metalkor-go-next-stage function) -;; (define-extern metalkor-setup-hit-anim function) -;; (define-extern metalkor-get-gem-tracker function) -;; (define-extern metalkor-handler function) -;; (define-extern metalkor-start-egg function) -;; (define-extern metalkor-check-egg function) -;; (define-extern metalkor-shoot-projectile function) -;; (define-extern metalkor-face-to-vector function) -;; (define-extern update-walk-anim function) -;; (define-extern rotate-and-update-hang-anim function) -;; (define-extern set-color-vectors function) -;; (define-extern metalkor-walk-the-walk function) -;; (define-extern metalkor-set-deadly function) +(define-extern *metalkor-spinner-setup* (array metalkor-spinner-info)) +(define-extern metalkor-start-spinner (function int vector handle :behavior metalkor)) +(define-extern metalkor-spinners-off (function none :behavior metalkor)) +(define-extern metalkor-lowtorso-spinners-off (function none :behavior metalkor)) +(define-extern metalkor-spinner-check (function int float vector none :behavior metalkor)) +(define-extern metalkor-lowtorso-spinner-check (function metalkor-lowtorso float float none :behavior metalkor)) ;; possibly wrong arg0 +(define-extern metalkor-update-hud (function none :behavior metalkor)) +(define-extern metalkor-all-spinners-on (function symbol :behavior metalkor)) +(define-extern metalkor-ja-float (function art-joint-anim float float float joint-control-channel :behavior metalkor)) +(define-extern metalkor-ja-float-stop (function art-joint-anim none :behavior metalkor)) +(define-extern metalkor-ja-float-children (function symbol :behavior metalkor)) +(define-extern metalkor-ja-float-group? (function art-joint-anim int :behavior metalkor)) +(define-extern metalkor-get-ring (function metalkor entity)) +(define-extern metalkor-common (function none :behavior metalkor)) +(define-extern set-countdown-to-roar (function none :behavior metalkor)) +(define-extern metalkor-go-next-stage (function none :behavior metalkor)) +(define-extern metalkor-setup-hit-anim (function attack-info process-drawable art-element art-element float none :behavior metalkor)) +(define-extern metalkor-get-gem-tracker (function process-focusable none :behavior metalkor)) +(define-extern metalkor-handler (function process int symbol event-message-block object :behavior metalkor)) +(define-extern metalkor-start-egg (function symbol :behavior metalkor)) +(define-extern metalkor-check-egg (function symbol :behavior metalkor)) +(define-extern metalkor-shoot-projectile (function none :behavior metalkor)) +(define-extern metalkor-face-to-vector (function vector float float none :behavior metalkor)) +(define-extern update-walk-anim (function vector symbol none :behavior metalkor)) +(define-extern rotate-and-update-hang-anim (function none :behavior metalkor)) +(define-extern set-color-vectors (function float none :behavior metalkor)) +(define-extern metalkor-walk-the-walk (function float symbol none :behavior metalkor)) +(define-extern metalkor-set-deadly (function metalkor symbol int none :behavior metalkor)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; metalkor-extras ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype nestb-formation (hover-formation) () :method-count-assert 16 @@ -43177,14 +43127,12 @@ (:methods ) ) -|# -#| (deftype rift-ring-ingame (process-drawable) - ((anim-speed delayed-rand-float :inline :offset-assert 196) - (stutter basic :offset-assert 224) - (spin-sound uint32 :offset-assert 228) - (spin-sound-playing basic :offset-assert 232) + ((anim-speed delayed-rand-float :inline :offset-assert 200) + (stutter symbol :offset-assert 228) + (spin-sound sound-id :offset-assert 232) + (spin-sound-playing symbol :offset-assert 236) ) :method-count-assert 21 :size-assert #xf0 @@ -43193,9 +43141,7 @@ (idle () _type_ :state 20) ) ) -|# -#| (deftype nest-break-precipice (process-drawable) () :method-count-assert 22 @@ -43206,9 +43152,7 @@ (die () _type_ :state 21) ) ) -|# -#| (deftype metalkor-rays (process-drawable) () :method-count-assert 21 @@ -43218,21 +43162,20 @@ (idle () _type_ :state 20) ) ) -|# -;; (define-extern metalkor-egg-handler function) -;; (define-extern metalkor-shot-move function) -;; (define-extern metalkor-legs-handler function) -;; (define-extern ik-adjust function) -;; (define-extern metalkor-update-ik function) -;; (define-extern *metalkor-lowtorso-spinner-setup* array) -;; (define-extern metalkor-lowtorso-start-spinner function) -;; (define-extern ja-aframe-num-of-proc function) -;; (define-extern metalkor-distort-update function) -;; (define-extern metalkor-rays-init-by-other function) -;; (define-extern *metalkor-bomb-collide-joints* array) -;; (define-extern metalkor-bomb-collide function) -;; (define-extern metalkor-bomb-ground-check function) +(define-extern metalkor-egg-handler (function process int symbol event-message-block object :behavior metalkor-egg)) +(define-extern metalkor-shot-move (function metalkor-shot none)) +(define-extern metalkor-legs-handler (function process int symbol event-message-block object :behavior metalkor-legs)) +(define-extern ik-adjust (function float :behavior metalkor-legs)) +(define-extern metalkor-update-ik (function none :behavior metalkor-legs)) +(define-extern *metalkor-lowtorso-spinner-setup* (array metalkor-spinner-info)) +(define-extern metalkor-lowtorso-start-spinner (function int vector none :behavior metalkor-lowtorso)) +(define-extern ja-aframe-num-of-proc (function process-drawable int float)) +(define-extern metalkor-distort-update (function none :behavior metalkor-distort)) +(define-extern metalkor-rays-init-by-other (function vector quaternion none :behavior metalkor-rays)) +(define-extern *metalkor-bomb-collide-joints* (array int8)) +(define-extern metalkor-bomb-collide (function vector :behavior metalkor-bomb)) +(define-extern metalkor-bomb-ground-check (function symbol :behavior metalkor-bomb)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; nestb-scenes ;; diff --git a/decompiler/config/jak2/anonymous_function_types.jsonc b/decompiler/config/jak2/anonymous_function_types.jsonc index 2a0c38a5b9..408179fc63 100644 --- a/decompiler/config/jak2/anonymous_function_types.jsonc +++ b/decompiler/config/jak2/anonymous_function_types.jsonc @@ -1222,5 +1222,10 @@ [12, "(function none :behavior task-manager)"], [13, "(function none :behavior task-manager)"] ], - "castle-baron": [[7, "(function collectable none)"]] + "castle-baron": [[7, "(function collectable none)"]], + "metalkor-extras": [[65, "(function vector :behavior metalkor-shot)"]], + "metalkor-setup": [ + [1, "(function gem-tracker none)"], + [2, "(function gem-tracker none)"] + ] } diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index bcd26ad1b1..8aec28d9fe 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -1633,5 +1633,26 @@ ["L529", "uint64", true], ["L530", "uint64", true], ["L527", "uint64", true] + ], + "metalkor-states": [ + ["L848", "vector"], + ["L847", "vector"], + ["L849", "vector"], + ["L844", "attack-info"], + ["L870", "uint64", true], + ["L868", "uint64", true], + ["L867", "uint64", true], + ["L871", "uint64", true], + ["L866", "uint64", true], + ["L869", "uint64", true] + ], + "metalkor-extras": [ + ["L382", "vector"], + ["L381", "attack-info"], + ["L420", "vector"], + ["L419", "vector"], + ["L430", "vector"], + ["L431", "vector"], + ["L423", "attack-info"] ] } diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc index 8719385e0c..213fd1a1c9 100644 --- a/decompiler/config/jak2/stack_structures.jsonc +++ b/decompiler/config/jak2/stack_structures.jsonc @@ -2100,5 +2100,30 @@ [656, "vector"], [736, "sphere"], [784, "enemy-init-by-other-params"] - ] + ], + "(method 20 metalkor)": [[16, "vector"]], + "metalkor-common": [[16, "script-context"]], + "metalkor-start-egg": [[16, "vector"]], + "metalkor-check-egg": [ + [16, "vector"], + [32, "vector"] + ], + "metalkor-bomb-ground-check": [[560, "bounding-box"]], + "metalkor-bomb-collide": [ + [624, "vector"], + [560, "bounding-box"] + ], + "metalkor-update-ik": [[688, "vector"]], + "(enter hatch metalkor-egg)": [[96, "enemy-init-by-other-params"]], + "(trans fall metalkor-egg)": [[16, "vector"]], + "(method 26 metalkor-shot)": [ + [144, "event-message-block"], + [48, "vector"] + ], + "(event idle metalkor-lowtorso)": [[176, "vector"]], + "metalkor-go-next-stage": [[160, "vector"]], + "(trans hang-shoot-n-launch metalkor)": [[32, "enemy-init-by-other-params"]], + "(trans test metalkor)": [[32, "vector"]], + "(trans explode metalkor)": [[16, "matrix"]], + "(method 12 metalkor-chain-physics)": [[560, "bounding-box"]] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index 8e72907b9d..97a2f323fe 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -9872,5 +9872,158 @@ [7, "v1", "krew-boss"], [18, "a1", "krew-boss"] ], - "(trans idle krew-boss)": [[417, "v0", "(array collide-shape)"]] + "(trans idle krew-boss)": [[417, "v0", "(array collide-shape)"]], + "(method 11 metalkor)": [ + [279, "v0", "(pointer actor-group)"], + ["_stack_", 16, "res-tag"] + ], + "(method 20 metalkor)": [[12, "a0", "collide-shape-prim-group"]], + "metalkor-get-ring": [ + [11, "v0", "(pointer actor-group)"], + ["_stack_", 16, "res-tag"] + ], + "metalkor-update-hud": [ + [13, "v1", "hud-metalkor"], + [19, "v1", "hud-metalkor"] + ], + "metalkor-common": [[151, "a0", "process-drawable"]], + "metalkor-handler": [ + [314, "s5", "attack-info"], + [319, "s5", "attack-info"], + [322, "s5", "attack-info"], + [325, "s5", "attack-info"], + [328, "s5", "attack-info"], + [331, "s5", "attack-info"], + [388, "s5", "attack-info"], + [394, "s5", "attack-info"], + [442, "s5", "attack-info"], + [447, "s5", "attack-info"] + ], + "metalkor-start-egg": [ + [73, "v1", "float"], + [47, "v1", "float"] + ], + "metalkor-check-egg": [[50, "v1", "process-focusable"]], + "metalkor-setup-hit-anim": [[31, "v1", "float"]], + "metalkor-set-deadly": [[2, "v1", "collide-shape-prim-group"]], + "(trans idle metalkor-rays)": [[4, "a0", "process"]], + "metalkor-distort-update": [[38, "a1", "process-drawable"]], + "(trans idle metalkor-wings)": [[4, "a0", "process"]], + "(enter break-it metalkor-spinner)": [[32, "v1", "float"]], + "(trans idle metalkor-spinner)": [ + [20, "a2", "process-drawable"], + [21, "v1", "int"] + ], + "(enter shoot-out metalkor-spinner)": [[13, "v1", "float"]], + "(trans idle metalkor-legs)": [ + [4, "a0", "process"], + [39, "gp", "process-drawable"], + [22, "v1", "metalkor-legs"], + [27, "v1", "metalkor-legs"], + [36, "a0", "metalkor-legs"], + [56, "v1", "metalkor-legs"] + ], + "(trans idle metalkor-lowtorso)": [ + [17, "a0", "process"], + [49, "a0", "metalkor-lowtorso"], + [52, "gp", "process-drawable"], + [35, "v1", "metalkor-lowtorso"], + [40, "v1", "metalkor-lowtorso"], + [69, "v1", "metalkor-lowtorso"] + ], + "(event idle metalkor-lowtorso)": [ + [15, "a0", "rgbaf"], + [20, "v1", "rgbaf"], + [166, "v1", "process-drawable"], + [170, "v1", "process-drawable"], + [6, "v1", "float"], + [96, "v1", "metalkor-lowtorso"], + [108, "a0", "metalkor-lowtorso"], + [112, "a0", "metalkor-lowtorso"] + ], + "metalkor-update-ik": [["_stack_", 736, "vector"]], + "(trans fall metalkor-egg)": [ + [44, "a0", "collide-shape-moving"], + [64, "a0", "collide-shape-moving"], + [69, "a0", "collide-shape-moving"], + [67, "v1", "collide-shape-moving"], + [49, "a0", "collide-shape-moving"] + ], + "(method 26 metalkor-shot)": [ + [223, "v1", "process-drawable"], + [344, "v1", "process-drawable"] + ], + "(method 20 metalkor-legs)": [[10, "v1", "collide-shape-prim-group"]], + "(trans shoot-out metalkor-spinner)": [ + [68, "a2", "metalkor"], + [69, "v1", "int"] + ], + "metalkor-legs-handler": [ + [39, "a0", "rgbaf"], + [44, "v1", "rgbaf"], + [70, "a0", "metalkor-legs"], + [74, "a0", "metalkor-legs"], + [58, "v1", "metalkor-legs"] + ], + "(method 13 metalkor-chain-physics)": [ + [93, "a0", "metalkor"], + [100, "a0", "metalkor"], + [120, "a0", "metalkor"], + [127, "a0", "metalkor"], + [406, "a0", "metalkor"], + [413, "a0", "metalkor"], + [435, "a0", "metalkor"], + [442, "a0", "metalkor"], + [146, "a0", "metalkor"], + [153, "a0", "metalkor"], + [273, "a0", "metalkor"], + [280, "a0", "metalkor"], + [28, "a0", "metalkor"], + [35, "a0", "metalkor"] + ], + "(trans get-close metalkor)": [[48, "v1", "float"]], + "(trans standing-shot metalkor)": [ + [29, "a0", "art-joint-anim"], + [33, "a0", "art-joint-anim"] + ], + "(trans chase-target metalkor)": [[37, "v1", "float"]], + "update-walk-anim": [ + [72, "a0", "art-joint-anim"], + [83, "a0", "art-joint-anim"], + [121, "a0", "art-joint-anim"], + [295, "v1", "float"], + [426, "v1", "float"] + ], + "metalkor-egg-reaction": [ + [10, "s5", "metalkor-egg"], + [116, "s5", "metalkor-egg"], + ["_stack_", 32, "float"], + [130, "s5", "metalkor-egg"] + ], + "metalkor-spinner-init-by-other": [ + [32, "a0", "process-drawable"], + [72, "v1", "float"], + [94, "v1", "float"] + ], + "metalkor-egg-init-by-other": [[94, "a0", "process-drawable"]], + "metalkor-wings-init-by-other": [[36, "a0", "process-drawable"]], + "metalkor-legs-init-by-other": [ + [604, "a0", "process-drawable"], + [686, "a0", "metalkor-legs"] + ], + "metalkor-lowtorso-init-by-other": [ + [677, "a0", "process-drawable"], + [754, "a0", "metalkor-lowtorso"] + ], + "metalkor-kid-init-by-other": [[37, "a0", "process-drawable"]], + "metalkor-explode-init-by-other": [[37, "a0", "process-drawable"]], + "rift-occlude-init-by-other": [[39, "a0", "process-drawable"]], + "(event idle gem-tracker)": [[37, "a1", "process"]], + "(trans hang-shoot-n-launch metalkor)": [ + [79, "v0", "(pointer actor-group)"], + [369, "v1", "art-joint-anim"], + [373, "v1", "art-joint-anim"], + ["_stack_", 16, "res-tag"] + ], + "(trans explode metalkor)": [[15, "v0", "entity-actor"]] } diff --git a/goal_src/jak2/levels/nest/boss/metalkor-extras.gc b/goal_src/jak2/levels/nest/boss/metalkor-extras.gc index 781d971832..c5a361f8d5 100644 --- a/goal_src/jak2/levels/nest/boss/metalkor-extras.gc +++ b/goal_src/jak2/levels/nest/boss/metalkor-extras.gc @@ -7,3 +7,2525 @@ ;; DECOMP BEGINS +(defbehavior metalkor-egg-handler metalkor-egg ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('track) + #f + ) + (('bonk) + (go-virtual egg-pop) + ) + (('attack) + (go-virtual egg-pop) + ) + ) + ) + +(defstate egg-pop (metalkor-egg) + :virtual #t + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 5))) + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 5)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate hatch (metalkor-egg) + :virtual #t + :enter (behavior () + (send-event (ppointer->process (-> self parent)) 'setup-flitter-gem) + (let ((s5-0 (new 'stack-no-clear 'enemy-init-by-other-params))) + (set! (-> s5-0 trans quad) (-> self root-override trans quad)) + (quaternion-copy! (-> s5-0 quat) (-> self root-override quat)) + (set! (-> s5-0 entity) (-> self entity)) + (set! (-> s5-0 directed?) #f) + (set! (-> s5-0 no-initial-move-to-ground?) #f) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 2) + (set! (-> gp-0 message) 'hatch) + (set! (-> gp-0 param 0) (the-as uint (-> self flitter-slot))) + (let ((s4-0 (get-process *default-dead-pool* metalkor-flitter #x4000))) + (set! (-> gp-0 param 1) + (the-as uint (ppointer->handle (when s4-0 + (let ((t9-3 (method-of-type process activate))) + (t9-3 + s4-0 + (ppointer->process (-> self parent)) + (symbol->string (-> metalkor-flitter symbol)) + (the-as pointer #x70004000) + ) + ) + (run-now-in-process s4-0 enemy-init-by-other self s5-0) + (-> s4-0 ppointer) + ) + ) + ) + ) + ) + (send-event-function (ppointer->process (-> self parent)) gp-0) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 5))) + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 5)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate fall (metalkor-egg) + :virtual #t + :event metalkor-egg-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (local-vars (v1-5 float) (v1-27 float) (v1-34 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'vector))) + (set! (-> gp-0 quad) (-> self root-override transv quad)) + (.lvf vf1 (&-> (-> self root-override transv) 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 ((f0-0 v1-5) + (f1-0 409.6) + ) + (cond + ((< f0-0 (* f1-0 f1-0)) + (go-virtual idle) + ) + ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4)) + (go-virtual hatch) + ) + (else + (vector-v++! + (-> self root-override transv) + (compute-acc-due-to-gravity (the-as collide-shape-moving (-> self root-override)) (new-stack-vector0) 1.0) + ) + (let ((a2-1 (new 'stack-no-clear 'collide-query))) + (set! (-> a2-1 collide-with) (collide-spec backgnd enemy obstacle hit-by-others-list pusher)) + (set! (-> a2-1 ignore-process0) self) + (set! (-> a2-1 ignore-process1) #f) + (set! (-> a2-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> a2-1 action-mask) (collide-action solid)) + (fill-cache-integrate-and-collide + (the-as collide-shape-moving (-> self root-override)) + (-> (the-as collide-shape-moving (-> self root-override)) transv) + a2-1 + (meters 0) + ) + ) + ) + ) + ) + (let* ((f0-1 81920.0) + (f0-3 (* f0-1 f0-1)) + ) + (.lvf vf1 (&-> gp-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-27 vf1) + (cond + ((and (< f0-3 v1-27) (let* ((f0-4 81920.0) + (f0-6 (* f0-4 f0-4)) + ) + (.lvf vf1 (&-> (-> self root-override transv) 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-34 vf1) + (>= f0-6 v1-34) + ) + ) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 4)) + ) + (else + (let ((v1-40 (ja-group))) + (cond + ((and v1-40 (= v1-40 (-> self draw art-group data 4))) + (ja :num! (seek!)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3)) + ) + ) + (else + (ja :num! (loop!)) + ) + ) + ) + ) + ) + ) + ) + (none) + ) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate idle (metalkor-egg) + :virtual #t + :event metalkor-egg-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3)) + (go-virtual hatch) + ) + (let ((v1-9 (ja-group))) + (cond + ((and v1-9 (= v1-9 (-> self draw art-group data 3))) + (ja :num! (loop!)) + ) + ((let ((v1-17 (ja-group))) + (and v1-17 (or (= v1-17 (-> self draw art-group data 7)) (= v1-17 (-> self draw art-group data 4)))) + ) + (ja :num! (seek!)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3)) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 4)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defun metalkor-shot-move ((arg0 metalkor-shot)) + (set! (-> arg0 old-transv quad) (-> arg0 root-override transv quad)) + (projectile-move-fill-line-sphere arg0) + (let ((s5-0 (-> arg0 root-override))) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (vector-! s4-0 (-> arg0 tail-pos) (-> s5-0 trans)) + (let ((f0-0 (vector-length s4-0))) + (when (< 49152.0 f0-0) + (vector-normalize! s4-0 49152.0) + (vector+! (-> arg0 tail-pos) (-> s5-0 trans) s4-0) + ) + ) + ) + (if (logtest? (-> s5-0 status) (collide-status touch-surface)) + (go (method-of-object arg0 impact)) + ) + ) + 0 + (none) + ) + +;; WARN: Return type mismatch vector vs none. +(defmethod init-proj-settings! metalkor-shot ((obj metalkor-shot)) + "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc" + (set! (-> obj tail-pos quad) (-> obj root-override trans quad)) + (set! (-> obj attack-mode) 'metalhead-shot) + (set! (-> obj max-speed) 532480.0) + (set! (-> obj move) metalkor-shot-move) + (set! (-> obj timeout) (seconds 0.767)) + (set-gravity-length (-> obj root-override dynam) 573440.0) + (set! (-> obj old-transv quad) (-> obj root-override transv quad)) + (none) + ) + +(defmethod spawn-shell-particles metalkor-shot ((obj metalkor-shot)) + "TODO - confirm" + (local-vars + (sv-224 (function vector entity-actor skeleton-group vector object none :behavior manipy)) + (sv-240 vector) + (sv-256 entity-actor) + ) + (let* ((s4-0 (-> obj root-override)) + (v0-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj tail-pos) (-> s4-0 trans)) 2048.0)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-0 quad) (-> s4-0 trans quad)) + (vector+! gp-0 gp-0 v0-0) + (let ((s4-1 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-1 + (let ((t9-2 (method-of-type part-tracker activate))) + (t9-2 + (the-as part-tracker s4-1) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-3 run-function-in-process) + (a0-7 s4-1) + (a1-5 part-tracker-init) + (a2-4 (-> *part-group-id-table* 141)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> gp-0 quad)) + ((the-as (function object object object object object object object object none) t9-3) + a0-7 + a1-5 + a2-4 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> s4-1 ppointer) + ) + ) + ) + (let ((s4-2 (new 'stack-no-clear 'vector))) + (set! (-> s4-2 quad) (-> obj root-override trans quad)) + (let ((gp-1 (new 'stack-no-clear 'quaternion))) + (let ((s3-0 (lambda :behavior metalkor-shot + () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 1.0) + (cond + ((>= 10.0 (ja-aframe-num 0)) + (let ((v0-1 (the-as vector (-> self draw color-emissive)))) + (set! (-> (the-as rgbaf v0-1) x) 1.0) + (set! (-> (the-as rgbaf v0-1) y) 1.0) + (set! (-> (the-as rgbaf v0-1) z) 1.0) + (set! (-> (the-as rgbaf v0-1) w) 1.0) + v0-1 + ) + ) + ((>= 20.0 (ja-aframe-num 0)) + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (new 'static 'vector :x 0.5 :z 0.5 :w 1.0) + (lerp-scale 0.0 1.0 (ja-aframe-num 0) 10.0 20.0) + ) + ) + (else + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector :x 0.5 :z 0.5 :w 1.0) + (new 'static 'vector :w 1.0) + (lerp-scale 0.0 1.0 (ja-aframe-num 0) 20.0 30.0) + ) + ) + ) + ) + ) + ) + (let ((s2-0 (new 'stack-no-clear 'matrix))) + (vector-normalize-copy! (-> s2-0 vector 1) (-> obj old-transv) -1.0) + (cond + ((and (< (fabs (-> s2-0 vector 1 y)) (fabs (-> s2-0 vector 1 x))) + (< (fabs (-> s2-0 vector 1 y)) (fabs (-> s2-0 vector 1 z))) + ) + (set-vector! (-> s2-0 vector 2) (-> s2-0 vector 1 z) 0.0 (- (-> s2-0 vector 1 x)) 1.0) + ) + ((< (fabs (-> s2-0 vector 1 z)) (fabs (-> s2-0 vector 1 x))) + (set-vector! (-> s2-0 vector 2) (-> s2-0 vector 1 y) (- (-> s2-0 vector 1 x)) 0.0 1.0) + ) + (else + (set-vector! (-> s2-0 vector 2) 0.0 (-> s2-0 vector 1 z) (- (-> s2-0 vector 1 y)) 0.0) + ) + ) + (vector-normalize! (-> s2-0 vector 2) 1.0) + (vector-cross! (the-as vector (-> s2-0 vector)) (-> s2-0 vector 1) (-> s2-0 vector 2)) + (matrix->quaternion gp-1 s2-0) + ) + (sound-play "nboss-shoot-hit") + (let* ((s1-1 (get-process *default-dead-pool* manipy #x4000)) + (s2-2 + (when s1-1 + (let ((t9-10 (method-of-type manipy activate))) + (t9-10 (the-as manipy s1-1) *default-pool* (symbol->string (-> manipy symbol)) (the-as pointer #x70004000)) + ) + (let ((s2-3 run-function-in-process) + (s0-0 s1-1) + ) + (set! sv-224 manipy-init) + (set! sv-240 s4-2) + (set! sv-256 (-> obj entity)) + (let ((t0-2 (art-group-get-by-name *level* "skel-bomb-blast" (the-as (pointer uint32) #f))) + (t1-2 #f) + (t2-2 0) + ) + ((the-as (function object object object object object object object none) s2-3) + s0-0 + sv-224 + sv-240 + sv-256 + t0-2 + t1-2 + t2-2 + ) + ) + ) + (-> s1-1 ppointer) + ) + ) + ) + (when s2-2 + (send-event (ppointer->process s2-2) 'anim-mode 'play1) + (send-event (ppointer->process s2-2) 'anim "idle") + (set-vector! (-> (the-as process-drawable (-> s2-2 0)) root scale) 0.4 1.0 0.4 1.0) + (send-event (ppointer->process s2-2) 'trans-hook s3-0) + (send-event (ppointer->process s2-2) 'rot-quat gp-1) + ) + ) + ) + (let ((s3-1 (process-spawn + manipy + :init manipy-init + s4-2 + (-> obj entity) + (art-group-get-by-name *level* "skel-generic-blast" (the-as (pointer uint32) #f)) + #f + 0 + ) + ) + ) + (when s3-1 + (send-event (ppointer->process s3-1) 'anim-mode 'play1) + (send-event (ppointer->process s3-1) 'anim "idle") + (set-vector! (-> (the-as process-drawable (-> s3-1 0)) root scale) 0.4 1.0 0.4 1.0) + (send-event (ppointer->process s3-1) 'rot-quat gp-1) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod get-trans metalkor-legs ((obj metalkor-legs) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (cond + ((or (= arg0 2) (= arg0 3)) + (let ((v0-0 (new 'static 'vector :w 1.0))) + (set! (-> v0-0 quad) + (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 0 prim-core world-sphere quad) + ) + (set! (-> v0-0 y) (+ 32768.0 (-> v0-0 y))) + v0-0 + ) + ) + (else + ((method-of-type process-focusable get-trans) obj arg0) + ) + ) + ) + +;; WARN: Return type mismatch process-focusable vs metalkor-legs. +(defmethod relocate metalkor-legs ((obj metalkor-legs) (arg0 int)) + (dotimes (v1-0 6) + (if (nonzero? (-> obj joint-ik v1-0)) + (&+! (-> obj joint-ik v1-0) arg0) + ) + ) + (the-as metalkor-legs ((method-of-type process-focusable relocate) obj arg0)) + ) + +(defbehavior metalkor-legs-handler metalkor-legs ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-0 object)) + (case arg2 + (('track) + (-> self trackable) + ) + (('attack) + (let ((v1-1 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-1 from) (process->ppointer arg0)) + (set! (-> v1-1 num-params) arg1) + (set! (-> v1-1 message) arg2) + (set! (-> v1-1 param 0) (-> arg3 param 0)) + (set! (-> v1-1 param 1) (-> arg3 param 1)) + (set! (-> v1-1 param 2) (-> arg3 param 2)) + (set! (-> v1-1 param 3) (-> arg3 param 3)) + (set! (-> v1-1 param 4) (-> arg3 param 4)) + (set! (-> v1-1 param 5) (-> arg3 param 5)) + (send-event-function (ppointer->process (-> self parent)) v1-1) + ) + ) + (('color) + (set! (-> self draw color-mult quad) (-> (the-as rgbaf (-> arg3 param 0)) quad)) + (set! v0-0 (-> self draw color-emissive)) + (set! (-> (the-as rgbaf v0-0) quad) (-> (the-as rgbaf (-> arg3 param 1)) quad)) + v0-0 + ) + (('trackable) + (set! v0-0 (-> arg3 param 0)) + (set! (-> self trackable) (the-as symbol v0-0)) + v0-0 + ) + (('ja-float) + (dotimes (s5-0 3) + (when (not (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim)) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (get-art-by-name (-> self draw art-group) (the-as string (-> arg3 param 0)) art-joint-anim) + ) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + (the-as int (-> arg3 param 1)) + ) + (return #t) + ) + ) + #f + ) + ) + ) + +(defbehavior ik-adjust metalkor-legs () + (let* ((f0-1 (* 0.0033333334 (the float (- (-> self clock frame-counter) (-> self state-time))))) + (f0-2 (* 9102.223 f0-1)) + (f0-3 (- f0-2 (* (the float (the int (/ f0-2 65536.0))) 65536.0))) + (f0-4 (sin f0-3)) + ) + (* 8192.0 f0-4) + ) + ) + +(defbehavior metalkor-update-ik metalkor-legs () + (local-vars (sv-736 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'collide-query)) + (s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + (let ((v1-1 (-> gp-0 bbox)) + (a0-2 (-> self root-override trans)) + (a1-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> a1-1 x) 32768.0) + (set! (-> a1-1 y) 32768.0) + (set! (-> a1-1 z) 32768.0) + (set! (-> a1-1 w) 1.0) + (vector-! (the-as vector v1-1) a0-2 a1-1) + ) + (let ((v1-3 (-> gp-0 bbox max)) + (a0-4 (-> self root-override trans)) + (a1-2 (new 'stack-no-clear 'vector)) + ) + (set! (-> a1-2 x) 32768.0) + (set! (-> a1-2 y) 32768.0) + (set! (-> a1-2 z) 32768.0) + (set! (-> a1-2 w) 1.0) + (vector+! v1-3 a0-4 a1-2) + ) + (set! (-> gp-0 collide-with) (collide-spec backgnd)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (fill-using-bounding-box *collide-cache* gp-0) + (dotimes (s4-0 6) + (-> self joint-ik s4-0 shoulder-matrix-no-ik) + (let ((a2-8 (-> self joint-ik s4-0 elbow-matrix-no-ik)) + (s2-0 (new 'stack-no-clear 'vector)) + (v1-15 (new 'stack-no-clear 'vector)) + ) + (set! (-> v1-15 quad) (-> (new 'static 'vector :y 1.0) quad)) + (new 'stack-no-clear 'vector) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (let ((a1-4 s2-0)) + (let ((a0-9 (-> a2-8 trans))) + (let ((a2-9 (-> a2-8 vector 1))) + (let ((a3-3 (-> *metalkor-ik-setup* s4-0 hand-dist))) + (.mov vf7 a3-3) + ) + (.lvf vf5 (&-> a2-9 quad)) + ) + (.lvf vf4 (&-> a0-9 quad)) + ) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> a1-4 quad) vf6) + ) + (set! (-> s3-0 quad) (-> s2-0 quad)) + (let ((a2-10 (-> gp-0 start-pos))) + (let ((a0-11 s3-0)) + (let ((a1-7 v1-15)) + (let ((a3-5 24576.0)) + (.mov vf7 a3-5) + ) + (.lvf vf5 (&-> a1-7 quad)) + ) + (.lvf vf4 (&-> a0-11 quad)) + ) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> a2-10 quad) vf6) + ) + (vector-float*! (-> gp-0 move-dist) v1-15 -73728.0) + (let ((v1-16 gp-0)) + (set! (-> v1-16 radius) 40.96) + (set! (-> v1-16 collide-with) (collide-spec backgnd)) + (set! (-> v1-16 ignore-process0) #f) + (set! (-> v1-16 ignore-process1) #f) + (set! (-> v1-16 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-16 action-mask) (collide-action solid)) + ) + (let ((f0-12 (probe-using-line-sphere *collide-cache* gp-0))) + (when (>= f0-12 0.0) + (let ((f1-2 + (vector-dot (-> s5-0 vector 1) (vector-! (new 'stack-no-clear 'vector) s2-0 (-> self root-override trans))) + ) + ) + (cond + ((>= 409.6 f1-2) + (vector+float*! s3-0 (-> gp-0 start-pos) (-> gp-0 move-dist) f0-12) + (set! (-> self foot-locks s4-0 lock target) 1.0) + ) + (else + (vector+float*! s3-0 (-> gp-0 start-pos) (-> gp-0 move-dist) (- f0-12 (* 0.000013563368 f1-2))) + (set! (-> self foot-locks s4-0 lock target) 0.0) + ) + ) + ) + ) + ) + ((method-of-type cam-float-seeker update!) (the-as cam-float-seeker (-> self foot-locks s4-0)) 0.0) + (cond + ((-> self foot-locks s4-0 initialized) + (let ((s2-1 vector-lerp!) + (s1-0 s3-0) + (s0-0 s3-0) + ) + (set! sv-736 (the-as vector (+ (the-as uint (-> self foot-locks 0 old-position)) (* s4-0 64)))) + (let ((a3-6 (parameter-ease-sin-clamp (-> self foot-locks s4-0 lock value)))) + (s2-1 s1-0 s0-0 sv-736 a3-6) + ) + ) + ) + (else + (set! (-> self foot-locks s4-0 initialized) #t) + ) + ) + (handle-copy! (-> self joint-ik s4-0) s3-0) + (set! (-> (the-as (pointer uint128) (+ (the-as uint (-> self foot-locks 0 old-position)) (* s4-0 64)))) + (-> s3-0 quad) + ) + ) + ) + ) + ) + 0 + (none) + ) + ) + +(defstate idle (metalkor-legs) + :virtual #t + :event metalkor-legs-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (dotimes (gp-0 6) + (enable-set! (-> self joint-ik gp-0) #t) + ((method-of-type cam-float-seeker init) (the-as cam-float-seeker (-> self foot-locks gp-0)) 0.0 0.1 0.3 0.9) + (set! (-> self foot-locks gp-0 initialized) #f) + ) + (none) + ) + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (let ((gp-0 (ppointer->process (-> self parent)))) + (when gp-0 + (dotimes (s5-0 3) + (when (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (let ((v1-11 (ja-channel-float! + (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + 0.0 + 0.0 + 0.0 + ) + ) + ) + (when v1-11 + (let ((a0-11 (-> (the-as process-drawable gp-0) + skel + channel + (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + ) + ) + ) + (set! (-> v1-11 frame-num) (-> a0-11 frame-num)) + (set! (-> v1-11 frame-interp 0) (-> a0-11 frame-interp 0)) + (set! (-> v1-11 frame-interp 1) (-> a0-11 frame-interp 1)) + ) + (do-joint-math (-> self draw) (-> self node-list) (-> self skel)) + ) + ) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) #f) + ) + ) + ) + ) + (metalkor-update-ik) + (none) + ) + :code (the-as (function none :behavior metalkor-legs) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(define *metalkor-lowtorso-spinner-setup* + (new 'static 'boxed-array :type metalkor-spinner-info + (new 'static 'metalkor-spinner-info :joint-index #x29 :launch-angle 18204.445) + (new 'static 'metalkor-spinner-info :joint-index #x1e :launch-angle 25486.223) + (new 'static 'metalkor-spinner-info :joint-index #x26 :launch-angle -18204.445) + (new 'static 'metalkor-spinner-info :joint-index #x21 :launch-angle -25486.223) + ) + ) + +;; WARN: Function metalkor-lowtorso-start-spinner has a return type of none, but the expression builder found a return statement. +(defbehavior metalkor-lowtorso-start-spinner metalkor-lowtorso ((arg0 int) (arg1 vector)) + (when (< arg0 4) + (if (handle->process (-> self spinners arg0)) + (return #f) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (sin (-> *metalkor-lowtorso-spinner-setup* arg0 launch-angle))) + (f0-2 (cos (-> *metalkor-lowtorso-spinner-setup* arg0 launch-angle))) + ) + (set-vector! + s5-0 + (+ (* f0-2 (-> arg1 x)) (* f30-0 (-> arg1 z))) + 0.0 + (- (* f0-2 (-> arg1 z)) (* f30-0 (-> arg1 x))) + 1.0 + ) + ) + (vector-normalize! s5-0 (* 81920.0 (cos 10922.667))) + (+! (-> s5-0 y) (* 81920.0 (sin 10922.667))) + (set! (-> s5-0 y) (+ 12288.0 (-> s5-0 y))) + (vector+! s5-0 s5-0 (-> self entity trans)) + (set! (-> self spinners arg0) + (ppointer->handle + (process-spawn metalkor-spinner s5-0 (-> *metalkor-lowtorso-spinner-setup* arg0 joint-index) :to self) + ) + ) + ) + ) + (none) + ) + +(defun ja-aframe-num-of-proc ((arg0 process-drawable) (arg1 int)) + (let* ((a0-2 (-> arg0 skel root-channel arg1)) + (v1-2 (-> a0-2 frame-group)) + ) + (if (and v1-2 (nonzero? v1-2)) + (+ (* (-> a0-2 frame-num) (-> v1-2 artist-step)) (-> v1-2 artist-base)) + 0.0 + ) + ) + ) + +(defmethod apply-gravity metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int) (arg2 process-drawable)) + (local-vars (f0-16 float) (f0-31 float)) + (cond + ((zero? arg1) + (set! (-> obj joint-length) 8192.0) + ) + ((= arg1 1) + (set! (-> obj joint-length) 12288.0) + ) + ((= arg1 2) + (set! (-> obj joint-length) 8192.0) + ) + (else + (let ((v1-8 (-> arg2 parent))) + (if (and (-> (the-as metalkor (if v1-8 + (the-as metalkor (-> v1-8 0 self)) + ) + ) + next-state + ) + (let ((v1-12 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-12 + (the-as metalkor (-> v1-12 0 self)) + ) + ) + next-state + name + ) + 'hang-shoot-n-launch + ) + ) + ) + (set! (-> obj joint-length) 5734.4) + (set! (-> obj joint-length) 5324.8) + ) + ) + ) + ) + (vector-float*! + arg0 + (-> obj gravity) + (* 4096.0 (-> self clock time-adjust-ratio) (lerp-scale 0.2 0.1 (the float arg1) 0.0 20.0)) + ) + (vector-float*! arg0 arg0 0.75) + (set! (-> obj axial-slop) (* 364.0889 (the float arg1))) + (let ((f26-0 (-> obj prev-rotation)) + (f28-0 (-> obj prev-y-rotation)) + (f30-1 (ja-aframe-num-of-proc (the-as process-drawable (ppointer->process (-> arg2 parent))) 0)) + ) + (let* ((v1-27 (-> arg2 parent)) + (s2-2 (and (and (-> (the-as metalkor (if v1-27 + (the-as metalkor (-> v1-27 0 self)) + ) + ) + next-state + ) + (let ((v1-31 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-31 + (the-as metalkor (-> v1-31 0 self)) + ) + ) + next-state + name + ) + 'tail-attack + ) + ) + ) + (< 20.0 f30-1) + (< f30-1 39.0) + ) + ) + ) + (let ((v1-38 (-> arg2 parent))) + (set! f28-0 + (cond + ((and (and (-> (the-as metalkor (if v1-38 + (the-as metalkor (-> v1-38 0 self)) + ) + ) + next-state + ) + (let ((v1-42 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-42 + (the-as metalkor (-> v1-42 0 self)) + ) + ) + next-state + name + ) + 'start-second-stage + ) + ) + ) + (< f30-1 60.0) + ) + (set! f26-0 0.0) + 0.0 + ) + ((let ((v1-49 (-> arg2 parent))) + (and (-> (the-as metalkor (if v1-49 + (the-as metalkor (-> v1-49 0 self)) + ) + ) + next-state + ) + (let* ((v1-53 (-> arg2 parent)) + (v1-56 (-> (the-as metalkor (if v1-53 + (the-as metalkor (-> v1-53 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-56 'hang-shoot-n-launch) (= v1-56 'start-second-stage)) + ) + ) + ) + (let ((f1-3 (cond + ((zero? arg1) + (set! f0-16 -9102.223) + 0.0 + ) + ((< arg1 9) + (set! f0-16 (+ 2002.4889 f26-0)) + (+ 546.13336 f28-0) + ) + ((< arg1 12) + (set! f0-16 (+ 2730.6667 f26-0)) + (+ 2002.4889 f28-0) + ) + ((< arg1 15) + (set! f0-16 (+ 910.2222 f26-0)) + (+ -5461.3335 f28-0) + ) + (else + (set! f0-16 (+ -3640.889 f26-0)) + (+ -5461.3335 f28-0) + ) + ) + ) + ) + (set! f26-0 (+ f0-16 (* 182.04445 (-> obj osc-z value)))) + (+ f1-3 (* 182.04445 (-> obj osc-y value))) + ) + ) + (else + (cond + (s2-2 + (cond + ((zero? arg1) + (set! f26-0 -16384.0) + (set! f28-0 0.0) + (set! s2-2 #f) + ) + ((< arg1 9) + (set! f26-0 (cond + ((or (< f30-1 25.0) (< 38.0 f30-1)) + (+ -4733.156 f26-0) + ) + ((< f30-1 31.0) + (+ -6371.5557 f26-0) + ) + (else + (+ -2912.7112 f26-0) + ) + ) + ) + (set! s2-2 #f) + ) + (else + (vector-! arg0 (target-pos 0) (the-as vector (-> obj chain-joints arg1))) + (vector-normalize! arg0 12288.0) + ) + ) + ) + (else + (let ((v1-90 (-> arg2 parent))) + (cond + ((and (-> (the-as metalkor (if v1-90 + (the-as metalkor (-> v1-90 0 self)) + ) + ) + next-state + ) + (let* ((v1-94 (-> arg2 parent)) + (v1-97 (-> (the-as metalkor (if v1-94 + (the-as metalkor (-> v1-94 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-97 'fall-down) (= v1-97 'collapse) (= v1-97 'last-gasp) (= v1-97 'fly-to-ring) (= v1-97 'explode)) + ) + ) + (cond + ((zero? arg1) + (set! f26-0 -3640.889) + (set! f28-0 0.0) + ) + (else + (* 0.5 f26-0) + ) + ) + ) + (else + (cond + ((zero? arg1) + (set! f0-31 -16384.0) + (set! f28-0 0.0) + ) + ((< arg1 9) + (set! f0-31 (+ -4187.0225 f26-0)) + ) + ((< arg1 12) + (set! f0-31 (+ 8556.089 f26-0)) + ) + ((< arg1 15) + (set! f0-31 (+ -910.2222 f26-0)) + ) + ((< arg1 18) + (set! f0-31 (+ -10012.444 f26-0)) + ) + (else + (set! f0-31 (+ 910.2222 f26-0)) + ) + ) + (set! f26-0 (+ f0-31 (* 182.04445 (-> obj osc-z value)))) + (+! f28-0 (* 182.04445 (-> obj osc-y value))) + ) + ) + ) + ) + ) + f28-0 + ) + ) + ) + ) + (set! (-> obj prev-rotation) f26-0) + (set! (-> obj prev-y-rotation) f28-0) + (when (not s2-2) + (let ((a1-11 (-> arg2 node-list data 3 bone transform)) + (s2-3 (new 'stack-no-clear 'matrix)) + ) + (matrix-axis-angle! s2-3 (the-as vector a1-11) f26-0) + (vector-matrix*! arg0 arg0 s2-3) + (let ((a1-13 (-> arg2 node-list data 3 bone transform vector 1))) + (matrix-axis-angle! s2-3 a1-13 f28-0) + ) + (vector-matrix*! arg0 arg0 s2-3) + ) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* arg1 64))) + (lerp-scale 0.9 0.5 (the float arg1) 0.0 20.0) + ) + ) + ) + (let ((v1-124 (-> arg2 parent))) + (if (and (-> (the-as metalkor (if v1-124 + (the-as metalkor (-> v1-124 0 self)) + ) + ) + next-state + ) + (let* ((v1-128 (-> arg2 parent)) + (v1-131 (-> (the-as metalkor (if v1-128 + (the-as metalkor (-> v1-128 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-131 'fall-down) (= v1-131 'collapse) (= v1-131 'start-second-stage)) + ) + ) + (vector-float*! arg0 arg0 1.1) + ) + ) + (let ((v1-135 (-> arg2 parent))) + (cond + ((and (and (-> (the-as metalkor (if v1-135 + (the-as metalkor (-> v1-135 0 self)) + ) + ) + next-state + ) + (let ((v1-139 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-139 + (the-as metalkor (-> v1-139 0 self)) + ) + ) + next-state + name + ) + 'tail-attack + ) + ) + ) + (< 18.0 f30-1) + (and (< f30-1 39.0) (> arg1 0) (< arg1 9)) + ) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* (+ arg1 -1) 64))) + 0.9 + ) + ) + ((-> obj move-with-parent) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* (+ arg1 -1) 64))) + 0.8 + ) + ) + ) + ) + ) + 0 + (none) + ) + +(defmethod chain-physics-method-16 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 int)) + 10922.667 + ) + +(defmethod chain-physics-method-14 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int)) + (vector-reset! arg0) + 0 + (none) + ) + +(defmethod clamp-length metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 vector) (arg2 object) (arg3 process-drawable)) + ((method-of-type chain-physics clamp-length) obj arg0 arg1 arg2 arg3) + (when (< 5 (the-as int arg2)) + (let ((a0-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> arg3 node-list data 3))) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (vector-! s5-1 arg0 a0-2) + (let ((f0-0 (vector-normalize-ret-len! s5-1 1.0))) + (if (< f0-0 32768.0) + (vector+float*! arg0 arg0 s5-1 (- 32768.0 f0-0)) + ) + ) + ) + ) + ) + +(defmethod gravity-update metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 process-drawable)) + (let ((t9-0 (method-of-type chain-physics gravity-update))) + (t9-0 obj arg0) + ) + (update! (-> obj rand-y)) + (update! (-> obj rand-z)) + (update! (-> obj osc-y) (-> obj rand-y value)) + (update! (-> obj osc-z) (-> obj rand-z value)) + (let ((s5-1 (new 'stack-no-clear 'collide-query))) + (let ((s4-0 (new 'stack-no-clear 'bounding-box))) + (let ((s3-0 (new 'stack-no-clear 'sphere))) + (vector<-cspace! s3-0 (-> arg0 node-list data 19)) + (set! (-> s3-0 r) 61440.0) + (set-from-sphere! s4-0 s3-0) + ) + (set! (-> s5-1 collide-with) (collide-spec player-list special-obstacle)) + (set! (-> s5-1 ignore-process0) #f) + (set! (-> s5-1 ignore-process1) #f) + (set! (-> s5-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> s5-1 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> s5-1 bbox)) (the-as pointer s4-0) 32) + ) + (fill-using-bounding-box *collide-cache* s5-1) + ) + 0 + (none) + ) + +(defmethod chain-physics-method-17 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int)) + (local-vars (v1-26 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let* ((s5-0 (new 'stack-no-clear 'collide-query)) + (v1-2 (-> obj chain-joints arg1)) + (s4-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> v1-2 position))) + (s3-0 0) + ) + (set! (-> arg0 quad) (-> v1-2 position quad)) + (until (or (< 6 s3-0) (begin + (.lvf vf1 (&-> s4-1 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-26 vf1) + (let ((f0-7 v1-26) + (f1-5 409.6) + ) + (< f0-7 (* f1-5 f1-5)) + ) + ) + ) + (+! s3-0 1) + (set! (-> s5-0 start-pos quad) (-> arg0 quad)) + (set! (-> s5-0 move-dist quad) (-> s4-1 quad)) + (let ((v1-7 s5-0)) + (set! (-> v1-7 radius) 4096.0) + (set! (-> v1-7 collide-with) (collide-spec special-obstacle)) + (set! (-> v1-7 ignore-process0) #f) + (set! (-> v1-7 ignore-process1) #f) + (set! (-> v1-7 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-7 action-mask) (collide-action solid)) + ) + (set! (-> s5-0 num-spheres) (the-as uint #f)) + (let ((f0-1 (probe-using-line-sphere *collide-cache* s5-0))) + (cond + ((>= f0-1 0.0) + (let ((f0-2 (fmin 1.0 f0-1))) + (vector+float*! arg0 arg0 s4-1 f0-2) + (vector-float*! s4-1 s4-1 (- 1.0 f0-2)) + ) + (let ((f0-5 (vector-dot s4-1 (-> s5-0 best-other-tri normal)))) + (vector--float*! s4-1 s4-1 (-> s5-0 best-other-tri normal) (* 1.2 f0-5)) + ) + ) + (else + (vector+! arg0 arg0 s4-1) + (goto cfg-11) + ) + ) + ) + ) + ) + (label cfg-11) + 0 + (none) + ) + ) + +;; WARN: Return type mismatch process-focusable vs metalkor-lowtorso. +(defmethod relocate metalkor-lowtorso ((obj metalkor-lowtorso) (arg0 int)) + (if (nonzero? (-> obj tail)) + (&+! (-> obj tail) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-1)) + (&+! (-> obj egg-toss-joint-1) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-2)) + (&+! (-> obj egg-toss-joint-2) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-3)) + (&+! (-> obj egg-toss-joint-3) arg0) + ) + (the-as metalkor-lowtorso ((method-of-type process-focusable relocate) obj arg0)) + ) + +(defstate idle (metalkor-lowtorso) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (local-vars (v0-0 object)) + (the-as + object + (case event-type + (('egg-toss) + (set! (-> self egg-toss-joint-angle target) (the-as float (-> event param 0))) + ) + (('color) + (set! (-> self draw color-mult quad) (-> (the-as rgbaf (-> event param 0)) quad)) + (set! v0-0 (-> self draw color-emissive)) + (set! (-> (the-as rgbaf v0-0) quad) (-> (the-as rgbaf (-> event param 1)) quad)) + v0-0 + ) + (('move-chain) + (let ((v1-7 (-> event param 0)) + (a0-9 (-> self tail)) + ) + (dotimes (a1-1 (the-as int (-> a0-9 num-joints))) + (vector+! + (the-as vector (-> a0-9 chain-joints a1-1)) + (the-as vector (-> a0-9 chain-joints a1-1)) + (the-as vector v1-7) + ) + ) + ) + #f + ) + (('spinner) + (let ((v1-10 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (the-as object (metalkor-lowtorso-start-spinner (the-as int (-> event param 0)) (-> v1-10 vector 2))) + ) + ) + (('spinner-off) + (let ((gp-1 (-> event param 0))) + (when (< (the-as int gp-1) 4) + (let ((a0-17 (handle->process (-> self spinners gp-1)))) + (when a0-17 + (send-event a0-17 'break) + (set! (-> self spinners gp-1) (the-as handle #f)) + #f + ) + ) + ) + ) + ) + (('ja-float) + (dotimes (s5-1 3) + (when (not (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 float-anim)) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 float-anim) + (get-art-by-name (-> self draw art-group) (the-as string (-> event param 0)) art-joint-anim) + ) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 channel-index) + (the-as int (-> event param 1)) + ) + (set! v0-0 #t) + (goto cfg-31) + ) + ) + (set! v0-0 #f) + (label cfg-31) + v0-0 + ) + (('attack) + (let ((v1-32 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-32 from) (process->ppointer proc)) + (set! (-> v1-32 num-params) arg1) + (set! (-> v1-32 message) event-type) + (set! (-> v1-32 param 0) (-> event param 0)) + (set! (-> v1-32 param 1) (-> event param 1)) + (set! (-> v1-32 param 2) (-> event param 2)) + (set! (-> v1-32 param 3) (-> event param 3)) + (set! (-> v1-32 param 4) (-> event param 4)) + (set! (-> v1-32 param 5) (-> event param 5)) + (send-event-function (ppointer->process (-> self parent)) v1-32) + ) + ) + (('touch) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (set! (-> s4-0 quad) (-> self entity trans quad)) + (let* ((s3-0 proc) + (v1-36 (if (type? s3-0 process-drawable) + s3-0 + ) + ) + ) + (when v1-36 + (let ((s3-2 (vector-! (new 'stack-no-clear 'vector) (-> (the-as process-drawable v1-36) root trans) s4-0)) + (s4-2 (vector-! + (new 'stack-no-clear 'vector) + (-> (the-as process-drawable v1-36) root trans) + (-> self root-override trans) + ) + ) + ) + (set! (-> s3-2 y) 0.0) + (set! (-> s4-2 y) 0.0) + (when (< (vector-dot s3-2 s4-2) 0.0) + (vector-normalize! s3-2 1.0) + (vector-normalize! s4-2 1.0) + (vector-flatten! s4-2 s4-2 s3-2) + ) + (vector-normalize! s4-2 32768.0) + (let ((a1-14 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-14 from) (process->ppointer self)) + (set! (-> a1-14 num-params) 2) + (set! (-> a1-14 message) 'attack) + (set! (-> a1-14 param 0) (-> event param 0)) + (let ((v1-47 (new 'static 'attack-info :mask (attack-info-mask vector mode shove-up id)))) + (let* ((a0-50 *game-info*) + (a2-9 (+ (-> a0-50 attack-id) 1)) + ) + (set! (-> a0-50 attack-id) a2-9) + (set! (-> v1-47 id) a2-9) + ) + (set! (-> v1-47 mode) 'deadly) + (set! (-> v1-47 vector quad) (-> s4-2 quad)) + (set! (-> v1-47 shove-up) 16384.0) + (set! (-> a1-14 param 1) (the-as uint v1-47)) + ) + (when (send-event-function proc a1-14) + (set! (-> self no-collision-timer) (-> self clock frame-counter)) + (let ((v1-52 (-> self root-override root-prim))) + (set! (-> v1-52 prim-core collide-as) (collide-spec)) + (set! (-> v1-52 prim-core collide-with) (collide-spec)) + ) + 0 + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set-params! (-> self egg-toss-joint-angle) 0.0 0.05 0.3 0.9) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self no-collision-timer)) (seconds 0.1)) + (let ((v1-5 (-> self root-override root-prim))) + (set! (-> v1-5 prim-core collide-as) (-> self root-override backup-collide-as)) + (set! (-> v1-5 prim-core collide-with) (-> self root-override backup-collide-with)) + ) + ) + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (let ((gp-0 (ppointer->process (-> self parent)))) + (when gp-0 + (dotimes (s5-0 3) + (when (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (let ((v1-17 (ja-channel-float! + (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + 0.0 + 0.0 + 0.0 + ) + ) + ) + (when v1-17 + (let ((a0-16 (-> (the-as process-drawable gp-0) + skel + channel + (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + ) + ) + ) + (set! (-> v1-17 frame-num) (-> a0-16 frame-num)) + (set! (-> v1-17 frame-interp 0) (-> a0-16 frame-interp 0)) + (set! (-> v1-17 frame-interp 1) (-> a0-16 frame-interp 1)) + ) + (do-joint-math (-> self draw) (-> self node-list) (-> self skel)) + ) + ) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) #f) + ) + ) + ) + ) + (update! (-> self egg-toss-joint-angle) 0.0) + (let ((f30-0 (* 910.2222 (-> self egg-toss-joint-angle value)))) + (quaternion-set! (-> self egg-toss-joint-1 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + (quaternion-set! (-> self egg-toss-joint-2 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + (quaternion-set! (-> self egg-toss-joint-3 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + ) + (when (not (-> self tail-initialized)) + (set! (-> self tail-initialized) #t) + (initialize-chain-joints (-> self tail)) + ) + (let ((v1-38 (ja-group))) + (set! (-> self tail move-with-parent) + (the-as symbol (and (and v1-38 (or (= v1-38 (-> self draw art-group data 18)) + (= v1-38 (-> self draw art-group data 19)) + (= v1-38 (-> self draw art-group data 20)) + ) + ) + (< (ja-aframe-num 0) 45.0) + ) + ) + ) + ) + (update (-> self tail) self) + (none) + ) + :code (the-as (function none :behavior metalkor-lowtorso) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(deftype nestb-formation (hover-formation) + () + :heap-base #x10 + :method-count-assert 16 + :size-assert #x90 + :flag-assert #x1000100090 + ) + + +(defmethod hover-formation-method-15 nestb-formation ((obj nestb-formation) (arg0 vector) (arg1 vector)) + (logior! (-> obj formation flags) 2) + 0 + ) + +;; WARN: Return type mismatch symbol vs none. +(defmethod init-enemy! metalkor-flitter ((obj metalkor-flitter)) + "Common method called to initialize the enemy, typically sets up default field values and calls ancillary helper methods" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-flitter" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (init-enemy-behaviour-and-stats! obj *metalkor-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) + (set! (-> obj minimap) #f) + (none) + ) + +(defmethod dispose! metalkor-flitter ((obj metalkor-flitter)) + "Cleans-up the enemy and any associated resources. Potentially spawns skull gems" + (with-pp + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (when (and (>= (-> obj enemy-info-override gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (let ((a1-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-0 from) (process->ppointer pp)) + (set! (-> a1-0 num-params) 0) + (set! (-> a1-0 message) 'have-gem?) + (or (send-event-function (ppointer->process (-> obj parent)) a1-0) + (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-override gem-no-seg)) + (the-as int (-> obj enemy-info-override gem-seg)) + ) + (let ((v1-30 + (ppointer->process + (birth-pickup-at-point + (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info-override gem-joint))) + (pickup-type gem) + 1.0 + #t + (ppointer->process (-> obj parent)) + (-> obj fact-info-override) + ) + ) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'flitter-change-gem obj v1-30) + ) + ) + ) + ((method-of-type flitter dispose!) obj) + (none) + ) + ) + +(defmethod dispose! metalkor-wasp ((obj metalkor-wasp)) + "Cleans-up the enemy and any associated resources. Potentially spawns skull gems" + (with-pp + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (when (and (>= (-> obj enemy-info gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (let ((a1-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-0 from) (process->ppointer pp)) + (set! (-> a1-0 num-params) 0) + (set! (-> a1-0 message) 'have-gem?) + (or (send-event-function (ppointer->process (-> obj parent)) a1-0) + (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 ((v1-28 + (ppointer->process + (birth-pickup-at-point + (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info gem-joint))) + (pickup-type gem) + 1.0 + #t + *entity-pool* + (-> obj fact-info-override) + ) + ) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'wasp-change-gem obj v1-28) + ) + ) + ) + ((method-of-type wasp dispose!) obj) + (none) + ) + ) + +(defskelgroup skel-rift-ring-ingame rift-ring-in-game rift-ring-in-game-lod0-jg rift-ring-in-game-idle-ja + ((rift-ring-in-game-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + ) + +(deftype rift-ring-ingame (process-drawable) + ((anim-speed delayed-rand-float :inline :offset-assert 200) + (stutter symbol :offset-assert 228) + (spin-sound sound-id :offset-assert 232) + (spin-sound-playing symbol :offset-assert 236) + ) + :heap-base #x70 + :method-count-assert 21 + :size-assert #xf0 + :flag-assert #x15007000f0 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(defstate idle (rift-ring-ingame) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('stutter) + (set! (-> self stutter) (the-as symbol (-> event param 0))) + (set-params! (-> self anim-speed) 3 15 0.25) + (reset! (-> self anim-speed)) + (set! (-> self anim-speed value) -0.25) + ) + ) + ) + ) + :trans (behavior () + (cond + ((-> self stutter) + (update! (-> self anim-speed)) + (ja :num! (loop! (+ 0.125 (-> self anim-speed value)))) + ) + (else + (ja :num! (loop!)) + ) + ) + (sound-play "warp-ring" :id (-> self spin-sound) :position (-> self root trans)) + (set! (-> self spin-sound-playing) #t) + (none) + ) + :code (the-as (function none :behavior rift-ring-ingame) sleep-code) + :post (behavior () + (spawn (-> self part) (-> self root trans)) + (ja-post) + (none) + ) + ) + +(defmethod deactivate rift-ring-ingame ((obj rift-ring-ingame)) + (if (-> obj spin-sound-playing) + (sound-stop (-> obj spin-sound)) + ) + ((method-of-type process-drawable deactivate) obj) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! rift-ring-ingame ((obj rift-ring-ingame) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (set! (-> obj root) (new 'process 'trsqv)) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-rift-ring-ingame" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1236) obj)) + (set! (-> obj draw light-index) (the-as uint 10)) + (set! (-> obj stutter) #f) + (set! (-> obj spin-sound) (new-sound-id)) + (set! (-> obj spin-sound-playing) #f) + (go (method-of-object obj idle)) + (none) + ) + +;; WARN: Return type mismatch vector vs none. +(defmethod apply-gravity metalkor-spinner-chain-physics ((obj metalkor-spinner-chain-physics) (arg0 vector) (arg1 int) (arg2 process-drawable)) + (vector-float*! arg0 (-> obj gravity) (-> obj gravity-mult)) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* arg1 64))) + (-> obj velocity-mult) + ) + (none) + ) + +(defmethod chain-physics-method-14 metalkor-spinner-chain-physics ((obj metalkor-spinner-chain-physics) (arg0 vector) (arg1 int)) + (vector-reset! arg0) + 0 + (none) + ) + +;; WARN: Return type mismatch process-drawable vs metalkor-spinner. +(defmethod relocate metalkor-spinner ((obj metalkor-spinner) (arg0 int)) + (if (nonzero? (-> obj chain)) + (&+! (-> obj chain) arg0) + ) + (the-as metalkor-spinner ((method-of-type process-drawable relocate) obj arg0)) + ) + +(defstate break-it (metalkor-spinner) + :virtual #t + :enter (behavior () + (set! (-> self chain joint-length) (* 12288.0 (-> self root scale y))) + (set! (-> self root scale y) 1.0) + (initialize-chain-joints (-> self chain)) + (set! (-> self state-time) (-> self clock frame-counter)) + (let* ((f30-0 0.9) + (f28-0 0.2) + (v1-12 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-13 (the-as number (logior #x3f800000 v1-12))) + ) + (set! (-> self anim-speed) (+ f30-0 (* f28-0 (+ -1.0 (the-as float v1-13))))) + ) + (turn-off (-> self chain) (the-as time-frame (the int (* 300.0 (rand-vu-float-range 0.9 1.2))))) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 52) :num! min) + (none) + ) + :trans (behavior () + (let* ((v1-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root quat))) + (a2-1 (quaternion-from-two-vectors-partial! + (new 'stack-no-clear 'quaternion) + (-> v1-1 vector 1) + (new 'static 'vector :y 1.0) + 0.1 + ) + ) + ) + (quaternion*! (-> self root quat) (-> self root quat) a2-1) + ) + (quaternion-normalize! (-> self root quat)) + (update (-> self chain) self) + (cond + ((< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) + ) + ((let ((v1-13 (ja-group))) + (and v1-13 (= v1-13 (-> self draw art-group data 53))) + ) + (ja :num! (seek! max (-> self anim-speed))) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 53) :num! min) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +(defstate idle (metalkor-spinner) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('break) + (go-virtual break-it) + ) + ) + ) + :enter (behavior () + (ja :group! (-> self draw art-group data 50)) + (none) + ) + :trans (behavior () + (ja :num! (loop!)) + (let* ((t9-1 vector<-cspace!) + (a0-1 (new 'stack-no-clear 'vector)) + (v1-6 (+ (* (-> self parent-joint-index) 32) 12)) + (a1-1 (-> self parent)) + (v1-7 (t9-1 + a0-1 + (the-as + cspace + (+ v1-6 (the-as int (-> (the-as process-drawable (if a1-1 + (the-as process-drawable (-> a1-1 0 self)) + ) + ) + node-list + ) + ) + ) + ) + ) + ) + (gp-1 (vector-! (new 'stack-no-clear 'vector) v1-7 (-> self root trans))) + (f30-0 (vector-normalize-ret-len! gp-1 1.0)) + ) + (quaternion-from-two-vectors! (-> self root quat) (new 'static 'vector :y -1.0) gp-1) + (set! (-> self root scale y) (* 0.000009042245 f30-0)) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +(defstate shoot-out (metalkor-spinner) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('break) + (the-as symbol (deactivate self)) + ) + ) + ) + ) + :enter (behavior () + (let* ((f30-0 0.9) + (f28-0 0.2) + (v1-3 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-4 (the-as number (logior #x3f800000 v1-3))) + ) + (set! (-> self anim-speed) (+ f30-0 (* f28-0 (+ -1.0 (the-as float v1-4))))) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 51))) + (ja :num! (seek! max (-> self anim-speed))) + (when (ja-done? 0) + (set! (-> self root trans quad) (-> self target-pos quad)) + (go-virtual idle) + ) + ) + (else + (ja :group! (-> self draw art-group data 51) :num! min) + ) + ) + ) + (let* ((t9-4 vector<-cspace!) + (a0-9 (new 'stack-no-clear 'vector)) + (v1-25 (+ (* (-> self parent-joint-index) 32) 12)) + (a1-2 (-> self parent)) + (s5-0 (t9-4 + a0-9 + (the-as cspace (+ v1-25 (the-as int (-> (the-as metalkor (if a1-2 + (the-as metalkor (-> a1-2 0 self)) + ) + ) + node-list + ) + ) + ) + ) + ) + ) + (gp-2 (vector-! (new 'stack-no-clear 'vector) s5-0 (-> self target-pos))) + ) + (let ((f0-4 (vector-normalize-ret-len! gp-2 1.0))) + (set! (-> self root scale y) (* 0.000009042245 f0-4)) + (vector+float*! (-> self root trans) s5-0 gp-2 (- f0-4)) + ) + (quaternion-from-two-vectors! (-> self root quat) (new 'static 'vector :y -1.0) gp-2) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +(defskelgroup skel-nest-break-precipice nest-break-precipice nest-break-precipice-lod0-jg nest-break-precipice-idle-ja + ((nest-break-precipice-lod0-mg (meters 999999))) + :bounds (static-spherem -28 20 30 24) + ) + +(deftype nest-break-precipice (process-drawable) + () + :heap-base #x50 + :method-count-assert 22 + :size-assert #xc8 + :flag-assert #x16005000c8 + (:methods + (idle () _type_ :state 20) + (die () _type_ :state 21) + ) + ) + + +(defstate idle (nest-break-precipice) + :virtual #t + :enter (behavior () + (ja-post) + (none) + ) + :code (the-as (function none :behavior nest-break-precipice) sleep-code) + ) + +(defstate die (nest-break-precipice) + :virtual #t + :trans (behavior () + (cleanup-for-death self) + (deactivate self) + (none) + ) + :code (the-as (function none :behavior nest-break-precipice) sleep-code) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! nest-break-precipice ((obj nest-break-precipice) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (set! (-> obj root) (new 'process 'trsqv)) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as + skeleton-group + (art-group-get-by-name *level* "skel-nest-break-precipice" (the-as (pointer uint32) #f)) + ) + (the-as pair 0) + ) + (set! (-> obj draw light-index) (the-as uint 17)) + (if (task-node-closed? (game-task-node nest-boss-introduction)) + (go (method-of-object obj die)) + (go (method-of-object obj idle)) + ) + (none) + ) + +(defmethod draw hud-metalkor ((obj hud-metalkor)) + (set-hud-piece-position! (-> obj sprites 1) (the int (+ 462.0 (* 130.0 (-> obj offset)))) 350) + (set-as-offset-from! (the-as hud-sprite (-> obj sprites)) (the-as vector4w (-> obj sprites 1)) -32 0) + (set-as-offset-from! (-> obj sprites 5) (the-as vector4w (-> obj sprites 1)) -62 14) + (set-as-offset-from! (-> obj sprites 6) (the-as vector4w (-> obj sprites 1)) -32 14) + (let ((s5-0 (-> obj values 0 current)) + (f30-0 (* 0.01 (the float (-> obj values 1 current)))) + ) + (set-as-offset-from! (-> obj sprites 4) (the-as vector4w (-> obj sprites 1)) -92 15) + (cond + ((= s5-0 1) + (set! (-> obj sprites 4 color x) 0) + (set! (-> obj sprites 4 color y) 255) + (set! f30-0 (+ 2.0 f30-0)) + ) + ((= s5-0 2) + (set! (-> obj sprites 4 color y) 255) + (set! (-> obj sprites 4 color x) 255) + (set! f30-0 (+ 1.0 f30-0)) + ) + ((= s5-0 3) + (set! (-> obj sprites 4 color x) 255) + (set! (-> obj sprites 4 color y) 0) + 0 + ) + (else + (set! f30-0 0.0) + ) + ) + (set! (-> obj sprites 4 scale-x) (* -7.25 f30-0)) + ) + ((method-of-type hud draw) obj) + 0 + (none) + ) + +(defmethod init-callback hud-metalkor ((obj hud-metalkor)) + (set! (-> obj gui-id) + (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0) + ) + (set! (-> obj values 0 target) 1) + (set! (-> obj values 1 target) 100) + (logior! (-> obj flags) (hud-flags show)) + (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3b :page #x67a))) + (set! (-> obj sprites 0 flags) (the-as uint 4)) + (set! (-> obj sprites 1 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3c :page #x67a))) + (set! (-> obj sprites 1 flags) (the-as uint 4)) + (set! (-> obj sprites 5 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a))) + (set! (-> obj sprites 5 scale-x) 0.5) + (set! (-> obj sprites 5 flags) (the-as uint 4)) + (set! (-> obj sprites 6 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a))) + (set! (-> obj sprites 6 scale-x) 0.5) + (set! (-> obj sprites 6 flags) (the-as uint 4)) + (set! (-> obj sprites 4 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a))) + (set! (-> obj sprites 4 scale-y) 3.25) + (set! (-> obj sprites 4 color z) 0) + (set! (-> obj sprites 4 flags) (the-as uint 4)) + (set! (-> obj sprites 3 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a))) + (set! (-> obj sprites 3 scale-y) 1.5) + (set! (-> obj sprites 3 color z) 0) + (set! (-> obj sprites 3 flags) (the-as uint 4)) + 0 + (none) + ) + +(defstate idle (nestb-tail-bound) + :virtual #t + :code (the-as (function none :behavior nestb-tail-bound) sleep-code) + ) + +(defstate idle (metalkor-kid) + :virtual #t + :trans (behavior () + (ja :num! (loop!)) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3))) + (none) + ) + :code (the-as (function none :behavior metalkor-kid) sleep-code) + :post (the-as (function none :behavior metalkor-kid) ja-post) + ) + +(defstate idle (metalkor-wings) + :virtual #t + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (none) + ) + :code (the-as (function none :behavior metalkor-wings) sleep-code) + :post (the-as (function none :behavior metalkor-wings) ja-post) + ) + +(defbehavior metalkor-distort-update metalkor-distort () + (let ((s5-0 (camera-matrix)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (let ((f30-0 4096.0)) + (let ((f28-1 (* 0.00013563369 (tan (* 0.5 (-> *math-camera* fov))) f30-0))) + (matrix->quaternion (-> self root-override quat) s5-0) + (set-vector! (-> self root-override scale) f28-1 f28-1 f28-1 1.0) + ) + (let ((t9-3 vector<-cspace!) + (a0-3 gp-0) + (v1-7 (-> self parent)) + ) + (t9-3 a0-3 (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + node-list + data + 7 + ) + ) + ) + (vector-! gp-0 gp-0 (camera-pos)) + (vector-normalize! gp-0 f30-0) + ) + (vector+! (-> self root-override trans) (camera-pos) gp-0) + ) + 0 + (none) + ) + +(defstate idle (metalkor-distort) + :virtual #t + :enter (behavior () + (metalkor-distort-update) + (none) + ) + :trans (behavior () + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-distort) sleep-code) + :post (the-as (function none :behavior metalkor-distort) ja-post) + ) + +(defskelgroup skel-metalkor-rays metalkor-rays metalkor-rays-lod0-jg metalkor-rays-idle-ja + ((metalkor-rays-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 30) + ) + +(deftype metalkor-rays (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(defstate idle (metalkor-rays) + :virtual #t + :enter (behavior () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 0.0) + (none) + ) + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t "") + (let ((f0-0 (calc-fade-from-fog (-> self root trans)))) + (set-vector! (-> self draw color-emissive) f0-0 f0-0 f0-0 1.0) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-rays) sleep-code) + :post (the-as (function none :behavior metalkor-rays) ja-post) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-rays-init-by-other metalkor-rays ((arg0 vector) (arg1 quaternion)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (quaternion-copy! (-> self root quat) arg1) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-rays" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (go-virtual idle) + (none) + ) + +(set! (-> *lightning-spec-id-table* 29) (new 'static 'lightning-spec + :name "lightning-metalkor-explode" + :flags (lightning-spec-flags lsf0) + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) + :fade-start-factor 0.2 + :texture (new 'static 'texture-id :index #x83 :page #xc) + :reduction 0.42 + :num-points 16 + :box-size 8192.0 + :merge-factor 0.6 + :merge-count 2 + :radius 3276.8 + :duration 45.0 + :duration-rand 60.0 + :sound #f + ) + ) + +(set! (-> *lightning-spec-id-table* 30) (new 'static 'lightning-spec + :name "lightning-metalkor-explode-thick" + :flags (lightning-spec-flags lsf0) + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) + :fade-start-factor 0.2 + :texture (new 'static 'texture-id :index #x83 :page #xc) + :reduction 0.42 + :num-points 32 + :box-size 40960.0 + :merge-factor 0.6 + :merge-count 2 + :radius 12288.0 + :duration 60.0 + :sound #f + ) + ) + +(defstate idle (metalkor-explode) + :virtual #t + :enter (behavior () + (process-spawn metalkor-rays (-> self root trans) (-> self root quat) :to self) + (none) + ) + :trans (behavior () + (local-vars (sv-384 symbol) (sv-400 symbol) (sv-416 vector) (sv-432 matrix)) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (when (and (< f30-0 40.0) (>= (ja-aframe-num 0) 40.0)) + (send-event (ppointer->process (-> self parent)) 'exploding) + (activate! *camera-smush-control* 1638.4 37 210 1.0 0.995 (-> self clock)) + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-6 (method-of-type part-tracker activate))) + (t9-6 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((s5-0 run-function-in-process) + (s4-0 gp-0) + (s3-0 part-tracker-init) + (s2-0 (-> *part-group-id-table* 1238)) + (s1-0 0) + (s0-0 #f) + ) + (set! sv-384 (the-as symbol #f)) + (set! sv-400 (the-as symbol #f)) + (set! sv-432 *launch-matrix*) + (set! sv-416 (-> sv-432 trans)) + (let ((v1-27 (-> (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)) quad))) + (set! (-> sv-416 quad) v1-27) + ) + ((the-as (function object object object object object object object object none) s5-0) + s4-0 + s3-0 + s2-0 + s1-0 + s0-0 + sv-384 + sv-400 + sv-432 + ) + ) + (-> gp-0 ppointer) + ) + ) + ) + ) + (when (< 40.0 (ja-aframe-num 0)) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 70))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 71))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 20))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 59))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 60))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 22))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 24))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 54))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 53))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 57))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 56))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 28))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 46))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 48))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 44))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 50))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3))) + ) + (if (ja-done? 0) + (send-event (ppointer->process (-> self parent)) 'explode-done) + ) + (process-drawable-shock-effect + self + (-> *lightning-spec-id-table* 29) + lightning-probe-callback + (-> *part-id-table* 429) + 0 + 0 + 40960.0 + ) + (let ((a0-51 (handle->process (-> self ring)))) + (if a0-51 + (process-drawable2-shock-effect + (the-as process-drawable a0-51) + self + (-> *lightning-spec-id-table* 30) + lightning-probe-callback + (-> *part-id-table* 429) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-explode) sleep-code) + :post (the-as (function none :behavior metalkor-explode) ja-post) + ) + +(defstate idle (rift-occlude) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as + object + (case event-type + (('movie-pos) + (format 0 "changing to movie position~%") + (let ((a2-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root quat)))) + (vector+! + (-> self root trans) + (-> self original-trans) + (vector-matrix*! (new 'stack-no-clear 'vector) (new 'static 'vector :x -10240.0 :y -7168.0 :z 11264.0) a2-1) + ) + ) + (the-as symbol (ja-post)) + ) + ) + ) + ) + :enter (behavior () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 0.0) + (ja-post) + (none) + ) + :trans (behavior () + (let ((f0-0 (calc-fade-from-fog (-> self root trans)))) + (set-vector! (-> self draw color-emissive) f0-0 f0-0 f0-0 1.0) + ) + (none) + ) + :code (the-as (function none :behavior rift-occlude) sleep-code) + ) + +;; WARN: Return type mismatch process-drawable vs metalkor-bomb. +(defmethod relocate metalkor-bomb ((obj metalkor-bomb) (arg0 int)) + (dotimes (v1-0 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (when (nonzero? (-> obj joint-mods v1-0)) + (if (nonzero? (-> obj joint-mods v1-0)) + (&+! (-> obj joint-mods v1-0) arg0) + ) + ) + ) + (the-as metalkor-bomb ((method-of-type process-drawable relocate) obj arg0)) + ) + +(define *metalkor-bomb-collide-joints* (new 'static 'boxed-array :type int8 + 5 + #x8 + #xb + #xe + #x11 + #x14 + #x17 + #x1a + #x1d + #x20 + #x23 + #x26 + #x29 + #x2c + #x2f + #x32 + #x35 + #x38 + #x3b + #x3e + #x41 + #x44 + #x47 + #x4a + #x4d + #x50 + #x53 + #x56 + #x59 + #x5c + ) + ) + +(defbehavior metalkor-bomb-collide metalkor-bomb () + (local-vars (at-0 int)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'collide-query))) + (let ((s5-0 (new 'stack-no-clear 'bounding-box))) + (let ((a1-0 (new 'stack-no-clear 'sphere))) + (set! (-> a1-0 quad) (-> self root-override trans quad)) + (set! (-> a1-0 r) 204800.0) + (set-from-sphere! s5-0 a1-0) + ) + (set! (-> gp-0 collide-with) (collide-spec jak crate enemy hit-by-others-list player-list pusher)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> gp-0 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> gp-0 bbox)) (the-as pointer s5-0) 32) + ) + (fill-using-bounding-box *collide-cache* gp-0) + ) + (let ((s5-1 (new 'stack-no-clear 'vector)) + (gp-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-1 quad) (-> self root-override trans quad)) + (vector<-cspace! + (-> self root-override trans) + (-> self node-list data (-> *metalkor-bomb-collide-joints* (+ (-> *metalkor-bomb-collide-joints* length) -1))) + ) + (dotimes (s4-0 (-> *metalkor-bomb-collide-joints* length)) + (vector<-cspace! s5-1 (-> self node-list data (-> *metalkor-bomb-collide-joints* s4-0))) + (vector-! s5-1 s5-1 (-> self root-override trans)) + (let ((v1-26 s5-1)) + (.lvf vf1 (&-> s5-1 quad)) + (let ((f0-1 (-> self clock frames-per-second))) + (.mov at-0 f0-1) + ) + (.mov vf2 at-0) + (.mov.vf vf1 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> v1-26 quad) vf1) + ) + (integrate-and-collide! (-> self root-override) s5-1) + ) + (let ((v0-6 (-> self root-override trans))) + (set! (-> v0-6 quad) (-> gp-1 quad)) + v0-6 + ) + ) + ) + ) + +(defbehavior metalkor-bomb-ground-check metalkor-bomb () + (let ((gp-0 (new 'stack-no-clear 'collide-query))) + (let ((s5-0 (new 'stack-no-clear 'bounding-box))) + (let ((a1-0 (new 'stack-no-clear 'sphere))) + (set! (-> a1-0 quad) (-> self root-override trans quad)) + (set! (-> a1-0 r) 204800.0) + (set-from-sphere! s5-0 a1-0) + ) + (set! (-> gp-0 collide-with) (collide-spec player-list special-obstacle)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> gp-0 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> gp-0 bbox)) (the-as pointer s5-0) 32) + ) + (fill-using-bounding-box *collide-cache* gp-0) + (dotimes (s5-1 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (let ((s4-0 (vector<-cspace! + (new 'stack-no-clear 'vector) + (-> self node-list data (-> *metalkor-bomb-probe-joints* s5-1)) + ) + ) + ) + (set! (-> gp-0 start-pos quad) (-> s4-0 quad)) + (set! (-> gp-0 start-pos y) (+ 81920.0 (-> gp-0 start-pos y))) + (set! (-> gp-0 move-dist quad) (-> (new 'static 'vector :y -163840.0) quad)) + (let ((v1-17 gp-0)) + (set! (-> v1-17 radius) 4096.0) + (set! (-> v1-17 collide-with) (collide-spec special-obstacle)) + (set! (-> v1-17 ignore-process0) #f) + (set! (-> v1-17 ignore-process1) #f) + (set! (-> v1-17 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-17 action-mask) (collide-action solid)) + ) + (let ((f0-4 (probe-using-line-sphere *collide-cache* gp-0))) + (cond + ((>= f0-4 0.0) + (let* ((f1-3 (* -163840.0 (+ -0.5 f0-4))) + (f0-8 (- (fmin 139264.0 (fmax 83558.4 (+ (-> s4-0 y) f1-3))) (-> s4-0 y))) + ) + (if (nonzero? (-> self joint-mods s5-1)) + (+! (-> self joint-mods s5-1 trans y) f0-8) + ) + ) + ) + (else + ) + ) + ) + ) + ) + ) + #f + ) + +(defstate idle (metalkor-bomb) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('touched 'touch) + (let ((a1-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-3 from) (process->ppointer self)) + (set! (-> a1-3 num-params) 2) + (set! (-> a1-3 message) 'attack) + (set! (-> a1-3 param 0) (-> event param 0)) + (let ((v1-6 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id)))) + (let* ((a2-3 *game-info*) + (a3-2 (+ (-> a2-3 attack-id) 1)) + ) + (set! (-> a2-3 attack-id) a3-2) + (set! (-> v1-6 id) a3-2) + ) + (set! (-> v1-6 mode) 'deadly) + (set! (-> v1-6 shove-back) 0.0) + (set! (-> v1-6 shove-up) 16384.0) + (set! (-> a1-3 param 1) (the-as uint v1-6)) + ) + (send-event-function proc a1-3) + ) + ) + ) + ) + :trans (behavior () + (ja :num! (seek! max 0.25)) + (if (ja-done? 0) + (deactivate self) + ) + (metalkor-bomb-ground-check) + (metalkor-bomb-collide) + (none) + ) + :code (the-as (function none :behavior metalkor-bomb) sleep-code) + :post (the-as (function none :behavior metalkor-bomb) ja-post) + ) diff --git a/goal_src/jak2/levels/nest/boss/metalkor-setup.gc b/goal_src/jak2/levels/nest/boss/metalkor-setup.gc index 55ea0e4eae..8c01f33828 100644 --- a/goal_src/jak2/levels/nest/boss/metalkor-setup.gc +++ b/goal_src/jak2/levels/nest/boss/metalkor-setup.gc @@ -5,5 +5,1719 @@ ;; name in dgo: metalkor-setup ;; dgos: NEB +(declare-type metalkor process-focusable) +(define-extern metalkor-go-next-stage (function none :behavior metalkor)) + ;; DECOMP BEGINS +(defskelgroup skel-metalkor-bomb metalkor-bomb metalkor-bomb-lod0-jg metalkor-bomb-idle-ja + ((metalkor-bomb-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 100) + :sort 4 + ) + +(defskelgroup skel-rift-occlude rift-occlude rift-occlude-lod0-jg rift-occlude-idle-ja + ((rift-occlude-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 5) + ) + +(defskelgroup skel-metalkor-distort metalkor-distort metalkor-distort-lod0-jg metalkor-distort-idle-ja + ((metalkor-distort-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 5) + ) + +(defskelgroup skel-metalkor-explode metalkor-explode metalkor-explode-lod0-jg metalkor-explode-idle-ja + ((metalkor-explode-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + ) + +(defskelgroup skel-metalkor-kid kid kid-lod0-jg 19 + ((kid-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 2) + :shadow kid-shadow-mg + :origin-joint-index 13 + ) + +(defskelgroup skel-metalkor-egg metalkor-egg metalkor-egg-lod0-jg metalkor-egg-tumble-ja + ((metalkor-egg-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 4) + :shadow metalkor-egg-shadow-mg + ) + +(defskelgroup skel-metalkor metalkor metalkor-lod0-jg metalkor-idle-ja + ((metalkor-lod0-mg (meters 999999))) + :bounds (static-spherem 0 2 2 8) + :shadow metalkor-shadow-mg + :origin-joint-index 3 + ) + +(defskelgroup skel-metalkor-spinner metalkor metalkor-spinner-lod0-jg metalkor-spinner-idle-ja + ((metalkor-spinner-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + :origin-joint-index 8 + ) + +(defskelgroup skel-metalkor-lowtorso metalkor-lowtorso metalkor-lowtorso-lod0-jg metalkor-lowtorso-idle-ja + ((metalkor-lowtorso-lod0-mg (meters 999999))) + :bounds (static-spherem 0 -9 -12 22) + :shadow metalkor-lowtorso-shadow-mg + :origin-joint-index 3 + ) + +(defskelgroup skel-metalkor-legs metalkor-legs metalkor-legs-lod0-jg metalkor-legs-idle-ja + ((metalkor-legs-lod0-mg (meters 999999))) + :bounds (static-spherem 0 -9 2 15) + :shadow metalkor-legs-shadow-mg + :origin-joint-index 3 + ) + +(defskelgroup skel-metalkor-wings metalkor-wings metalkor-wings-lod0-jg metalkor-wings-idle-ja + ((metalkor-wings-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 30) + :shadow metalkor-wings-shadow-mg + ) + +(defskelgroup skel-nestb-tail-bound nestb-tail-bound nestb-tail-bound-lod0-jg nestb-tail-bound-idle-ja + ((nestb-tail-bound-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 100) + ) + +(deftype metalkor-bomb (process-drawable) + ((root-override collide-shape-moving :offset 128) + (joint-mods joint-mod 49 :offset-assert 200) + ) + :heap-base #x110 + :method-count-assert 21 + :size-assert #x18c + :flag-assert #x150110018c + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype gem-tracker (process) + ((gems handle 10 :offset-assert 128) + (gems-collected int8 :offset-assert 208) + (perm-byte-index int8 :offset-assert 209) + ) + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + (:methods + (idle () _type_ :state 14) + ) + ) + + +(defbehavior gem-tracker-get-slot gem-tracker ((arg0 process)) + (cond + (arg0 + (dotimes (v1-0 10) + (if (= (handle->process (-> self gems v1-0)) arg0) + (return v1-0) + ) + ) + -1 + ) + (else + (let ((v1-3 (-> self gems-collected)) + (v0-0 -1) + ) + (dotimes (a0-1 10) + (if (handle->process (-> self gems a0-1)) + (+! v1-3 1) + (set! v0-0 a0-1) + ) + ) + (if (>= v1-3 10) + (return -1) + ) + v0-0 + ) + ) + ) + ) + +(defstate idle (gem-tracker) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('spawn-with-gem?) + (!= (gem-tracker-get-slot (the-as process #f)) -1) + ) + (('have-gem?) + (!= (gem-tracker-get-slot proc) -1) + ) + (('change-gem 'flitter-change-gem 'wasp-change-gem) + (let ((v1-3 (gem-tracker-get-slot (the-as process (-> event param 0))))) + (when (!= v1-3 -1) + (let ((gp-1 (-> event param 1))) + (set! (-> self gems v1-3) (process->handle (the-as process gp-1))) + (if (type? gp-1 gem) + (send-event (the-as process-tree gp-1) 'get-notify self) + ) + ) + ) + ) + ) + (('notify) + (case (-> event param 0) + (('pickup) + (+! (-> self gems-collected) 1) + (let ((v1-14 (-> self entity extra perm))) + (logior! (-> v1-14 status) (entity-perm-status bit-5)) + (let ((v0-1 (the-as object (-> self gems-collected)))) + (set! (-> v1-14 user-int8 (-> self perm-byte-index)) (the-as int v0-1)) + v0-1 + ) + ) + ) + ) + ) + ) + ) + :code (the-as (function none :behavior gem-tracker) sleep-code) + ) + +(deftype flitter-gem-tracker (gem-tracker) + () + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + ) + + +(deftype wasp-gem-tracker (gem-tracker) + () + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + ) + + +(deftype rift-occlude (process-drawable) + ((original-trans vector :inline :offset-assert 208) + ) + :heap-base #x60 + :method-count-assert 21 + :size-assert #xe0 + :flag-assert #x15006000e0 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype metalkor-distort (process-drawable) + ((root-override collide-shape-moving :offset 128) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype metalkor-explode (process-drawable) + ((ring handle :offset-assert 200) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xd0 + :flag-assert #x15005000d0 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype metalkor-kid (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype nestb-tail-bound (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype metalkor-ja-float-info (structure) + ((float-anim art-joint-anim :offset-assert 0) + (channel-index int8 :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + + +(deftype metalkor-spinner-info (structure) + ((joint-index int8 :offset-assert 0) + (launch-angle float :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + + +(deftype metalkor-shot (metalhead-shot) + ((old-transv vector :inline :offset-assert 496) + ) + :heap-base #x180 + :method-count-assert 40 + :size-assert #x200 + :flag-assert #x2801800200 + ) + + +(define *metalkor-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 #f + :hover-if-no-ground #f + :idle-anim-script #f + :idle-anim -1 + :notice-anim -1 + :hostile-anim -1 + :hit-anim -1 + :knocked-anim -1 + :knocked-land-anim -1 + :die-anim -1 + :die-falling-anim -1 + :victory-anim -1 + :jump-wind-up-anim -1 + :jump-in-air-anim -1 + :jump-land-anim -1 + :neck-joint -1 + :notice-distance (meters 30) + :notice-distance-delta (meters 10) + :default-hit-points 1 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 3) + :attack-shove-up (meters 2) + :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 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 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 1) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint -1 + :gem-offset (new 'static 'sphere :r 163840.0) + :callback-info #f + :use-momentum #f + :use-frustration #t + :use-stop-chase #f + :use-circling #f + :use-pacing #f + :walk-anim -1 + :turn-anim -1 + :run-anim -1 + :taunt-anim -1 + :run-travel-speed (meters 6) + :run-acceleration (meters 1) + :run-turning-acceleration (meters 2) + :walk-travel-speed (meters 3) + :walk-acceleration (meters 1) + :walk-turning-acceleration (meters 1) + :maximum-rotation-rate (degrees 720.0) + :notice-nav-radius (meters 1) + :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! (-> *metalkor-flitter-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +(deftype metalkor-flitter (flitter) + () + :heap-base #x240 + :method-count-assert 184 + :size-assert #x2b8 + :flag-assert #xb8024002b8 + ) + + +(deftype metalkor-wasp (wasp) + () + :heap-base #x310 + :method-count-assert 166 + :size-assert #x388 + :flag-assert #xa603100388 + ) + + +(deftype metalkor-spinner-chain-physics (chain-physics) + ((gravity-mult float :offset-assert 1392) + (velocity-mult float :offset-assert 1396) + ) + :method-count-assert 18 + :size-assert #x578 + :flag-assert #x1200000578 + ) + + +(deftype metalkor-spinner (process-drawable) + ((parent-joint-index int8 :offset-assert 200) + (target-pos vector :inline :offset-assert 208) + (chain metalkor-spinner-chain-physics :offset-assert 224) + (anim-speed float :offset-assert 228) + ) + :heap-base #x70 + :method-count-assert 23 + :size-assert #xe8 + :flag-assert #x17007000e8 + (:methods + (break-it () _type_ :state 20) + (idle () _type_ :state 21) + (shoot-out () _type_ :state 22) + ) + ) + + +(deftype metalkor-egg (process-focusable) + ((last-hit-normal vector :inline :offset-assert 208) + (sticky-time time-frame :offset-assert 224) + (flitter-slot int8 :offset-assert 232) + ) + :heap-base #x70 + :method-count-assert 31 + :size-assert #xe9 + :flag-assert #x1f007000e9 + (:methods + (egg-pop () _type_ :state 27) + (fall () _type_ :state 28) + (hatch () _type_ :state 29) + (idle () _type_ :state 30) + ) + ) + + +(deftype metalkor-wings (process-drawable) + ((prefix string :offset-assert 200) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xcc + :flag-assert #x15005000cc + (:methods + (idle () _type_ :state 20) + ) + ) + + +(deftype metalkor-foot-lock (structure) + ((lock cam-float-seeker :inline :offset-assert 0) + (old-position vector :inline :offset-assert 32) + (initialized symbol :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + ) + + +(deftype metalkor-legs (process-focusable) + ((prefix string :offset-assert 204) + (trackable symbol :offset-assert 208) + (joint-ik joint-mod-ik 6 :offset-assert 212) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 236) + (foot-locks metalkor-foot-lock 6 :inline :offset 288) + ) + :heap-base #x220 + :method-count-assert 28 + :size-assert #x2a0 + :flag-assert #x1c022002a0 + (:methods + (idle () _type_ :state 27) + ) + ) + + +(deftype metalkor-chain-physics (chain-physics) + ((prev-rotation float :offset-assert 1392) + (prev-y-rotation float :offset-assert 1396) + (osc-z oscillating-float :inline :offset-assert 1400) + (osc-y oscillating-float :inline :offset-assert 1424) + (rand-z delayed-rand-float :inline :offset-assert 1448) + (rand-y delayed-rand-float :inline :offset-assert 1480) + (move-with-parent symbol :offset-assert 1508) + ) + :method-count-assert 18 + :size-assert #x5e8 + :flag-assert #x12000005e8 + ) + + +(deftype metalkor-lowtorso (process-focusable) + ((prefix string :offset-assert 204) + (tail metalkor-chain-physics :offset-assert 208) + (tail-initialized symbol :offset-assert 212) + (spinners handle 4 :offset-assert 216) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 248) + (no-collision-timer time-frame :offset 296) + (egg-toss-joint-1 joint-mod :offset-assert 304) + (egg-toss-joint-2 joint-mod :offset-assert 308) + (egg-toss-joint-3 joint-mod :offset-assert 312) + (egg-toss-joint-angle oscillating-float :inline :offset-assert 316) + ) + :heap-base #xe0 + :method-count-assert 28 + :size-assert #x154 + :flag-assert #x1c00e00154 + (:methods + (idle () _type_ :state 27) + ) + ) + + +(deftype metalkor (process-focusable) + ((trackable symbol :offset-assert 204) + (flitters handle 10 :offset-assert 208) + (flitter-gem-tracker handle :offset-assert 288) + (wasps handle 3 :offset-assert 296) + (wasp-gem-tracker handle :offset-assert 320) + (last-flitter-launched int8 :offset-assert 328) + (last-wasp-launched int8 :offset-assert 329) + (live-flitters int8 :offset-assert 330) + (live-wasps int8 :offset-assert 331) + (shoot-timer time-frame :offset-assert 336) + (target-angle float :offset-assert 344) + (wave-timer time-frame :offset-assert 352) + (in-wave symbol :offset-assert 360) + (flitter-timer time-frame :offset-assert 368) + (wasp-timer time-frame :offset-assert 376) + (launching-flitters symbol :offset-assert 384) + (launching-wasps symbol :offset-assert 388) + (egg-timer time-frame :offset-assert 392) + (last-close-attack int8 :offset-assert 400) + (last-standing-attack int8 :offset-assert 401) + (stage int8 :offset-assert 402) + (next-stage-timer time-frame :offset-assert 408) + (initial-y float :offset-assert 416) + (shots-fired int16 :offset-assert 420) + (stage-hit-points float :offset-assert 424) + (hud handle :offset-assert 432) + (lowtorso handle :offset-assert 440) + (legs handle :offset-assert 448) + (wings handle :offset-assert 456) + (kid handle :offset-assert 464) + (explode handle :offset-assert 472) + (rift-occlude handle :offset-assert 480) + (last-attack-id uint32 :offset-assert 488) + (current-nav-poly nav-poly :offset-assert 492) + (shot-anticipate sparticle-launch-control :offset-assert 496) + (spinners handle 4 :offset-assert 504) + (neck joint-mod :offset-assert 536) + (previous-flat-travel vector :inline :offset-assert 544) + (previous-flat-travel-timer time-frame :offset-assert 560) + (previous-flat-travel-long-timer time-frame :offset-assert 568) + (min-state-hit-points float :offset-assert 576) + (countdown-to-roar int8 :offset-assert 580) + (for-back-interp cam-float-seeker :inline :offset-assert 584) + (run-walk-interp cam-float-seeker :inline :offset-assert 608) + (left-right-interp cam-float-seeker :inline :offset-assert 632) + (walk-turn-interp cam-float-seeker :inline :offset-assert 656) + (idle-interp cam-float-seeker :inline :offset-assert 680) + (tmp-hit-points float :offset-assert 704) + (reps-till-idle-alt int8 :offset-assert 708) + (last-rotation float :offset-assert 712) + (no-collision-timer time-frame :offset-assert 720) + (egg-angle float :offset 736) + (arm-frame float :offset-assert 740) + (been-to-entity symbol :offset-assert 744) + (flying-speed cam-float-seeker :inline :offset-assert 748) + (wing-sound sound-id :offset-assert 772) + (wing-sound-playing symbol :offset-assert 776) + (explode-sound sound-id :offset-assert 780) + (bomb-sound sound-id :offset-assert 784) + (stop-bomb-sound symbol :offset-assert 788) + (hit-ring-trans vector :inline :offset-assert 800) + (hit-ring-offset vector :inline :offset-assert 816) + (ring-cam-pos cam-float-seeker :inline :offset-assert 832) + (need-teleport symbol :offset-assert 856) + ) + :heap-base #x2e0 + :method-count-assert 43 + :size-assert #x35c + :flag-assert #x2b02e0035c + (:methods + (beaten (symbol) _type_ :state 27) + (explode () _type_ :state 28) + (fly-to-ring () _type_ :state 29) + (last-gasp () _type_ :state 30) + (overload-recover () _type_ :state 31) + (fall-down () _type_ :state 32) + (tail-attack () _type_ :state 33) + (foot-attack () _type_ :state 34) + (get-close () _type_ :state 35) + (standing-shot () _type_ :state 36) + (chase-target () _type_ :state 37) + (play-drop-movie () _type_ :state 38) + (start-second-stage () _type_ :state 39) + (hang-shoot-n-launch () _type_ :state 40) + (hidden () _type_ :state 41) + (test () _type_ :state 42) + ) + ) + + +(define *metalkor-bomb-probe-joints* (new 'static 'boxed-array :type int8 + 3 + 4 + #x7 + #xa + #xd + #x10 + #x13 + #x16 + #x19 + #x1c + #x1f + #x22 + #x25 + #x28 + #x2b + #x2e + #x31 + #x34 + #x37 + #x3a + #x3d + #x40 + #x43 + #x46 + #x49 + #x4c + #x4f + #x52 + #x55 + #x58 + #x5b + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-bomb-init-by-other metalkor-bomb ((arg0 vector) (arg1 entity-actor)) + (process-entity-set! self arg1) + (let ((s5-0 (new 'process 'collide-shape-moving self (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 ((v1-6 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-6 prim-core collide-as) (collide-spec projectile)) + (set! (-> v1-6 prim-core collide-with) + (collide-spec jak crate enemy obstacle hit-by-others-list player-list pusher) + ) + (set! (-> v1-6 prim-core action) (collide-action)) + (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0) + (set! (-> s5-0 total-prims) (the-as uint 1)) + (set! (-> s5-0 root-prim) v1-6) + ) + (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w))) + (let ((v1-9 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with)) + ) + (set! (-> s5-0 event-self) 'touched) + (set! (-> self root-override) s5-0) + ) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (quaternion-identity! (-> self root-override quat)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-bomb" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> self draw level-index) (the-as uint (-> *level* default-level index))) + (dotimes (gp-2 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (set! (-> self joint-mods gp-2) + (new 'process 'joint-mod (joint-mod-mode joint-set*) self (-> *metalkor-bomb-probe-joints* gp-2)) + ) + (if (nonzero? (-> self joint-mods gp-2)) + (set! (-> self joint-mods gp-2 track-mode) (track-mode no-rotate no-scale)) + ) + ) + (go-virtual idle) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! nestb-tail-bound ((obj nestb-tail-bound) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-others)))) + (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-2 prim-core collide-as) (collide-spec special-obstacle)) + (set! (-> v1-2 prim-core action) (collide-action solid)) + (set! (-> v1-2 transform-index) 3) + (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 409600.0) + (set! (-> s4-0 total-prims) (the-as uint 1)) + (set! (-> s4-0 root-prim) v1-2) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-5 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with)) + ) + (set! (-> obj root) s4-0) + ) + (process-drawable-from-entity! obj arg0) + (set! (-> obj root trans y) (+ -36864.0 (-> obj root trans y))) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-nestb-tail-bound" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (transform-post) + (logior! (-> obj draw status) (draw-control-status no-draw-bounds)) + (go (method-of-object obj idle)) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior gem-tracker-init-by-other gem-tracker ((arg0 entity-actor) (arg1 int)) + (set! (-> self entity) arg0) + (dotimes (v1-0 10) + (set! (-> self gems v1-0) (the-as handle #f)) + ) + (set! (-> self perm-byte-index) arg1) + (let ((v1-5 (-> self entity extra perm))) + (logior! (-> v1-5 status) (entity-perm-status bit-5)) + (set! (-> self gems-collected) (the-as int (-> v1-5 user-uint8 (-> self perm-byte-index)))) + ) + (go-virtual idle) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior rift-occlude-init-by-other rift-occlude ((arg0 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (process-drawable-from-entity! self (the-as entity-actor arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-rift-occlude" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (logclear! (-> self mask) (process-mask enemy)) + (set! (-> self original-trans quad) (-> self root trans quad)) + (let ((v1-7 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (go-virtual idle) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-distort-init-by-other metalkor-distort ((arg0 vector) (arg1 quaternion)) + (set! (-> self root-override) (the-as collide-shape-moving (new 'process 'trsqv))) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (quaternion-copy! (-> self root-override quat) arg1) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-distort" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (go-virtual idle) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-explode-init-by-other metalkor-explode ((arg0 vector) (arg1 quaternion) (arg2 handle)) + (set! (-> self root) (new 'process 'trsqv)) + (quaternion-copy! (-> self root quat) arg1) + (set! (-> self root trans quad) (-> arg0 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-explode" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-7 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self ring) arg2) + (set! (-> self part) (create-launch-control (-> *part-group-id-table* 1237) self)) + (go-virtual idle) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-kid-init-by-other metalkor-kid ((arg0 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (set! (-> self root trans y) (+ 61440.0 (-> self root trans y))) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-kid" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-9 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-9 + (the-as process-drawable (-> v1-9 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self part) (create-launch-control (-> *part-group-id-table* 1233) self)) + (go-virtual idle) + (none) + ) + +(define *metalkor-spinner-chain-setup* (new 'static 'boxed-array :type chain-physics-setup + (new 'static 'chain-physics-setup :joint-index 4) + (new 'static 'chain-physics-setup :joint-index 5) + (new 'static 'chain-physics-setup :joint-index 6) + (new 'static 'chain-physics-setup :joint-index 7) + (new 'static 'chain-physics-setup :joint-index 8) + (new 'static 'chain-physics-setup :joint-index 9) + (new 'static 'chain-physics-setup :joint-index 10) + (new 'static 'chain-physics-setup :joint-index 11) + (new 'static 'chain-physics-setup :joint-index 12) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-spinner-init-by-other metalkor-spinner ((arg0 vector) (arg1 int)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-spinner" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-6 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-6 + (the-as process-drawable (-> v1-6 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self parent-joint-index) arg1) + (set! (-> self target-pos quad) (-> arg0 quad)) + (set! (-> self chain) (new 'process 'metalkor-spinner-chain-physics)) + (chain-physics-initialize self (-> self chain) 3 4096.0 *metalkor-spinner-chain-setup*) + (let* ((f30-0 4096.0) + (f28-0 0.4) + (f26-0 0.2) + (v1-18 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-19 (the-as number (logior #x3f800000 v1-18))) + ) + (set! (-> self chain gravity-mult) (* f30-0 (+ f28-0 (* f26-0 (+ -1.0 (the-as float v1-19)))))) + ) + (let* ((f30-1 0.8) + (f28-1 0.19) + (v1-25 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-26 (the-as number (logior #x3f800000 v1-25))) + ) + (set! (-> self chain velocity-mult) (+ f30-1 (* f28-1 (+ -1.0 (the-as float v1-26))))) + ) + (set! (-> self event-hook) (-> (method-of-object self shoot-out) event)) + (go-virtual shoot-out) + (none) + ) + +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Unsupported inline assembly instruction kind - [mula.s f1, f4] +;; ERROR: Unsupported inline assembly instruction kind - [madda.s f2, f5] +;; ERROR: Unsupported inline assembly instruction kind - [madd.s f1, f3, f6] +(defbehavior metalkor-egg-reaction metalkor-egg ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector)) + (local-vars (v1-11 float) (f1-1 float) (sv-16 vector) (sv-32 float) (sv-48 float) (sv-64 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (set! sv-16 arg3) + (cshape-reaction-update-state arg0 arg1 sv-16) + (let ((s5-0 (-> arg0 process))) + (cond + ((>= (- (-> self clock frame-counter) (-> (the-as metalkor-egg s5-0) sticky-time)) (seconds 0.05)) + (let ((t9-1 vector--float*!) + (a0-3 arg2) + (a1-1 sv-16) + (a2-2 (-> arg0 surface-normal)) + (f0-0 1.01) + ) + (let* ((v1-4 (-> arg0 surface-normal)) + (f1-0 (-> sv-16 x)) + (f2-0 (-> sv-16 y)) + (f3-0 (-> sv-16 z)) + (f4-0 (-> v1-4 x)) + (f5-0 (-> v1-4 y)) + (f6-0 (-> v1-4 z)) + ) + ; (.mula.s f1-0 f4-0) + ; (.madda.s f2-0 f5-0) + ; (.madd.s f1-1 f3-0 f6-0) + (set! f1-1 (+ (* f1-0 f4-0) (* f2-0 f5-0) (* f3-0 f6-0))) + ) + (t9-1 a0-3 a1-1 a2-2 (* f0-0 f1-1)) + ) + (let ((s3-0 arg2) + (s2-0 arg2) + (s1-0 lerp-scale) + (s0-0 0.94) + ) + (set! sv-32 (the-as float 1.0)) + (set! sv-48 (-> arg0 surface-normal y)) + (set! sv-64 (cos 5461.3335)) + (let ((t0-0 (cos 16384.0))) + (vector-float*! s3-0 s2-0 (s1-0 s0-0 sv-32 sv-48 sv-64 t0-0)) + ) + ) + ) + (else + (vector--float*! + arg2 + sv-16 + (-> arg0 surface-normal) + (* (vector-dot sv-16 (-> arg0 surface-normal)) (rand-vu-float-range 1.2 1.4)) + ) + ) + ) + (.lvf vf1 (&-> arg2 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-11 vf1) + (let ((f0-10 v1-11) + (f1-3 409.6) + ) + (cond + ((< f0-10 (* f1-3 f1-3)) + (set! (-> arg2 quad) (the-as uint128 0)) + 0 + ) + ((let ((f1-6 4096.0)) + (and (< (* f1-6 f1-6) f0-10) + (>= (- (-> self clock frame-counter) (-> (the-as metalkor-egg s5-0) sticky-time)) (seconds 0.2)) + ) + ) + (vector-float*! arg2 arg2 (/ 4096.0 (sqrtf f0-10))) + ) + ) + ) + (if (< (-> arg0 surface-normal y) 1.0) + (set! (-> (the-as metalkor-egg s5-0) last-hit-normal quad) (-> arg0 surface-normal quad)) + ) + ) + (-> arg0 status) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-egg-init-by-other metalkor-egg ((arg0 vector) (arg1 vector) (arg2 int)) + (let ((s3-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s3-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s3-0 reaction) metalkor-egg-reaction) + (set! (-> s3-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((v1-6 (new 'process 'collide-shape-prim-sphere s3-0 (the-as uint 0)))) + (set! (-> v1-6 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-6 prim-core collide-with) (collide-spec backgnd jak bot hit-by-others-list player-list)) + (set! (-> v1-6 prim-core action) (collide-action solid)) + (set! (-> v1-6 transform-index) 3) + (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0) + (set! (-> s3-0 total-prims) (the-as uint 1)) + (set! (-> s3-0 root-prim) v1-6) + ) + (set! (-> s3-0 nav-radius) (* 0.75 (-> s3-0 root-prim local-sphere w))) + (let ((v1-9 (-> s3-0 root-prim))) + (set! (-> s3-0 backup-collide-as) (-> v1-9 prim-core collide-as)) + (set! (-> s3-0 backup-collide-with) (-> v1-9 prim-core collide-with)) + ) + (set! (-> s3-0 event-self) 'touched) + (set! (-> s3-0 max-iteration-count) (the-as uint 3)) + (set! (-> self root-override) s3-0) + ) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (set! (-> self root-override transv quad) (-> arg1 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-egg" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-20 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-20 + (the-as process-drawable (-> v1-20 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self mask) (logior (process-mask enemy) (-> self mask))) + (set-vector! (-> self last-hit-normal) 0.0 1.0 0.0 1.0) + (set! (-> self sticky-time) 0) + (set! (-> self flitter-slot) arg2) + (go-virtual fall) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-wings-init-by-other metalkor-wings ((arg0 vector) (arg1 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root pause-adjust-distance) 409600.0) + (set! (-> self root trans quad) (-> arg1 quad)) + (set! (-> self prefix) (the-as string arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-wings" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-8 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-8 + (the-as process-drawable (-> v1-8 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (go-virtual idle) + (none) + ) + +(deftype metalkor-ik-setup (structure) + ((elbow-index int32 :offset-assert 0) + (hand-dist float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + + +(define *metalkor-ik-setup* (new 'static 'boxed-array :type metalkor-ik-setup + (new 'static 'metalkor-ik-setup :elbow-index 7 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 12 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 17 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 22 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 27 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 32 :hand-dist 28041.217) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-legs-init-by-other metalkor-legs ((arg0 string) (arg1 vector)) + (let ((s4-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 18) 0))) + (set! (-> s4-0 total-prims) (the-as uint 19)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 3) + (set-vector! (-> s3-0 local-sphere) 0.0 -32768.0 0.0 49152.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 6) + (set-vector! (-> v1-13 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 7) + (set-vector! (-> v1-15 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 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 hit-by-others-list player-list)) + (set! (-> v1-17 prim-core action) (collide-action solid)) + (set! (-> v1-17 transform-index) 8) + (set-vector! (-> v1-17 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (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 hit-by-others-list player-list)) + (set! (-> v1-19 prim-core action) (collide-action solid)) + (set! (-> v1-19 transform-index) 11) + (set-vector! (-> v1-19 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (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 hit-by-others-list player-list)) + (set! (-> v1-21 prim-core action) (collide-action solid)) + (set! (-> v1-21 transform-index) 12) + (set-vector! (-> v1-21 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (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 hit-by-others-list player-list)) + (set! (-> v1-23 prim-core action) (collide-action solid)) + (set! (-> v1-23 transform-index) 13) + (set-vector! (-> v1-23 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (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 hit-by-others-list player-list)) + (set! (-> v1-25 prim-core action) (collide-action solid)) + (set! (-> v1-25 transform-index) 16) + (set-vector! (-> v1-25 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0)))) + (set! (-> v1-27 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-27 prim-core action) (collide-action solid)) + (set! (-> v1-27 transform-index) 17) + (set-vector! (-> v1-27 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0)))) + (set! (-> v1-29 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-29 prim-core action) (collide-action solid)) + (set! (-> v1-29 transform-index) 18) + (set-vector! (-> v1-29 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 11) (the-as uint 0)))) + (set! (-> v1-31 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-31 prim-core action) (collide-action solid)) + (set! (-> v1-31 transform-index) 21) + (set-vector! (-> v1-31 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-33 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 10) (the-as uint 0)))) + (set! (-> v1-33 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-33 prim-core action) (collide-action solid)) + (set! (-> v1-33 transform-index) 22) + (set-vector! (-> v1-33 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-35 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 0)))) + (set! (-> v1-35 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-35 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-35 prim-core action) (collide-action solid)) + (set! (-> v1-35 transform-index) 23) + (set-vector! (-> v1-35 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-37 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 14) (the-as uint 0)))) + (set! (-> v1-37 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-37 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-37 prim-core action) (collide-action solid)) + (set! (-> v1-37 transform-index) 26) + (set-vector! (-> v1-37 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-39 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 13) (the-as uint 0)))) + (set! (-> v1-39 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-39 prim-core action) (collide-action solid)) + (set! (-> v1-39 transform-index) 27) + (set-vector! (-> v1-39 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-41 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 12) (the-as uint 0)))) + (set! (-> v1-41 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-41 prim-core action) (collide-action solid)) + (set! (-> v1-41 transform-index) 28) + (set-vector! (-> v1-41 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-43 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 17) (the-as uint 0)))) + (set! (-> v1-43 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-43 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-43 prim-core action) (collide-action solid)) + (set! (-> v1-43 transform-index) 31) + (set-vector! (-> v1-43 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-45 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 16) (the-as uint 0)))) + (set! (-> v1-45 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-45 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-45 prim-core action) (collide-action solid)) + (set! (-> v1-45 transform-index) 32) + (set-vector! (-> v1-45 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-47 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 15) (the-as uint 0)))) + (set! (-> v1-47 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-47 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-47 prim-core action) (collide-action solid)) + (set! (-> v1-47 transform-index) 33) + (set-vector! (-> v1-47 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-50 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-50 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-50 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> self root-override) s4-0) + ) + (set! (-> self root-override pause-adjust-distance) 409600.0) + (set! (-> self root-override trans quad) (-> arg1 quad)) + (set! (-> self prefix) arg0) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-legs" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-60 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-60 + (the-as process-drawable (-> v1-60 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self mask) (logior (process-mask enemy) (-> self mask))) + (set! (-> self trackable) #f) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (dotimes (gp-2 6) + (set! (-> self joint-ik gp-2) (new + 'process + 'joint-mod-ik + self + (-> *metalkor-ik-setup* gp-2 elbow-index) + (-> *metalkor-ik-setup* gp-2 hand-dist) + ) + ) + (set! (-> self joint-ik gp-2 elbow-pole-vector-axis) (the-as uint 0)) + (set! (-> self joint-ik gp-2 elbow-rotation-axis) (the-as uint 2)) + ) + (logior! (-> self joint-ik 0 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 1 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 2 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 3 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 4 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 5 flags) (joint-mod-ik-flags elbow-rot-neg)) + (dotimes (v1-102 3) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* v1-102 16))) ja-float-info 0 float-anim) #f) + ) + (go-virtual idle) + (none) + ) + +(define *metalkor-lowtorso-chain-setup* (new 'static 'boxed-array :type chain-physics-setup + (new 'static 'chain-physics-setup :joint-index 8) + (new 'static 'chain-physics-setup :joint-index 9) + (new 'static 'chain-physics-setup :joint-index 10) + (new 'static 'chain-physics-setup :joint-index 11) + (new 'static 'chain-physics-setup :joint-index 12) + (new 'static 'chain-physics-setup :joint-index 13) + (new 'static 'chain-physics-setup :joint-index 14) + (new 'static 'chain-physics-setup :joint-index 15) + (new 'static 'chain-physics-setup :joint-index 16) + (new 'static 'chain-physics-setup :joint-index 17) + (new 'static 'chain-physics-setup :joint-index 18) + (new 'static 'chain-physics-setup :joint-index 19) + (new 'static 'chain-physics-setup :joint-index 20) + (new 'static 'chain-physics-setup :joint-index 21) + (new 'static 'chain-physics-setup :joint-index 22) + (new 'static 'chain-physics-setup :joint-index 23) + (new 'static 'chain-physics-setup :joint-index 24) + (new 'static 'chain-physics-setup :joint-index 25) + (new 'static 'chain-physics-setup :joint-index 26) + (new 'static 'chain-physics-setup :joint-index 27) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-lowtorso-init-by-other metalkor-lowtorso ((arg0 vector) (arg1 vector)) + (let ((s4-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 21) 0))) + (set! (-> s4-0 total-prims) (the-as uint 22)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 14) + (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 65536.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 19) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 8) + (set-vector! (-> v1-13 local-sphere) 0.0 8192.0 0.0 20480.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 18) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 9) + (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 17408.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 17) (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 hit-by-others-list player-list)) + (set! (-> v1-17 prim-core action) (collide-action solid)) + (set! (-> v1-17 transform-index) 10) + (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 16) (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 hit-by-others-list player-list)) + (set! (-> v1-19 prim-core action) (collide-action solid)) + (set! (-> v1-19 transform-index) 11) + (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 15) (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 hit-by-others-list player-list)) + (set! (-> v1-21 prim-core action) (collide-action solid)) + (set! (-> v1-21 transform-index) 12) + (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 14) (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 hit-by-others-list player-list)) + (set! (-> v1-23 prim-core action) (collide-action solid)) + (set! (-> v1-23 transform-index) 13) + (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 13) (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 hit-by-others-list player-list)) + (set! (-> v1-25 prim-core action) (collide-action solid)) + (set! (-> v1-25 transform-index) 14) + (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 12) (the-as uint 0)))) + (set! (-> v1-27 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-27 prim-core action) (collide-action solid)) + (set! (-> v1-27 transform-index) 15) + (set-vector! (-> v1-27 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 11) (the-as uint 0)))) + (set! (-> v1-29 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-29 prim-core action) (collide-action solid)) + (set! (-> v1-29 transform-index) 16) + (set-vector! (-> v1-29 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 10) (the-as uint 0)))) + (set! (-> v1-31 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-31 prim-core action) (collide-action solid)) + (set! (-> v1-31 transform-index) 17) + (set-vector! (-> v1-31 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-33 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 0)))) + (set! (-> v1-33 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-33 prim-core action) (collide-action solid)) + (set! (-> v1-33 transform-index) 18) + (set-vector! (-> v1-33 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-35 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0)))) + (set! (-> v1-35 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-35 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-35 prim-core action) (collide-action solid)) + (set! (-> v1-35 transform-index) 19) + (set-vector! (-> v1-35 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-37 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0)))) + (set! (-> v1-37 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-37 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-37 prim-core action) (collide-action solid)) + (set! (-> v1-37 transform-index) 20) + (set-vector! (-> v1-37 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-39 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0)))) + (set! (-> v1-39 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-39 prim-core action) (collide-action solid)) + (set! (-> v1-39 transform-index) 21) + (set-vector! (-> v1-39 local-sphere) 0.0 4096.0 0.0 10240.0) + ) + (let ((v1-41 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0)))) + (set! (-> v1-41 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-41 prim-core action) (collide-action solid)) + (set! (-> v1-41 transform-index) 22) + (set-vector! (-> v1-41 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-43 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0)))) + (set! (-> v1-43 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-43 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-43 prim-core action) (collide-action solid)) + (set! (-> v1-43 transform-index) 23) + (set-vector! (-> v1-43 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-45 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0)))) + (set! (-> v1-45 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-45 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-45 prim-core action) (collide-action solid)) + (set! (-> v1-45 transform-index) 24) + (set-vector! (-> v1-45 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-47 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0)))) + (set! (-> v1-47 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-47 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-47 prim-core action) (collide-action solid)) + (set! (-> v1-47 transform-index) 25) + (set-vector! (-> v1-47 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-49 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-49 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-49 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-49 prim-core action) (collide-action solid)) + (set! (-> v1-49 transform-index) 26) + (set-vector! (-> v1-49 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-51 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-51 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-51 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-51 prim-core action) (collide-action solid)) + (set! (-> v1-51 transform-index) 27) + (set-vector! (-> v1-51 local-sphere) 0.0 2048.0 -2048.0 10240.0) + ) + (let ((v1-53 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 20) (the-as uint 0)))) + (set! (-> v1-53 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-53 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-53 prim-core action) (collide-action solid)) + (set! (-> v1-53 transform-index) 5) + (set-vector! (-> v1-53 local-sphere) 0.0 10240.0 -8192.0 26624.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-56 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-56 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-56 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> self root-override) s4-0) + ) + (set! (-> self root-override pause-adjust-distance) 409600.0) + (set! (-> self root-override trans quad) (-> arg1 quad)) + (set! (-> self prefix) (the-as string arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-lowtorso" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-66 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-66 + (the-as process-drawable (-> v1-66 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (set! (-> self tail) (new 'process 'metalkor-chain-physics)) + (chain-physics-initialize self (-> self tail) 7 5324.8 *metalkor-lowtorso-chain-setup*) + (set-params! (-> self tail osc-z) 0.0 0.01 0.1 0.9) + (set-params! (-> self tail osc-y) 0.0 0.01 0.1 0.9) + (set-params! (-> self tail rand-z) 6 150 1.0) + (set-params! (-> self tail rand-y) 6 150 1.0) + (set! (-> self tail axial-slop) 910.2222) + (set! (-> self tail-initialized) #f) + (dotimes (v1-88 4) + (set! (-> self spinners v1-88) (the-as handle #f)) + ) + (dotimes (v1-91 3) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* v1-91 16))) ja-float-info 0 float-anim) #f) + ) + (let ((v1-95 (-> self root-override root-prim))) + (set! (-> self root-override backup-collide-as) (-> v1-95 prim-core collide-as)) + (set! (-> self root-override backup-collide-with) (-> v1-95 prim-core collide-with)) + ) + (set! (-> self no-collision-timer) 0) + (set! (-> self egg-toss-joint-1) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 5)) + (set! (-> self egg-toss-joint-2) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 6)) + (set! (-> self egg-toss-joint-3) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 7)) + (set-params! (-> self egg-toss-joint-angle) 0.0 0.01 0.1 0.9) + (go-virtual idle) + (none) + ) + +(defmethod init-from-entity! metalkor ((obj metalkor) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (local-vars (sv-16 res-tag)) + (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 4) 0))) + (set! (-> s4-0 total-prims) (the-as uint 5)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 3) + (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 40960.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 6) + (set-vector! (-> v1-13 local-sphere) 0.0 -4096.0 4096.0 20480.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 5) + (set-vector! (-> v1-15 local-sphere) 0.0 2048.0 2048.0 20480.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 1)))) + (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 solid)) + (set! (-> v1-17 transform-index) 9) + (set-vector! (-> v1-17 local-sphere) 0.0 8192.0 -20480.0 24576.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 1)))) + (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 solid)) + (set! (-> v1-19 transform-index) 12) + (set-vector! (-> v1-19 local-sphere) 0.0 8192.0 -20480.0 24576.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-22 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-22 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-22 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> obj root-override) s4-0) + ) + (set! (-> obj root-override pause-adjust-distance) 409600.0) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask))) + (set! (-> obj draw light-index) (the-as uint 10)) + (set! (-> obj lowtorso) (the-as handle #f)) + (set! (-> obj trackable) #f) + (dotimes (v1-33 10) + (set! (-> obj flitters v1-33) (the-as handle #f)) + ) + (dotimes (v1-36 3) + (set! (-> obj wasps v1-36) (the-as handle #f)) + ) + (set! (-> obj initial-y) (-> obj root-override trans y)) + (set! (-> obj hud) (the-as handle #f)) + (set! (-> obj legs) (the-as handle #f)) + (set! (-> obj kid) (the-as handle #f)) + (set! (-> obj wings) (the-as handle #f)) + (set! (-> obj explode) (the-as handle #f)) + (set! (-> obj rift-occlude) (the-as handle #f)) + (set! (-> obj last-attack-id) (the-as uint 0)) + (let ((a0-40 (nav-mesh-from-res-tag (-> obj entity) 'nav-mesh-actor 1))) + (if a0-40 + (change-to a0-40 obj) + ) + ) + (set! (-> obj current-nav-poly) #f) + (set! (-> obj shot-anticipate) (create-launch-control (-> *part-group-id-table* 1232) obj)) + (set! (-> obj last-flitter-launched) 0) + (set! (-> obj last-wasp-launched) 0) + (set! (-> obj live-flitters) 0) + (set! (-> obj live-wasps) 0) + (set! (-> obj flitter-gem-tracker) (the-as handle #f)) + (set! (-> obj wasp-gem-tracker) (the-as handle #f)) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-47 (res-lump-data (-> obj entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-47 (> (-> sv-16 elt-count) 0)) + (let ((v1-48 (-> v1-47 0))) + (when (>= (-> v1-48 length) 1) + (let ((s5-2 (-> v1-48 data 0 actor))) + (let ((a0-52 (search-process-tree + *active-pool* + (the-as + (function process-tree object) + (lambda ((arg0 gem-tracker)) (= (-> arg0 type) flitter-gem-tracker) (none)) + ) + ) + ) + ) + (if a0-52 + (set! (-> obj flitter-gem-tracker) (process->handle a0-52)) + (set! (-> obj flitter-gem-tracker) + (ppointer->handle + (process-spawn flitter-gem-tracker :init gem-tracker-init-by-other s5-2 0 :to *entity-pool*) + ) + ) + ) + ) + (let ((a0-63 + (search-process-tree *active-pool* (the-as + (function process-tree object) + (lambda ((arg0 gem-tracker)) (= (-> arg0 type) wasp-gem-tracker) (none)) + ) + ) + ) + ) + (if a0-63 + (set! (-> obj wasp-gem-tracker) (process->handle a0-63)) + (set! (-> obj wasp-gem-tracker) + (ppointer->handle (process-spawn wasp-gem-tracker :init gem-tracker-init-by-other s5-2 1 :to *entity-pool*)) + ) + ) + ) + ) + ) + ) + ) + ) + (copy-nav-enemy-info! *metalkor-flitter-nav-enemy-info* *flitter-nav-enemy-info*) + (set! (-> *metalkor-flitter-nav-enemy-info* notice-distance) 1638400.0) + (dotimes (v1-71 4) + (set! (-> obj spinners v1-71) (the-as handle #f)) + ) + (set! (-> obj neck) (new 'process 'joint-mod (joint-mod-mode flex-blend) obj 6)) + (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) 409600.0) + (set! (-> obj neck ignore-angle) 16384.0) + (mode-set! (-> obj neck) (joint-mod-mode look-at)) + (set! (-> obj previous-flat-travel-timer) 0) + (set! (-> obj previous-flat-travel-long-timer) 0) + (set! (-> obj countdown-to-roar) 3) + (let ((v1-88 (-> obj root-override root-prim))) + (set! (-> obj root-override backup-collide-as) (-> v1-88 prim-core collide-as)) + (set! (-> obj root-override backup-collide-with) (-> v1-88 prim-core collide-with)) + ) + (set! (-> obj no-collision-timer) 0) + (set! (-> obj wing-sound) (new-sound-id)) + (set! (-> obj wing-sound-playing) #f) + (set! (-> obj explode-sound) (new-sound-id)) + (set! (-> obj bomb-sound) (new-sound-id)) + (set! (-> obj stage) -1) + (metalkor-go-next-stage) + (none) + ) diff --git a/goal_src/jak2/levels/nest/boss/metalkor-states.gc b/goal_src/jak2/levels/nest/boss/metalkor-states.gc index 7c5df6c9bb..7a108027f2 100644 --- a/goal_src/jak2/levels/nest/boss/metalkor-states.gc +++ b/goal_src/jak2/levels/nest/boss/metalkor-states.gc @@ -7,3 +7,2920 @@ ;; DECOMP BEGINS +(define *metalkor-spinner-setup* + (new 'static 'boxed-array :type metalkor-spinner-info + (new 'static 'metalkor-spinner-info :joint-index #x43 :launch-angle 7281.778) + (new 'static 'metalkor-spinner-info :joint-index #x40 :launch-angle 14563.556) + (new 'static 'metalkor-spinner-info :joint-index #x46 :launch-angle -7281.778) + (new 'static 'metalkor-spinner-info :joint-index #x3d :launch-angle -14563.556) + ) + ) + +;; WARN: Return type mismatch int vs handle. +(defbehavior metalkor-start-spinner metalkor ((arg0 int) (arg1 vector)) + (the-as + handle + (when (< arg0 4) + (if (handle->process (-> self spinners arg0)) + (return (the-as handle #f)) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (sin (-> *metalkor-spinner-setup* arg0 launch-angle))) + (f0-2 (cos (-> *metalkor-spinner-setup* arg0 launch-angle))) + ) + (set-vector! + s5-0 + (+ (* f0-2 (-> arg1 x)) (* f30-0 (-> arg1 z))) + 0.0 + (- (* f0-2 (-> arg1 z)) (* f30-0 (-> arg1 x))) + 1.0 + ) + ) + (vector-normalize! s5-0 (* 81920.0 (cos 10922.667))) + (+! (-> s5-0 y) (* 81920.0 (sin 10922.667))) + (set! (-> s5-0 y) (+ 12288.0 (-> s5-0 y))) + (vector+! s5-0 s5-0 (-> self entity trans)) + (let ((v0-0 (ppointer->handle + (process-spawn metalkor-spinner s5-0 (-> *metalkor-spinner-setup* arg0 joint-index) :to self) + ) + ) + ) + (set! (-> self spinners arg0) (the-as handle v0-0)) + v0-0 + ) + ) + ) + ) + ) + +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-spinners-off metalkor () + (dotimes (gp-0 4) + (let ((a0-1 (handle->process (-> self spinners gp-0)))) + (when a0-1 + (send-event a0-1 'break) + (set! (-> self spinners gp-0) (the-as handle #f)) + ) + ) + ) + (none) + ) + +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-lowtorso-spinners-off metalkor () + (let ((gp-0 (handle->process (-> self lowtorso)))) + (when gp-0 + (dotimes (s5-0 4) + (send-event gp-0 'spinner-off s5-0) + ) + ) + ) + (none) + ) + +;; WARN: Return type mismatch handle vs none. +(defbehavior metalkor-spinner-check metalkor ((arg0 int) (arg1 float) (arg2 vector)) + (if (and (not (handle->process (-> self spinners arg0))) (< arg1 (ja-aframe-num 0))) + (metalkor-start-spinner arg0 arg2) + ) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-lowtorso-spinner-check metalkor ((arg0 metalkor-lowtorso) (arg1 float) (arg2 float)) + (when (and (>= arg1 arg2) (< arg1 (ja-aframe-num 0))) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner arg0) + ) + ) + ) + (none) + ) + +(defbehavior metalkor-update-hud metalkor () + (let ((v1-1 (handle->process (-> self hud)))) + (when v1-1 + (set! (-> (the-as hud-metalkor v1-1) values 0 target) (-> self stage)) + (set! (-> (the-as hud-metalkor v1-1) values 1 target) (the int (* 100.0 (-> self stage-hit-points)))) + ) + ) + (none) + ) + +(defbehavior metalkor-all-spinners-on metalkor () + (let ((gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (dotimes (s5-0 4) + (metalkor-start-spinner s5-0 (-> gp-0 vector 2)) + ) + ) + (dotimes (gp-1 4) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner gp-1) + ) + ) + ) + #f + ) + +(defbehavior metalkor-ja-float metalkor ((arg0 art-joint-anim) (arg1 float) (arg2 float) (arg3 float)) + (dotimes (v1-0 (the-as int (+ (-> self skel active-channels) (-> self skel float-channels)))) + (let ((a1-3 (-> self skel channel v1-0 frame-group))) + (if (and a1-3 (nonzero? a1-3) (= (-> self skel channel v1-0 command) (joint-control-command float)) (= a1-3 arg0)) + (return (the-as joint-control-channel #f)) + ) + ) + ) + (let ((v1-3 (ja-channel-float! arg0 0.0 0.0 0.0))) + (when v1-3 + (set! (-> v1-3 param 0) arg1) + (set! (-> v1-3 param 1) arg2) + (set! (-> v1-3 param 2) arg3) + (set! (-> v1-3 num-func) num-func-interp-play!) + v1-3 + ) + ) + ) + +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-ja-float-stop metalkor ((arg0 art-joint-anim)) + (countdown (s5-0 (-> self skel float-channels)) + (let* ((v1-3 (+ s5-0 (-> self skel active-channels))) + (a0-3 (-> self skel channel v1-3 frame-group)) + ) + (if (and a0-3 (nonzero? a0-3) (= (-> self skel channel v1-3 command) (joint-control-command float)) (= a0-3 arg0)) + (joint-channel-float-delete! (-> self skel channel v1-3)) + ) + ) + ) + (none) + ) + +(defbehavior metalkor-ja-float-children metalkor () + (dotimes (gp-0 (the-as int (+ (-> self skel active-channels) (-> self skel float-channels)))) + (let ((v1-2 (-> self skel channel gp-0 frame-group))) + (cond + ((or (not v1-2) (zero? v1-2) (!= (-> self skel channel gp-0 command) 42)) + ) + ((= v1-2 (-> self draw art-group data 23)) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hang-pre-shot" gp-0) + ) + ((= v1-2 (-> self draw art-group data 32)) + (send-event (handle->process (-> self legs)) 'ja-float "pre-shot" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "pre-shot" gp-0) + ) + ((= v1-2 (-> self draw art-group data 34)) + (send-event (handle->process (-> self legs)) 'ja-float "hit" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit" gp-0) + ) + ((= v1-2 (-> self draw art-group data 35)) + (send-event (handle->process (-> self legs)) 'ja-float "hit-left" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit-left" gp-0) + ) + ((= v1-2 (-> self draw art-group data 36)) + (send-event (handle->process (-> self legs)) 'ja-float "hit-right" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit-right" gp-0) + ) + ) + ) + ) + #f + ) + +(defbehavior metalkor-ja-float-group? metalkor ((arg0 art-joint-anim)) + (countdown (v1-1 (-> self skel float-channels)) + (let* ((a1-2 (+ v1-1 (-> self skel active-channels))) + (a2-2 (-> self skel channel a1-2 frame-group)) + ) + (if (and a2-2 (nonzero? a2-2) (= (-> self skel channel a1-2 command) (joint-control-command float)) (= a2-2 arg0)) + (return (the-as int a1-2)) + ) + ) + ) + -1 + ) + +;; WARN: Check prologue - tricky store of r0 +(defun metalkor-get-ring ((arg0 metalkor)) + (local-vars (sv-16 res-tag)) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-1 (res-lump-data (-> arg0 entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-1 (< (the-as uint 2) (-> sv-16 elt-count))) + (let ((v1-2 (-> v1-1 2))) + (if (>= (-> v1-2 length) 1) + (return (-> v1-2 data 0 actor)) + ) + ) + ) + ) + (the-as entity #f) + ) + +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-common metalkor () + (cond + ((and (= (ja-group-size) 9) (= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 41) + ) + ) + (let ((v1-8 (-> self skel effect))) + (set! (-> v1-8 channel-offset) 8) + ) + 0 + ) + (else + (let ((v1-11 (-> self skel effect))) + (set! (-> v1-11 channel-offset) 0) + ) + 0 + ) + ) + (if (and (nonzero? (-> self next-stage-timer)) + (>= (- (-> self clock frame-counter) (-> self next-stage-timer)) 0) + ) + (metalkor-go-next-stage) + ) + (when (>= (- (-> self clock frame-counter) (-> self no-collision-timer)) (seconds 0.1)) + (let ((v1-25 (-> self root-override root-prim))) + (set! (-> v1-25 prim-core collide-as) (-> self root-override backup-collide-as)) + (set! (-> v1-25 prim-core collide-with) (-> self root-override backup-collide-with)) + ) + ) + (case (-> self stage) + ((2) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f)) + '(want-anim "nest-kor-boss-fight-mid") + ) + ) + ((3) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f)) + '(want-anim "outro-nest") + ) + ) + ) + (when (nonzero? (-> self neck)) + (let* ((gp-0 *target*) + (a0-20 (if (type? gp-0 process-focusable) + gp-0 + ) + ) + ) + (if a0-20 + (target-set! (-> self neck) (get-trans a0-20 2)) + ) + ) + ) + (set! (-> self trackable) #t) + (let ((t0-2 (new 'static 'vector))) + (set! (-> t0-2 quad) (-> self root-override trans quad)) + (set! (-> t0-2 y) (+ 16384.0 (-> t0-2 y))) + (set-setting! 'point-of-interest 'abs t0-2 0) + ) + (set! (-> self live-flitters) 0) + (dotimes (gp-2 10) + (let ((a0-24 (handle->process (-> self flitters gp-2)))) + (when a0-24 + (if (< (-> (the-as process-drawable a0-24) root trans y) (+ -204800.0 (-> self root-override trans y))) + (send-event a0-24 'die-fast) + (+! (-> self live-flitters) 1) + ) + ) + ) + ) + (set! (-> self live-wasps) 0) + (dotimes (v1-65 3) + (if (handle->process (-> self wasps v1-65)) + (+! (-> self live-wasps) 1) + ) + ) + (metalkor-ja-float-children) + (none) + ) + +(defmethod deactivate metalkor ((obj metalkor)) + (if (-> obj wing-sound-playing) + (sound-stop (-> obj wing-sound)) + ) + ((method-of-type process-focusable deactivate) obj) + (none) + ) + +;; WARN: Return type mismatch process-focusable vs metalkor. +(defmethod relocate metalkor ((obj metalkor) (arg0 int)) + (if (nonzero? (-> obj shot-anticipate)) + (&+! (-> obj shot-anticipate) arg0) + ) + (if (nonzero? (-> obj neck)) + (&+! (-> obj neck) arg0) + ) + (the-as metalkor ((method-of-type process-focusable relocate) obj arg0)) + ) + +(defmethod get-trans metalkor ((obj metalkor) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (local-vars (s5-0 vector)) + (cond + ((or (= arg0 2) (= arg0 3)) + (set! s5-0 (new 'static 'vector)) + (set! (-> s5-0 quad) + (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 0 prim-core world-sphere quad) + ) + (set! (-> s5-0 w) 61440.0) + s5-0 + ) + ((= arg0 4) + (set! s5-0 (new 'static 'vector)) + (cond + ((zero? (-> obj skel active-channels)) + ) + ((or (and (-> obj next-state) (= (-> obj next-state name) 'explode)) + (and (and (-> obj next-state) (= (-> obj next-state name) 'fly-to-ring)) (-> obj been-to-entity)) + ) + (vector<-cspace! s5-0 (-> obj node-list data 3)) + ) + (else + (set! (-> s5-0 quad) (-> obj root-override trans quad)) + (set! (-> s5-0 y) (+ 8192.0 (-> s5-0 y))) + ) + ) + (when (< 0.0 (-> obj ring-cam-pos value)) + (let ((a0-15 (metalkor-get-ring obj)) + (a2-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> a2-0 quad) (-> a0-15 trans quad)) + (set! (-> a2-0 y) (+ -65536.0 (-> a2-0 y))) + (vector-lerp! s5-0 s5-0 a2-0 (-> obj ring-cam-pos value)) + ) + ) + s5-0 + ) + (else + ((method-of-type process-focusable get-trans) obj arg0) + ) + ) + ) + +(defbehavior set-countdown-to-roar metalkor () + (case (-> self stage) + ((1) + (set! (-> self countdown-to-roar) (rand-vu-int-range 2 5)) + ) + (else + (set! (-> self countdown-to-roar) (rand-vu-int-range 1 3)) + ) + ) + (none) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-go-next-stage metalkor () + (let ((v1-1 (-> self skel effect))) + (set! (-> v1-1 channel-offset) 0) + ) + 0 + (set! (-> self stage) (min 5 (+ (-> self stage) 1))) + (if (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status subtask-complete))) + (set! (-> self stage) (max 3 (-> self stage))) + ) + (if (task-node-closed? (game-task-node nest-boss-resolution)) + (set! (-> self stage) (max 5 (-> self stage))) + ) + (set! (-> self stage-hit-points) 1.0) + (set! (-> self next-stage-timer) 0) + (init (-> self ring-cam-pos) 0.0 0.01 0.1 0.9) + (when (not (handle->process (-> self rift-occlude))) + (if (metalkor-get-ring self) + (set! (-> self rift-occlude) + (ppointer->handle (process-spawn rift-occlude (metalkor-get-ring self) :to self)) + ) + ) + ) + (let ((v1-28 (-> self stage))) + (cond + ((zero? v1-28) + (set! (-> self root-override trans y) (+ -12288.0 (-> self entity trans y))) + (go-virtual hidden) + ) + ((= v1-28 1) + (set-setting! 'music 'danger4 0 0) + (set! (-> self hud) (ppointer->handle (process-spawn hud-metalkor :init hud-init-by-other :to self))) + (metalkor-update-hud) + (set! (-> self lowtorso) + (ppointer->handle (process-spawn metalkor-lowtorso "" (-> self root-override trans) :to self)) + ) + (set! (-> self kid) (ppointer->handle (process-spawn metalkor-kid (-> self entity trans) :to self))) + (let ((gp-4 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (dotimes (s5-1 4) + (metalkor-start-spinner s5-1 (-> gp-4 vector 2)) + ) + ) + (dotimes (gp-5 4) + (let ((a0-44 (handle->process (-> self lowtorso)))) + (if a0-44 + (send-event a0-44 'spinner gp-5) + ) + ) + ) + (set-countdown-to-roar) + (set-setting! 'fov 'abs #x466eeeef 0) + (ja :group! (-> self draw art-group data 9) :num! min) + (go-virtual hang-shoot-n-launch) + ) + ((= v1-28 2) + (set-setting! 'music 'danger4 0 0) + (set-countdown-to-roar) + (go-virtual start-second-stage) + ) + ((= v1-28 3) + (set-setting! 'music 'danger4 0 0) + (set! (-> self last-close-attack) 0) + (set! (-> self last-standing-attack) 0) + (cond + ((not (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status subtask-complete))) + ) + (go-virtual play-drop-movie) + ) + ((zero? (-> self nav)) + (format 0 "ERROR: metalkor nav mesh not found~%") + (go-virtual beaten (not (task-node-closed? (game-task-node nest-boss-resolution)))) + ) + (else + (metalkor-spinners-off) + (metalkor-lowtorso-spinners-off) + (dotimes (gp-8 3) + (let ((a0-61 (handle->process (-> self wasps gp-8)))) + (if a0-61 + (send-event a0-61 'die-fast) + ) + ) + ) + (let ((v1-106 (new 'stack-no-clear 'vector))) + (set! (-> v1-106 quad) (-> self entity trans quad)) + (set! (-> v1-106 x) (+ 90112.0 (-> v1-106 x))) + (set! (-> v1-106 z) (+ -90112.0 (-> v1-106 z))) + (set! (-> self root-override trans quad) (-> v1-106 quad)) + ) + (when (not (handle->process (-> self hud))) + (set! (-> self hud) (ppointer->handle (process-spawn hud-metalkor :init hud-init-by-other :to self))) + (metalkor-update-hud) + ) + (if (not (handle->process (-> self lowtorso))) + (set! (-> self lowtorso) + (ppointer->handle (process-spawn metalkor-lowtorso "" (-> self root-override trans) :to self)) + ) + ) + (if (not (handle->process (-> self kid))) + (set! (-> self kid) (ppointer->handle (process-spawn metalkor-kid (-> self entity trans) :to self))) + ) + (set! (-> self legs) + (ppointer->handle (process-spawn metalkor-legs "" (-> self root-override trans) :to self)) + ) + (set-setting! 'fov 'abs #x466eeeef 0) + (go-virtual chase-target) + ) + ) + ) + ((= v1-28 4) + (set-setting! 'music 'danger4 0 0) + (set! (-> self wings) + (ppointer->handle (process-spawn metalkor-wings "" (-> self root-override trans) :to self)) + ) + (send-event (handle->process (-> self hud)) 'hide-and-die) + (go-virtual last-gasp) + ) + (else + (go-virtual beaten (not (task-node-closed? (game-task-node nest-boss-resolution)))) + ) + ) + ) + (none) + ) + +;; WARN: Return type mismatch float vs none. +(defbehavior metalkor-setup-hit-anim metalkor ((arg0 attack-info) (arg1 process-drawable) (arg2 art-element) (arg3 art-element) (arg4 float)) + (ja-channel-push! 2 0) + (ja :group! arg2 :num! min) + (let* ((f30-0 -0.5) + (v1-5 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-6 (the-as number (logior #x3f800000 v1-5))) + (f30-1 (+ f30-0 (+ -1.0 (the-as float v1-6)))) + (s2-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s1-1 (new 'stack-no-clear 'attack-info)) + ) + (attack-info-method-9 arg0 s1-1 arg1 self) + (vector-flatten! (-> s1-1 trans) (-> s1-1 trans) (-> s2-1 vector 1)) + (let ((f30-2 (fmax -1.0 (fmin 1.0 (+ f30-1 (vector-dot (-> s1-1 trans) (the-as vector (-> s2-1 vector)))))))) + (set! f30-2 (cond + ((>= f30-2 0.0) + (ja :chan 1 :group! arg3 :num! min) + f30-2 + ) + (else + (ja :chan 1 :group! arg4 :num! min) + (- f30-2) + ) + ) + ) + (let ((v1-24 (-> self skel root-channel 1))) + (set! (-> v1-24 frame-interp 1) f30-2) + (set! (-> v1-24 frame-interp 0) f30-2) + ) + ) + ) + (none) + ) + +;; WARN: Return type mismatch process vs none. +(defbehavior metalkor-get-gem-tracker metalkor ((arg0 process-focusable)) + (cond + ((type? arg0 metalkor-wasp) + (handle->process (-> self wasp-gem-tracker)) + ) + ((type? arg0 metalkor-flitter) + (handle->process (-> self flitter-gem-tracker)) + ) + (else + ) + ) + (none) + ) + +;; WARN: Return type mismatch none vs object. +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 72] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 107] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 143] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 173] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 254] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 266] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 291] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 489] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 571] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 580] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 666] +(defbehavior metalkor-handler metalkor ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-2 none)) + (the-as + object + (case arg2 + (('skip) + (dotimes (gp-1 10) + (let ((a0-4 (handle->process (-> self flitters gp-1)))) + (if a0-4 + (send-event a0-4 'die-fast) + ) + ) + ) + (dotimes (gp-2 3) + (let ((a0-8 (handle->process (-> self wasps gp-2)))) + (if a0-8 + (send-event a0-8 'die-fast) + ) + ) + ) + (metalkor-go-next-stage) + ) + (('track) + (-> self trackable) + ) + (('flitter-change-gem) + (let ((v1-23 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-23 from) (process->ppointer arg0)) + (set! (-> v1-23 num-params) arg1) + (set! (-> v1-23 message) arg2) + (set! (-> v1-23 param 0) (-> arg3 param 0)) + (set! (-> v1-23 param 1) (-> arg3 param 1)) + (set! (-> v1-23 param 2) (-> arg3 param 2)) + (set! (-> v1-23 param 3) (-> arg3 param 3)) + (set! (-> v1-23 param 4) (-> arg3 param 4)) + (set! (-> v1-23 param 5) (-> arg3 param 5)) + (send-event-function (handle->process (-> self flitter-gem-tracker)) v1-23) + ) + ) + (('wasp-change-gem) + (let ((v1-24 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-24 from) (process->ppointer arg0)) + (set! (-> v1-24 num-params) arg1) + (set! (-> v1-24 message) arg2) + (set! (-> v1-24 param 0) (-> arg3 param 0)) + (set! (-> v1-24 param 1) (-> arg3 param 1)) + (set! (-> v1-24 param 2) (-> arg3 param 2)) + (set! (-> v1-24 param 3) (-> arg3 param 3)) + (set! (-> v1-24 param 4) (-> arg3 param 4)) + (set! (-> v1-24 param 5) (-> arg3 param 5)) + (send-event-function (handle->process (-> self wasp-gem-tracker)) v1-24) + ) + ) + (('have-gem?) + (let ((s4-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> s4-0 from) (process->ppointer arg0)) + (set! (-> s4-0 num-params) arg1) + (set! (-> s4-0 message) arg2) + (set! (-> s4-0 param 0) (-> arg3 param 0)) + (set! (-> s4-0 param 1) (-> arg3 param 1)) + (set! (-> s4-0 param 2) (-> arg3 param 2)) + (set! (-> s4-0 param 3) (-> arg3 param 3)) + (set! (-> s4-0 param 4) (-> arg3 param 4)) + (set! (-> s4-0 param 5) (-> arg3 param 5)) + (send-event-function (the-as process-tree (metalkor-get-gem-tracker (the-as process-focusable arg0))) s4-0) + ) + ) + (('setup-flitter-gem) + (let ((gp-3 (-> self entity extra))) + (cond + ((send-event (handle->process (-> self flitter-gem-tracker)) 'spawn-with-gem?) + (set! v0-2 (the-as none (logclear (-> gp-3 perm status) (entity-perm-status save)))) + (set! (-> gp-3 perm status) (the-as entity-perm-status v0-2)) + ) + (else + (set! v0-2 (the-as none (logior (-> gp-3 perm status) (entity-perm-status save)))) + (set! (-> gp-3 perm status) (the-as entity-perm-status v0-2)) + ) + ) + ) + v0-2 + ) + (('hatch) + (let ((v1-41 (-> arg3 param 0))) + (set! (-> self flitters v1-41) (the-as handle (-> arg3 param 1))) + (send-event + (handle->process (-> self flitter-gem-tracker)) + 'change-gem + #f + (handle->process (-> self flitters v1-41)) + ) + ) + ) + (('child-die) + (cond + ((not (and (-> self next-state) (= (-> self next-state name) 'hang-shoot-n-launch))) + #f + ) + ((>= 1 (-> self countdown-to-roar)) + (set-countdown-to-roar) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 21) :num! min) + (metalkor-all-spinners-on) + ) + (else + (set! v0-2 (the-as none (+ (-> self countdown-to-roar) -1))) + (set! (-> self countdown-to-roar) (the-as int v0-2)) + v0-2 + ) + ) + ) + (('attack) + (let ((f28-0 1.0) + (s5-2 (the-as object (-> arg3 param 1))) + (f30-0 (* 0.2 (the float (the int (* 4.99 (-> self stage-hit-points)))))) + ) + (when (!= (-> self stage-hit-points) 0.0) + (when (or (not (logtest? (-> (the-as attack-info s5-2) mask) (attack-info-mask id))) + (!= (-> self last-attack-id) (-> (the-as attack-info s5-2) id)) + ) + (if (logtest? (-> (the-as attack-info s5-2) mask) (attack-info-mask id)) + (set! (-> self last-attack-id) (-> (the-as attack-info s5-2) id)) + ) + (if (logtest? (attack-info-mask damage) (-> (the-as attack-info s5-2) mask)) + (set! f28-0 (-> (the-as attack-info s5-2) damage)) + ) + (let* ((s4-1 arg0) + (f0-4 (cond + ((if (type? s4-1 gun-blue-shot) + s4-1 + ) + (if (= (-> self stage) 3) + (* 0.0012 f28-0) + (* 0.0024 f28-0) + ) + ) + (else + (let ((s4-2 arg0)) + (cond + ((if (type? s4-2 gun-dark-shot) + s4-2 + ) + (if (= (-> self stage) 3) + (* 0.003 f28-0) + (* 0.006 f28-0) + ) + ) + ((= (-> self stage) 3) + (* 0.004 f28-0) + ) + (else + (* 0.008 f28-0) + ) + ) + ) + ) + ) + ) + ) + (if (and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info s5-2) mask)) + (logtest? (penetrate dark-bomb) (-> (the-as attack-info s5-2) penetrate-using)) + ) + (set! f0-4 0.5) + ) + (if (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + (set! f0-4 (* 0.6666667 f0-4)) + ) + (if (not (and (-> self next-state) (let ((v1-109 (-> self next-state name))) + (or (= v1-109 'fall-down) + (= v1-109 'overload-recover) + (= v1-109 'tail-attack) + (= v1-109 'foot-attack) + (= v1-109 'start-second-stage) + ) + ) + ) + ) + (set! (-> self stage-hit-points) (fmax 0.0 (- (-> self stage-hit-points) f0-4))) + ) + ) + (metalkor-update-hud) + (cond + ((and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info s5-2) mask)) + (logtest? (penetrate dark-bomb) (-> (the-as attack-info s5-2) penetrate-using)) + (= (-> self stage-hit-points) 0.0) + ) + (set! v0-2 (the-as none (+ (-> self clock frame-counter) (seconds 1)))) + (set! (-> self next-stage-timer) (the-as time-frame v0-2)) + v0-2 + ) + ((= (-> self stage-hit-points) 0.0) + (metalkor-go-next-stage) + ) + ((and (-> self next-state) (= (-> self next-state name) 'hang-shoot-n-launch)) + (metalkor-setup-hit-anim + (the-as attack-info s5-2) + (the-as process-drawable arg0) + (-> self draw art-group data 18) + (-> self draw art-group data 20) + (the-as float (-> self draw art-group data 19)) + ) + (metalkor-all-spinners-on) + ) + ((and (and (-> self next-state) (= (-> self next-state name) 'fall-down)) + (let ((v1-139 (ja-group))) + (or (not (and v1-139 (= v1-139 (-> self draw art-group data 7)))) (>= (ja-aframe-num 0) 10.0)) + ) + ) + (metalkor-setup-hit-anim + (the-as attack-info s5-2) + (the-as process-drawable arg0) + (-> self draw art-group data 25) + (-> self draw art-group data 27) + (the-as float (-> self draw art-group data 26)) + ) + ) + ((and (-> self next-state) (let ((v1-153 (-> self next-state name))) + (or (= v1-153 'chase-target) + (= v1-153 'standing-shot) + (= v1-153 'overload-recover) + (= v1-153 'tail-attack) + (= v1-153 'foot-attack) + (= v1-153 'get-close) + ) + ) + ) + (if (< (-> self stage-hit-points) f30-0) + (go-virtual fall-down) + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 34)) 1.0 0.25 2.0) + ) + ) + ) + ) + ) + ) + ) + (('touch) + (when ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self root-override) + (the-as uint 1) + ) + (let* ((s4-3 arg0) + (gp-5 (if (type? s4-3 process-focusable) + s4-3 + ) + ) + ) + (when gp-5 + (let ((s3-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s4-4 (new 'stack-no-clear 'vector)) + ) + (if (>= (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 42))) 0) + (vector+! s4-4 (-> s3-0 vector 2) (the-as vector (-> s3-0 vector))) + (vector-! s4-4 (-> s3-0 vector 2) (the-as vector (-> s3-0 vector))) + ) + (set! (-> s4-4 y) 0.0) + (vector-normalize! s4-4 32768.0) + (set! (-> s4-4 y) 24576.0) + (let ((a1-43 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-43 from) (process->ppointer self)) + (set! (-> a1-43 num-params) 2) + (set! (-> a1-43 message) 'attack) + (set! (-> a1-43 param 0) (-> arg3 param 0)) + (let ((v1-170 (new 'static 'attack-info :mask (attack-info-mask vector shove-up id)))) + (let* ((a0-116 *game-info*) + (a2-15 (+ (-> a0-116 attack-id) 1)) + ) + (set! (-> a0-116 attack-id) a2-15) + (set! (-> v1-170 id) a2-15) + ) + (set! (-> v1-170 vector quad) (-> s4-4 quad)) + (set! (-> v1-170 shove-up) 24576.0) + (set! (-> a1-43 param 1) (the-as uint v1-170)) + ) + (when (send-event-function gp-5 a1-43) + (set! (-> self no-collision-timer) (-> self clock frame-counter)) + (let ((v1-175 (-> self root-override root-prim))) + (set! (-> v1-175 prim-core collide-as) (collide-spec)) + (set! (-> v1-175 prim-core collide-with) (collide-spec)) + ) + 0 + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + +(defbehavior metalkor-start-egg metalkor () + (if (nonzero? (-> self egg-timer)) + (return #f) + ) + (dotimes (v1-3 10) + (when (not (handle->process (-> self flitters v1-3))) + (new 'stack-no-clear 'vector) + (let ((f0-1 (* 182.04445 (rand-vu-float-range 70.0 290.0)))) + (set! (-> self egg-timer) (-> self clock frame-counter)) + (set! (-> self egg-angle) f0-1) + (if (< 32768.0 f0-1) + (send-event (handle->process (-> self lowtorso)) 'egg-toss 1.0) + (send-event (handle->process (-> self lowtorso)) 'egg-toss -1.0) + ) + ) + (return #f) + ) + ) + #f + ) + +(defbehavior metalkor-check-egg metalkor () + (local-vars (v0-0 symbol)) + (if (zero? (-> self egg-timer)) + (return #f) + ) + (if (< (- (-> self clock frame-counter) (-> self egg-timer)) (seconds 0.2)) + (return #t) + ) + (dotimes (gp-0 10) + (when (not (handle->process (-> self flitters gp-0))) + (let ((s4-0 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-0 quad) (-> self root-override trans quad)) + (let ((v1-19 (handle->process (-> self lowtorso)))) + (if v1-19 + (vector<-cspace! s5-0 (-> (the-as process-focusable v1-19) node-list data 11)) + ) + ) + (let ((s2-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (set-vector! s4-0 (* 102400.0 (sin (-> self egg-angle))) 81920.0 (* 102400.0 (cos (-> self egg-angle))) 1.0) + (vector-matrix*! s4-0 s4-0 s2-0) + ) + (when (-> self entity) + (let ((v1-31 (-> self entity extra))) + (logior! (-> v1-31 perm status) (entity-perm-status save)) + ) + ) + (sound-play "nboss-spawn") + (set! (-> self flitters gp-0) (ppointer->handle (process-spawn metalkor-egg s5-0 s4-0 gp-0 :to self))) + ) + (send-event (handle->process (-> self lowtorso)) 'egg-toss 0) + (set! (-> self egg-timer) 0) + (return #f) + ) + ) + (return #f) + v0-0 + ) + +(defbehavior metalkor-shoot-projectile metalkor () + (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params))) + (set! (-> gp-0 ent) (-> self entity)) + (set! (-> gp-0 charge) 1.0) + (set! (-> gp-0 options) (projectile-options)) + (set! (-> gp-0 notify-handle) (the-as handle #f)) + (set! (-> gp-0 owner-handle) (the-as handle #f)) + (set! (-> gp-0 ignore-handle) (process->handle self)) + (let* ((v1-5 *game-info*) + (a0-5 (+ (-> v1-5 attack-id) 1)) + ) + (set! (-> v1-5 attack-id) a0-5) + (set! (-> gp-0 attack-id) a0-5) + ) + (set! (-> gp-0 timeout) (seconds 4)) + (vector<-cspace! (-> gp-0 pos) (-> self node-list data 7)) + (vector-! (-> gp-0 vel) (target-pos 0) (-> gp-0 pos)) + (vector-normalize! (-> gp-0 vel) 491520.0) + (if (spawn-projectile metalkor-shot gp-0 self *default-dead-pool*) + (+! (-> self shots-fired) 1) + ) + ) + (none) + ) + +(defbehavior metalkor-face-to-vector metalkor ((arg0 vector) (arg1 float) (arg2 float)) + (let ((s4-0 (new 'stack-no-clear 'matrix)) + (s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (gp-0 (new 'stack-no-clear 'matrix)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (vector-! s3-0 arg0 (-> self root-override trans)) + (vector-flatten! s3-0 s3-0 (-> s5-0 vector 1)) + (vector-normalize! s3-0 1.0) + (matrix-from-two-vectors-max-angle-partial! + s4-0 + (-> s5-0 vector 2) + s3-0 + (* arg1 (-> self clock time-adjust-ratio)) + (* arg2 (-> self clock time-adjust-ratio)) + ) + ) + (matrix*! gp-0 s5-0 s4-0) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (set! (-> self last-rotation) (acos (vector-dot (-> s5-0 vector 2) (-> gp-0 vector 2)))) + (if (< (vector-dot (-> gp-0 vector 2) (the-as vector (-> s5-0 vector))) 0.0) + (set! (-> self last-rotation) (- (-> self last-rotation))) + ) + (cond + ((< (fabs (-> self last-rotation)) 20.024889) + (set! (-> self last-rotation) 0.0) + ) + (else + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + ) + ) + ) + 0 + (none) + ) + +;; WARN: Return type mismatch float vs none. +(defbehavior update-walk-anim metalkor ((arg0 vector) (arg1 symbol)) + (local-vars (f24-0 float)) + (let ((v1-2 (ja-group))) + (cond + ((and (and v1-2 (= v1-2 (-> self draw art-group data 33))) (begin (ja :num! (seek!)) (not (ja-done? 0)))) + ) + (else + (let* ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) arg0)) + (v1-16 s5-1) + (f26-0 (sqrtf (+ (* (-> v1-16 x) (-> v1-16 x)) (* (-> v1-16 z) (-> v1-16 z))))) + (v1-19 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + 0.0 + (let ((f30-0 0.0) + (f28-0 0.0) + ) + 0.0 + (let ((f0-11 (* 0.000024414063 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames)) + f26-0 + ) + ) + (f26-1 (* 0.000015258789 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 6)) frames num-frames)) + f26-0 + ) + ) + ) + (cond + ((or (< 1.0 f26-1) arg1) + (set! f24-0 0.0) + ) + ((< f0-11 1.0) + (set! f24-0 1.0) + (set! f26-1 f0-11) + ) + (else + (set! f24-0 (/ (- 1.0 f26-1) (- f0-11 f26-1))) + (set! f26-1 1.0) + ) + ) + (let ((f0-15 (* 0.000045776367 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 37)) frames num-frames)) + (-> self last-rotation) + ) + ) + ) + (when (and (< (vector-dot s5-1 (-> v1-19 vector 2)) 0.0) (not arg1)) + (set! f26-1 (- f26-1)) + (set! f0-15 (- f0-15)) + ) + (if (< f0-15 0.0) + (set! f30-0 1.0) + ) + (when (and (< (fabs f26-1) (fabs f0-15)) (not arg1)) + (set! f26-1 f0-15) + (set! f28-0 1.0) + ) + ) + (let ((f22-0 (if (and (= f26-1 0.0) (not arg1)) + 1.0 + 0.0 + ) + ) + ) + (let ((v1-41 (ja-group))) + (cond + ((not (and v1-41 (= v1-41 (-> self draw art-group data 6)))) + (ja-channel-push! 9 (seconds 0.5)) + (ja :group! (-> self draw art-group data 6) :num! min) + (ja :chan 1 :group! (-> self draw art-group data 40) :num! min) + (set! (-> self skel root-channel 2 command) (joint-control-command push)) + (ja :chan 2 :group! (-> self draw art-group data 5) :num! min) + (ja :chan 3 :group! (-> self draw art-group data 39) :num! min) + (set! (-> self skel root-channel 4 command) (joint-control-command stack)) + (set! (-> self skel root-channel 5 command) (joint-control-command push)) + (ja :chan 5 :group! (-> self draw art-group data 37) :num! min) + (ja :chan 6 :group! (-> self draw art-group data 38) :num! min) + (set! (-> self skel root-channel 7 command) (joint-control-command stack)) + (let* ((v1-79 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-80 (the-as number (logior #x3f800000 v1-79))) + ) + (cond + ((< (+ -1.0 (the-as float v1-80)) 0.2) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + (else + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 0 1)) + ) + ) + ) + (init + (-> self for-back-interp) + (if (< f26-1 0.0) + 1.0 + 0.0 + ) + 0.01 + 0.1 + 0.9 + ) + (init (-> self run-walk-interp) f24-0 0.01 0.1 0.9) + (init (-> self left-right-interp) f30-0 0.01 0.1 0.9) + (init (-> self walk-turn-interp) f28-0 0.01 0.1 0.9) + (init (-> self idle-interp) f22-0 0.01 0.1 0.9) + ) + ((= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 41) + ) + (ja :chan 8 :num! (seek!)) + (when (ja-done? 8) + (let* ((v1-117 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-118 (the-as number (logior #x3f800000 v1-117))) + ) + (cond + ((< (+ -1.0 (the-as float v1-118)) 0.2) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + (else + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 0 1)) + ) + ) + ) + ) + ) + ((= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 4) + ) + (ja :chan 8 :num! (seek!)) + (when (ja-done? 8) + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 2 4)) + ) + ) + ((zero? (-> self reps-till-idle-alt)) + (ja :chan 8 :num! (seek!)) + (if (ja-done? 8) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + ) + (else + (let ((f20-0 (ja-aframe-num 8))) + (ja :chan 8 :num! (loop!)) + (if (< (ja-aframe-num 8) f20-0) + (+! (-> self reps-till-idle-alt) -1) + ) + ) + ) + ) + ) + (let ((a0-94 (-> self skel root-channel 0))) + (set! (-> a0-94 param 0) f26-1) + (joint-control-channel-group-eval! a0-94 (the-as art-joint-anim #f) num-func-loop-speedless!) + ) + (ja :chan 1 :num! (chan 0)) + (ja :chan 2 :num! (chan 0)) + (ja :chan 3 :num! (chan 0)) + (ja :chan 5 :num! (chan 0)) + (ja :chan 6 :num! (chan 0)) + (set! (-> self for-back-interp target) (if (< f26-1 0.0) + 1.0 + 0.0 + ) + ) + (set! (-> self run-walk-interp target) f24-0) + (set! (-> self left-right-interp target) f30-0) + (set! (-> self walk-turn-interp target) f28-0) + (cond + ((or (< 0.5 (-> self idle-interp target)) (< f22-0 0.5)) + (set! (-> self idle-interp target) f22-0) + ) + ((< (-> self idle-interp value) 0.01) + (ja :chan 8 :group! (-> self draw art-group data 41) :num! min) + (set! (-> self idle-interp target) f22-0) + ) + ) + ) + ) + ) + ) + (update! (-> self for-back-interp) 0.0) + (update! (-> self run-walk-interp) 0.0) + (update! (-> self left-right-interp) 0.0) + (update! (-> self walk-turn-interp) 0.0) + (update! (-> self idle-interp) 0.0) + (let ((v1-217 (-> self skel root-channel 1)) + (f0-58 (-> self for-back-interp value)) + ) + (set! (-> v1-217 frame-interp 1) f0-58) + (set! (-> v1-217 frame-interp 0) f0-58) + ) + (let ((v1-221 (-> self skel root-channel 3)) + (f0-59 (-> self for-back-interp value)) + ) + (set! (-> v1-221 frame-interp 1) f0-59) + (set! (-> v1-221 frame-interp 0) f0-59) + ) + (let ((v1-225 (-> self skel root-channel 4)) + (f0-60 (-> self run-walk-interp value)) + ) + (set! (-> v1-225 frame-interp 1) f0-60) + (set! (-> v1-225 frame-interp 0) f0-60) + ) + (let ((v1-229 (-> self skel root-channel 6)) + (f0-61 (-> self left-right-interp value)) + ) + (set! (-> v1-229 frame-interp 1) f0-61) + (set! (-> v1-229 frame-interp 0) f0-61) + ) + (let ((v1-233 (-> self skel root-channel 7)) + (f0-62 (-> self walk-turn-interp value)) + ) + (set! (-> v1-233 frame-interp 1) f0-62) + (set! (-> v1-233 frame-interp 0) f0-62) + ) + (let ((v1-237 (-> self skel root-channel 8)) + (f0-63 (-> self idle-interp value)) + ) + (set! (-> v1-237 frame-interp 1) f0-63) + (set! (-> v1-237 frame-interp 0) f0-63) + ) + ) + ) + ) + (none) + ) + +;; WARN: Return type mismatch symbol vs none. +(defbehavior rotate-and-update-hang-anim metalkor () + (let ((s5-0 (new 'stack-no-clear 'matrix)) + (gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (set! (-> s3-0 quad) (-> (target-pos 0) quad)) + (vector-! s4-0 s3-0 (-> self root-override trans)) + ) + (vector-flatten! s4-0 s4-0 (-> gp-0 vector 1)) + (vector-normalize! s4-0 1.0) + (let ((f26-0 (acos (vector-dot s4-0 (-> gp-0 vector 2)))) + (f30-0 0.0) + ) + (let ((f28-0 (ja-aframe-num 0))) + (set! (-> self target-angle) f26-0) + (if (< 0.0 (vector-dot s4-0 (the-as vector (-> gp-0 vector)))) + (set! f26-0 (- f26-0)) + ) + (let ((v1-12 (ja-group))) + (cond + ((and (and v1-12 (or (= v1-12 (-> self draw art-group data 18)) + (= v1-12 (-> self draw art-group data 21)) + (= v1-12 (-> self draw art-group data 24)) + ) + ) + (begin (ja :num! (seek!)) (not (ja-done? 0))) + ) + ) + ((and (< 8738.134 f26-0) + (let ((v1-30 (ja-group))) + (not (and v1-30 (or (= v1-30 (-> self draw art-group data 10)) (= v1-30 (-> self draw art-group data 11))))) + ) + ) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 10) :num! min) + (metalkor-spinners-off) + ) + ((and (< f26-0 -8738.134) + (let ((v1-44 (ja-group))) + (not (and v1-44 (or (= v1-44 (-> self draw art-group data 13)) (= v1-44 (-> self draw art-group data 14))))) + ) + ) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 13) :num! min) + (metalkor-spinners-off) + ) + (else + (let ((v1-55 (ja-group))) + (cond + ((and v1-55 (= v1-55 (-> self draw art-group data 10))) + (ja :num! (seek!)) + (metalkor-spinner-check 0 10.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 11.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 12.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 13.0 (-> gp-0 vector 2)) + (if (and (>= 20.0 f28-0) (< 20.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 30.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 31.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 32.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 33.0 f28-0) + (set! f30-0 (/ 12288.0 (the float (ja-num-frames 0)))) + (cond + ((not (ja-done? 0)) + ) + ((< 8738.134 f26-0) + (ja :group! (-> self draw art-group data 11) :num! min) + ) + (else + (ja :group! (-> self draw art-group data 12) :num! min) + ) + ) + ) + ((let ((v1-87 (ja-group))) + (and v1-87 (= v1-87 (-> self draw art-group data 11))) + ) + (if (< 8738.134 f26-0) + (ja :num! (loop!)) + (ja :num! (seek!)) + ) + (if (and (>= 40.0 f28-0) (< 40.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 0 50.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 51.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 52.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 53.0 (-> gp-0 vector 2)) + (if (and (>= 60.0 f28-0) (< 60.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 70.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 71.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 72.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 73.0 f28-0) + (set! f30-0 (/ 16384.0 (the float (ja-num-frames 0)))) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 12) :num! min) + ) + ) + ((let ((v1-124 (ja-group))) + (and v1-124 (= v1-124 (-> self draw art-group data 12))) + ) + (ja :num! (seek!)) + (if (and (>= 80.0 f28-0) (< 80.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 0 90.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 91.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 92.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 93.0 (-> gp-0 vector 2)) + (if (< (ja-aframe-num 0) 100.0) + (set! f30-0 (/ 4096.0 (the float (/ (ja-num-frames 0) 2)))) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + ((let ((v1-154 (ja-group))) + (and v1-154 (= v1-154 (-> self draw art-group data 13))) + ) + (ja :num! (seek!)) + (metalkor-spinner-check 2 10.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 11.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 12.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 13.0 (-> gp-0 vector 2)) + (if (and (>= 20.0 f28-0) (< 20.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 30.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 31.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 32.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 33.0 f28-0) + (set! f30-0 (/ -12288.0 (the float (ja-num-frames 0)))) + (cond + ((not (ja-done? 0)) + ) + ((< f26-0 -8738.134) + (ja :group! (-> self draw art-group data 14) :num! min) + ) + (else + (ja :group! (-> self draw art-group data 15) :num! min) + ) + ) + ) + ((let ((v1-186 (ja-group))) + (and v1-186 (= v1-186 (-> self draw art-group data 14))) + ) + (if (< f26-0 -8738.134) + (ja :num! (loop!)) + (ja :num! (seek!)) + ) + (if (and (>= 40.0 f28-0) (< 40.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 2 50.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 51.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 52.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 53.0 (-> gp-0 vector 2)) + (if (and (>= 60.0 f28-0) (< 60.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 70.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 71.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 72.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 73.0 f28-0) + (set! f30-0 (/ -16384.0 (the float (ja-num-frames 0)))) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 15) :num! min) + ) + ) + ((let ((v1-223 (ja-group))) + (and v1-223 (= v1-223 (-> self draw art-group data 15))) + ) + (ja :num! (seek!)) + (if (and (>= 80.0 f28-0) (< 80.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 2 90.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 91.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 92.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 93.0 (-> gp-0 vector 2)) + (if (< (ja-aframe-num 0) 80.0) + (set! f30-0 (/ -4096.0 (the float (/ (ja-num-frames 0) 2)))) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + (else + (let ((v1-253 (ja-group))) + (cond + ((and v1-253 (= v1-253 (-> self draw art-group data 9))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (when (!= f30-0 0.0) + (matrix-axis-angle! s5-0 (-> gp-0 vector 1) (* 0.5 (-> self clock time-adjust-ratio) f30-0)) + (matrix*! gp-0 gp-0 s5-0) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + ) + ) + ) + (dotimes (gp-1 (ja-group-size)) + (if (nonzero? gp-1) + (ja :chan gp-1 :num! (loop!)) + ) + ) + (none) + ) + +(defstate beaten (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('occlude-off) + (let ((a0-3 (handle->process (-> self rift-occlude)))) + (if a0-3 + (the-as symbol (deactivate a0-3)) + ) + ) + ) + ) + ) + ) + :enter (behavior ((arg0 symbol)) + (ja-channel-set! 0) + (ja-post) + (send-event (handle->process (-> self hud)) 'hide-and-die) + (set! (-> self hud) (the-as handle #f)) + (remove-setting! 'point-of-interest) + (remove-setting! 'fov) + (when arg0 + (remove-setting! 'music) + (send-event (handle->process (-> self rift-occlude)) 'movie-pos) + (outro-play) + ) + (none) + ) + :exit (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3) :num! min) + (none) + ) + :code (the-as (function symbol none :behavior metalkor) sleep-code) + ) + +(defstate explode (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('exploding) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 1) + (set! (-> gp-0 message) 'stutter) + (set! (-> gp-0 param 0) (the-as uint #f)) + (let ((s5-0 send-event-function) + (v1-4 (metalkor-get-ring self)) + ) + (s5-0 + (if v1-4 + (-> v1-4 extra process) + ) + gp-0 + ) + ) + ) + ) + (('explode-done) + (the-as object (metalkor-go-next-stage)) + ) + ) + ) + ) + :enter (behavior () + (process-grab? *target* #f) + (set-setting! 'entity-name "camera-271" 0 0) + (send-event *camera* 'change-target self) + (none) + ) + :exit (behavior () + (process-release? *target*) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 1) + (set! (-> gp-0 message) 'stutter) + (set! (-> gp-0 param 0) (the-as uint #f)) + (let ((s5-0 send-event-function) + (v1-3 (metalkor-get-ring self)) + ) + (s5-0 + (if v1-3 + (-> v1-3 extra process) + ) + gp-0 + ) + ) + ) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3) :num! min) + (let ((a0-7 (handle->process (-> self explode)))) + (if a0-7 + (deactivate a0-7) + ) + ) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (none) + ) + :trans (behavior () + (when (not (handle->process (-> self explode))) + (let ((v1-4 (the-as entity-actor (metalkor-get-ring self)))) + (when v1-4 + (let ((s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> v1-4 quat))) + (gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + (let ((s4-0 (new 'stack-no-clear 'matrix))) + (vector-negate! (-> s5-0 vector 2) (-> s5-0 vector 2)) + (matrix-from-two-vectors-max-angle-partial! s4-0 (-> gp-0 vector 2) (-> s5-0 vector 2) 273.06668 0.75) + (matrix*! gp-0 gp-0 s4-0) + ) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + (let ((f0-1 (vector-dot (-> gp-0 vector 1) (new 'static 'vector :y 1.0)))) + (let* ((f1-0 1.0) + (f2-0 f0-1) + (f1-2 (sqrtf (- f1-0 (* f2-0 f2-0)))) + ) + (vector+float*! + (-> self root-override trans) + (-> self hit-ring-trans) + (-> self hit-ring-offset) + (* 73728.0 f1-2) + ) + ) + (+! (-> self root-override trans y) (* 73728.0 (- 1.0 f0-1))) + ) + ) + ) + ) + (let ((v1-21 (ja-group))) + (cond + ((and v1-21 (= v1-21 (-> self draw art-group data 47))) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (if (and (< f30-0 16.0) (>= (ja-aframe-num 0) 16.0)) + (set-action! + *gui-control* + (gui-action play) + (-> self explode-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + ) + (when (ja-done? 0) + (ja-channel-set! 0) + (set! (-> self explode) (ppointer->handle (process-spawn + metalkor-explode + (-> self root-override trans) + (-> self root-override quat) + (process->handle (-> (metalkor-get-ring self) extra process)) + :to self + ) + ) + ) + ) + ) + (else + (ja :group! (-> self draw art-group data 47) :num! min) + (let ((gp-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-3 from) (process->ppointer self)) + (set! (-> gp-3 num-params) 1) + (set! (-> gp-3 message) 'stutter) + (set! (-> gp-3 param 0) (the-as uint #t)) + (let ((s5-2 send-event-function) + (v1-61 (metalkor-get-ring self)) + ) + (s5-2 + (if v1-61 + (-> v1-61 extra process) + ) + gp-3 + ) + ) + ) + (process-spawn metalkor-distort (-> self root-override trans) (-> self root-override quat) :to self) + ) + ) + ) + ) + (update! (-> self ring-cam-pos) 0.0) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate fly-to-ring (metalkor) + :virtual #t + :enter (behavior () + (process-grab? *target* #f) + (set! (-> self been-to-entity) #f) + (sound-play "nboss-hover" :id (-> self wing-sound) :position (-> self root-override trans)) + (set! (-> self wing-sound-playing) #t) + (init (-> self flying-speed) 0.0 0.01 0.1 0.9) + (set! (-> self flying-speed target) 1.0) + (let ((a0-6 (metalkor-get-ring self))) + (cond + (a0-6 + (set! (-> self hit-ring-trans quad) (-> a0-6 trans quad)) + (set! (-> self hit-ring-trans y) (+ -110592.0 (-> self hit-ring-trans y))) + (vector-! (-> self hit-ring-offset) (-> self hit-ring-trans) (-> self entity trans)) + (set! (-> self hit-ring-offset y) 0.0) + (vector-normalize! (-> self hit-ring-offset) 1.0) + (vector+float*! (-> self hit-ring-trans) (-> self hit-ring-trans) (-> self hit-ring-offset) -16384.0) + ) + (else + (set! (-> self hit-ring-trans quad) (-> self entity trans quad)) + (set-vector! (-> self hit-ring-offset) 1.0 0.0 0.0 1.0) + ) + ) + ) + (set-setting! 'entity-name "camera-272" 0 0) + (send-event *camera* 'change-target self) + (set! (-> self need-teleport) #f) + (set-setting! 'teleport-on-entity-change 'abs #t 0) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 1.0) + ) + (set! (-> self explode-sound) + (add-process *gui-control* self (gui-channel jak) (gui-action queue) "nbexplo" -99.0 0) + ) + (none) + ) + :exit (behavior () + (process-release? *target*) + (when (-> self wing-sound-playing) + (sound-stop (-> self wing-sound)) + (set! (-> self wing-sound-playing) #f) + ) + (vector+float*! (-> self hit-ring-trans) (-> self hit-ring-trans) (-> self hit-ring-offset) 32768.0) + (set! (-> self root-override trans quad) (-> self hit-ring-trans quad)) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (remove-setting! 'teleport-on-entity-change) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 46))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 46) :num! min) + ) + ) + ) + (update! (-> self flying-speed) 0.0) + (metalkor-face-to-vector (-> self hit-ring-trans) 728.1778 0.005) + (cond + ((-> self been-to-entity) + (vector-seek-3d-smooth! + (-> self root-override trans) + (-> self hit-ring-trans) + (* 3072.0 (-> self flying-speed value)) + 0.5 + ) + (let ((f0-4 (vector-vector-distance-squared (-> self root-override trans) (-> self hit-ring-trans))) + (f1-1 4096.0) + ) + (cond + ((< f0-4 (* f1-1 f1-1)) + (go-virtual explode) + ) + ((let ((f1-4 40960.0)) + (< f0-4 (* f1-4 f1-4)) + ) + (set! (-> self ring-cam-pos target) 1.0) + ) + ) + ) + ) + (else + (let ((gp-1 (new 'stack-no-clear 'vector))) + (set! (-> gp-1 quad) (-> self entity trans quad)) + (set! (-> gp-1 y) (+ -61440.0 (-> gp-1 y))) + (vector-seek-3d-smooth! (-> self root-override trans) gp-1 (* 3072.0 (-> self flying-speed value)) 0.5) + (let ((f0-10 (vector-vector-distance-squared (-> self root-override trans) gp-1)) + (f1-9 12288.0) + ) + (when (< f0-10 (* f1-9 f1-9)) + (set! (-> self been-to-entity) #t) + (set-setting! 'entity-name "camera-271" 0 0) + ) + ) + ) + ) + ) + (when (nonzero? (-> self neck)) + (let ((v1-46 (metalkor-get-ring self))) + (if v1-46 + (target-set! (-> self neck) (-> v1-46 trans)) + ) + ) + ) + (update! (-> self ring-cam-pos) 0.0) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate last-gasp (metalkor) + :virtual #t + :enter (behavior () + (set-setting! 'music #f 0 0) + (process-grab? *target* #f) + (set-setting! 'entity-name "camera-272" 0 0) + (remove-setting! 'point-of-interest) + (send-event *camera* 'change-target self) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (none) + ) + :exit (behavior () + (process-release? *target*) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 7))) + (ja :num! (seek! max 0.5)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 45) :num! min) + ) + ) + ((let ((v1-21 (ja-group))) + (and v1-21 (= v1-21 (-> self draw art-group data 45))) + ) + (ja :num! (seek!)) + (if (and (< 218.0 (ja-aframe-num 0)) (nonzero? (-> self neck))) + (set! (-> self neck flex-blend) 1.0) + ) + (if (ja-done? 0) + (go-virtual fly-to-ring) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 7) :num! min) + ) + ) + ) + (when (nonzero? (-> self neck)) + (let ((v1-50 (metalkor-get-ring self))) + (if v1-50 + (target-set! (-> self neck) (-> v1-50 trans)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate overload-recover (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 30) :num! min) + (none) + ) + :exit (behavior () + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 1.0) + ) + (none) + ) + :trans (behavior () + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual get-close) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; WARN: Return type mismatch object vs none. +(defbehavior set-color-vectors metalkor ((arg0 float)) + (vector-lerp! + (-> self draw color-mult) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) + (new 'static 'vector) + (fmin 1.0 arg0) + ) + (set! (-> self draw color-mult w) 1.0) + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) + arg0 + ) + (send-event (handle->process (-> self legs)) 'color (-> self draw color-mult) (-> self draw color-emissive)) + (send-event + (handle->process (-> self lowtorso)) + 'color + (-> self draw color-mult) + (-> self draw color-emissive) + ) + (none) + ) + +(defstate fall-down (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self min-state-hit-points) (+ -0.34 (-> self stage-hit-points))) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (set! (-> self bomb-sound) + (add-process *gui-control* self (gui-channel jak) (gui-action queue) "nbshock" -99.0 0) + ) + (set! (-> self stop-bomb-sound) #t) + (none) + ) + :exit (behavior () + (if (-> self stop-bomb-sound) + (set-action! + *gui-control* + (gui-action stop) + (-> self bomb-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (none) + ) + :trans (behavior () + (if (or (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) + (>= (-> self min-state-hit-points) (-> self stage-hit-points)) + ) + (go-virtual overload-recover) + ) + (let ((v1-10 (ja-group))) + (cond + ((and v1-10 (or (= v1-10 (-> self draw art-group data 7)) (= v1-10 (-> self draw art-group data 25)))) + (let ((f30-0 (ja-aframe-num 0))) + (let ((a0-10 (-> self skel root-channel 0))) + (set! (-> a0-10 param 0) (the float (+ (-> a0-10 frame-group frames num-frames) -1))) + (let ((v1-21 (ja-group))) + (set! (-> a0-10 param 1) (if (and v1-21 (= v1-21 (-> self draw art-group data 7))) + 0.5 + 1.0 + ) + ) + ) + (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-seek!) + ) + (when (and (< f30-0 6.0) (>= (ja-aframe-num 0) 6.0)) + (process-spawn metalkor-bomb (-> self root-override trans) (-> self entity) :to self :stack-size #x6000) + (set-action! + *gui-control* + (gui-action play) + (-> self bomb-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> self stop-bomb-sound) #f) + ) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 8) :num! min) + ) + ) + (else + (let ((v1-49 (ja-group))) + (cond + ((and v1-49 (= v1-49 (-> self draw art-group data 8))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 7) :num! min) + ) + ) + ) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate play-drop-movie (metalkor) + :virtual #t + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (process-entity-status! self (entity-perm-status subtask-complete) #t) + (process-spawn scene-player :init scene-player-init "nest-kor-boss-fight-mid" #t "nestb-boss") + (none) + ) + :trans (behavior () + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) + (deactivate self) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; WARN: Return type mismatch object vs none. +;; WARN: Function metalkor-walk-the-walk has a return type of none, but the expression builder found a return statement. +(defbehavior metalkor-walk-the-walk metalkor ((arg0 float) (arg1 symbol)) + (local-vars (v1-32 float) (v1-38 float) (v1-80 float) (sv-864 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (let ((v1-2 (ja-group))) + (if (and (and v1-2 (= v1-2 (-> self draw art-group data 33))) (begin (ja :num! (seek!)) (not (ja-done? 0)))) + (return #f) + ) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (set! (-> s5-0 quad) (-> self root-override trans quad)) + (set! sv-864 (target-pos 0)) + (metalkor-face-to-vector sv-864 546.13336 0.005) + (when (and (nonzero? (-> self previous-flat-travel-long-timer)) + (>= (+ (-> self clock frame-counter) (seconds -1.2)) (-> self previous-flat-travel-long-timer)) + ) + (set! (-> self previous-flat-travel-long-timer) 0) + (set! (-> self previous-flat-travel-timer) 0) + 0 + ) + (let ((s2-0 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (* 4096.0 (* 0.25 (-> self clock time-adjust-ratio)))) + (s1-0 #f) + ) + (set! (-> s3-0 quad) (-> self root-override trans quad)) + (vector-! s4-0 s3-0 sv-864) + (set! (-> s4-0 y) 0.0) + (let* ((f0-5 arg0) + (f0-7 (* f0-5 f0-5)) + ) + (.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-32 vf1) + (if (< f0-7 v1-32) + (set! s1-0 #t) + ) + ) + (vector-normalize! s4-0 arg0) + (let ((v1-35 s4-0)) + (let ((a0-15 s4-0)) + (.mov.vf vf6 vf0 :mask #b1000) + (.lvf vf4 (&-> a0-15 quad)) + ) + (.lvf vf5 (&-> sv-864 quad)) + (.add.vf vf6 vf4 vf5 :mask #b111) + (.svf (&-> v1-35 quad) vf6) + ) + (vector-! s4-0 s4-0 s3-0) + (set! (-> s4-0 y) 0.0) + (.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-38 vf1) + (let ((f0-9 v1-38) + (f1-3 f30-0) + ) + (if (< (* f1-3 f1-3) f0-9) + (vector-float*! s4-0 s4-0 (/ f30-0 (sqrtf f0-9))) + ) + ) + (set! (-> s2-0 poly) (-> self current-nav-poly)) + (dotimes (s0-1 5) + (let ((f30-1 (vector-length s4-0))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) s3-0 (-> s2-0 poly) s4-0 s2-0) + (cond + ((-> s2-0 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s2-0) + (let ((f28-0 (vector-length s4-0))) + (vector-flatten! s4-0 s4-0 (-> s2-0 boundary-normal)) + (let ((f0-12 (- f30-1 f28-0))) + (vector-normalize! s4-0 f0-12) + ) + ) + (if (and (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer)) + (< (vector-dot s4-0 (-> self previous-flat-travel)) 0.0) + ) + (vector-negate! s4-0 s4-0) + ) + (set! (-> s3-0 x) (-> s2-0 intersection x)) + (set! (-> s3-0 z) (-> s2-0 intersection z)) + (vector-! s3-0 s3-0 (-> s2-0 boundary-normal)) + (when (or s1-0 (> s0-1 0) (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer))) + (set! (-> self previous-flat-travel quad) (-> s4-0 quad)) + (set! (-> self previous-flat-travel-timer) (-> self clock frame-counter)) + (if (zero? (-> self previous-flat-travel-long-timer)) + (set! (-> self previous-flat-travel-long-timer) (-> self clock frame-counter)) + ) + ) + ) + (else + (goto cfg-43) + ) + ) + ) + ) + ) + (label cfg-43) + (vector+! s4-0 s3-0 s4-0) + ) + (vector-! s4-0 s4-0 (-> self root-override 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-80 vf1) + (let ((f0-17 v1-80) + (f1-7 40.96) + ) + (if (< f0-17 (* f1-7 f1-7)) + (vector-reset! s4-0) + ) + ) + (vector+! (-> self root-override trans) (-> self root-override trans) s4-0) + ) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (let ((s4-1 (new 'stack 'collide-query))) + (if (above-ground? + (-> self root-override) + s4-1 + (-> self root-override trans) + (collide-spec backgnd) + 12288.0 + 122880.0 + 1024.0 + ) + (set! (-> self root-override trans y) (-> s4-1 best-other-tri intersect y)) + ) + ) + (update-walk-anim s5-0 arg1) + (let ((v1-98 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) s5-0))) + (vector-float*! v1-98 v1-98 0.5) + (set! (-> v1-98 y) 0.0) + (send-event (handle->process (-> self lowtorso)) 'move-chain v1-98) + ) + ) + (none) + ) + ) + +(defstate tail-attack (metalkor) + :virtual #t + :event metalkor-handler + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 31))) + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual chase-target) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 31) :num! min) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defbehavior metalkor-set-deadly metalkor ((arg0 metalkor) (arg1 symbol) (arg2 int)) + (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child arg2))) + (cond + (arg1 + (set! (-> v1-3 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list)) + ) + (else + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + 0 + ) + ) + ) + (none) + ) + +(defstate foot-attack (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (let ((s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (gp-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (-> self entity trans))) + ) + (vector-flatten! gp-1 gp-1 (-> s5-0 vector 1)) + (cond + ((< (vector-dot gp-1 (the-as vector (-> s5-0 vector))) 0.0) + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 43)) 1.0 1.0 4.0) + (metalkor-set-deadly self #t 2) + ) + (else + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 42)) 1.0 1.0 4.0) + (metalkor-set-deadly self #t 3) + ) + ) + ) + (set! (-> self arm-frame) -1000.0) + (none) + ) + :exit (behavior () + (metalkor-set-deadly self #f 2) + (metalkor-set-deadly self #f 3) + (none) + ) + :trans (behavior () + (local-vars (a0-10 int)) + -1 + (let ((a0-1 (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 42))))) + (cond + ((>= a0-1 0) + (let ((f30-0 (ja-aframe-num a0-1))) + (if (< f30-0 10.0) + (metalkor-walk-the-walk 36864.0 #t) + ) + (cond + ((and (< (-> self arm-frame) 12.9) (>= f30-0 12.9)) + (sound-play "nboss-arm") + ) + ((and (< (-> self arm-frame) 15.9) (>= f30-0 15.9)) + (sound-play "nboss-growl") + ) + ) + (set! (-> self arm-frame) f30-0) + ) + ) + ((begin + (set! a0-10 (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 43)))) + (>= a0-10 0) + ) + (let ((f30-1 (ja-aframe-num a0-10))) + (if (< f30-1 52.0) + (metalkor-walk-the-walk 36864.0 #t) + ) + (cond + ((and (< (-> self arm-frame) 54.4) (>= f30-1 54.4)) + (sound-play "nboss-arm") + ) + ((and (< (-> self arm-frame) 56.9) (>= f30-1 56.9)) + (sound-play "nboss-growl") + ) + ) + (set! (-> self arm-frame) f30-1) + ) + ) + (else + (go-virtual chase-target) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate get-close (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (cond + ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4)) + (go-virtual chase-target) + ) + ((let ((f0-0 57344.0)) + (< (* f0-0 f0-0) (vector-vector-xz-distance-squared (-> self root-override trans) (target-pos 0))) + ) + ) + ((or (< (-> self last-close-attack) -1) + (and (< (-> self last-close-attack) 2) + (let* ((v1-14 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-15 (the-as number (logior #x3f800000 v1-14))) + ) + (< (+ -1.0 (the-as float v1-15)) 0.5) + ) + ) + ) + (set! (-> self last-close-attack) (max 1 (+ (-> self last-close-attack) 1))) + (go-virtual foot-attack) + ) + (else + (set! (-> self last-close-attack) (min -1 (+ (-> self last-close-attack) -1))) + (go-virtual tail-attack) + ) + ) + (metalkor-walk-the-walk 53248.0 #f) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate standing-shot (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self shots-fired) 0) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (none) + ) + :exit (behavior () + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 32))) + (none) + ) + :trans (behavior () + (if (>= (-> self shots-fired) (-> self stage)) + (go-virtual chase-target) + ) + (metalkor-walk-the-walk 122880.0 #f) + (spawn (-> self shot-anticipate) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 7))) + (let* ((a0-4 (-> self draw art-group data 32)) + (f0-2 + (/ (the float (-> (the-as art-joint-anim a0-4) frames num-frames)) (-> (the-as art-joint-anim a0-4) speed)) + ) + (f1-1 45.0) + ) + (if (zero? (-> self shots-fired)) + (set! f1-1 75.0) + ) + (if (metalkor-ja-float (the-as art-joint-anim a0-4) (/ f0-2 f1-1) 1.0 f0-2) + (sound-play "nboss-pre-shot") + ) + ) + (when (or (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.25)) + (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.75)) + (nonzero? (-> self shots-fired)) + ) + ) + (set! (-> self state-time) (-> self clock frame-counter)) + (metalkor-shoot-projectile) + (set-nestb-purple! (fmax 1.0 (get-nestb-purple))) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 32))) + (ja-channel-push! 1 (seconds 0.05)) + (ja :group! (-> self draw art-group data 33) :num! min) + ) + (if (zero? (-> self shots-fired)) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0013333333 (the float (- (-> self clock frame-counter) (-> self state-time))))) + ) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0022222223 (the float (- (-> self clock frame-counter) (-> self state-time))))) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate chase-target (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (when (and (not (and v1-2 (= v1-2 (-> self draw art-group data 33)))) + (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3)) + ) + (cond + ((or (< (-> self last-standing-attack) -1) + (and (< (-> self last-standing-attack) 2) + (let* ((v1-14 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-15 (the-as number (logior #x3f800000 v1-14))) + ) + (< (+ -1.0 (the-as float v1-15)) 0.5) + ) + ) + ) + (set! (-> self last-standing-attack) (max 1 (+ (-> self last-standing-attack) 1))) + (go-virtual get-close) + ) + (else + (set! (-> self last-standing-attack) (min -1 (+ (-> self last-standing-attack) -1))) + (go-virtual standing-shot) + ) + ) + ) + ) + (metalkor-walk-the-walk 122880.0 #f) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate start-second-stage (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 44) :num! min) + (metalkor-spinners-off) + (dotimes (gp-1 4) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner gp-1) + ) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 21))) + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual hang-shoot-n-launch) + ) + ) + ((let ((v1-17 (ja-group))) + (and v1-17 (= v1-17 (-> self draw art-group data 44))) + ) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (cond + ((and (< f30-0 84.0) (>= (ja-aframe-num 0) 84.0)) + (let ((gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (metalkor-start-spinner 1 (-> gp-0 vector 2)) + (metalkor-start-spinner 3 (-> gp-0 vector 2)) + ) + ) + ((and (< f30-0 85.0) (>= (ja-aframe-num 0) 85.0)) + (let ((gp-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (metalkor-start-spinner 0 (-> gp-1 vector 2)) + (metalkor-start-spinner 2 (-> gp-1 vector 2)) + ) + ) + ) + ) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 21) :num! min) + ) + ) + (else + (ja :group! (-> self draw art-group data 44) :num! min) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate hang-shoot-n-launch (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (set! (-> self shots-fired) 0) + (set! (-> self wave-timer) 0) + (set! (-> self in-wave) #f) + (set! (-> self flitter-timer) 0) + (set! (-> self wasp-timer) 0) + (set! (-> self launching-flitters) #f) + (set! (-> self launching-wasps) #f) + (set! (-> self egg-timer) 0) + 0 + (none) + ) + :exit (behavior () + (send-event (handle->process (-> self lowtorso)) 'egg-toss 0) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 23))) + (none) + ) + :trans (behavior () + (local-vars (sv-16 res-tag)) + (let ((v1-0 7500)) + (if (and (-> self in-wave) (= (-> self stage) 1)) + (set! v1-0 3000) + ) + (when (>= (- (-> self clock frame-counter) (-> self wave-timer)) v1-0) + (set! (-> self in-wave) (not (-> self in-wave))) + (set! (-> self wave-timer) (-> self clock frame-counter)) + ) + ) + (cond + ((or (!= (-> self stage) 2) (not (-> self in-wave)) (>= (-> self live-wasps) 3)) + (set! (-> self launching-wasps) #f) + ) + ((< (-> self live-wasps) 2) + (set! (-> self launching-wasps) #t) + ) + ) + (when (and (-> self launching-wasps) (>= (- (-> self clock frame-counter) (-> self wasp-timer)) (seconds 1.5))) + (set! (-> self wasp-timer) (-> self clock frame-counter)) + (dotimes (gp-0 3) + (when (not (handle->process (-> self wasps gp-0))) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-31 (res-lump-data (-> self entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-31 (< (the-as uint 1) (-> sv-16 elt-count))) + (let ((v1-32 (-> v1-31 1))) + (+! (-> self last-wasp-launched) 1) + (when (>= (-> self last-wasp-launched) (-> v1-32 length)) + (set! (-> self last-wasp-launched) 0) + 0 + ) + (when (< (-> self last-wasp-launched) (-> v1-32 length)) + (let ((s4-0 (-> v1-32 data (-> self last-wasp-launched) actor)) + (s5-0 (new 'stack-no-clear 'enemy-init-by-other-params)) + ) + (when (not (-> s4-0 extra process)) + (let ((s3-0 (-> s4-0 extra))) + (if (send-event (handle->process (-> self wasp-gem-tracker)) 'spawn-with-gem?) + (logclear! (-> s3-0 perm status) (entity-perm-status save)) + (logior! (-> s3-0 perm status) (entity-perm-status save)) + ) + ) + (set! (-> s5-0 trans quad) (-> s4-0 trans quad)) + (quaternion-copy! (-> s5-0 quat) (-> self root-override quat)) + (set! (-> s5-0 entity) s4-0) + (set! (-> s5-0 directed?) #f) + (set! (-> s5-0 no-initial-move-to-ground?) #f) + (let ((s4-1 (get-process *default-dead-pool* metalkor-wasp #x4000))) + (set! (-> self wasps gp-0) + (ppointer->handle (when s4-1 + (let ((t9-4 (method-of-type process activate))) + (t9-4 s4-1 self (symbol->string (-> metalkor-wasp symbol)) (the-as pointer #x70004000)) + ) + (run-now-in-process s4-1 enemy-init-by-other self s5-0) + (-> s4-1 ppointer) + ) + ) + ) + ) + (send-event + (handle->process (-> self wasp-gem-tracker)) + 'change-gem + #f + (handle->process (-> self wasps gp-0)) + ) + (goto cfg-69) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (label cfg-69) + (cond + ((< (-> self live-flitters) 3) + (set! (-> self launching-flitters) #t) + ) + ((or (!= (-> self stage) 1) (not (-> self in-wave)) (>= (-> self live-flitters) 10)) + (set! (-> self launching-flitters) #f) + ) + ((< (-> self live-flitters) 5) + (set! (-> self launching-flitters) #t) + ) + ) + (rotate-and-update-hang-anim) + (if (and (< 10922.667 (-> self target-angle)) + (< (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 3.75)) + (zero? (mod (-> self shots-fired) (-> self stage))) + ) + (set! (-> self shoot-timer) + (the-as time-frame (max (-> self shoot-timer) (+ (-> self clock frame-counter) (seconds -2.75)))) + ) + ) + (cond + ((metalkor-check-egg) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + ) + ((or (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 3.75)) + (nonzero? (mod (-> self shots-fired) (-> self stage))) + ) + (set! (-> self flitter-timer) (-> self clock frame-counter)) + (spawn (-> self shot-anticipate) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 7))) + (if (zero? (mod (-> self shots-fired) (-> self stage))) + (set-nestb-purple! + (fmax + (get-nestb-purple) + (* 0.0013333333 (the float (+ (- (seconds -3.75) (-> self shoot-timer)) (-> self clock frame-counter)))) + ) + ) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0022222223 (the float (- (-> self clock frame-counter) (-> self shoot-timer))))) + ) + ) + (let* ((v1-123 (the-as art-joint-anim (-> self draw art-group data 23))) + (f0-7 (/ (the float (-> v1-123 frames num-frames)) (-> v1-123 speed))) + (f1-6 45.0) + ) + (if (zero? (mod (-> self shots-fired) (-> self stage))) + (set! f1-6 75.0) + ) + (if (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 23)) (/ f0-7 f1-6) 1.0 f0-7) + (sound-play "nboss-pre-shot") + ) + ) + (when (or (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 5)) + (and (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 0.75)) + (nonzero? (mod (-> self shots-fired) (-> self stage))) + ) + ) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (metalkor-shoot-projectile) + (set-nestb-purple! (fmax 1.0 (get-nestb-purple))) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 23))) + (ja-channel-push! 1 (seconds 0.05)) + (ja :group! (-> self draw art-group data 24) :num! min) + (metalkor-all-spinners-on) + ) + ) + ((and (-> self launching-flitters) + (>= (+ (-> self clock frame-counter) (seconds -0.5)) (-> self flitter-timer)) + ) + (set! (-> self flitter-timer) (-> self clock frame-counter)) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (metalkor-start-egg) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +(defstate hidden (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('occlude-off) + (let ((a0-3 (handle->process (-> self rift-occlude)))) + (if a0-3 + (the-as symbol (deactivate a0-3)) + ) + ) + ) + ) + ) + ) + :trans (behavior () + (if (task-node-closed? (game-task-node nest-boss-introduction)) + (metalkor-go-next-stage) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + ) + +(defstate test (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (ja :group! (-> self draw art-group data 5)) + (none) + ) + :trans (behavior () + (local-vars (v1-72 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.017)) (cpad-hold? 1 x)) + (go-virtual test) + ) + (let ((s4-0 (new-stack-vector0)) + (s2-0 (new-stack-vector0)) + (s5-0 (new 'stack-no-clear 'matrix)) + (s1-0 (new 'stack-no-clear 'matrix)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-0 quad) (-> self root-override trans quad)) + (set! (-> s4-0 y) (analog-input (the-as int (-> *cpad-list* cpads 1 rightx)) 128.0 48.0 110.0 1.0)) + (set! (-> s2-0 z) (analog-input (the-as int (-> *cpad-list* cpads 1 lefty)) 128.0 48.0 110.0 1.0)) + (vector-float*! s4-0 s4-0 -364.0889) + (quaternion->matrix s1-0 (-> self root-override quat)) + (matrix-rotate-y! s5-0 (-> s4-0 y)) + (set! (-> self last-rotation) (-> s4-0 y)) + (matrix*! s1-0 s5-0 s1-0) + (matrix-remove-z-rot s1-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) s1-0) + (quaternion-normalize! (-> self root-override quat)) + (when (and (nonzero? (-> self previous-flat-travel-long-timer)) + (>= (+ (-> self clock frame-counter) (seconds -1.2)) (-> self previous-flat-travel-long-timer)) + ) + (set! (-> self previous-flat-travel-long-timer) 0) + (set! (-> self previous-flat-travel-timer) 0) + 0 + ) + (let ((s3-0 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (let ((s4-1 (new 'stack-no-clear 'vector))) + (let ((f0-5 2048.0)) + (set! (-> s4-1 quad) (-> self root-override trans quad)) + (vector-float*! s5-1 (-> s1-0 vector 2) (* (-> s2-0 z) (- f0-5))) + ) + (set! (-> s5-1 y) 0.0) + (set! (-> s3-0 poly) (-> self current-nav-poly)) + (dotimes (s2-1 5) + (let ((f30-0 (vector-length s5-1))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) s4-1 (-> s3-0 poly) s5-1 s3-0) + (cond + ((-> s3-0 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s3-0) + (let ((f28-0 (vector-length s5-1))) + (vector-flatten! s5-1 s5-1 (-> s3-0 boundary-normal)) + (let ((f0-9 (- f30-0 f28-0))) + (vector-normalize! s5-1 f0-9) + ) + ) + (if (and (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer)) + (< (vector-dot s5-1 (-> self previous-flat-travel)) 0.0) + ) + (vector-negate! s5-1 s5-1) + ) + (set! (-> s4-1 x) (-> s3-0 intersection x)) + (set! (-> s4-1 z) (-> s3-0 intersection z)) + (vector-! s4-1 s4-1 (-> s3-0 boundary-normal)) + (when (or (> s2-1 0) (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer))) + (set! (-> self previous-flat-travel quad) (-> s5-1 quad)) + (set! (-> self previous-flat-travel-timer) (-> self clock frame-counter)) + (if (zero? (-> self previous-flat-travel-long-timer)) + (set! (-> self previous-flat-travel-long-timer) (-> self clock frame-counter)) + ) + ) + ) + (else + (goto cfg-30) + ) + ) + ) + ) + (label cfg-30) + (vector+! s5-1 s4-1 s5-1) + ) + (vector-! s5-1 s5-1 (-> self root-override trans)) + (.lvf vf1 (&-> s5-1 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-72 vf1) + (let ((f0-14 v1-72) + (f1-2 1024.0) + ) + (if (< (* f1-2 f1-2) f0-14) + (vector-float*! s5-1 s5-1 (/ 1024.0 (sqrtf f0-14))) + ) + ) + (vector+! (-> self root-override trans) (-> self root-override trans) s5-1) + ) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (let ((s5-2 (new 'stack 'collide-query))) + (if (above-ground? + (-> self root-override) + s5-2 + (-> self root-override trans) + (collide-spec backgnd) + 12288.0 + 122880.0 + 1024.0 + ) + (set! (-> self root-override trans y) (-> s5-2 best-other-tri intersect y)) + ) + ) + (update-walk-anim gp-0 #f) + ) + (let ((s4-2 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (v1-94 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s3-1 (new 'stack-no-clear 'vector)) + (s5-3 (new 'stack-no-clear 'vector)) + (gp-1 (new 'stack-no-clear 'vector)) + ) + (let ((f0-18 81920.0)) + (set! (-> gp-1 quad) (-> self root-override trans quad)) + (set! (-> s5-3 quad) (-> v1-94 vector 2 quad)) + (set! (-> s5-3 y) 0.0) + (vector-normalize! s5-3 f0-18) + ) + (set! (-> s4-2 poly) (-> self current-nav-poly)) + (dotimes (s2-2 5) + (let ((f30-1 (vector-length s5-3))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) gp-1 (-> s4-2 poly) s5-3 s4-2) + (cond + ((-> s4-2 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s4-2) + (camera-line (-> s4-2 vert-prev) (-> s4-2 vert-0) (new 'static 'vector4w :x #xff :w #x80)) + (camera-line (-> s4-2 vert-0) (-> s4-2 vert-1) (new 'static 'vector4w :y #xff :w #x80)) + (camera-line (-> s4-2 vert-1) (-> s4-2 vert-next) (new 'static 'vector4w :z #xff :w #x80)) + (camera-line-rel gp-1 s5-3 (new 'static 'vector4w :x #xff :w #x80)) + (let ((f28-1 (vector-length s5-3))) + (vector-flatten! s5-3 s5-3 (-> s4-2 boundary-normal)) + (let ((f0-19 (- f30-1 f28-1))) + (vector-normalize! s5-3 f0-19) + ) + ) + (set! (-> gp-1 x) (-> s4-2 intersection x)) + (set! (-> gp-1 z) (-> s4-2 intersection z)) + (vector-! gp-1 gp-1 (-> s4-2 boundary-normal)) + (vector+! s3-1 (-> s4-2 vert-prev) (-> s4-2 vert-0)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 prev-normal) 12288.0 (new 'static 'vector4w :x #xff :w #x80)) + (vector+! s3-1 (-> s4-2 vert-0) (-> s4-2 vert-1)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 boundary-normal) 12288.0 (new 'static 'vector4w :y #xff :w #x80)) + (vector+! s3-1 (-> s4-2 vert-1) (-> s4-2 vert-next)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 next-normal) 12288.0 (new 'static 'vector4w :z #xff :w #x80)) + ) + (else + (goto cfg-42) + ) + ) + ) + ) + (label cfg-42) + (camera-line-rel gp-1 s5-3 (new 'static 'vector4w :x #xff :w #x80)) + ) + (metalkor-common) + (none) + ) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) diff --git a/goal_src/jak2/levels/nest/boss/nestb-scenes.gc b/goal_src/jak2/levels/nest/boss/nestb-scenes.gc index 5294ec573b..08f1ddb340 100644 --- a/goal_src/jak2/levels/nest/boss/nestb-scenes.gc +++ b/goal_src/jak2/levels/nest/boss/nestb-scenes.gc @@ -1772,8 +1772,8 @@ This commonly includes things such as: ) (defun nestb-login () - ;; (set! *nav-network* (new 'loading-level 'nav-network)) - ;; (nav-network-method-9 *nav-network*) + (set! *nav-network* (new 'loading-level 'nav-network)) + (nav-network-method-9 *nav-network*) 0 (none) ) @@ -1788,7 +1788,7 @@ This commonly includes things such as: ) (defun nestb-activate ((arg0 level)) - ;; (nav-network-method-10 *nav-network* arg0 *nestb-adjacency*) + (nav-network-method-10 *nav-network* arg0 *nestb-adjacency*) 0 (none) ) diff --git a/test/decompiler/reference/jak2/levels/nest/boss/metalkor-extras_REF.gc b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-extras_REF.gc new file mode 100644 index 0000000000..61c05f9bf0 --- /dev/null +++ b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-extras_REF.gc @@ -0,0 +1,2669 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for function metalkor-egg-handler +(defbehavior metalkor-egg-handler metalkor-egg ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (case arg2 + (('track) + #f + ) + (('bonk) + (go-virtual egg-pop) + ) + (('attack) + (go-virtual egg-pop) + ) + ) + ) + +;; failed to figure out what this is: +(defstate egg-pop (metalkor-egg) + :virtual #t + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 5))) + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 5)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate hatch (metalkor-egg) + :virtual #t + :enter (behavior () + (send-event (ppointer->process (-> self parent)) 'setup-flitter-gem) + (let ((s5-0 (new 'stack-no-clear 'enemy-init-by-other-params))) + (set! (-> s5-0 trans quad) (-> self root-override trans quad)) + (quaternion-copy! (-> s5-0 quat) (-> self root-override quat)) + (set! (-> s5-0 entity) (-> self entity)) + (set! (-> s5-0 directed?) #f) + (set! (-> s5-0 no-initial-move-to-ground?) #f) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 2) + (set! (-> gp-0 message) 'hatch) + (set! (-> gp-0 param 0) (the-as uint (-> self flitter-slot))) + (let ((s4-0 (get-process *default-dead-pool* metalkor-flitter #x4000))) + (set! (-> gp-0 param 1) + (the-as uint (ppointer->handle (when s4-0 + (let ((t9-3 (method-of-type process activate))) + (t9-3 + s4-0 + (ppointer->process (-> self parent)) + (symbol->string (-> metalkor-flitter symbol)) + (the-as pointer #x70004000) + ) + ) + (run-now-in-process s4-0 enemy-init-by-other self s5-0) + (-> s4-0 ppointer) + ) + ) + ) + ) + ) + (send-event-function (ppointer->process (-> self parent)) gp-0) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 5))) + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 5)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate fall (metalkor-egg) + :virtual #t + :event metalkor-egg-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (local-vars (v1-5 float) (v1-27 float) (v1-34 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'vector))) + (set! (-> gp-0 quad) (-> self root-override transv quad)) + (.lvf vf1 (&-> (-> self root-override transv) 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 ((f0-0 v1-5) + (f1-0 409.6) + ) + (cond + ((< f0-0 (* f1-0 f1-0)) + (go-virtual idle) + ) + ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4)) + (go-virtual hatch) + ) + (else + (vector-v++! + (-> self root-override transv) + (compute-acc-due-to-gravity (the-as collide-shape-moving (-> self root-override)) (new-stack-vector0) 1.0) + ) + (let ((a2-1 (new 'stack-no-clear 'collide-query))) + (set! (-> a2-1 collide-with) (collide-spec backgnd enemy obstacle hit-by-others-list pusher)) + (set! (-> a2-1 ignore-process0) self) + (set! (-> a2-1 ignore-process1) #f) + (set! (-> a2-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> a2-1 action-mask) (collide-action solid)) + (fill-cache-integrate-and-collide + (the-as collide-shape-moving (-> self root-override)) + (-> (the-as collide-shape-moving (-> self root-override)) transv) + a2-1 + (meters 0) + ) + ) + ) + ) + ) + (let* ((f0-1 81920.0) + (f0-3 (* f0-1 f0-1)) + ) + (.lvf vf1 (&-> gp-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-27 vf1) + (cond + ((and (< f0-3 v1-27) (let* ((f0-4 81920.0) + (f0-6 (* f0-4 f0-4)) + ) + (.lvf vf1 (&-> (-> self root-override transv) 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-34 vf1) + (>= f0-6 v1-34) + ) + ) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 4)) + ) + (else + (let ((v1-40 (ja-group))) + (cond + ((and v1-40 (= v1-40 (-> self draw art-group data 4))) + (ja :num! (seek!)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3)) + ) + ) + (else + (ja :num! (loop!)) + ) + ) + ) + ) + ) + ) + ) + (none) + ) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-egg) + :virtual #t + :event metalkor-egg-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3)) + (go-virtual hatch) + ) + (let ((v1-9 (ja-group))) + (cond + ((and v1-9 (= v1-9 (-> self draw art-group data 3))) + (ja :num! (loop!)) + ) + ((let ((v1-17 (ja-group))) + (and v1-17 (or (= v1-17 (-> self draw art-group data 7)) (= v1-17 (-> self draw art-group data 4)))) + ) + (ja :num! (seek!)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3)) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 4)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-egg) sleep-code) + :post (behavior () + (ja-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition for function metalkor-shot-move +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defun metalkor-shot-move ((arg0 metalkor-shot)) + (set! (-> arg0 old-transv quad) (-> arg0 root-override transv quad)) + (projectile-move-fill-line-sphere arg0) + (let ((s5-0 (-> arg0 root-override))) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (vector-! s4-0 (-> arg0 tail-pos) (-> s5-0 trans)) + (let ((f0-0 (vector-length s4-0))) + (when (< 49152.0 f0-0) + (vector-normalize! s4-0 49152.0) + (vector+! (-> arg0 tail-pos) (-> s5-0 trans) s4-0) + ) + ) + ) + (if (logtest? (-> s5-0 status) (collide-status touch-surface)) + (go (method-of-object arg0 impact)) + ) + ) + 0 + (none) + ) + +;; definition for method 31 of type metalkor-shot +;; INFO: Used lq/sq +;; WARN: Return type mismatch vector vs none. +(defmethod init-proj-settings! metalkor-shot ((obj metalkor-shot)) + "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc" + (set! (-> obj tail-pos quad) (-> obj root-override trans quad)) + (set! (-> obj attack-mode) 'metalhead-shot) + (set! (-> obj max-speed) 532480.0) + (set! (-> obj move) metalkor-shot-move) + (set! (-> obj timeout) (seconds 0.767)) + (set-gravity-length (-> obj root-override dynam) 573440.0) + (set! (-> obj old-transv quad) (-> obj root-override transv quad)) + (none) + ) + +;; definition for method 26 of type metalkor-shot +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod spawn-shell-particles metalkor-shot ((obj metalkor-shot)) + "TODO - confirm" + (local-vars + (sv-224 (function vector entity-actor skeleton-group vector object none :behavior manipy)) + (sv-240 vector) + (sv-256 entity-actor) + ) + (let* ((s4-0 (-> obj root-override)) + (v0-0 (vector-normalize! (vector-! (new 'stack-no-clear 'vector) (-> obj tail-pos) (-> s4-0 trans)) 2048.0)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-0 quad) (-> s4-0 trans quad)) + (vector+! gp-0 gp-0 v0-0) + (let ((s4-1 (get-process *default-dead-pool* part-tracker #x4000))) + (when s4-1 + (let ((t9-2 (method-of-type part-tracker activate))) + (t9-2 + (the-as part-tracker s4-1) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((t9-3 run-function-in-process) + (a0-7 s4-1) + (a1-5 part-tracker-init) + (a2-4 (-> *part-group-id-table* 141)) + (a3-1 0) + (t0-0 #f) + (t1-0 #f) + (t2-0 #f) + (t3-0 *launch-matrix*) + ) + (set! (-> t3-0 trans quad) (-> gp-0 quad)) + ((the-as (function object object object object object object object object none) t9-3) + a0-7 + a1-5 + a2-4 + a3-1 + t0-0 + t1-0 + t2-0 + t3-0 + ) + ) + (-> s4-1 ppointer) + ) + ) + ) + (let ((s4-2 (new 'stack-no-clear 'vector))) + (set! (-> s4-2 quad) (-> obj root-override trans quad)) + (let ((gp-1 (new 'stack-no-clear 'quaternion))) + (let ((s3-0 (lambda :behavior metalkor-shot + () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 1.0) + (cond + ((>= 10.0 (ja-aframe-num 0)) + (let ((v0-1 (the-as vector (-> self draw color-emissive)))) + (set! (-> (the-as rgbaf v0-1) x) 1.0) + (set! (-> (the-as rgbaf v0-1) y) 1.0) + (set! (-> (the-as rgbaf v0-1) z) 1.0) + (set! (-> (the-as rgbaf v0-1) w) 1.0) + v0-1 + ) + ) + ((>= 20.0 (ja-aframe-num 0)) + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0) + (new 'static 'vector :x 0.5 :z 0.5 :w 1.0) + (lerp-scale 0.0 1.0 (ja-aframe-num 0) 10.0 20.0) + ) + ) + (else + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector :x 0.5 :z 0.5 :w 1.0) + (new 'static 'vector :w 1.0) + (lerp-scale 0.0 1.0 (ja-aframe-num 0) 20.0 30.0) + ) + ) + ) + ) + ) + ) + (let ((s2-0 (new 'stack-no-clear 'matrix))) + (vector-normalize-copy! (-> s2-0 vector 1) (-> obj old-transv) -1.0) + (cond + ((and (< (fabs (-> s2-0 vector 1 y)) (fabs (-> s2-0 vector 1 x))) + (< (fabs (-> s2-0 vector 1 y)) (fabs (-> s2-0 vector 1 z))) + ) + (set-vector! (-> s2-0 vector 2) (-> s2-0 vector 1 z) 0.0 (- (-> s2-0 vector 1 x)) 1.0) + ) + ((< (fabs (-> s2-0 vector 1 z)) (fabs (-> s2-0 vector 1 x))) + (set-vector! (-> s2-0 vector 2) (-> s2-0 vector 1 y) (- (-> s2-0 vector 1 x)) 0.0 1.0) + ) + (else + (set-vector! (-> s2-0 vector 2) 0.0 (-> s2-0 vector 1 z) (- (-> s2-0 vector 1 y)) 0.0) + ) + ) + (vector-normalize! (-> s2-0 vector 2) 1.0) + (vector-cross! (the-as vector (-> s2-0 vector)) (-> s2-0 vector 1) (-> s2-0 vector 2)) + (matrix->quaternion gp-1 s2-0) + ) + (sound-play "nboss-shoot-hit") + (let* ((s1-1 (get-process *default-dead-pool* manipy #x4000)) + (s2-2 + (when s1-1 + (let ((t9-10 (method-of-type manipy activate))) + (t9-10 (the-as manipy s1-1) *default-pool* (symbol->string (-> manipy symbol)) (the-as pointer #x70004000)) + ) + (let ((s2-3 run-function-in-process) + (s0-0 s1-1) + ) + (set! sv-224 manipy-init) + (set! sv-240 s4-2) + (set! sv-256 (-> obj entity)) + (let ((t0-2 (art-group-get-by-name *level* "skel-bomb-blast" (the-as (pointer uint32) #f))) + (t1-2 #f) + (t2-2 0) + ) + ((the-as (function object object object object object object object none) s2-3) + s0-0 + sv-224 + sv-240 + sv-256 + t0-2 + t1-2 + t2-2 + ) + ) + ) + (-> s1-1 ppointer) + ) + ) + ) + (when s2-2 + (send-event (ppointer->process s2-2) 'anim-mode 'play1) + (send-event (ppointer->process s2-2) 'anim "idle") + (set-vector! (-> (the-as process-drawable (-> s2-2 0)) root scale) 0.4 1.0 0.4 1.0) + (send-event (ppointer->process s2-2) 'trans-hook s3-0) + (send-event (ppointer->process s2-2) 'rot-quat gp-1) + ) + ) + ) + (let ((s3-1 (process-spawn + manipy + :init manipy-init + s4-2 + (-> obj entity) + (art-group-get-by-name *level* "skel-generic-blast" (the-as (pointer uint32) #f)) + #f + 0 + ) + ) + ) + (when s3-1 + (send-event (ppointer->process s3-1) 'anim-mode 'play1) + (send-event (ppointer->process s3-1) 'anim "idle") + (set-vector! (-> (the-as process-drawable (-> s3-1 0)) root scale) 0.4 1.0 0.4 1.0) + (send-event (ppointer->process s3-1) 'rot-quat gp-1) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 20 of type metalkor-legs +;; INFO: Used lq/sq +(defmethod get-trans metalkor-legs ((obj metalkor-legs) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (cond + ((or (= arg0 2) (= arg0 3)) + (let ((v0-0 (new 'static 'vector :w 1.0))) + (set! (-> v0-0 quad) + (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 0 prim-core world-sphere quad) + ) + (set! (-> v0-0 y) (+ 32768.0 (-> v0-0 y))) + v0-0 + ) + ) + (else + ((method-of-type process-focusable get-trans) obj arg0) + ) + ) + ) + +;; definition for method 7 of type metalkor-legs +;; WARN: Return type mismatch process-focusable vs metalkor-legs. +(defmethod relocate metalkor-legs ((obj metalkor-legs) (arg0 int)) + (dotimes (v1-0 6) + (if (nonzero? (-> obj joint-ik v1-0)) + (&+! (-> obj joint-ik v1-0) arg0) + ) + ) + (the-as metalkor-legs ((method-of-type process-focusable relocate) obj arg0)) + ) + +;; definition for function metalkor-legs-handler +;; INFO: Used lq/sq +(defbehavior metalkor-legs-handler metalkor-legs ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-0 object)) + (case arg2 + (('track) + (-> self trackable) + ) + (('attack) + (let ((v1-1 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-1 from) (process->ppointer arg0)) + (set! (-> v1-1 num-params) arg1) + (set! (-> v1-1 message) arg2) + (set! (-> v1-1 param 0) (-> arg3 param 0)) + (set! (-> v1-1 param 1) (-> arg3 param 1)) + (set! (-> v1-1 param 2) (-> arg3 param 2)) + (set! (-> v1-1 param 3) (-> arg3 param 3)) + (set! (-> v1-1 param 4) (-> arg3 param 4)) + (set! (-> v1-1 param 5) (-> arg3 param 5)) + (send-event-function (ppointer->process (-> self parent)) v1-1) + ) + ) + (('color) + (set! (-> self draw color-mult quad) (-> (the-as rgbaf (-> arg3 param 0)) quad)) + (set! v0-0 (-> self draw color-emissive)) + (set! (-> (the-as rgbaf v0-0) quad) (-> (the-as rgbaf (-> arg3 param 1)) quad)) + v0-0 + ) + (('trackable) + (set! v0-0 (-> arg3 param 0)) + (set! (-> self trackable) (the-as symbol v0-0)) + v0-0 + ) + (('ja-float) + (dotimes (s5-0 3) + (when (not (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim)) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (get-art-by-name (-> self draw art-group) (the-as string (-> arg3 param 0)) art-joint-anim) + ) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + (the-as int (-> arg3 param 1)) + ) + (return #t) + ) + ) + #f + ) + ) + ) + +;; definition for function ik-adjust +(defbehavior ik-adjust metalkor-legs () + (let* ((f0-1 (* 0.0033333334 (the float (- (-> self clock frame-counter) (-> self state-time))))) + (f0-2 (* 9102.223 f0-1)) + (f0-3 (- f0-2 (* (the float (the int (/ f0-2 65536.0))) 65536.0))) + (f0-4 (sin f0-3)) + ) + (* 8192.0 f0-4) + ) + ) + +;; definition for function metalkor-update-ik +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-update-ik metalkor-legs () + (local-vars (sv-736 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'collide-query)) + (s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + (let ((v1-1 (-> gp-0 bbox)) + (a0-2 (-> self root-override trans)) + (a1-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> a1-1 x) 32768.0) + (set! (-> a1-1 y) 32768.0) + (set! (-> a1-1 z) 32768.0) + (set! (-> a1-1 w) 1.0) + (vector-! (the-as vector v1-1) a0-2 a1-1) + ) + (let ((v1-3 (-> gp-0 bbox max)) + (a0-4 (-> self root-override trans)) + (a1-2 (new 'stack-no-clear 'vector)) + ) + (set! (-> a1-2 x) 32768.0) + (set! (-> a1-2 y) 32768.0) + (set! (-> a1-2 z) 32768.0) + (set! (-> a1-2 w) 1.0) + (vector+! v1-3 a0-4 a1-2) + ) + (set! (-> gp-0 collide-with) (collide-spec backgnd)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (fill-using-bounding-box *collide-cache* gp-0) + (dotimes (s4-0 6) + (-> self joint-ik s4-0 shoulder-matrix-no-ik) + (let ((a2-8 (-> self joint-ik s4-0 elbow-matrix-no-ik)) + (s2-0 (new 'stack-no-clear 'vector)) + (v1-15 (new 'stack-no-clear 'vector)) + ) + (set! (-> v1-15 quad) (-> (new 'static 'vector :y 1.0) quad)) + (new 'stack-no-clear 'vector) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (let ((a1-4 s2-0)) + (let ((a0-9 (-> a2-8 trans))) + (let ((a2-9 (-> a2-8 vector 1))) + (let ((a3-3 (-> *metalkor-ik-setup* s4-0 hand-dist))) + (.mov vf7 a3-3) + ) + (.lvf vf5 (&-> a2-9 quad)) + ) + (.lvf vf4 (&-> a0-9 quad)) + ) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> a1-4 quad) vf6) + ) + (set! (-> s3-0 quad) (-> s2-0 quad)) + (let ((a2-10 (-> gp-0 start-pos))) + (let ((a0-11 s3-0)) + (let ((a1-7 v1-15)) + (let ((a3-5 24576.0)) + (.mov vf7 a3-5) + ) + (.lvf vf5 (&-> a1-7 quad)) + ) + (.lvf vf4 (&-> a0-11 quad)) + ) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> a2-10 quad) vf6) + ) + (vector-float*! (-> gp-0 move-dist) v1-15 -73728.0) + (let ((v1-16 gp-0)) + (set! (-> v1-16 radius) 40.96) + (set! (-> v1-16 collide-with) (collide-spec backgnd)) + (set! (-> v1-16 ignore-process0) #f) + (set! (-> v1-16 ignore-process1) #f) + (set! (-> v1-16 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-16 action-mask) (collide-action solid)) + ) + (let ((f0-12 (probe-using-line-sphere *collide-cache* gp-0))) + (when (>= f0-12 0.0) + (let ((f1-2 + (vector-dot (-> s5-0 vector 1) (vector-! (new 'stack-no-clear 'vector) s2-0 (-> self root-override trans))) + ) + ) + (cond + ((>= 409.6 f1-2) + (vector+float*! s3-0 (-> gp-0 start-pos) (-> gp-0 move-dist) f0-12) + (set! (-> self foot-locks s4-0 lock target) 1.0) + ) + (else + (vector+float*! s3-0 (-> gp-0 start-pos) (-> gp-0 move-dist) (- f0-12 (* 0.000013563368 f1-2))) + (set! (-> self foot-locks s4-0 lock target) 0.0) + ) + ) + ) + ) + ) + ((method-of-type cam-float-seeker update!) (the-as cam-float-seeker (-> self foot-locks s4-0)) 0.0) + (cond + ((-> self foot-locks s4-0 initialized) + (let ((s2-1 vector-lerp!) + (s1-0 s3-0) + (s0-0 s3-0) + ) + (set! sv-736 (the-as vector (+ (the-as uint (-> self foot-locks 0 old-position)) (* s4-0 64)))) + (let ((a3-6 (parameter-ease-sin-clamp (-> self foot-locks s4-0 lock value)))) + (s2-1 s1-0 s0-0 sv-736 a3-6) + ) + ) + ) + (else + (set! (-> self foot-locks s4-0 initialized) #t) + ) + ) + (handle-copy! (-> self joint-ik s4-0) s3-0) + (set! (-> (the-as (pointer uint128) (+ (the-as uint (-> self foot-locks 0 old-position)) (* s4-0 64)))) + (-> s3-0 quad) + ) + ) + ) + ) + ) + 0 + (none) + ) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-legs) + :virtual #t + :event metalkor-legs-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (dotimes (gp-0 6) + (enable-set! (-> self joint-ik gp-0) #t) + ((method-of-type cam-float-seeker init) (the-as cam-float-seeker (-> self foot-locks gp-0)) 0.0 0.1 0.3 0.9) + (set! (-> self foot-locks gp-0 initialized) #f) + ) + (none) + ) + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (let ((gp-0 (ppointer->process (-> self parent)))) + (when gp-0 + (dotimes (s5-0 3) + (when (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (let ((v1-11 (ja-channel-float! + (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + 0.0 + 0.0 + 0.0 + ) + ) + ) + (when v1-11 + (let ((a0-11 (-> (the-as process-drawable gp-0) + skel + channel + (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + ) + ) + ) + (set! (-> v1-11 frame-num) (-> a0-11 frame-num)) + (set! (-> v1-11 frame-interp 0) (-> a0-11 frame-interp 0)) + (set! (-> v1-11 frame-interp 1) (-> a0-11 frame-interp 1)) + ) + (do-joint-math (-> self draw) (-> self node-list) (-> self skel)) + ) + ) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) #f) + ) + ) + ) + ) + (metalkor-update-ik) + (none) + ) + :code (the-as (function none :behavior metalkor-legs) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition for symbol *metalkor-lowtorso-spinner-setup*, type (array metalkor-spinner-info) +(define *metalkor-lowtorso-spinner-setup* + (new 'static 'boxed-array :type metalkor-spinner-info + (new 'static 'metalkor-spinner-info :joint-index #x29 :launch-angle 18204.445) + (new 'static 'metalkor-spinner-info :joint-index #x1e :launch-angle 25486.223) + (new 'static 'metalkor-spinner-info :joint-index #x26 :launch-angle -18204.445) + (new 'static 'metalkor-spinner-info :joint-index #x21 :launch-angle -25486.223) + ) + ) + +;; definition for function metalkor-lowtorso-start-spinner +;; WARN: Return type mismatch int vs none. +;; WARN: Function metalkor-lowtorso-start-spinner has a return type of none, but the expression builder found a return statement. +(defbehavior metalkor-lowtorso-start-spinner metalkor-lowtorso ((arg0 int) (arg1 vector)) + (when (< arg0 4) + (if (handle->process (-> self spinners arg0)) + (return #f) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (sin (-> *metalkor-lowtorso-spinner-setup* arg0 launch-angle))) + (f0-2 (cos (-> *metalkor-lowtorso-spinner-setup* arg0 launch-angle))) + ) + (set-vector! + s5-0 + (+ (* f0-2 (-> arg1 x)) (* f30-0 (-> arg1 z))) + 0.0 + (- (* f0-2 (-> arg1 z)) (* f30-0 (-> arg1 x))) + 1.0 + ) + ) + (vector-normalize! s5-0 (* 81920.0 (cos 10922.667))) + (+! (-> s5-0 y) (* 81920.0 (sin 10922.667))) + (set! (-> s5-0 y) (+ 12288.0 (-> s5-0 y))) + (vector+! s5-0 s5-0 (-> self entity trans)) + (set! (-> self spinners arg0) + (ppointer->handle + (process-spawn metalkor-spinner s5-0 (-> *metalkor-lowtorso-spinner-setup* arg0 joint-index) :to self) + ) + ) + ) + ) + (none) + ) + +;; definition for function ja-aframe-num-of-proc +(defun ja-aframe-num-of-proc ((arg0 process-drawable) (arg1 int)) + (let* ((a0-2 (-> arg0 skel root-channel arg1)) + (v1-2 (-> a0-2 frame-group)) + ) + (if (and v1-2 (nonzero? v1-2)) + (+ (* (-> a0-2 frame-num) (-> v1-2 artist-step)) (-> v1-2 artist-base)) + 0.0 + ) + ) + ) + +;; definition for method 13 of type metalkor-chain-physics +;; WARN: Return type mismatch int vs none. +(defmethod apply-gravity metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int) (arg2 process-drawable)) + (local-vars (f0-16 float) (f0-31 float)) + (cond + ((zero? arg1) + (set! (-> obj joint-length) 8192.0) + ) + ((= arg1 1) + (set! (-> obj joint-length) 12288.0) + ) + ((= arg1 2) + (set! (-> obj joint-length) 8192.0) + ) + (else + (let ((v1-8 (-> arg2 parent))) + (if (and (-> (the-as metalkor (if v1-8 + (the-as metalkor (-> v1-8 0 self)) + ) + ) + next-state + ) + (let ((v1-12 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-12 + (the-as metalkor (-> v1-12 0 self)) + ) + ) + next-state + name + ) + 'hang-shoot-n-launch + ) + ) + ) + (set! (-> obj joint-length) 5734.4) + (set! (-> obj joint-length) 5324.8) + ) + ) + ) + ) + (vector-float*! + arg0 + (-> obj gravity) + (* 4096.0 (-> self clock time-adjust-ratio) (lerp-scale 0.2 0.1 (the float arg1) 0.0 20.0)) + ) + (vector-float*! arg0 arg0 0.75) + (set! (-> obj axial-slop) (* 364.0889 (the float arg1))) + (let ((f26-0 (-> obj prev-rotation)) + (f28-0 (-> obj prev-y-rotation)) + (f30-1 (ja-aframe-num-of-proc (the-as process-drawable (ppointer->process (-> arg2 parent))) 0)) + ) + (let* ((v1-27 (-> arg2 parent)) + (s2-2 (and (and (-> (the-as metalkor (if v1-27 + (the-as metalkor (-> v1-27 0 self)) + ) + ) + next-state + ) + (let ((v1-31 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-31 + (the-as metalkor (-> v1-31 0 self)) + ) + ) + next-state + name + ) + 'tail-attack + ) + ) + ) + (< 20.0 f30-1) + (< f30-1 39.0) + ) + ) + ) + (let ((v1-38 (-> arg2 parent))) + (set! f28-0 + (cond + ((and (and (-> (the-as metalkor (if v1-38 + (the-as metalkor (-> v1-38 0 self)) + ) + ) + next-state + ) + (let ((v1-42 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-42 + (the-as metalkor (-> v1-42 0 self)) + ) + ) + next-state + name + ) + 'start-second-stage + ) + ) + ) + (< f30-1 60.0) + ) + (set! f26-0 0.0) + 0.0 + ) + ((let ((v1-49 (-> arg2 parent))) + (and (-> (the-as metalkor (if v1-49 + (the-as metalkor (-> v1-49 0 self)) + ) + ) + next-state + ) + (let* ((v1-53 (-> arg2 parent)) + (v1-56 (-> (the-as metalkor (if v1-53 + (the-as metalkor (-> v1-53 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-56 'hang-shoot-n-launch) (= v1-56 'start-second-stage)) + ) + ) + ) + (let ((f1-3 (cond + ((zero? arg1) + (set! f0-16 -9102.223) + 0.0 + ) + ((< arg1 9) + (set! f0-16 (+ 2002.4889 f26-0)) + (+ 546.13336 f28-0) + ) + ((< arg1 12) + (set! f0-16 (+ 2730.6667 f26-0)) + (+ 2002.4889 f28-0) + ) + ((< arg1 15) + (set! f0-16 (+ 910.2222 f26-0)) + (+ -5461.3335 f28-0) + ) + (else + (set! f0-16 (+ -3640.889 f26-0)) + (+ -5461.3335 f28-0) + ) + ) + ) + ) + (set! f26-0 (+ f0-16 (* 182.04445 (-> obj osc-z value)))) + (+ f1-3 (* 182.04445 (-> obj osc-y value))) + ) + ) + (else + (cond + (s2-2 + (cond + ((zero? arg1) + (set! f26-0 -16384.0) + (set! f28-0 0.0) + (set! s2-2 #f) + ) + ((< arg1 9) + (set! f26-0 (cond + ((or (< f30-1 25.0) (< 38.0 f30-1)) + (+ -4733.156 f26-0) + ) + ((< f30-1 31.0) + (+ -6371.5557 f26-0) + ) + (else + (+ -2912.7112 f26-0) + ) + ) + ) + (set! s2-2 #f) + ) + (else + (vector-! arg0 (target-pos 0) (the-as vector (-> obj chain-joints arg1))) + (vector-normalize! arg0 12288.0) + ) + ) + ) + (else + (let ((v1-90 (-> arg2 parent))) + (cond + ((and (-> (the-as metalkor (if v1-90 + (the-as metalkor (-> v1-90 0 self)) + ) + ) + next-state + ) + (let* ((v1-94 (-> arg2 parent)) + (v1-97 (-> (the-as metalkor (if v1-94 + (the-as metalkor (-> v1-94 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-97 'fall-down) (= v1-97 'collapse) (= v1-97 'last-gasp) (= v1-97 'fly-to-ring) (= v1-97 'explode)) + ) + ) + (cond + ((zero? arg1) + (set! f26-0 -3640.889) + (set! f28-0 0.0) + ) + (else + (* 0.5 f26-0) + ) + ) + ) + (else + (cond + ((zero? arg1) + (set! f0-31 -16384.0) + (set! f28-0 0.0) + ) + ((< arg1 9) + (set! f0-31 (+ -4187.0225 f26-0)) + ) + ((< arg1 12) + (set! f0-31 (+ 8556.089 f26-0)) + ) + ((< arg1 15) + (set! f0-31 (+ -910.2222 f26-0)) + ) + ((< arg1 18) + (set! f0-31 (+ -10012.444 f26-0)) + ) + (else + (set! f0-31 (+ 910.2222 f26-0)) + ) + ) + (set! f26-0 (+ f0-31 (* 182.04445 (-> obj osc-z value)))) + (+! f28-0 (* 182.04445 (-> obj osc-y value))) + ) + ) + ) + ) + ) + f28-0 + ) + ) + ) + ) + (set! (-> obj prev-rotation) f26-0) + (set! (-> obj prev-y-rotation) f28-0) + (when (not s2-2) + (let ((a1-11 (-> arg2 node-list data 3 bone transform)) + (s2-3 (new 'stack-no-clear 'matrix)) + ) + (matrix-axis-angle! s2-3 (the-as vector a1-11) f26-0) + (vector-matrix*! arg0 arg0 s2-3) + (let ((a1-13 (-> arg2 node-list data 3 bone transform vector 1))) + (matrix-axis-angle! s2-3 a1-13 f28-0) + ) + (vector-matrix*! arg0 arg0 s2-3) + ) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* arg1 64))) + (lerp-scale 0.9 0.5 (the float arg1) 0.0 20.0) + ) + ) + ) + (let ((v1-124 (-> arg2 parent))) + (if (and (-> (the-as metalkor (if v1-124 + (the-as metalkor (-> v1-124 0 self)) + ) + ) + next-state + ) + (let* ((v1-128 (-> arg2 parent)) + (v1-131 (-> (the-as metalkor (if v1-128 + (the-as metalkor (-> v1-128 0 self)) + ) + ) + next-state + name + ) + ) + ) + (or (= v1-131 'fall-down) (= v1-131 'collapse) (= v1-131 'start-second-stage)) + ) + ) + (vector-float*! arg0 arg0 1.1) + ) + ) + (let ((v1-135 (-> arg2 parent))) + (cond + ((and (and (-> (the-as metalkor (if v1-135 + (the-as metalkor (-> v1-135 0 self)) + ) + ) + next-state + ) + (let ((v1-139 (-> arg2 parent))) + (= (-> (the-as metalkor (if v1-139 + (the-as metalkor (-> v1-139 0 self)) + ) + ) + next-state + name + ) + 'tail-attack + ) + ) + ) + (< 18.0 f30-1) + (and (< f30-1 39.0) (> arg1 0) (< arg1 9)) + ) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* (+ arg1 -1) 64))) + 0.9 + ) + ) + ((-> obj move-with-parent) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* (+ arg1 -1) 64))) + 0.8 + ) + ) + ) + ) + ) + 0 + (none) + ) + +;; definition for method 16 of type metalkor-chain-physics +(defmethod chain-physics-method-16 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 int)) + 10922.667 + ) + +;; definition for method 14 of type metalkor-chain-physics +;; WARN: Return type mismatch int vs none. +(defmethod chain-physics-method-14 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int)) + (vector-reset! arg0) + 0 + (none) + ) + +;; definition for method 15 of type metalkor-chain-physics +(defmethod clamp-length metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 vector) (arg2 object) (arg3 process-drawable)) + ((method-of-type chain-physics clamp-length) obj arg0 arg1 arg2 arg3) + (when (< 5 (the-as int arg2)) + (let ((a0-2 (vector<-cspace! (new 'stack-no-clear 'vector) (-> arg3 node-list data 3))) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (vector-! s5-1 arg0 a0-2) + (let ((f0-0 (vector-normalize-ret-len! s5-1 1.0))) + (if (< f0-0 32768.0) + (vector+float*! arg0 arg0 s5-1 (- 32768.0 f0-0)) + ) + ) + ) + ) + ) + +;; definition for method 12 of type metalkor-chain-physics +;; WARN: Return type mismatch int vs none. +(defmethod gravity-update metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 process-drawable)) + (let ((t9-0 (method-of-type chain-physics gravity-update))) + (t9-0 obj arg0) + ) + (update! (-> obj rand-y)) + (update! (-> obj rand-z)) + (update! (-> obj osc-y) (-> obj rand-y value)) + (update! (-> obj osc-z) (-> obj rand-z value)) + (let ((s5-1 (new 'stack-no-clear 'collide-query))) + (let ((s4-0 (new 'stack-no-clear 'bounding-box))) + (let ((s3-0 (new 'stack-no-clear 'sphere))) + (vector<-cspace! s3-0 (-> arg0 node-list data 19)) + (set! (-> s3-0 r) 61440.0) + (set-from-sphere! s4-0 s3-0) + ) + (set! (-> s5-1 collide-with) (collide-spec player-list special-obstacle)) + (set! (-> s5-1 ignore-process0) #f) + (set! (-> s5-1 ignore-process1) #f) + (set! (-> s5-1 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> s5-1 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> s5-1 bbox)) (the-as pointer s4-0) 32) + ) + (fill-using-bounding-box *collide-cache* s5-1) + ) + 0 + (none) + ) + +;; definition for method 17 of type metalkor-chain-physics +;; INFO: Used lq/sq +;; WARN: Return type mismatch int vs none. +(defmethod chain-physics-method-17 metalkor-chain-physics ((obj metalkor-chain-physics) (arg0 vector) (arg1 int)) + (local-vars (v1-26 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let* ((s5-0 (new 'stack-no-clear 'collide-query)) + (v1-2 (-> obj chain-joints arg1)) + (s4-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> v1-2 position))) + (s3-0 0) + ) + (set! (-> arg0 quad) (-> v1-2 position quad)) + (until (or (< 6 s3-0) (begin + (.lvf vf1 (&-> s4-1 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-26 vf1) + (let ((f0-7 v1-26) + (f1-5 409.6) + ) + (< f0-7 (* f1-5 f1-5)) + ) + ) + ) + (+! s3-0 1) + (set! (-> s5-0 start-pos quad) (-> arg0 quad)) + (set! (-> s5-0 move-dist quad) (-> s4-1 quad)) + (let ((v1-7 s5-0)) + (set! (-> v1-7 radius) 4096.0) + (set! (-> v1-7 collide-with) (collide-spec special-obstacle)) + (set! (-> v1-7 ignore-process0) #f) + (set! (-> v1-7 ignore-process1) #f) + (set! (-> v1-7 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-7 action-mask) (collide-action solid)) + ) + (set! (-> s5-0 num-spheres) (the-as uint #f)) + (let ((f0-1 (probe-using-line-sphere *collide-cache* s5-0))) + (cond + ((>= f0-1 0.0) + (let ((f0-2 (fmin 1.0 f0-1))) + (vector+float*! arg0 arg0 s4-1 f0-2) + (vector-float*! s4-1 s4-1 (- 1.0 f0-2)) + ) + (let ((f0-5 (vector-dot s4-1 (-> s5-0 best-other-tri normal)))) + (vector--float*! s4-1 s4-1 (-> s5-0 best-other-tri normal) (* 1.2 f0-5)) + ) + ) + (else + (vector+! arg0 arg0 s4-1) + (goto cfg-11) + ) + ) + ) + ) + ) + (label cfg-11) + 0 + (none) + ) + ) + +;; definition for method 7 of type metalkor-lowtorso +;; WARN: Return type mismatch process-focusable vs metalkor-lowtorso. +(defmethod relocate metalkor-lowtorso ((obj metalkor-lowtorso) (arg0 int)) + (if (nonzero? (-> obj tail)) + (&+! (-> obj tail) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-1)) + (&+! (-> obj egg-toss-joint-1) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-2)) + (&+! (-> obj egg-toss-joint-2) arg0) + ) + (if (nonzero? (-> obj egg-toss-joint-3)) + (&+! (-> obj egg-toss-joint-3) arg0) + ) + (the-as metalkor-lowtorso ((method-of-type process-focusable relocate) obj arg0)) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-lowtorso) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (local-vars (v0-0 object)) + (the-as + object + (case event-type + (('egg-toss) + (set! (-> self egg-toss-joint-angle target) (the-as float (-> event param 0))) + ) + (('color) + (set! (-> self draw color-mult quad) (-> (the-as rgbaf (-> event param 0)) quad)) + (set! v0-0 (-> self draw color-emissive)) + (set! (-> (the-as rgbaf v0-0) quad) (-> (the-as rgbaf (-> event param 1)) quad)) + v0-0 + ) + (('move-chain) + (let ((v1-7 (-> event param 0)) + (a0-9 (-> self tail)) + ) + (dotimes (a1-1 (the-as int (-> a0-9 num-joints))) + (vector+! + (the-as vector (-> a0-9 chain-joints a1-1)) + (the-as vector (-> a0-9 chain-joints a1-1)) + (the-as vector v1-7) + ) + ) + ) + #f + ) + (('spinner) + (let ((v1-10 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (the-as object (metalkor-lowtorso-start-spinner (the-as int (-> event param 0)) (-> v1-10 vector 2))) + ) + ) + (('spinner-off) + (let ((gp-1 (-> event param 0))) + (when (< (the-as int gp-1) 4) + (let ((a0-17 (handle->process (-> self spinners gp-1)))) + (when a0-17 + (send-event a0-17 'break) + (set! (-> self spinners gp-1) (the-as handle #f)) + #f + ) + ) + ) + ) + ) + (('ja-float) + (dotimes (s5-1 3) + (when (not (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 float-anim)) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 float-anim) + (get-art-by-name (-> self draw art-group) (the-as string (-> event param 0)) art-joint-anim) + ) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-1 16))) ja-float-info 0 channel-index) + (the-as int (-> event param 1)) + ) + (set! v0-0 #t) + (goto cfg-31) + ) + ) + (set! v0-0 #f) + (label cfg-31) + v0-0 + ) + (('attack) + (let ((v1-32 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-32 from) (process->ppointer proc)) + (set! (-> v1-32 num-params) arg1) + (set! (-> v1-32 message) event-type) + (set! (-> v1-32 param 0) (-> event param 0)) + (set! (-> v1-32 param 1) (-> event param 1)) + (set! (-> v1-32 param 2) (-> event param 2)) + (set! (-> v1-32 param 3) (-> event param 3)) + (set! (-> v1-32 param 4) (-> event param 4)) + (set! (-> v1-32 param 5) (-> event param 5)) + (send-event-function (ppointer->process (-> self parent)) v1-32) + ) + ) + (('touch) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (set! (-> s4-0 quad) (-> self entity trans quad)) + (let* ((s3-0 proc) + (v1-36 (if (type? s3-0 process-drawable) + s3-0 + ) + ) + ) + (when v1-36 + (let ((s3-2 (vector-! (new 'stack-no-clear 'vector) (-> (the-as process-drawable v1-36) root trans) s4-0)) + (s4-2 (vector-! + (new 'stack-no-clear 'vector) + (-> (the-as process-drawable v1-36) root trans) + (-> self root-override trans) + ) + ) + ) + (set! (-> s3-2 y) 0.0) + (set! (-> s4-2 y) 0.0) + (when (< (vector-dot s3-2 s4-2) 0.0) + (vector-normalize! s3-2 1.0) + (vector-normalize! s4-2 1.0) + (vector-flatten! s4-2 s4-2 s3-2) + ) + (vector-normalize! s4-2 32768.0) + (let ((a1-14 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-14 from) (process->ppointer self)) + (set! (-> a1-14 num-params) 2) + (set! (-> a1-14 message) 'attack) + (set! (-> a1-14 param 0) (-> event param 0)) + (let ((v1-47 (new 'static 'attack-info :mask (attack-info-mask vector mode shove-up id)))) + (let* ((a0-50 *game-info*) + (a2-9 (+ (-> a0-50 attack-id) 1)) + ) + (set! (-> a0-50 attack-id) a2-9) + (set! (-> v1-47 id) a2-9) + ) + (set! (-> v1-47 mode) 'deadly) + (set! (-> v1-47 vector quad) (-> s4-2 quad)) + (set! (-> v1-47 shove-up) 16384.0) + (set! (-> a1-14 param 1) (the-as uint v1-47)) + ) + (when (send-event-function proc a1-14) + (set! (-> self no-collision-timer) (-> self clock frame-counter)) + (let ((v1-52 (-> self root-override root-prim))) + (set! (-> v1-52 prim-core collide-as) (collide-spec)) + (set! (-> v1-52 prim-core collide-with) (collide-spec)) + ) + 0 + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set-params! (-> self egg-toss-joint-angle) 0.0 0.05 0.3 0.9) + (none) + ) + :trans (behavior () + (when (>= (- (-> self clock frame-counter) (-> self no-collision-timer)) (seconds 0.1)) + (let ((v1-5 (-> self root-override root-prim))) + (set! (-> v1-5 prim-core collide-as) (-> self root-override backup-collide-as)) + (set! (-> v1-5 prim-core collide-with) (-> self root-override backup-collide-with)) + ) + ) + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (let ((gp-0 (ppointer->process (-> self parent)))) + (when gp-0 + (dotimes (s5-0 3) + (when (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + (let ((v1-17 (ja-channel-float! + (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) + 0.0 + 0.0 + 0.0 + ) + ) + ) + (when v1-17 + (let ((a0-16 (-> (the-as process-drawable gp-0) + skel + channel + (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 channel-index) + ) + ) + ) + (set! (-> v1-17 frame-num) (-> a0-16 frame-num)) + (set! (-> v1-17 frame-interp 0) (-> a0-16 frame-interp 0)) + (set! (-> v1-17 frame-interp 1) (-> a0-16 frame-interp 1)) + ) + (do-joint-math (-> self draw) (-> self node-list) (-> self skel)) + ) + ) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* s5-0 16))) ja-float-info 0 float-anim) #f) + ) + ) + ) + ) + (update! (-> self egg-toss-joint-angle) 0.0) + (let ((f30-0 (* 910.2222 (-> self egg-toss-joint-angle value)))) + (quaternion-set! (-> self egg-toss-joint-1 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + (quaternion-set! (-> self egg-toss-joint-2 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + (quaternion-set! (-> self egg-toss-joint-3 quat) 0.0 0.0 (sin f30-0) (cos f30-0)) + ) + (when (not (-> self tail-initialized)) + (set! (-> self tail-initialized) #t) + (initialize-chain-joints (-> self tail)) + ) + (let ((v1-38 (ja-group))) + (set! (-> self tail move-with-parent) + (the-as symbol (and (and v1-38 (or (= v1-38 (-> self draw art-group data 18)) + (= v1-38 (-> self draw art-group data 19)) + (= v1-38 (-> self draw art-group data 20)) + ) + ) + (< (ja-aframe-num 0) 45.0) + ) + ) + ) + ) + (update (-> self tail) self) + (none) + ) + :code (the-as (function none :behavior metalkor-lowtorso) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition of type nestb-formation +(deftype nestb-formation (hover-formation) + () + :heap-base #x10 + :method-count-assert 16 + :size-assert #x90 + :flag-assert #x1000100090 + ) + +;; definition for method 3 of type nestb-formation +(defmethod inspect nestb-formation ((obj nestb-formation)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type hover-formation inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition for method 15 of type nestb-formation +(defmethod hover-formation-method-15 nestb-formation ((obj nestb-formation) (arg0 vector) (arg1 vector)) + (logior! (-> obj formation flags) 2) + 0 + ) + +;; definition for method 115 of type metalkor-flitter +;; WARN: Return type mismatch symbol vs none. +(defmethod init-enemy! metalkor-flitter ((obj metalkor-flitter)) + "Common method called to initialize the enemy, typically sets up default field values and calls ancillary helper methods" + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-flitter" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (init-enemy-behaviour-and-stats! obj *metalkor-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) + (set! (-> obj minimap) #f) + (none) + ) + +;; definition for method 132 of type metalkor-flitter +(defmethod dispose! metalkor-flitter ((obj metalkor-flitter)) + "Cleans-up the enemy and any associated resources. Potentially spawns skull gems" + (with-pp + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (when (and (>= (-> obj enemy-info-override gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (let ((a1-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-0 from) (process->ppointer pp)) + (set! (-> a1-0 num-params) 0) + (set! (-> a1-0 message) 'have-gem?) + (or (send-event-function (ppointer->process (-> obj parent)) a1-0) + (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-override gem-no-seg)) + (the-as int (-> obj enemy-info-override gem-seg)) + ) + (let ((v1-30 + (ppointer->process + (birth-pickup-at-point + (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info-override gem-joint))) + (pickup-type gem) + 1.0 + #t + (ppointer->process (-> obj parent)) + (-> obj fact-info-override) + ) + ) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'flitter-change-gem obj v1-30) + ) + ) + ) + ((method-of-type flitter dispose!) obj) + (none) + ) + ) + +;; definition for method 132 of type metalkor-wasp +(defmethod dispose! metalkor-wasp ((obj metalkor-wasp)) + "Cleans-up the enemy and any associated resources. Potentially spawns skull gems" + (with-pp + (when (not (logtest? (enemy-flag recover-applied-velocity) (-> obj enemy-flags))) + (when (and (>= (-> obj enemy-info gem-joint) 0) + (not (logtest? (enemy-flag cam-attack-mode) (-> obj enemy-flags))) + (let ((a1-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-0 from) (process->ppointer pp)) + (set! (-> a1-0 num-params) 0) + (set! (-> a1-0 message) 'have-gem?) + (or (send-event-function (ppointer->process (-> obj parent)) a1-0) + (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 ((v1-28 + (ppointer->process + (birth-pickup-at-point + (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data (-> obj enemy-info gem-joint))) + (pickup-type gem) + 1.0 + #t + *entity-pool* + (-> obj fact-info-override) + ) + ) + ) + ) + (send-event (ppointer->process (-> obj parent)) 'wasp-change-gem obj v1-28) + ) + ) + ) + ((method-of-type wasp dispose!) obj) + (none) + ) + ) + +;; failed to figure out what this is: +(defskelgroup skel-rift-ring-ingame rift-ring-in-game rift-ring-in-game-lod0-jg rift-ring-in-game-idle-ja + ((rift-ring-in-game-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + ) + +;; definition of type rift-ring-ingame +(deftype rift-ring-ingame (process-drawable) + ((anim-speed delayed-rand-float :inline :offset-assert 200) + (stutter symbol :offset-assert 228) + (spin-sound sound-id :offset-assert 232) + (spin-sound-playing symbol :offset-assert 236) + ) + :heap-base #x70 + :method-count-assert 21 + :size-assert #xf0 + :flag-assert #x15007000f0 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type rift-ring-ingame +(defmethod inspect rift-ring-ingame ((obj rift-ring-ingame)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Tanim-speed: #~%" (-> obj anim-speed)) + (format #t "~2Tstutter: ~A~%" (-> obj stutter)) + (format #t "~2Tspin-sound: ~D~%" (-> obj spin-sound)) + (format #t "~2Tspin-sound-playing: ~A~%" (-> obj spin-sound-playing)) + (label cfg-4) + obj + ) + +;; failed to figure out what this is: +(defstate idle (rift-ring-ingame) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('stutter) + (set! (-> self stutter) (the-as symbol (-> event param 0))) + (set-params! (-> self anim-speed) 3 15 0.25) + (reset! (-> self anim-speed)) + (set! (-> self anim-speed value) -0.25) + ) + ) + ) + ) + :trans (behavior () + (cond + ((-> self stutter) + (update! (-> self anim-speed)) + (ja :num! (loop! (+ 0.125 (-> self anim-speed value)))) + ) + (else + (ja :num! (loop!)) + ) + ) + (sound-play "warp-ring" :id (-> self spin-sound) :position (-> self root trans)) + (set! (-> self spin-sound-playing) #t) + (none) + ) + :code (the-as (function none :behavior rift-ring-ingame) sleep-code) + :post (behavior () + (spawn (-> self part) (-> self root trans)) + (ja-post) + (none) + ) + ) + +;; definition for method 10 of type rift-ring-ingame +(defmethod deactivate rift-ring-ingame ((obj rift-ring-ingame)) + (if (-> obj spin-sound-playing) + (sound-stop (-> obj spin-sound)) + ) + ((method-of-type process-drawable deactivate) obj) + (none) + ) + +;; definition for method 11 of type rift-ring-ingame +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! rift-ring-ingame ((obj rift-ring-ingame) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (set! (-> obj root) (new 'process 'trsqv)) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-rift-ring-ingame" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 1236) obj)) + (set! (-> obj draw light-index) (the-as uint 10)) + (set! (-> obj stutter) #f) + (set! (-> obj spin-sound) (new-sound-id)) + (set! (-> obj spin-sound-playing) #f) + (go (method-of-object obj idle)) + (none) + ) + +;; definition for method 13 of type metalkor-spinner-chain-physics +;; WARN: Return type mismatch vector vs none. +(defmethod apply-gravity metalkor-spinner-chain-physics ((obj metalkor-spinner-chain-physics) (arg0 vector) (arg1 int) (arg2 process-drawable)) + (vector-float*! arg0 (-> obj gravity) (-> obj gravity-mult)) + (vector+float*! + arg0 + arg0 + (the-as vector (+ (the-as uint (-> obj chain-joints 0 velocity)) (* arg1 64))) + (-> obj velocity-mult) + ) + (none) + ) + +;; definition for method 14 of type metalkor-spinner-chain-physics +;; WARN: Return type mismatch int vs none. +(defmethod chain-physics-method-14 metalkor-spinner-chain-physics ((obj metalkor-spinner-chain-physics) (arg0 vector) (arg1 int)) + (vector-reset! arg0) + 0 + (none) + ) + +;; definition for method 7 of type metalkor-spinner +;; WARN: Return type mismatch process-drawable vs metalkor-spinner. +(defmethod relocate metalkor-spinner ((obj metalkor-spinner) (arg0 int)) + (if (nonzero? (-> obj chain)) + (&+! (-> obj chain) arg0) + ) + (the-as metalkor-spinner ((method-of-type process-drawable relocate) obj arg0)) + ) + +;; failed to figure out what this is: +(defstate break-it (metalkor-spinner) + :virtual #t + :enter (behavior () + (set! (-> self chain joint-length) (* 12288.0 (-> self root scale y))) + (set! (-> self root scale y) 1.0) + (initialize-chain-joints (-> self chain)) + (set! (-> self state-time) (-> self clock frame-counter)) + (let* ((f30-0 0.9) + (f28-0 0.2) + (v1-12 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-13 (the-as number (logior #x3f800000 v1-12))) + ) + (set! (-> self anim-speed) (+ f30-0 (* f28-0 (+ -1.0 (the-as float v1-13))))) + ) + (turn-off (-> self chain) (the-as time-frame (the int (* 300.0 (rand-vu-float-range 0.9 1.2))))) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 52) :num! min) + (none) + ) + :trans (behavior () + (let* ((v1-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root quat))) + (a2-1 (quaternion-from-two-vectors-partial! + (new 'stack-no-clear 'quaternion) + (-> v1-1 vector 1) + (new 'static 'vector :y 1.0) + 0.1 + ) + ) + ) + (quaternion*! (-> self root quat) (-> self root quat) a2-1) + ) + (quaternion-normalize! (-> self root quat)) + (update (-> self chain) self) + (cond + ((< (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) + ) + ((let ((v1-13 (ja-group))) + (and v1-13 (= v1-13 (-> self draw art-group data 53))) + ) + (ja :num! (seek! max (-> self anim-speed))) + (if (ja-done? 0) + (deactivate self) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 53) :num! min) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-spinner) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('break) + (go-virtual break-it) + ) + ) + ) + :enter (behavior () + (ja :group! (-> self draw art-group data 50)) + (none) + ) + :trans (behavior () + (ja :num! (loop!)) + (let* ((t9-1 vector<-cspace!) + (a0-1 (new 'stack-no-clear 'vector)) + (v1-6 (+ (* (-> self parent-joint-index) 32) 12)) + (a1-1 (-> self parent)) + (v1-7 (t9-1 + a0-1 + (the-as + cspace + (+ v1-6 (the-as int (-> (the-as process-drawable (if a1-1 + (the-as process-drawable (-> a1-1 0 self)) + ) + ) + node-list + ) + ) + ) + ) + ) + ) + (gp-1 (vector-! (new 'stack-no-clear 'vector) v1-7 (-> self root trans))) + (f30-0 (vector-normalize-ret-len! gp-1 1.0)) + ) + (quaternion-from-two-vectors! (-> self root quat) (new 'static 'vector :y -1.0) gp-1) + (set! (-> self root scale y) (* 0.000009042245 f30-0)) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +;; failed to figure out what this is: +(defstate shoot-out (metalkor-spinner) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('break) + (the-as symbol (deactivate self)) + ) + ) + ) + ) + :enter (behavior () + (let* ((f30-0 0.9) + (f28-0 0.2) + (v1-3 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-4 (the-as number (logior #x3f800000 v1-3))) + ) + (set! (-> self anim-speed) (+ f30-0 (* f28-0 (+ -1.0 (the-as float v1-4))))) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 51))) + (ja :num! (seek! max (-> self anim-speed))) + (when (ja-done? 0) + (set! (-> self root trans quad) (-> self target-pos quad)) + (go-virtual idle) + ) + ) + (else + (ja :group! (-> self draw art-group data 51) :num! min) + ) + ) + ) + (let* ((t9-4 vector<-cspace!) + (a0-9 (new 'stack-no-clear 'vector)) + (v1-25 (+ (* (-> self parent-joint-index) 32) 12)) + (a1-2 (-> self parent)) + (s5-0 (t9-4 + a0-9 + (the-as cspace (+ v1-25 (the-as int (-> (the-as metalkor (if a1-2 + (the-as metalkor (-> a1-2 0 self)) + ) + ) + node-list + ) + ) + ) + ) + ) + ) + (gp-2 (vector-! (new 'stack-no-clear 'vector) s5-0 (-> self target-pos))) + ) + (let ((f0-4 (vector-normalize-ret-len! gp-2 1.0))) + (set! (-> self root scale y) (* 0.000009042245 f0-4)) + (vector+float*! (-> self root trans) s5-0 gp-2 (- f0-4)) + ) + (quaternion-from-two-vectors! (-> self root quat) (new 'static 'vector :y -1.0) gp-2) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-spinner) sleep-code) + :post (the-as (function none :behavior metalkor-spinner) ja-post) + ) + +;; failed to figure out what this is: +(defskelgroup skel-nest-break-precipice nest-break-precipice nest-break-precipice-lod0-jg nest-break-precipice-idle-ja + ((nest-break-precipice-lod0-mg (meters 999999))) + :bounds (static-spherem -28 20 30 24) + ) + +;; definition of type nest-break-precipice +(deftype nest-break-precipice (process-drawable) + () + :heap-base #x50 + :method-count-assert 22 + :size-assert #xc8 + :flag-assert #x16005000c8 + (:methods + (idle () _type_ :state 20) + (die () _type_ :state 21) + ) + ) + +;; definition for method 3 of type nest-break-precipice +(defmethod inspect nest-break-precipice ((obj nest-break-precipice)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; failed to figure out what this is: +(defstate idle (nest-break-precipice) + :virtual #t + :enter (behavior () + (ja-post) + (none) + ) + :code (the-as (function none :behavior nest-break-precipice) sleep-code) + ) + +;; failed to figure out what this is: +(defstate die (nest-break-precipice) + :virtual #t + :trans (behavior () + (cleanup-for-death self) + (deactivate self) + (none) + ) + :code (the-as (function none :behavior nest-break-precipice) sleep-code) + ) + +;; definition for method 11 of type nest-break-precipice +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! nest-break-precipice ((obj nest-break-precipice) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (set! (-> obj root) (new 'process 'trsqv)) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as + skeleton-group + (art-group-get-by-name *level* "skel-nest-break-precipice" (the-as (pointer uint32) #f)) + ) + (the-as pair 0) + ) + (set! (-> obj draw light-index) (the-as uint 17)) + (if (task-node-closed? (game-task-node nest-boss-introduction)) + (go (method-of-object obj die)) + (go (method-of-object obj idle)) + ) + (none) + ) + +;; definition for method 15 of type hud-metalkor +;; WARN: Return type mismatch int vs none. +(defmethod draw hud-metalkor ((obj hud-metalkor)) + (set-hud-piece-position! (-> obj sprites 1) (the int (+ 462.0 (* 130.0 (-> obj offset)))) 350) + (set-as-offset-from! (the-as hud-sprite (-> obj sprites)) (the-as vector4w (-> obj sprites 1)) -32 0) + (set-as-offset-from! (-> obj sprites 5) (the-as vector4w (-> obj sprites 1)) -62 14) + (set-as-offset-from! (-> obj sprites 6) (the-as vector4w (-> obj sprites 1)) -32 14) + (let ((s5-0 (-> obj values 0 current)) + (f30-0 (* 0.01 (the float (-> obj values 1 current)))) + ) + (set-as-offset-from! (-> obj sprites 4) (the-as vector4w (-> obj sprites 1)) -92 15) + (cond + ((= s5-0 1) + (set! (-> obj sprites 4 color x) 0) + (set! (-> obj sprites 4 color y) 255) + (set! f30-0 (+ 2.0 f30-0)) + ) + ((= s5-0 2) + (set! (-> obj sprites 4 color y) 255) + (set! (-> obj sprites 4 color x) 255) + (set! f30-0 (+ 1.0 f30-0)) + ) + ((= s5-0 3) + (set! (-> obj sprites 4 color x) 255) + (set! (-> obj sprites 4 color y) 0) + 0 + ) + (else + (set! f30-0 0.0) + ) + ) + (set! (-> obj sprites 4 scale-x) (* -7.25 f30-0)) + ) + ((method-of-type hud draw) obj) + 0 + (none) + ) + +;; definition for method 17 of type hud-metalkor +;; WARN: Return type mismatch int vs none. +(defmethod init-callback hud-metalkor ((obj hud-metalkor)) + (set! (-> obj gui-id) + (add-process *gui-control* obj (gui-channel hud-middle-right) (gui-action hidden) (-> obj name) 81920.0 0) + ) + (set! (-> obj values 0 target) 1) + (set! (-> obj values 1 target) 100) + (logior! (-> obj flags) (hud-flags show)) + (set! (-> obj sprites 0 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3b :page #x67a))) + (set! (-> obj sprites 0 flags) (the-as uint 4)) + (set! (-> obj sprites 1 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3c :page #x67a))) + (set! (-> obj sprites 1 flags) (the-as uint 4)) + (set! (-> obj sprites 5 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a))) + (set! (-> obj sprites 5 scale-x) 0.5) + (set! (-> obj sprites 5 flags) (the-as uint 4)) + (set! (-> obj sprites 6 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x3d :page #x67a))) + (set! (-> obj sprites 6 scale-x) 0.5) + (set! (-> obj sprites 6 flags) (the-as uint 4)) + (set! (-> obj sprites 4 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a))) + (set! (-> obj sprites 4 scale-y) 3.25) + (set! (-> obj sprites 4 color z) 0) + (set! (-> obj sprites 4 flags) (the-as uint 4)) + (set! (-> obj sprites 3 tex) (lookup-texture-by-id (new 'static 'texture-id :index #x41 :page #x67a))) + (set! (-> obj sprites 3 scale-y) 1.5) + (set! (-> obj sprites 3 color z) 0) + (set! (-> obj sprites 3 flags) (the-as uint 4)) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate idle (nestb-tail-bound) + :virtual #t + :code (the-as (function none :behavior nestb-tail-bound) sleep-code) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-kid) + :virtual #t + :trans (behavior () + (ja :num! (loop!)) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3))) + (none) + ) + :code (the-as (function none :behavior metalkor-kid) sleep-code) + :post (the-as (function none :behavior metalkor-kid) ja-post) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-wings) + :virtual #t + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t (-> self prefix)) + (none) + ) + :code (the-as (function none :behavior metalkor-wings) sleep-code) + :post (the-as (function none :behavior metalkor-wings) ja-post) + ) + +;; definition for function metalkor-distort-update +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-distort-update metalkor-distort () + (let ((s5-0 (camera-matrix)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (let ((f30-0 4096.0)) + (let ((f28-1 (* 0.00013563369 (tan (* 0.5 (-> *math-camera* fov))) f30-0))) + (matrix->quaternion (-> self root-override quat) s5-0) + (set-vector! (-> self root-override scale) f28-1 f28-1 f28-1 1.0) + ) + (let ((t9-3 vector<-cspace!) + (a0-3 gp-0) + (v1-7 (-> self parent)) + ) + (t9-3 a0-3 (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + node-list + data + 7 + ) + ) + ) + (vector-! gp-0 gp-0 (camera-pos)) + (vector-normalize! gp-0 f30-0) + ) + (vector+! (-> self root-override trans) (camera-pos) gp-0) + ) + 0 + (none) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-distort) + :virtual #t + :enter (behavior () + (metalkor-distort-update) + (none) + ) + :trans (behavior () + (ja :num! (seek!)) + (if (ja-done? 0) + (deactivate self) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-distort) sleep-code) + :post (the-as (function none :behavior metalkor-distort) ja-post) + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-rays metalkor-rays metalkor-rays-lod0-jg metalkor-rays-idle-ja + ((metalkor-rays-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 30) + ) + +;; definition of type metalkor-rays +(deftype metalkor-rays (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-rays +(defmethod inspect metalkor-rays ((obj metalkor-rays)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-rays) + :virtual #t + :enter (behavior () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 0.0) + (none) + ) + :trans (behavior () + (clone-anim-once (ppointer->handle (-> self parent)) #t "") + (let ((f0-0 (calc-fade-from-fog (-> self root trans)))) + (set-vector! (-> self draw color-emissive) f0-0 f0-0 f0-0 1.0) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-rays) sleep-code) + :post (the-as (function none :behavior metalkor-rays) ja-post) + ) + +;; definition for function metalkor-rays-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-rays-init-by-other metalkor-rays ((arg0 vector) (arg1 quaternion)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (quaternion-copy! (-> self root quat) arg1) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-rays" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (go-virtual idle) + (none) + ) + +;; failed to figure out what this is: +(set! (-> *lightning-spec-id-table* 29) (new 'static 'lightning-spec + :name "lightning-metalkor-explode" + :flags (lightning-spec-flags lsf0) + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) + :fade-start-factor 0.2 + :texture (new 'static 'texture-id :index #x83 :page #xc) + :reduction 0.42 + :num-points 16 + :box-size 8192.0 + :merge-factor 0.6 + :merge-count 2 + :radius 3276.8 + :duration 45.0 + :duration-rand 60.0 + :sound #f + ) + ) + +;; failed to figure out what this is: +(set! (-> *lightning-spec-id-table* 30) (new 'static 'lightning-spec + :name "lightning-metalkor-explode-thick" + :flags (lightning-spec-flags lsf0) + :start-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :end-color (new 'static 'rgba :r #xff :g #xff :b #xff :a #x80) + :fade-to-color (new 'static 'rgba :r #xbf :b #x8f :a #x5) + :fade-start-factor 0.2 + :texture (new 'static 'texture-id :index #x83 :page #xc) + :reduction 0.42 + :num-points 32 + :box-size 40960.0 + :merge-factor 0.6 + :merge-count 2 + :radius 12288.0 + :duration 60.0 + :sound #f + ) + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-explode) + :virtual #t + :enter (behavior () + (process-spawn metalkor-rays (-> self root trans) (-> self root quat) :to self) + (none) + ) + :trans (behavior () + (local-vars (sv-384 symbol) (sv-400 symbol) (sv-416 vector) (sv-432 matrix)) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (when (and (< f30-0 40.0) (>= (ja-aframe-num 0) 40.0)) + (send-event (ppointer->process (-> self parent)) 'exploding) + (activate! *camera-smush-control* 1638.4 37 210 1.0 0.995 (-> self clock)) + (let ((gp-0 (get-process *default-dead-pool* part-tracker #x4000))) + (when gp-0 + (let ((t9-6 (method-of-type part-tracker activate))) + (t9-6 + (the-as part-tracker gp-0) + *entity-pool* + (symbol->string (-> part-tracker symbol)) + (the-as pointer #x70004000) + ) + ) + (let ((s5-0 run-function-in-process) + (s4-0 gp-0) + (s3-0 part-tracker-init) + (s2-0 (-> *part-group-id-table* 1238)) + (s1-0 0) + (s0-0 #f) + ) + (set! sv-384 (the-as symbol #f)) + (set! sv-400 (the-as symbol #f)) + (set! sv-432 *launch-matrix*) + (set! sv-416 (-> sv-432 trans)) + (let ((v1-27 (-> (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3)) quad))) + (set! (-> sv-416 quad) v1-27) + ) + ((the-as (function object object object object object object object object none) s5-0) + s4-0 + s3-0 + s2-0 + s1-0 + s0-0 + sv-384 + sv-400 + sv-432 + ) + ) + (-> gp-0 ppointer) + ) + ) + ) + ) + (when (< 40.0 (ja-aframe-num 0)) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 70))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 71))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 20))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 59))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 60))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 22))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 24))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 54))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 53))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 57))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 56))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 28))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 46))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 48))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 44))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 50))) + (spawn (-> self part) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 3))) + ) + (if (ja-done? 0) + (send-event (ppointer->process (-> self parent)) 'explode-done) + ) + (process-drawable-shock-effect + self + (-> *lightning-spec-id-table* 29) + lightning-probe-callback + (-> *part-id-table* 429) + 0 + 0 + 40960.0 + ) + (let ((a0-51 (handle->process (-> self ring)))) + (if a0-51 + (process-drawable2-shock-effect + (the-as process-drawable a0-51) + self + (-> *lightning-spec-id-table* 30) + lightning-probe-callback + (-> *part-id-table* 429) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor-explode) sleep-code) + :post (the-as (function none :behavior metalkor-explode) ja-post) + ) + +;; failed to figure out what this is: +(defstate idle (rift-occlude) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as + object + (case event-type + (('movie-pos) + (format 0 "changing to movie position~%") + (let ((a2-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root quat)))) + (vector+! + (-> self root trans) + (-> self original-trans) + (vector-matrix*! (new 'stack-no-clear 'vector) (new 'static 'vector :x -10240.0 :y -7168.0 :z 11264.0) a2-1) + ) + ) + (the-as symbol (ja-post)) + ) + ) + ) + ) + :enter (behavior () + (set-vector! (-> self draw color-mult) 0.0 0.0 0.0 0.0) + (ja-post) + (none) + ) + :trans (behavior () + (let ((f0-0 (calc-fade-from-fog (-> self root trans)))) + (set-vector! (-> self draw color-emissive) f0-0 f0-0 f0-0 1.0) + ) + (none) + ) + :code (the-as (function none :behavior rift-occlude) sleep-code) + ) + +;; definition for method 7 of type metalkor-bomb +;; WARN: Return type mismatch process-drawable vs metalkor-bomb. +(defmethod relocate metalkor-bomb ((obj metalkor-bomb) (arg0 int)) + (dotimes (v1-0 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (when (nonzero? (-> obj joint-mods v1-0)) + (if (nonzero? (-> obj joint-mods v1-0)) + (&+! (-> obj joint-mods v1-0) arg0) + ) + ) + ) + (the-as metalkor-bomb ((method-of-type process-drawable relocate) obj arg0)) + ) + +;; definition for symbol *metalkor-bomb-collide-joints*, type (array int8) +(define *metalkor-bomb-collide-joints* (new 'static 'boxed-array :type int8 + 5 + #x8 + #xb + #xe + #x11 + #x14 + #x17 + #x1a + #x1d + #x20 + #x23 + #x26 + #x29 + #x2c + #x2f + #x32 + #x35 + #x38 + #x3b + #x3e + #x41 + #x44 + #x47 + #x4a + #x4d + #x50 + #x53 + #x56 + #x59 + #x5c + ) + ) + +;; definition for function metalkor-bomb-collide +;; INFO: Used lq/sq +(defbehavior metalkor-bomb-collide metalkor-bomb () + (local-vars (at-0 int)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (let ((gp-0 (new 'stack-no-clear 'collide-query))) + (let ((s5-0 (new 'stack-no-clear 'bounding-box))) + (let ((a1-0 (new 'stack-no-clear 'sphere))) + (set! (-> a1-0 quad) (-> self root-override trans quad)) + (set! (-> a1-0 r) 204800.0) + (set-from-sphere! s5-0 a1-0) + ) + (set! (-> gp-0 collide-with) (collide-spec jak crate enemy hit-by-others-list player-list pusher)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> gp-0 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> gp-0 bbox)) (the-as pointer s5-0) 32) + ) + (fill-using-bounding-box *collide-cache* gp-0) + ) + (let ((s5-1 (new 'stack-no-clear 'vector)) + (gp-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-1 quad) (-> self root-override trans quad)) + (vector<-cspace! + (-> self root-override trans) + (-> self node-list data (-> *metalkor-bomb-collide-joints* (+ (-> *metalkor-bomb-collide-joints* length) -1))) + ) + (dotimes (s4-0 (-> *metalkor-bomb-collide-joints* length)) + (vector<-cspace! s5-1 (-> self node-list data (-> *metalkor-bomb-collide-joints* s4-0))) + (vector-! s5-1 s5-1 (-> self root-override trans)) + (let ((v1-26 s5-1)) + (.lvf vf1 (&-> s5-1 quad)) + (let ((f0-1 (-> self clock frames-per-second))) + (.mov at-0 f0-1) + ) + (.mov vf2 at-0) + (.mov.vf vf1 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> v1-26 quad) vf1) + ) + (integrate-and-collide! (-> self root-override) s5-1) + ) + (let ((v0-6 (-> self root-override trans))) + (set! (-> v0-6 quad) (-> gp-1 quad)) + v0-6 + ) + ) + ) + ) + +;; definition for function metalkor-bomb-ground-check +;; INFO: Used lq/sq +(defbehavior metalkor-bomb-ground-check metalkor-bomb () + (let ((gp-0 (new 'stack-no-clear 'collide-query))) + (let ((s5-0 (new 'stack-no-clear 'bounding-box))) + (let ((a1-0 (new 'stack-no-clear 'sphere))) + (set! (-> a1-0 quad) (-> self root-override trans quad)) + (set! (-> a1-0 r) 204800.0) + (set-from-sphere! s5-0 a1-0) + ) + (set! (-> gp-0 collide-with) (collide-spec player-list special-obstacle)) + (set! (-> gp-0 ignore-process0) #f) + (set! (-> gp-0 ignore-process1) #f) + (set! (-> gp-0 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> gp-0 action-mask) (collide-action solid)) + (mem-copy! (the-as pointer (-> gp-0 bbox)) (the-as pointer s5-0) 32) + ) + (fill-using-bounding-box *collide-cache* gp-0) + (dotimes (s5-1 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (let ((s4-0 (vector<-cspace! + (new 'stack-no-clear 'vector) + (-> self node-list data (-> *metalkor-bomb-probe-joints* s5-1)) + ) + ) + ) + (set! (-> gp-0 start-pos quad) (-> s4-0 quad)) + (set! (-> gp-0 start-pos y) (+ 81920.0 (-> gp-0 start-pos y))) + (set! (-> gp-0 move-dist quad) (-> (new 'static 'vector :y -163840.0) quad)) + (let ((v1-17 gp-0)) + (set! (-> v1-17 radius) 4096.0) + (set! (-> v1-17 collide-with) (collide-spec special-obstacle)) + (set! (-> v1-17 ignore-process0) #f) + (set! (-> v1-17 ignore-process1) #f) + (set! (-> v1-17 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1)) + (set! (-> v1-17 action-mask) (collide-action solid)) + ) + (let ((f0-4 (probe-using-line-sphere *collide-cache* gp-0))) + (cond + ((>= f0-4 0.0) + (let* ((f1-3 (* -163840.0 (+ -0.5 f0-4))) + (f0-8 (- (fmin 139264.0 (fmax 83558.4 (+ (-> s4-0 y) f1-3))) (-> s4-0 y))) + ) + (if (nonzero? (-> self joint-mods s5-1)) + (+! (-> self joint-mods s5-1 trans y) f0-8) + ) + ) + ) + (else + ) + ) + ) + ) + ) + ) + #f + ) + +;; failed to figure out what this is: +(defstate idle (metalkor-bomb) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('touched 'touch) + (let ((a1-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-3 from) (process->ppointer self)) + (set! (-> a1-3 num-params) 2) + (set! (-> a1-3 message) 'attack) + (set! (-> a1-3 param 0) (-> event param 0)) + (let ((v1-6 (new 'static 'attack-info :mask (attack-info-mask mode shove-back shove-up id)))) + (let* ((a2-3 *game-info*) + (a3-2 (+ (-> a2-3 attack-id) 1)) + ) + (set! (-> a2-3 attack-id) a3-2) + (set! (-> v1-6 id) a3-2) + ) + (set! (-> v1-6 mode) 'deadly) + (set! (-> v1-6 shove-back) 0.0) + (set! (-> v1-6 shove-up) 16384.0) + (set! (-> a1-3 param 1) (the-as uint v1-6)) + ) + (send-event-function proc a1-3) + ) + ) + ) + ) + :trans (behavior () + (ja :num! (seek! max 0.25)) + (if (ja-done? 0) + (deactivate self) + ) + (metalkor-bomb-ground-check) + (metalkor-bomb-collide) + (none) + ) + :code (the-as (function none :behavior metalkor-bomb) sleep-code) + :post (the-as (function none :behavior metalkor-bomb) ja-post) + ) + + + + diff --git a/test/decompiler/reference/jak2/levels/nest/boss/metalkor-setup_REF.gc b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-setup_REF.gc new file mode 100644 index 0000000000..8830a82e1d --- /dev/null +++ b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-setup_REF.gc @@ -0,0 +1,2206 @@ +;;-*-Lisp-*- +(in-package goal) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-bomb metalkor-bomb metalkor-bomb-lod0-jg metalkor-bomb-idle-ja + ((metalkor-bomb-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 100) + :sort 4 + ) + +;; failed to figure out what this is: +(defskelgroup skel-rift-occlude rift-occlude rift-occlude-lod0-jg rift-occlude-idle-ja + ((rift-occlude-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 5) + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-distort metalkor-distort metalkor-distort-lod0-jg metalkor-distort-idle-ja + ((metalkor-distort-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 5) + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-explode metalkor-explode metalkor-explode-lod0-jg metalkor-explode-idle-ja + ((metalkor-explode-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-kid kid kid-lod0-jg 19 + ((kid-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 2) + :shadow kid-shadow-mg + :origin-joint-index 13 + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-egg metalkor-egg metalkor-egg-lod0-jg metalkor-egg-tumble-ja + ((metalkor-egg-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 4) + :shadow metalkor-egg-shadow-mg + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor metalkor metalkor-lod0-jg metalkor-idle-ja + ((metalkor-lod0-mg (meters 999999))) + :bounds (static-spherem 0 2 2 8) + :shadow metalkor-shadow-mg + :origin-joint-index 3 + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-spinner metalkor metalkor-spinner-lod0-jg metalkor-spinner-idle-ja + ((metalkor-spinner-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 40) + :origin-joint-index 8 + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-lowtorso metalkor-lowtorso metalkor-lowtorso-lod0-jg metalkor-lowtorso-idle-ja + ((metalkor-lowtorso-lod0-mg (meters 999999))) + :bounds (static-spherem 0 -9 -12 22) + :shadow metalkor-lowtorso-shadow-mg + :origin-joint-index 3 + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-legs metalkor-legs metalkor-legs-lod0-jg metalkor-legs-idle-ja + ((metalkor-legs-lod0-mg (meters 999999))) + :bounds (static-spherem 0 -9 2 15) + :shadow metalkor-legs-shadow-mg + :origin-joint-index 3 + ) + +;; failed to figure out what this is: +(defskelgroup skel-metalkor-wings metalkor-wings metalkor-wings-lod0-jg metalkor-wings-idle-ja + ((metalkor-wings-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 30) + :shadow metalkor-wings-shadow-mg + ) + +;; failed to figure out what this is: +(defskelgroup skel-nestb-tail-bound nestb-tail-bound nestb-tail-bound-lod0-jg nestb-tail-bound-idle-ja + ((nestb-tail-bound-lod0-mg (meters 999999))) + :bounds (static-spherem 0 0 0 100) + ) + +;; definition of type metalkor-bomb +(deftype metalkor-bomb (process-drawable) + ((root-override collide-shape-moving :offset 128) + (joint-mods joint-mod 49 :offset-assert 200) + ) + :heap-base #x110 + :method-count-assert 21 + :size-assert #x18c + :flag-assert #x150110018c + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-bomb +(defmethod inspect metalkor-bomb ((obj metalkor-bomb)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Tjoint-mods[49] @ #x~X~%" (-> obj joint-mods)) + (label cfg-4) + obj + ) + +;; definition of type gem-tracker +(deftype gem-tracker (process) + ((gems handle 10 :offset-assert 128) + (gems-collected int8 :offset-assert 208) + (perm-byte-index int8 :offset-assert 209) + ) + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + (:methods + (idle () _type_ :state 14) + ) + ) + +;; definition for method 3 of type gem-tracker +(defmethod inspect gem-tracker ((obj gem-tracker)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process inspect))) + (t9-0 obj) + ) + (format #t "~2Tgems[10] @ #x~X~%" (-> obj gems)) + (format #t "~2Tgems-collected: ~D~%" (-> obj gems-collected)) + (format #t "~2Tperm-byte-index: ~D~%" (-> obj perm-byte-index)) + (label cfg-4) + obj + ) + +;; definition for function gem-tracker-get-slot +(defbehavior gem-tracker-get-slot gem-tracker ((arg0 process)) + (cond + (arg0 + (dotimes (v1-0 10) + (if (= (handle->process (-> self gems v1-0)) arg0) + (return v1-0) + ) + ) + -1 + ) + (else + (let ((v1-3 (-> self gems-collected)) + (v0-0 -1) + ) + (dotimes (a0-1 10) + (if (handle->process (-> self gems a0-1)) + (+! v1-3 1) + (set! v0-0 a0-1) + ) + ) + (if (>= v1-3 10) + (return -1) + ) + v0-0 + ) + ) + ) + ) + +;; failed to figure out what this is: +(defstate idle (gem-tracker) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (case event-type + (('spawn-with-gem?) + (!= (gem-tracker-get-slot (the-as process #f)) -1) + ) + (('have-gem?) + (!= (gem-tracker-get-slot proc) -1) + ) + (('change-gem 'flitter-change-gem 'wasp-change-gem) + (let ((v1-3 (gem-tracker-get-slot (the-as process (-> event param 0))))) + (when (!= v1-3 -1) + (let ((gp-1 (-> event param 1))) + (set! (-> self gems v1-3) (process->handle (the-as process gp-1))) + (if (type? gp-1 gem) + (send-event (the-as process-tree gp-1) 'get-notify self) + ) + ) + ) + ) + ) + (('notify) + (case (-> event param 0) + (('pickup) + (+! (-> self gems-collected) 1) + (let ((v1-14 (-> self entity extra perm))) + (logior! (-> v1-14 status) (entity-perm-status bit-5)) + (let ((v0-1 (the-as object (-> self gems-collected)))) + (set! (-> v1-14 user-int8 (-> self perm-byte-index)) (the-as int v0-1)) + v0-1 + ) + ) + ) + ) + ) + ) + ) + :code (the-as (function none :behavior gem-tracker) sleep-code) + ) + +;; definition of type flitter-gem-tracker +(deftype flitter-gem-tracker (gem-tracker) + () + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + ) + +;; definition for method 3 of type flitter-gem-tracker +(defmethod inspect flitter-gem-tracker ((obj flitter-gem-tracker)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type gem-tracker inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type wasp-gem-tracker +(deftype wasp-gem-tracker (gem-tracker) + () + :heap-base #x60 + :method-count-assert 15 + :size-assert #xd2 + :flag-assert #xf006000d2 + ) + +;; definition for method 3 of type wasp-gem-tracker +(defmethod inspect wasp-gem-tracker ((obj wasp-gem-tracker)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type gem-tracker inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type rift-occlude +(deftype rift-occlude (process-drawable) + ((original-trans vector :inline :offset-assert 208) + ) + :heap-base #x60 + :method-count-assert 21 + :size-assert #xe0 + :flag-assert #x15006000e0 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type rift-occlude +(defmethod inspect rift-occlude ((obj rift-occlude)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Toriginal-trans: #~%" (-> obj original-trans)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-distort +(deftype metalkor-distort (process-drawable) + ((root-override collide-shape-moving :offset 128) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-distort +(defmethod inspect metalkor-distort ((obj metalkor-distort)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type metalkor-explode +(deftype metalkor-explode (process-drawable) + ((ring handle :offset-assert 200) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xd0 + :flag-assert #x15005000d0 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-explode +(defmethod inspect metalkor-explode ((obj metalkor-explode)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Tring: ~D~%" (-> obj ring)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-kid +(deftype metalkor-kid (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-kid +(defmethod inspect metalkor-kid ((obj metalkor-kid)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type nestb-tail-bound +(deftype nestb-tail-bound (process-drawable) + () + :heap-base #x50 + :method-count-assert 21 + :size-assert #xc8 + :flag-assert #x15005000c8 + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type nestb-tail-bound +(defmethod inspect nestb-tail-bound ((obj nestb-tail-bound)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type metalkor-ja-float-info +(deftype metalkor-ja-float-info (structure) + ((float-anim art-joint-anim :offset-assert 0) + (channel-index int8 :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +;; definition for method 3 of type metalkor-ja-float-info +(defmethod inspect metalkor-ja-float-info ((obj metalkor-ja-float-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'metalkor-ja-float-info) + (format #t "~1Tfloat-anim: ~A~%" (-> obj float-anim)) + (format #t "~1Tchannel-index: ~D~%" (-> obj channel-index)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-spinner-info +(deftype metalkor-spinner-info (structure) + ((joint-index int8 :offset-assert 0) + (launch-angle float :offset-assert 4) + ) + :pack-me + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; definition for method 3 of type metalkor-spinner-info +(defmethod inspect metalkor-spinner-info ((obj metalkor-spinner-info)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'metalkor-spinner-info) + (format #t "~1Tjoint-index: ~D~%" (-> obj joint-index)) + (format #t "~1Tlaunch-angle: ~f~%" (-> obj launch-angle)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-shot +(deftype metalkor-shot (metalhead-shot) + ((old-transv vector :inline :offset-assert 496) + ) + :heap-base #x180 + :method-count-assert 40 + :size-assert #x200 + :flag-assert #x2801800200 + ) + +;; definition for method 3 of type metalkor-shot +(defmethod inspect metalkor-shot ((obj metalkor-shot)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type metalhead-shot inspect))) + (t9-0 obj) + ) + (format #t "~2Told-transv: #~%" (-> obj old-transv)) + (label cfg-4) + obj + ) + +;; definition for symbol *metalkor-flitter-nav-enemy-info*, type nav-enemy-info +(define *metalkor-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 #f + :hover-if-no-ground #f + :idle-anim-script #f + :idle-anim -1 + :notice-anim -1 + :hostile-anim -1 + :hit-anim -1 + :knocked-anim -1 + :knocked-land-anim -1 + :die-anim -1 + :die-falling-anim -1 + :victory-anim -1 + :jump-wind-up-anim -1 + :jump-in-air-anim -1 + :jump-land-anim -1 + :neck-joint -1 + :notice-distance (meters 30) + :notice-distance-delta (meters 10) + :default-hit-points 1 + :gnd-collide-with (collide-spec backgnd) + :overlaps-others-collide-with-filter (collide-spec jak bot player-list) + :movement-gravity (meters -100) + :friction 0.8 + :attack-shove-back (meters 3) + :attack-shove-up (meters 2) + :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 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 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 1) + :shadow-max-y (meters 1) + :shadow-min-y (meters -1) + :shadow-locus-dist (meters 150) + :gem-joint -1 + :gem-offset (new 'static 'sphere :r 163840.0) + :callback-info #f + :use-momentum #f + :use-frustration #t + :use-stop-chase #f + :use-circling #f + :use-pacing #f + :walk-anim -1 + :turn-anim -1 + :run-anim -1 + :taunt-anim -1 + :run-travel-speed (meters 6) + :run-acceleration (meters 1) + :run-turning-acceleration (meters 2) + :walk-travel-speed (meters 3) + :walk-acceleration (meters 1) + :walk-turning-acceleration (meters 1) + :maximum-rotation-rate (degrees 720.0) + :notice-nav-radius (meters 1) + :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! (-> *metalkor-flitter-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*) + +;; definition of type metalkor-flitter +(deftype metalkor-flitter (flitter) + () + :heap-base #x240 + :method-count-assert 184 + :size-assert #x2b8 + :flag-assert #xb8024002b8 + ) + +;; definition for method 3 of type metalkor-flitter +(defmethod inspect metalkor-flitter ((obj metalkor-flitter)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type flitter inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type metalkor-wasp +(deftype metalkor-wasp (wasp) + () + :heap-base #x310 + :method-count-assert 166 + :size-assert #x388 + :flag-assert #xa603100388 + ) + +;; definition for method 3 of type metalkor-wasp +(defmethod inspect metalkor-wasp ((obj metalkor-wasp)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type wasp inspect))) + (t9-0 obj) + ) + (label cfg-4) + obj + ) + +;; definition of type metalkor-spinner-chain-physics +(deftype metalkor-spinner-chain-physics (chain-physics) + ((gravity-mult float :offset-assert 1392) + (velocity-mult float :offset-assert 1396) + ) + :method-count-assert 18 + :size-assert #x578 + :flag-assert #x1200000578 + ) + +;; definition for method 3 of type metalkor-spinner-chain-physics +(defmethod inspect metalkor-spinner-chain-physics ((obj metalkor-spinner-chain-physics)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tchain-joints[20] @ #x~X~%" (-> obj chain-joints)) + (format #t "~1Tnum-joints: ~D~%" (-> obj num-joints)) + (format #t "~1Troot-joint-index: ~D~%" (-> obj root-joint-index)) + (format #t "~1Tjoint-length: ~f~%" (-> obj joint-length)) + (format #t "~1Tgravity: #~%" (-> obj gravity)) + (format #t "~1Tgravity-target: #~%" (-> obj gravity-target)) + (format #t "~1Tstretch-vel: ~f~%" (-> obj stretch-vel)) + (format #t "~1Tstretch-vel-parallel: ~f~%" (-> obj stretch-vel-parallel)) + (format #t "~1Tcompress-vel: ~f~%" (-> obj compress-vel)) + (format #t "~1Tcompress-vel-parallel: ~f~%" (-> obj compress-vel-parallel)) + (format #t "~1Tnegate-y: ~A~%" (-> obj negate-y)) + (format #t "~1Taxial-slop: ~f~%" (-> obj axial-slop)) + (format #t "~1Tmaximum-stretch: ~f~%" (-> obj maximum-stretch)) + (format #t "~1Tturn-off-start: ~D~%" (-> obj turn-off-start)) + (format #t "~1Tturn-off-duration: ~D~%" (-> obj turn-off-duration)) + (format #t "~1Tgravity-mult: ~f~%" (-> obj gravity-mult)) + (format #t "~1Tvelocity-mult: ~f~%" (-> obj velocity-mult)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-spinner +(deftype metalkor-spinner (process-drawable) + ((parent-joint-index int8 :offset-assert 200) + (target-pos vector :inline :offset-assert 208) + (chain metalkor-spinner-chain-physics :offset-assert 224) + (anim-speed float :offset-assert 228) + ) + :heap-base #x70 + :method-count-assert 23 + :size-assert #xe8 + :flag-assert #x17007000e8 + (:methods + (break-it () _type_ :state 20) + (idle () _type_ :state 21) + (shoot-out () _type_ :state 22) + ) + ) + +;; definition for method 3 of type metalkor-spinner +(defmethod inspect metalkor-spinner ((obj metalkor-spinner)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Tparent-joint-index: ~D~%" (-> obj parent-joint-index)) + (format #t "~2Ttarget-pos: #~%" (-> obj target-pos)) + (format #t "~2Tchain: ~A~%" (-> obj chain)) + (format #t "~2Tanim-speed: ~f~%" (-> obj anim-speed)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-egg +(deftype metalkor-egg (process-focusable) + ((last-hit-normal vector :inline :offset-assert 208) + (sticky-time time-frame :offset-assert 224) + (flitter-slot int8 :offset-assert 232) + ) + :heap-base #x70 + :method-count-assert 31 + :size-assert #xe9 + :flag-assert #x1f007000e9 + (:methods + (egg-pop () _type_ :state 27) + (fall () _type_ :state 28) + (hatch () _type_ :state 29) + (idle () _type_ :state 30) + ) + ) + +;; definition for method 3 of type metalkor-egg +(defmethod inspect metalkor-egg ((obj metalkor-egg)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-focusable inspect))) + (t9-0 obj) + ) + (format #t "~2Tlast-hit-normal: #~%" (-> obj last-hit-normal)) + (format #t "~2Tsticky-time: ~D~%" (-> obj sticky-time)) + (format #t "~2Tflitter-slot: ~D~%" (-> obj flitter-slot)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-wings +(deftype metalkor-wings (process-drawable) + ((prefix string :offset-assert 200) + ) + :heap-base #x50 + :method-count-assert 21 + :size-assert #xcc + :flag-assert #x15005000cc + (:methods + (idle () _type_ :state 20) + ) + ) + +;; definition for method 3 of type metalkor-wings +(defmethod inspect metalkor-wings ((obj metalkor-wings)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-drawable inspect))) + (t9-0 obj) + ) + (format #t "~2Tprefix: ~A~%" (-> obj prefix)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-foot-lock +(deftype metalkor-foot-lock (structure) + ((lock cam-float-seeker :inline :offset-assert 0) + (old-position vector :inline :offset-assert 32) + (initialized symbol :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + ) + +;; definition for method 3 of type metalkor-foot-lock +(defmethod inspect metalkor-foot-lock ((obj metalkor-foot-lock)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'metalkor-foot-lock) + (format #t "~1Tlock: #~%" (-> obj lock)) + (format #t "~1Told-position: #~%" (-> obj old-position)) + (format #t "~1Tinitialized: ~A~%" (-> obj initialized)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-legs +(deftype metalkor-legs (process-focusable) + ((prefix string :offset-assert 204) + (trackable symbol :offset-assert 208) + (joint-ik joint-mod-ik 6 :offset-assert 212) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 236) + (foot-locks metalkor-foot-lock 6 :inline :offset 288) + ) + :heap-base #x220 + :method-count-assert 28 + :size-assert #x2a0 + :flag-assert #x1c022002a0 + (:methods + (idle () _type_ :state 27) + ) + ) + +;; definition for method 3 of type metalkor-legs +(defmethod inspect metalkor-legs ((obj metalkor-legs)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-focusable inspect))) + (t9-0 obj) + ) + (format #t "~2Tprefix: ~A~%" (-> obj prefix)) + (format #t "~2Ttrackable: ~A~%" (-> obj trackable)) + (format #t "~2Tjoint-ik[6] @ #x~X~%" (-> obj joint-ik)) + (format #t "~2Tja-float-info[3] @ #x~X~%" (-> obj ja-float-info)) + (format #t "~2Tfoot-locks[6] @ #x~X~%" (-> obj foot-locks)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-chain-physics +(deftype metalkor-chain-physics (chain-physics) + ((prev-rotation float :offset-assert 1392) + (prev-y-rotation float :offset-assert 1396) + (osc-z oscillating-float :inline :offset-assert 1400) + (osc-y oscillating-float :inline :offset-assert 1424) + (rand-z delayed-rand-float :inline :offset-assert 1448) + (rand-y delayed-rand-float :inline :offset-assert 1480) + (move-with-parent symbol :offset-assert 1508) + ) + :method-count-assert 18 + :size-assert #x5e8 + :flag-assert #x12000005e8 + ) + +;; definition for method 3 of type metalkor-chain-physics +(defmethod inspect metalkor-chain-physics ((obj metalkor-chain-physics)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tchain-joints[20] @ #x~X~%" (-> obj chain-joints)) + (format #t "~1Tnum-joints: ~D~%" (-> obj num-joints)) + (format #t "~1Troot-joint-index: ~D~%" (-> obj root-joint-index)) + (format #t "~1Tjoint-length: ~f~%" (-> obj joint-length)) + (format #t "~1Tgravity: #~%" (-> obj gravity)) + (format #t "~1Tgravity-target: #~%" (-> obj gravity-target)) + (format #t "~1Tstretch-vel: ~f~%" (-> obj stretch-vel)) + (format #t "~1Tstretch-vel-parallel: ~f~%" (-> obj stretch-vel-parallel)) + (format #t "~1Tcompress-vel: ~f~%" (-> obj compress-vel)) + (format #t "~1Tcompress-vel-parallel: ~f~%" (-> obj compress-vel-parallel)) + (format #t "~1Tnegate-y: ~A~%" (-> obj negate-y)) + (format #t "~1Taxial-slop: ~f~%" (-> obj axial-slop)) + (format #t "~1Tmaximum-stretch: ~f~%" (-> obj maximum-stretch)) + (format #t "~1Tturn-off-start: ~D~%" (-> obj turn-off-start)) + (format #t "~1Tturn-off-duration: ~D~%" (-> obj turn-off-duration)) + (format #t "~1Tprev-rotation: ~f~%" (-> obj prev-rotation)) + (format #t "~1Tprev-y-rotation: ~f~%" (-> obj prev-y-rotation)) + (format #t "~1Tosc-z: #~%" (-> obj osc-z)) + (format #t "~1Tosc-y: #~%" (-> obj osc-y)) + (format #t "~1Trand-z: #~%" (-> obj rand-z)) + (format #t "~1Trand-y: #~%" (-> obj rand-y)) + (format #t "~1Tmove-with-parent: ~A~%" (-> obj move-with-parent)) + (label cfg-4) + obj + ) + +;; definition of type metalkor-lowtorso +(deftype metalkor-lowtorso (process-focusable) + ((prefix string :offset-assert 204) + (tail metalkor-chain-physics :offset-assert 208) + (tail-initialized symbol :offset-assert 212) + (spinners handle 4 :offset-assert 216) + (ja-float-info metalkor-ja-float-info 3 :inline :offset-assert 248) + (no-collision-timer time-frame :offset 296) + (egg-toss-joint-1 joint-mod :offset-assert 304) + (egg-toss-joint-2 joint-mod :offset-assert 308) + (egg-toss-joint-3 joint-mod :offset-assert 312) + (egg-toss-joint-angle oscillating-float :inline :offset-assert 316) + ) + :heap-base #xe0 + :method-count-assert 28 + :size-assert #x154 + :flag-assert #x1c00e00154 + (:methods + (idle () _type_ :state 27) + ) + ) + +;; definition for method 3 of type metalkor-lowtorso +(defmethod inspect metalkor-lowtorso ((obj metalkor-lowtorso)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-focusable inspect))) + (t9-0 obj) + ) + (format #t "~2Tprefix: ~A~%" (-> obj prefix)) + (format #t "~2Ttail: ~A~%" (-> obj tail)) + (format #t "~2Ttail-initialized: ~A~%" (-> obj tail-initialized)) + (format #t "~2Tspinners[4] @ #x~X~%" (-> obj spinners)) + (format #t "~2Tja-float-info[3] @ #x~X~%" (-> obj ja-float-info)) + (format #t "~2Tno-collision-timer: ~D~%" (-> obj no-collision-timer)) + (format #t "~2Tegg-toss-joint-1: ~A~%" (-> obj egg-toss-joint-1)) + (format #t "~2Tegg-toss-joint-2: ~A~%" (-> obj egg-toss-joint-2)) + (format #t "~2Tegg-toss-joint-3: ~A~%" (-> obj egg-toss-joint-3)) + (format #t "~2Tegg-toss-joint-angle: #~%" (-> obj egg-toss-joint-angle)) + (label cfg-4) + obj + ) + +;; definition of type metalkor +(deftype metalkor (process-focusable) + ((trackable symbol :offset-assert 204) + (flitters handle 10 :offset-assert 208) + (flitter-gem-tracker handle :offset-assert 288) + (wasps handle 3 :offset-assert 296) + (wasp-gem-tracker handle :offset-assert 320) + (last-flitter-launched int8 :offset-assert 328) + (last-wasp-launched int8 :offset-assert 329) + (live-flitters int8 :offset-assert 330) + (live-wasps int8 :offset-assert 331) + (shoot-timer time-frame :offset-assert 336) + (target-angle float :offset-assert 344) + (wave-timer time-frame :offset-assert 352) + (in-wave symbol :offset-assert 360) + (flitter-timer time-frame :offset-assert 368) + (wasp-timer time-frame :offset-assert 376) + (launching-flitters symbol :offset-assert 384) + (launching-wasps symbol :offset-assert 388) + (egg-timer time-frame :offset-assert 392) + (last-close-attack int8 :offset-assert 400) + (last-standing-attack int8 :offset-assert 401) + (stage int8 :offset-assert 402) + (next-stage-timer time-frame :offset-assert 408) + (initial-y float :offset-assert 416) + (shots-fired int16 :offset-assert 420) + (stage-hit-points float :offset-assert 424) + (hud handle :offset-assert 432) + (lowtorso handle :offset-assert 440) + (legs handle :offset-assert 448) + (wings handle :offset-assert 456) + (kid handle :offset-assert 464) + (explode handle :offset-assert 472) + (rift-occlude handle :offset-assert 480) + (last-attack-id uint32 :offset-assert 488) + (current-nav-poly nav-poly :offset-assert 492) + (shot-anticipate sparticle-launch-control :offset-assert 496) + (spinners handle 4 :offset-assert 504) + (neck joint-mod :offset-assert 536) + (previous-flat-travel vector :inline :offset-assert 544) + (previous-flat-travel-timer time-frame :offset-assert 560) + (previous-flat-travel-long-timer time-frame :offset-assert 568) + (min-state-hit-points float :offset-assert 576) + (countdown-to-roar int8 :offset-assert 580) + (for-back-interp cam-float-seeker :inline :offset-assert 584) + (run-walk-interp cam-float-seeker :inline :offset-assert 608) + (left-right-interp cam-float-seeker :inline :offset-assert 632) + (walk-turn-interp cam-float-seeker :inline :offset-assert 656) + (idle-interp cam-float-seeker :inline :offset-assert 680) + (tmp-hit-points float :offset-assert 704) + (reps-till-idle-alt int8 :offset-assert 708) + (last-rotation float :offset-assert 712) + (no-collision-timer time-frame :offset-assert 720) + (egg-angle float :offset 736) + (arm-frame float :offset-assert 740) + (been-to-entity symbol :offset-assert 744) + (flying-speed cam-float-seeker :inline :offset-assert 748) + (wing-sound sound-id :offset-assert 772) + (wing-sound-playing symbol :offset-assert 776) + (explode-sound sound-id :offset-assert 780) + (bomb-sound sound-id :offset-assert 784) + (stop-bomb-sound symbol :offset-assert 788) + (hit-ring-trans vector :inline :offset-assert 800) + (hit-ring-offset vector :inline :offset-assert 816) + (ring-cam-pos cam-float-seeker :inline :offset-assert 832) + (need-teleport symbol :offset-assert 856) + ) + :heap-base #x2e0 + :method-count-assert 43 + :size-assert #x35c + :flag-assert #x2b02e0035c + (:methods + (beaten (symbol) _type_ :state 27) + (explode () _type_ :state 28) + (fly-to-ring () _type_ :state 29) + (last-gasp () _type_ :state 30) + (overload-recover () _type_ :state 31) + (fall-down () _type_ :state 32) + (tail-attack () _type_ :state 33) + (foot-attack () _type_ :state 34) + (get-close () _type_ :state 35) + (standing-shot () _type_ :state 36) + (chase-target () _type_ :state 37) + (play-drop-movie () _type_ :state 38) + (start-second-stage () _type_ :state 39) + (hang-shoot-n-launch () _type_ :state 40) + (hidden () _type_ :state 41) + (test () _type_ :state 42) + ) + ) + +;; definition for method 3 of type metalkor +(defmethod inspect metalkor ((obj metalkor)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (let ((t9-0 (method-of-type process-focusable inspect))) + (t9-0 obj) + ) + (format #t "~2Ttrackable: ~A~%" (-> obj trackable)) + (format #t "~2Tflitters[10] @ #x~X~%" (-> obj flitters)) + (format #t "~2Tflitter-gem-tracker: ~D~%" (-> obj flitter-gem-tracker)) + (format #t "~2Twasps[3] @ #x~X~%" (-> obj wasps)) + (format #t "~2Twasp-gem-tracker: ~D~%" (-> obj wasp-gem-tracker)) + (format #t "~2Tlast-flitter-launched: ~D~%" (-> obj last-flitter-launched)) + (format #t "~2Tlast-wasp-launched: ~D~%" (-> obj last-wasp-launched)) + (format #t "~2Tlive-flitters: ~D~%" (-> obj live-flitters)) + (format #t "~2Tlive-wasps: ~D~%" (-> obj live-wasps)) + (format #t "~2Tshoot-timer: ~D~%" (-> obj shoot-timer)) + (format #t "~2Ttarget-angle: ~f~%" (-> obj target-angle)) + (format #t "~2Twave-timer: ~D~%" (-> obj wave-timer)) + (format #t "~2Tin-wave: ~A~%" (-> obj in-wave)) + (format #t "~2Tflitter-timer: ~D~%" (-> obj flitter-timer)) + (format #t "~2Twasp-timer: ~D~%" (-> obj wasp-timer)) + (format #t "~2Tlaunching-flitters: ~A~%" (-> obj launching-flitters)) + (format #t "~2Tlaunching-wasps: ~A~%" (-> obj launching-wasps)) + (format #t "~2Tegg-timer: ~D~%" (-> obj egg-timer)) + (format #t "~2Tlast-close-attack: ~D~%" (-> obj last-close-attack)) + (format #t "~2Tlast-standing-attack: ~D~%" (-> obj last-standing-attack)) + (format #t "~2Tstage: ~D~%" (-> obj stage)) + (format #t "~2Tnext-stage-timer: ~D~%" (-> obj next-stage-timer)) + (format #t "~2Tinitial-y: ~f~%" (-> obj initial-y)) + (format #t "~2Tshots-fired: ~D~%" (-> obj shots-fired)) + (format #t "~2Tstage-hit-points: ~f~%" (-> obj stage-hit-points)) + (format #t "~2Thud: ~D~%" (-> obj hud)) + (format #t "~2Tlowtorso: ~D~%" (-> obj lowtorso)) + (format #t "~2Tlegs: ~D~%" (-> obj legs)) + (format #t "~2Twings: ~D~%" (-> obj wings)) + (format #t "~2Tkid: ~D~%" (-> obj kid)) + (format #t "~2Texplode: ~D~%" (-> obj explode)) + (format #t "~2Trift-occlude: ~D~%" (-> obj rift-occlude)) + (format #t "~2Tlast-attack-id: ~D~%" (-> obj last-attack-id)) + (format #t "~2Tcurrent-nav-poly: #~%" (-> obj current-nav-poly)) + (format #t "~2Tshot-anticipate: ~A~%" (-> obj shot-anticipate)) + (format #t "~2Tspinners[4] @ #x~X~%" (-> obj spinners)) + (format #t "~2Tneck: ~A~%" (-> obj neck)) + (format #t "~2Tprevious-flat-travel: #~%" (-> obj previous-flat-travel)) + (format #t "~2Tprevious-flat-travel-timer: ~D~%" (-> obj previous-flat-travel-timer)) + (format #t "~2Tprevious-flat-travel-long-timer: ~D~%" (-> obj previous-flat-travel-long-timer)) + (format #t "~2Tmin-state-hit-points: ~f~%" (-> obj min-state-hit-points)) + (format #t "~2Tcountdown-to-roar: ~D~%" (-> obj countdown-to-roar)) + (format #t "~2Tfor-back-interp: #~%" (-> obj for-back-interp)) + (format #t "~2Trun-walk-interp: #~%" (-> obj run-walk-interp)) + (format #t "~2Tleft-right-interp: #~%" (-> obj left-right-interp)) + (format #t "~2Twalk-turn-interp: #~%" (-> obj walk-turn-interp)) + (format #t "~2Tidle-interp: #~%" (-> obj idle-interp)) + (format #t "~2Ttmp-hit-points: ~f~%" (-> obj tmp-hit-points)) + (format #t "~2Treps-till-idle-alt: ~D~%" (-> obj reps-till-idle-alt)) + (format #t "~2Tlast-rotation: ~f~%" (-> obj last-rotation)) + (format #t "~2Tno-collision-timer: ~D~%" (-> obj no-collision-timer)) + (format #t "~2Tegg-timer: ~D~%" (-> obj egg-timer)) + (format #t "~2Tegg-angle: ~f~%" (-> obj egg-angle)) + (format #t "~2Tarm-frame: ~f~%" (-> obj arm-frame)) + (format #t "~2Tbeen-to-entity: ~A~%" (-> obj been-to-entity)) + (format #t "~2Tflying-speed: #~%" (-> obj flying-speed)) + (format #t "~2Twing-sound: ~D~%" (-> obj wing-sound)) + (format #t "~2Twing-sound-playing: ~A~%" (-> obj wing-sound-playing)) + (format #t "~2Texplode-sound: ~D~%" (-> obj explode-sound)) + (format #t "~2Tbomb-sound: ~D~%" (-> obj bomb-sound)) + (format #t "~2Tstop-bomb-sound: ~A~%" (-> obj stop-bomb-sound)) + (format #t "~2Thit-ring-trans: #~%" (-> obj hit-ring-trans)) + (format #t "~2Thit-ring-offset: #~%" (-> obj hit-ring-offset)) + (format #t "~2Tring-cam-pos: #~%" (-> obj ring-cam-pos)) + (format #t "~2Tneed-teleport: ~A~%" (-> obj need-teleport)) + (label cfg-4) + obj + ) + +;; definition for symbol *metalkor-bomb-probe-joints*, type (array int8) +(define *metalkor-bomb-probe-joints* (new 'static 'boxed-array :type int8 + 3 + 4 + #x7 + #xa + #xd + #x10 + #x13 + #x16 + #x19 + #x1c + #x1f + #x22 + #x25 + #x28 + #x2b + #x2e + #x31 + #x34 + #x37 + #x3a + #x3d + #x40 + #x43 + #x46 + #x49 + #x4c + #x4f + #x52 + #x55 + #x58 + #x5b + ) + ) + +;; definition for function metalkor-bomb-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-bomb-init-by-other metalkor-bomb ((arg0 vector) (arg1 entity-actor)) + (process-entity-set! self arg1) + (let ((s5-0 (new 'process 'collide-shape-moving self (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 ((v1-6 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0)))) + (set! (-> v1-6 prim-core collide-as) (collide-spec projectile)) + (set! (-> v1-6 prim-core collide-with) + (collide-spec jak crate enemy obstacle hit-by-others-list player-list pusher) + ) + (set! (-> v1-6 prim-core action) (collide-action)) + (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0) + (set! (-> s5-0 total-prims) (the-as uint 1)) + (set! (-> s5-0 root-prim) v1-6) + ) + (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w))) + (let ((v1-9 (-> s5-0 root-prim))) + (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as)) + (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with)) + ) + (set! (-> s5-0 event-self) 'touched) + (set! (-> self root-override) s5-0) + ) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (quaternion-identity! (-> self root-override quat)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-bomb" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> self draw level-index) (the-as uint (-> *level* default-level index))) + (dotimes (gp-2 (min 49 (-> *metalkor-bomb-probe-joints* length))) + (set! (-> self joint-mods gp-2) + (new 'process 'joint-mod (joint-mod-mode joint-set*) self (-> *metalkor-bomb-probe-joints* gp-2)) + ) + (if (nonzero? (-> self joint-mods gp-2)) + (set! (-> self joint-mods gp-2 track-mode) (track-mode no-rotate no-scale)) + ) + ) + (go-virtual idle) + (none) + ) + +;; definition for method 11 of type nestb-tail-bound +;; WARN: Return type mismatch object vs none. +(defmethod init-from-entity! nestb-tail-bound ((obj nestb-tail-bound) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (let ((s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-others)))) + (let ((v1-2 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-2 prim-core collide-as) (collide-spec special-obstacle)) + (set! (-> v1-2 prim-core action) (collide-action solid)) + (set! (-> v1-2 transform-index) 3) + (set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 409600.0) + (set! (-> s4-0 total-prims) (the-as uint 1)) + (set! (-> s4-0 root-prim) v1-2) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-5 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-5 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-5 prim-core collide-with)) + ) + (set! (-> obj root) s4-0) + ) + (process-drawable-from-entity! obj arg0) + (set! (-> obj root trans y) (+ -36864.0 (-> obj root trans y))) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-nestb-tail-bound" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (transform-post) + (logior! (-> obj draw status) (draw-control-status no-draw-bounds)) + (go (method-of-object obj idle)) + (none) + ) + +;; definition for function gem-tracker-init-by-other +;; WARN: Return type mismatch object vs none. +(defbehavior gem-tracker-init-by-other gem-tracker ((arg0 entity-actor) (arg1 int)) + (set! (-> self entity) arg0) + (dotimes (v1-0 10) + (set! (-> self gems v1-0) (the-as handle #f)) + ) + (set! (-> self perm-byte-index) arg1) + (let ((v1-5 (-> self entity extra perm))) + (logior! (-> v1-5 status) (entity-perm-status bit-5)) + (set! (-> self gems-collected) (the-as int (-> v1-5 user-uint8 (-> self perm-byte-index)))) + ) + (go-virtual idle) + (none) + ) + +;; definition for function rift-occlude-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior rift-occlude-init-by-other rift-occlude ((arg0 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (process-drawable-from-entity! self (the-as entity-actor arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-rift-occlude" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (logclear! (-> self mask) (process-mask enemy)) + (set! (-> self original-trans quad) (-> self root trans quad)) + (let ((v1-7 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (go-virtual idle) + (none) + ) + +;; definition for function metalkor-distort-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-distort-init-by-other metalkor-distort ((arg0 vector) (arg1 quaternion)) + (set! (-> self root-override) (the-as collide-shape-moving (new 'process 'trsqv))) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (quaternion-copy! (-> self root-override quat) arg1) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-distort" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (go-virtual idle) + (none) + ) + +;; definition for function metalkor-explode-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-explode-init-by-other metalkor-explode ((arg0 vector) (arg1 quaternion) (arg2 handle)) + (set! (-> self root) (new 'process 'trsqv)) + (quaternion-copy! (-> self root quat) arg1) + (set! (-> self root trans quad) (-> arg0 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-explode" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-7 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-7 + (the-as process-drawable (-> v1-7 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self ring) arg2) + (set! (-> self part) (create-launch-control (-> *part-group-id-table* 1237) self)) + (go-virtual idle) + (none) + ) + +;; definition for function metalkor-kid-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-kid-init-by-other metalkor-kid ((arg0 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (set! (-> self root trans y) (+ 61440.0 (-> self root trans y))) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-kid" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-9 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-9 + (the-as process-drawable (-> v1-9 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self part) (create-launch-control (-> *part-group-id-table* 1233) self)) + (go-virtual idle) + (none) + ) + +;; definition for symbol *metalkor-spinner-chain-setup*, type (array chain-physics-setup) +(define *metalkor-spinner-chain-setup* (new 'static 'boxed-array :type chain-physics-setup + (new 'static 'chain-physics-setup :joint-index 4) + (new 'static 'chain-physics-setup :joint-index 5) + (new 'static 'chain-physics-setup :joint-index 6) + (new 'static 'chain-physics-setup :joint-index 7) + (new 'static 'chain-physics-setup :joint-index 8) + (new 'static 'chain-physics-setup :joint-index 9) + (new 'static 'chain-physics-setup :joint-index 10) + (new 'static 'chain-physics-setup :joint-index 11) + (new 'static 'chain-physics-setup :joint-index 12) + ) + ) + +;; definition for function metalkor-spinner-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-spinner-init-by-other metalkor-spinner ((arg0 vector) (arg1 int)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root trans quad) (-> arg0 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-spinner" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-6 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-6 + (the-as process-drawable (-> v1-6 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self parent-joint-index) arg1) + (set! (-> self target-pos quad) (-> arg0 quad)) + (set! (-> self chain) (new 'process 'metalkor-spinner-chain-physics)) + (chain-physics-initialize self (-> self chain) 3 4096.0 *metalkor-spinner-chain-setup*) + (let* ((f30-0 4096.0) + (f28-0 0.4) + (f26-0 0.2) + (v1-18 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-19 (the-as number (logior #x3f800000 v1-18))) + ) + (set! (-> self chain gravity-mult) (* f30-0 (+ f28-0 (* f26-0 (+ -1.0 (the-as float v1-19)))))) + ) + (let* ((f30-1 0.8) + (f28-1 0.19) + (v1-25 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-26 (the-as number (logior #x3f800000 v1-25))) + ) + (set! (-> self chain velocity-mult) (+ f30-1 (* f28-1 (+ -1.0 (the-as float v1-26))))) + ) + (set! (-> self event-hook) (-> (method-of-object self shoot-out) event)) + (go-virtual shoot-out) + (none) + ) + +;; definition for function metalkor-egg-reaction +;; INFO: Used lq/sq +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 32 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 48 mismatch: defined as size 4, got size 16 +;; ERROR: Stack slot load at 64 mismatch: defined as size 4, got size 16 +;; ERROR: Unsupported inline assembly instruction kind - [mula.s f1, f4] +;; ERROR: Unsupported inline assembly instruction kind - [madda.s f2, f5] +;; ERROR: Unsupported inline assembly instruction kind - [madd.s f1, f3, f6] +(defbehavior metalkor-egg-reaction metalkor-egg ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector)) + (local-vars (v1-11 float) (f1-1 float) (sv-16 vector) (sv-32 float) (sv-48 float) (sv-64 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (set! sv-16 arg3) + (cshape-reaction-update-state arg0 arg1 sv-16) + (let ((s5-0 (-> arg0 process))) + (cond + ((>= (- (-> self clock frame-counter) (-> (the-as metalkor-egg s5-0) sticky-time)) (seconds 0.05)) + (let ((t9-1 vector--float*!) + (a0-3 arg2) + (a1-1 sv-16) + (a2-2 (-> arg0 surface-normal)) + (f0-0 1.01) + ) + (let* ((v1-4 (-> arg0 surface-normal)) + (f1-0 (-> sv-16 x)) + (f2-0 (-> sv-16 y)) + (f3-0 (-> sv-16 z)) + (f4-0 (-> v1-4 x)) + (f5-0 (-> v1-4 y)) + (f6-0 (-> v1-4 z)) + ) + (.mula.s f1-0 f4-0) + (.madda.s f2-0 f5-0) + (.madd.s f1-1 f3-0 f6-0) + ) + (t9-1 a0-3 a1-1 a2-2 (* f0-0 f1-1)) + ) + (let ((s3-0 arg2) + (s2-0 arg2) + (s1-0 lerp-scale) + (s0-0 0.94) + ) + (set! sv-32 (the-as float 1.0)) + (set! sv-48 (-> arg0 surface-normal y)) + (set! sv-64 (cos 5461.3335)) + (let ((t0-0 (cos 16384.0))) + (vector-float*! s3-0 s2-0 (s1-0 s0-0 sv-32 sv-48 sv-64 t0-0)) + ) + ) + ) + (else + (vector--float*! + arg2 + sv-16 + (-> arg0 surface-normal) + (* (vector-dot sv-16 (-> arg0 surface-normal)) (rand-vu-float-range 1.2 1.4)) + ) + ) + ) + (.lvf vf1 (&-> arg2 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-11 vf1) + (let ((f0-10 v1-11) + (f1-3 409.6) + ) + (cond + ((< f0-10 (* f1-3 f1-3)) + (set! (-> arg2 quad) (the-as uint128 0)) + 0 + ) + ((let ((f1-6 4096.0)) + (and (< (* f1-6 f1-6) f0-10) + (>= (- (-> self clock frame-counter) (-> (the-as metalkor-egg s5-0) sticky-time)) (seconds 0.2)) + ) + ) + (vector-float*! arg2 arg2 (/ 4096.0 (sqrtf f0-10))) + ) + ) + ) + (if (< (-> arg0 surface-normal y) 1.0) + (set! (-> (the-as metalkor-egg s5-0) last-hit-normal quad) (-> arg0 surface-normal quad)) + ) + ) + (-> arg0 status) + ) + ) + +;; definition for function metalkor-egg-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-egg-init-by-other metalkor-egg ((arg0 vector) (arg1 vector) (arg2 int)) + (let ((s3-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s3-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s3-0 reaction) metalkor-egg-reaction) + (set! (-> s3-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((v1-6 (new 'process 'collide-shape-prim-sphere s3-0 (the-as uint 0)))) + (set! (-> v1-6 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-6 prim-core collide-with) (collide-spec backgnd jak bot hit-by-others-list player-list)) + (set! (-> v1-6 prim-core action) (collide-action solid)) + (set! (-> v1-6 transform-index) 3) + (set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 4096.0) + (set! (-> s3-0 total-prims) (the-as uint 1)) + (set! (-> s3-0 root-prim) v1-6) + ) + (set! (-> s3-0 nav-radius) (* 0.75 (-> s3-0 root-prim local-sphere w))) + (let ((v1-9 (-> s3-0 root-prim))) + (set! (-> s3-0 backup-collide-as) (-> v1-9 prim-core collide-as)) + (set! (-> s3-0 backup-collide-with) (-> v1-9 prim-core collide-with)) + ) + (set! (-> s3-0 event-self) 'touched) + (set! (-> s3-0 max-iteration-count) (the-as uint 3)) + (set! (-> self root-override) s3-0) + ) + (set! (-> self root-override trans quad) (-> arg0 quad)) + (set! (-> self root-override transv quad) (-> arg1 quad)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-egg" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-20 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-20 + (the-as process-drawable (-> v1-20 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (logclear! (-> self mask) (process-mask actor-pause)) + (set! (-> self mask) (logior (process-mask enemy) (-> self mask))) + (set-vector! (-> self last-hit-normal) 0.0 1.0 0.0 1.0) + (set! (-> self sticky-time) 0) + (set! (-> self flitter-slot) arg2) + (go-virtual fall) + (none) + ) + +;; definition for function metalkor-wings-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-wings-init-by-other metalkor-wings ((arg0 vector) (arg1 vector)) + (set! (-> self root) (new 'process 'trsqv)) + (set! (-> self root pause-adjust-distance) 409600.0) + (set! (-> self root trans quad) (-> arg1 quad)) + (set! (-> self prefix) (the-as string arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-wings" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-8 (-> self parent))) + (set! (-> self draw light-index) (-> (the-as process-drawable (if v1-8 + (the-as process-drawable (-> v1-8 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (go-virtual idle) + (none) + ) + +;; definition of type metalkor-ik-setup +(deftype metalkor-ik-setup (structure) + ((elbow-index int32 :offset-assert 0) + (hand-dist float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +;; definition for method 3 of type metalkor-ik-setup +(defmethod inspect metalkor-ik-setup ((obj metalkor-ik-setup)) + (when (not obj) + (set! obj obj) + (goto cfg-4) + ) + (format #t "[~8x] ~A~%" obj 'metalkor-ik-setup) + (format #t "~1Telbow-index: ~D~%" (-> obj elbow-index)) + (format #t "~1Thand-dist: ~f~%" (-> obj hand-dist)) + (label cfg-4) + obj + ) + +;; definition for symbol *metalkor-ik-setup*, type (array metalkor-ik-setup) +(define *metalkor-ik-setup* (new 'static 'boxed-array :type metalkor-ik-setup + (new 'static 'metalkor-ik-setup :elbow-index 7 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 12 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 17 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 22 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 27 :hand-dist 28041.217) + (new 'static 'metalkor-ik-setup :elbow-index 32 :hand-dist 28041.217) + ) + ) + +;; definition for function metalkor-legs-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-legs-init-by-other metalkor-legs ((arg0 string) (arg1 vector)) + (let ((s4-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 18) 0))) + (set! (-> s4-0 total-prims) (the-as uint 19)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 3) + (set-vector! (-> s3-0 local-sphere) 0.0 -32768.0 0.0 49152.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 6) + (set-vector! (-> v1-13 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 7) + (set-vector! (-> v1-15 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 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 hit-by-others-list player-list)) + (set! (-> v1-17 prim-core action) (collide-action solid)) + (set! (-> v1-17 transform-index) 8) + (set-vector! (-> v1-17 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (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 hit-by-others-list player-list)) + (set! (-> v1-19 prim-core action) (collide-action solid)) + (set! (-> v1-19 transform-index) 11) + (set-vector! (-> v1-19 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (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 hit-by-others-list player-list)) + (set! (-> v1-21 prim-core action) (collide-action solid)) + (set! (-> v1-21 transform-index) 12) + (set-vector! (-> v1-21 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (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 hit-by-others-list player-list)) + (set! (-> v1-23 prim-core action) (collide-action solid)) + (set! (-> v1-23 transform-index) 13) + (set-vector! (-> v1-23 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (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 hit-by-others-list player-list)) + (set! (-> v1-25 prim-core action) (collide-action solid)) + (set! (-> v1-25 transform-index) 16) + (set-vector! (-> v1-25 local-sphere) 0.0 6144.0 0.0 12288.0) + ) + (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0)))) + (set! (-> v1-27 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-27 prim-core action) (collide-action solid)) + (set! (-> v1-27 transform-index) 17) + (set-vector! (-> v1-27 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0)))) + (set! (-> v1-29 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-29 prim-core action) (collide-action solid)) + (set! (-> v1-29 transform-index) 18) + (set-vector! (-> v1-29 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 11) (the-as uint 0)))) + (set! (-> v1-31 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-31 prim-core action) (collide-action solid)) + (set! (-> v1-31 transform-index) 21) + (set-vector! (-> v1-31 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-33 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 10) (the-as uint 0)))) + (set! (-> v1-33 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-33 prim-core action) (collide-action solid)) + (set! (-> v1-33 transform-index) 22) + (set-vector! (-> v1-33 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-35 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 0)))) + (set! (-> v1-35 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-35 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-35 prim-core action) (collide-action solid)) + (set! (-> v1-35 transform-index) 23) + (set-vector! (-> v1-35 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-37 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 14) (the-as uint 0)))) + (set! (-> v1-37 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-37 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-37 prim-core action) (collide-action solid)) + (set! (-> v1-37 transform-index) 26) + (set-vector! (-> v1-37 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-39 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 13) (the-as uint 0)))) + (set! (-> v1-39 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-39 prim-core action) (collide-action solid)) + (set! (-> v1-39 transform-index) 27) + (set-vector! (-> v1-39 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-41 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 12) (the-as uint 0)))) + (set! (-> v1-41 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-41 prim-core action) (collide-action solid)) + (set! (-> v1-41 transform-index) 28) + (set-vector! (-> v1-41 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (let ((v1-43 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 17) (the-as uint 0)))) + (set! (-> v1-43 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-43 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-43 prim-core action) (collide-action solid)) + (set! (-> v1-43 transform-index) 31) + (set-vector! (-> v1-43 local-sphere) 0.0 -6144.0 0.0 12288.0) + ) + (let ((v1-45 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 16) (the-as uint 0)))) + (set! (-> v1-45 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-45 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-45 prim-core action) (collide-action solid)) + (set! (-> v1-45 transform-index) 32) + (set-vector! (-> v1-45 local-sphere) -4096.0 8192.0 0.0 13312.0) + ) + (let ((v1-47 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 15) (the-as uint 0)))) + (set! (-> v1-47 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-47 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-47 prim-core action) (collide-action solid)) + (set! (-> v1-47 transform-index) 33) + (set-vector! (-> v1-47 local-sphere) 0.0 4096.0 0.0 8192.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-50 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-50 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-50 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> self root-override) s4-0) + ) + (set! (-> self root-override pause-adjust-distance) 409600.0) + (set! (-> self root-override trans quad) (-> arg1 quad)) + (set! (-> self prefix) arg0) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-legs" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-60 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-60 + (the-as process-drawable (-> v1-60 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self mask) (logior (process-mask enemy) (-> self mask))) + (set! (-> self trackable) #f) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (dotimes (gp-2 6) + (set! (-> self joint-ik gp-2) (new + 'process + 'joint-mod-ik + self + (-> *metalkor-ik-setup* gp-2 elbow-index) + (-> *metalkor-ik-setup* gp-2 hand-dist) + ) + ) + (set! (-> self joint-ik gp-2 elbow-pole-vector-axis) (the-as uint 0)) + (set! (-> self joint-ik gp-2 elbow-rotation-axis) (the-as uint 2)) + ) + (logior! (-> self joint-ik 0 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 1 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 2 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 3 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 4 flags) (joint-mod-ik-flags elbow-rot-neg)) + (logior! (-> self joint-ik 5 flags) (joint-mod-ik-flags elbow-rot-neg)) + (dotimes (v1-102 3) + (set! (-> (the-as metalkor-legs (+ (the-as uint self) (* v1-102 16))) ja-float-info 0 float-anim) #f) + ) + (go-virtual idle) + (none) + ) + +;; definition for symbol *metalkor-lowtorso-chain-setup*, type (array chain-physics-setup) +(define *metalkor-lowtorso-chain-setup* (new 'static 'boxed-array :type chain-physics-setup + (new 'static 'chain-physics-setup :joint-index 8) + (new 'static 'chain-physics-setup :joint-index 9) + (new 'static 'chain-physics-setup :joint-index 10) + (new 'static 'chain-physics-setup :joint-index 11) + (new 'static 'chain-physics-setup :joint-index 12) + (new 'static 'chain-physics-setup :joint-index 13) + (new 'static 'chain-physics-setup :joint-index 14) + (new 'static 'chain-physics-setup :joint-index 15) + (new 'static 'chain-physics-setup :joint-index 16) + (new 'static 'chain-physics-setup :joint-index 17) + (new 'static 'chain-physics-setup :joint-index 18) + (new 'static 'chain-physics-setup :joint-index 19) + (new 'static 'chain-physics-setup :joint-index 20) + (new 'static 'chain-physics-setup :joint-index 21) + (new 'static 'chain-physics-setup :joint-index 22) + (new 'static 'chain-physics-setup :joint-index 23) + (new 'static 'chain-physics-setup :joint-index 24) + (new 'static 'chain-physics-setup :joint-index 25) + (new 'static 'chain-physics-setup :joint-index 26) + (new 'static 'chain-physics-setup :joint-index 27) + ) + ) + +;; definition for function metalkor-lowtorso-init-by-other +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-lowtorso-init-by-other metalkor-lowtorso ((arg0 vector) (arg1 vector)) + (let ((s4-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 21) 0))) + (set! (-> s4-0 total-prims) (the-as uint 22)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 14) + (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 65536.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 19) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 8) + (set-vector! (-> v1-13 local-sphere) 0.0 8192.0 0.0 20480.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 18) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 9) + (set-vector! (-> v1-15 local-sphere) 0.0 0.0 0.0 17408.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 17) (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 hit-by-others-list player-list)) + (set! (-> v1-17 prim-core action) (collide-action solid)) + (set! (-> v1-17 transform-index) 10) + (set-vector! (-> v1-17 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 16) (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 hit-by-others-list player-list)) + (set! (-> v1-19 prim-core action) (collide-action solid)) + (set! (-> v1-19 transform-index) 11) + (set-vector! (-> v1-19 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-21 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 15) (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 hit-by-others-list player-list)) + (set! (-> v1-21 prim-core action) (collide-action solid)) + (set! (-> v1-21 transform-index) 12) + (set-vector! (-> v1-21 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-23 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 14) (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 hit-by-others-list player-list)) + (set! (-> v1-23 prim-core action) (collide-action solid)) + (set! (-> v1-23 transform-index) 13) + (set-vector! (-> v1-23 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-25 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 13) (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 hit-by-others-list player-list)) + (set! (-> v1-25 prim-core action) (collide-action solid)) + (set! (-> v1-25 transform-index) 14) + (set-vector! (-> v1-25 local-sphere) 0.0 0.0 0.0 12288.0) + ) + (let ((v1-27 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 12) (the-as uint 0)))) + (set! (-> v1-27 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-27 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-27 prim-core action) (collide-action solid)) + (set! (-> v1-27 transform-index) 15) + (set-vector! (-> v1-27 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-29 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 11) (the-as uint 0)))) + (set! (-> v1-29 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-29 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-29 prim-core action) (collide-action solid)) + (set! (-> v1-29 transform-index) 16) + (set-vector! (-> v1-29 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-31 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 10) (the-as uint 0)))) + (set! (-> v1-31 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-31 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-31 prim-core action) (collide-action solid)) + (set! (-> v1-31 transform-index) 17) + (set-vector! (-> v1-31 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-33 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 9) (the-as uint 0)))) + (set! (-> v1-33 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-33 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-33 prim-core action) (collide-action solid)) + (set! (-> v1-33 transform-index) 18) + (set-vector! (-> v1-33 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-35 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 8) (the-as uint 0)))) + (set! (-> v1-35 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-35 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-35 prim-core action) (collide-action solid)) + (set! (-> v1-35 transform-index) 19) + (set-vector! (-> v1-35 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-37 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 7) (the-as uint 0)))) + (set! (-> v1-37 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-37 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-37 prim-core action) (collide-action solid)) + (set! (-> v1-37 transform-index) 20) + (set-vector! (-> v1-37 local-sphere) 0.0 2048.0 0.0 10240.0) + ) + (let ((v1-39 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 6) (the-as uint 0)))) + (set! (-> v1-39 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-39 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-39 prim-core action) (collide-action solid)) + (set! (-> v1-39 transform-index) 21) + (set-vector! (-> v1-39 local-sphere) 0.0 4096.0 0.0 10240.0) + ) + (let ((v1-41 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 5) (the-as uint 0)))) + (set! (-> v1-41 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-41 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-41 prim-core action) (collide-action solid)) + (set! (-> v1-41 transform-index) 22) + (set-vector! (-> v1-41 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-43 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 0)))) + (set! (-> v1-43 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-43 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-43 prim-core action) (collide-action solid)) + (set! (-> v1-43 transform-index) 23) + (set-vector! (-> v1-43 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-45 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 0)))) + (set! (-> v1-45 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-45 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-45 prim-core action) (collide-action solid)) + (set! (-> v1-45 transform-index) 24) + (set-vector! (-> v1-45 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-47 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 2) (the-as uint 0)))) + (set! (-> v1-47 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-47 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-47 prim-core action) (collide-action solid)) + (set! (-> v1-47 transform-index) 25) + (set-vector! (-> v1-47 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-49 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-49 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-49 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-49 prim-core action) (collide-action solid)) + (set! (-> v1-49 transform-index) 26) + (set-vector! (-> v1-49 local-sphere) 0.0 2048.0 0.0 8192.0) + ) + (let ((v1-51 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-51 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-51 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-51 prim-core action) (collide-action solid)) + (set! (-> v1-51 transform-index) 27) + (set-vector! (-> v1-51 local-sphere) 0.0 2048.0 -2048.0 10240.0) + ) + (let ((v1-53 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 20) (the-as uint 0)))) + (set! (-> v1-53 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-53 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-53 prim-core action) (collide-action solid)) + (set! (-> v1-53 transform-index) 5) + (set-vector! (-> v1-53 local-sphere) 0.0 10240.0 -8192.0 26624.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-56 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-56 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-56 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> self root-override) s4-0) + ) + (set! (-> self root-override pause-adjust-distance) 409600.0) + (set! (-> self root-override trans quad) (-> arg1 quad)) + (set! (-> self prefix) (the-as string arg0)) + (initialize-skeleton + self + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor-lowtorso" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (let ((v1-66 (-> self parent))) + (set! (-> self draw light-index) + (-> (the-as process-drawable (if v1-66 + (the-as process-drawable (-> v1-66 0 self)) + ) + ) + draw + light-index + ) + ) + ) + (set! (-> self event-hook) (-> (method-of-object self idle) event)) + (set! (-> self tail) (new 'process 'metalkor-chain-physics)) + (chain-physics-initialize self (-> self tail) 7 5324.8 *metalkor-lowtorso-chain-setup*) + (set-params! (-> self tail osc-z) 0.0 0.01 0.1 0.9) + (set-params! (-> self tail osc-y) 0.0 0.01 0.1 0.9) + (set-params! (-> self tail rand-z) 6 150 1.0) + (set-params! (-> self tail rand-y) 6 150 1.0) + (set! (-> self tail axial-slop) 910.2222) + (set! (-> self tail-initialized) #f) + (dotimes (v1-88 4) + (set! (-> self spinners v1-88) (the-as handle #f)) + ) + (dotimes (v1-91 3) + (set! (-> (the-as metalkor-lowtorso (+ (the-as uint self) (* v1-91 16))) ja-float-info 0 float-anim) #f) + ) + (let ((v1-95 (-> self root-override root-prim))) + (set! (-> self root-override backup-collide-as) (-> v1-95 prim-core collide-as)) + (set! (-> self root-override backup-collide-with) (-> v1-95 prim-core collide-with)) + ) + (set! (-> self no-collision-timer) 0) + (set! (-> self egg-toss-joint-1) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 5)) + (set! (-> self egg-toss-joint-2) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 6)) + (set! (-> self egg-toss-joint-3) (new 'process 'joint-mod (joint-mod-mode joint-set*) self 7)) + (set-params! (-> self egg-toss-joint-angle) 0.0 0.01 0.1 0.9) + (go-virtual idle) + (none) + ) + +;; definition for method 11 of type metalkor +;; INFO: Used lq/sq +(defmethod init-from-entity! metalkor ((obj metalkor) (arg0 entity-actor)) + "Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that. +This commonly includes things such as: +- stack size +- collision information +- loading the skeleton group / bones +- sounds" + (local-vars (sv-16 res-tag)) + (let ((s4-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player)))) + (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process)) + (set! (-> s4-0 reaction) cshape-reaction-default) + (set! (-> s4-0 no-reaction) + (the-as (function collide-shape-moving collide-query vector vector object) nothing) + ) + (let ((s3-0 (new 'process 'collide-shape-prim-group s4-0 (the-as uint 4) 0))) + (set! (-> s4-0 total-prims) (the-as uint 5)) + (set! (-> s3-0 prim-core collide-as) (collide-spec enemy)) + (set! (-> s3-0 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> s3-0 prim-core action) (collide-action solid)) + (set! (-> s3-0 transform-index) 3) + (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 40960.0) + (set! (-> s4-0 root-prim) s3-0) + ) + (let ((v1-13 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 0) (the-as uint 0)))) + (set! (-> v1-13 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-13 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-13 prim-core action) (collide-action solid)) + (set! (-> v1-13 transform-index) 6) + (set-vector! (-> v1-13 local-sphere) 0.0 -4096.0 4096.0 20480.0) + ) + (let ((v1-15 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 1) (the-as uint 0)))) + (set! (-> v1-15 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-15 prim-core collide-with) (collide-spec jak bot hit-by-others-list player-list)) + (set! (-> v1-15 prim-core action) (collide-action solid)) + (set! (-> v1-15 transform-index) 5) + (set-vector! (-> v1-15 local-sphere) 0.0 2048.0 2048.0 20480.0) + ) + (let ((v1-17 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 3) (the-as uint 1)))) + (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 solid)) + (set! (-> v1-17 transform-index) 9) + (set-vector! (-> v1-17 local-sphere) 0.0 8192.0 -20480.0 24576.0) + ) + (let ((v1-19 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint 4) (the-as uint 1)))) + (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 solid)) + (set! (-> v1-19 transform-index) 12) + (set-vector! (-> v1-19 local-sphere) 0.0 8192.0 -20480.0 24576.0) + ) + (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w))) + (let ((v1-22 (-> s4-0 root-prim))) + (set! (-> s4-0 backup-collide-as) (-> v1-22 prim-core collide-as)) + (set! (-> s4-0 backup-collide-with) (-> v1-22 prim-core collide-with)) + ) + (set! (-> s4-0 event-self) 'touched) + (set! (-> obj root-override) s4-0) + ) + (set! (-> obj root-override pause-adjust-distance) 409600.0) + (process-drawable-from-entity! obj arg0) + (initialize-skeleton + obj + (the-as skeleton-group (art-group-get-by-name *level* "skel-metalkor" (the-as (pointer uint32) #f))) + (the-as pair 0) + ) + (set! (-> obj mask) (logior (process-mask enemy) (-> obj mask))) + (set! (-> obj draw light-index) (the-as uint 10)) + (set! (-> obj lowtorso) (the-as handle #f)) + (set! (-> obj trackable) #f) + (dotimes (v1-33 10) + (set! (-> obj flitters v1-33) (the-as handle #f)) + ) + (dotimes (v1-36 3) + (set! (-> obj wasps v1-36) (the-as handle #f)) + ) + (set! (-> obj initial-y) (-> obj root-override trans y)) + (set! (-> obj hud) (the-as handle #f)) + (set! (-> obj legs) (the-as handle #f)) + (set! (-> obj kid) (the-as handle #f)) + (set! (-> obj wings) (the-as handle #f)) + (set! (-> obj explode) (the-as handle #f)) + (set! (-> obj rift-occlude) (the-as handle #f)) + (set! (-> obj last-attack-id) (the-as uint 0)) + (let ((a0-40 (nav-mesh-from-res-tag (-> obj entity) 'nav-mesh-actor 1))) + (if a0-40 + (change-to a0-40 obj) + ) + ) + (set! (-> obj current-nav-poly) #f) + (set! (-> obj shot-anticipate) (create-launch-control (-> *part-group-id-table* 1232) obj)) + (set! (-> obj last-flitter-launched) 0) + (set! (-> obj last-wasp-launched) 0) + (set! (-> obj live-flitters) 0) + (set! (-> obj live-wasps) 0) + (set! (-> obj flitter-gem-tracker) (the-as handle #f)) + (set! (-> obj wasp-gem-tracker) (the-as handle #f)) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-47 (res-lump-data (-> obj entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-47 (> (-> sv-16 elt-count) 0)) + (let ((v1-48 (-> v1-47 0))) + (when (>= (-> v1-48 length) 1) + (let ((s5-2 (-> v1-48 data 0 actor))) + (let ((a0-52 (search-process-tree + *active-pool* + (the-as + (function process-tree object) + (lambda ((arg0 gem-tracker)) (= (-> arg0 type) flitter-gem-tracker) (none)) + ) + ) + ) + ) + (if a0-52 + (set! (-> obj flitter-gem-tracker) (process->handle a0-52)) + (set! (-> obj flitter-gem-tracker) + (ppointer->handle + (process-spawn flitter-gem-tracker :init gem-tracker-init-by-other s5-2 0 :to *entity-pool*) + ) + ) + ) + ) + (let ((a0-63 + (search-process-tree *active-pool* (the-as + (function process-tree object) + (lambda ((arg0 gem-tracker)) (= (-> arg0 type) wasp-gem-tracker) (none)) + ) + ) + ) + ) + (if a0-63 + (set! (-> obj wasp-gem-tracker) (process->handle a0-63)) + (set! (-> obj wasp-gem-tracker) + (ppointer->handle (process-spawn wasp-gem-tracker :init gem-tracker-init-by-other s5-2 1 :to *entity-pool*)) + ) + ) + ) + ) + ) + ) + ) + ) + (copy-nav-enemy-info! *metalkor-flitter-nav-enemy-info* *flitter-nav-enemy-info*) + (set! (-> *metalkor-flitter-nav-enemy-info* notice-distance) 1638400.0) + (dotimes (v1-71 4) + (set! (-> obj spinners v1-71) (the-as handle #f)) + ) + (set! (-> obj neck) (new 'process 'joint-mod (joint-mod-mode flex-blend) obj 6)) + (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) 409600.0) + (set! (-> obj neck ignore-angle) 16384.0) + (mode-set! (-> obj neck) (joint-mod-mode look-at)) + (set! (-> obj previous-flat-travel-timer) 0) + (set! (-> obj previous-flat-travel-long-timer) 0) + (set! (-> obj countdown-to-roar) 3) + (let ((v1-88 (-> obj root-override root-prim))) + (set! (-> obj root-override backup-collide-as) (-> v1-88 prim-core collide-as)) + (set! (-> obj root-override backup-collide-with) (-> v1-88 prim-core collide-with)) + ) + (set! (-> obj no-collision-timer) 0) + (set! (-> obj wing-sound) (new-sound-id)) + (set! (-> obj wing-sound-playing) #f) + (set! (-> obj explode-sound) (new-sound-id)) + (set! (-> obj bomb-sound) (new-sound-id)) + (set! (-> obj stage) -1) + (metalkor-go-next-stage) + (none) + ) + + + + diff --git a/test/decompiler/reference/jak2/levels/nest/boss/metalkor-states_REF.gc b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-states_REF.gc new file mode 100644 index 0000000000..fda291a1c5 --- /dev/null +++ b/test/decompiler/reference/jak2/levels/nest/boss/metalkor-states_REF.gc @@ -0,0 +1,2984 @@ +;;-*-Lisp-*- +(in-package goal) + +;; definition for symbol *metalkor-spinner-setup*, type (array metalkor-spinner-info) +(define *metalkor-spinner-setup* + (new 'static 'boxed-array :type metalkor-spinner-info + (new 'static 'metalkor-spinner-info :joint-index #x43 :launch-angle 7281.778) + (new 'static 'metalkor-spinner-info :joint-index #x40 :launch-angle 14563.556) + (new 'static 'metalkor-spinner-info :joint-index #x46 :launch-angle -7281.778) + (new 'static 'metalkor-spinner-info :joint-index #x3d :launch-angle -14563.556) + ) + ) + +;; definition for function metalkor-start-spinner +;; WARN: Return type mismatch int vs handle. +(defbehavior metalkor-start-spinner metalkor ((arg0 int) (arg1 vector)) + (the-as + handle + (when (< arg0 4) + (if (handle->process (-> self spinners arg0)) + (return (the-as handle #f)) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (sin (-> *metalkor-spinner-setup* arg0 launch-angle))) + (f0-2 (cos (-> *metalkor-spinner-setup* arg0 launch-angle))) + ) + (set-vector! + s5-0 + (+ (* f0-2 (-> arg1 x)) (* f30-0 (-> arg1 z))) + 0.0 + (- (* f0-2 (-> arg1 z)) (* f30-0 (-> arg1 x))) + 1.0 + ) + ) + (vector-normalize! s5-0 (* 81920.0 (cos 10922.667))) + (+! (-> s5-0 y) (* 81920.0 (sin 10922.667))) + (set! (-> s5-0 y) (+ 12288.0 (-> s5-0 y))) + (vector+! s5-0 s5-0 (-> self entity trans)) + (let ((v0-0 (ppointer->handle + (process-spawn metalkor-spinner s5-0 (-> *metalkor-spinner-setup* arg0 joint-index) :to self) + ) + ) + ) + (set! (-> self spinners arg0) (the-as handle v0-0)) + v0-0 + ) + ) + ) + ) + ) + +;; definition for function metalkor-spinners-off +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-spinners-off metalkor () + (dotimes (gp-0 4) + (let ((a0-1 (handle->process (-> self spinners gp-0)))) + (when a0-1 + (send-event a0-1 'break) + (set! (-> self spinners gp-0) (the-as handle #f)) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-lowtorso-spinners-off +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-lowtorso-spinners-off metalkor () + (let ((gp-0 (handle->process (-> self lowtorso)))) + (when gp-0 + (dotimes (s5-0 4) + (send-event gp-0 'spinner-off s5-0) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-spinner-check +;; WARN: Return type mismatch handle vs none. +(defbehavior metalkor-spinner-check metalkor ((arg0 int) (arg1 float) (arg2 vector)) + (if (and (not (handle->process (-> self spinners arg0))) (< arg1 (ja-aframe-num 0))) + (metalkor-start-spinner arg0 arg2) + ) + (none) + ) + +;; definition for function metalkor-lowtorso-spinner-check +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-lowtorso-spinner-check metalkor ((arg0 metalkor-lowtorso) (arg1 float) (arg2 float)) + (when (and (>= arg1 arg2) (< arg1 (ja-aframe-num 0))) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner arg0) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-update-hud +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-update-hud metalkor () + (let ((v1-1 (handle->process (-> self hud)))) + (when v1-1 + (set! (-> (the-as hud-metalkor v1-1) values 0 target) (-> self stage)) + (set! (-> (the-as hud-metalkor v1-1) values 1 target) (the int (* 100.0 (-> self stage-hit-points)))) + ) + ) + (none) + ) + +;; definition for function metalkor-all-spinners-on +(defbehavior metalkor-all-spinners-on metalkor () + (let ((gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (dotimes (s5-0 4) + (metalkor-start-spinner s5-0 (-> gp-0 vector 2)) + ) + ) + (dotimes (gp-1 4) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner gp-1) + ) + ) + ) + #f + ) + +;; definition for function metalkor-ja-float +(defbehavior metalkor-ja-float metalkor ((arg0 art-joint-anim) (arg1 float) (arg2 float) (arg3 float)) + (dotimes (v1-0 (the-as int (+ (-> self skel active-channels) (-> self skel float-channels)))) + (let ((a1-3 (-> self skel channel v1-0 frame-group))) + (if (and a1-3 (nonzero? a1-3) (= (-> self skel channel v1-0 command) (joint-control-command float)) (= a1-3 arg0)) + (return (the-as joint-control-channel #f)) + ) + ) + ) + (let ((v1-3 (ja-channel-float! arg0 0.0 0.0 0.0))) + (when v1-3 + (set! (-> v1-3 param 0) arg1) + (set! (-> v1-3 param 1) arg2) + (set! (-> v1-3 param 2) arg3) + (set! (-> v1-3 num-func) num-func-interp-play!) + v1-3 + ) + ) + ) + +;; definition for function metalkor-ja-float-stop +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-ja-float-stop metalkor ((arg0 art-joint-anim)) + (countdown (s5-0 (-> self skel float-channels)) + (let* ((v1-3 (+ s5-0 (-> self skel active-channels))) + (a0-3 (-> self skel channel v1-3 frame-group)) + ) + (if (and a0-3 (nonzero? a0-3) (= (-> self skel channel v1-3 command) (joint-control-command float)) (= a0-3 arg0)) + (joint-channel-float-delete! (-> self skel channel v1-3)) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-ja-float-children +(defbehavior metalkor-ja-float-children metalkor () + (dotimes (gp-0 (the-as int (+ (-> self skel active-channels) (-> self skel float-channels)))) + (let ((v1-2 (-> self skel channel gp-0 frame-group))) + (cond + ((or (not v1-2) (zero? v1-2) (!= (-> self skel channel gp-0 command) 42)) + ) + ((= v1-2 (-> self draw art-group data 23)) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hang-pre-shot" gp-0) + ) + ((= v1-2 (-> self draw art-group data 32)) + (send-event (handle->process (-> self legs)) 'ja-float "pre-shot" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "pre-shot" gp-0) + ) + ((= v1-2 (-> self draw art-group data 34)) + (send-event (handle->process (-> self legs)) 'ja-float "hit" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit" gp-0) + ) + ((= v1-2 (-> self draw art-group data 35)) + (send-event (handle->process (-> self legs)) 'ja-float "hit-left" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit-left" gp-0) + ) + ((= v1-2 (-> self draw art-group data 36)) + (send-event (handle->process (-> self legs)) 'ja-float "hit-right" gp-0) + (send-event (handle->process (-> self lowtorso)) 'ja-float "hit-right" gp-0) + ) + ) + ) + ) + #f + ) + +;; definition for function metalkor-ja-float-group? +(defbehavior metalkor-ja-float-group? metalkor ((arg0 art-joint-anim)) + (countdown (v1-1 (-> self skel float-channels)) + (let* ((a1-2 (+ v1-1 (-> self skel active-channels))) + (a2-2 (-> self skel channel a1-2 frame-group)) + ) + (if (and a2-2 (nonzero? a2-2) (= (-> self skel channel a1-2 command) (joint-control-command float)) (= a2-2 arg0)) + (return (the-as int a1-2)) + ) + ) + ) + -1 + ) + +;; definition for function metalkor-get-ring +;; WARN: Check prologue - tricky store of r0 +;; INFO: Used lq/sq +(defun metalkor-get-ring ((arg0 metalkor)) + (local-vars (sv-16 res-tag)) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-1 (res-lump-data (-> arg0 entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-1 (< (the-as uint 2) (-> sv-16 elt-count))) + (let ((v1-2 (-> v1-1 2))) + (if (>= (-> v1-2 length) 1) + (return (-> v1-2 data 0 actor)) + ) + ) + ) + ) + (the-as entity #f) + ) + +;; definition for function metalkor-common +;; INFO: Used lq/sq +;; WARN: Return type mismatch symbol vs none. +(defbehavior metalkor-common metalkor () + (cond + ((and (= (ja-group-size) 9) (= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 41) + ) + ) + (let ((v1-8 (-> self skel effect))) + (set! (-> v1-8 channel-offset) 8) + ) + 0 + ) + (else + (let ((v1-11 (-> self skel effect))) + (set! (-> v1-11 channel-offset) 0) + ) + 0 + ) + ) + (if (and (nonzero? (-> self next-stage-timer)) + (>= (- (-> self clock frame-counter) (-> self next-stage-timer)) 0) + ) + (metalkor-go-next-stage) + ) + (when (>= (- (-> self clock frame-counter) (-> self no-collision-timer)) (seconds 0.1)) + (let ((v1-25 (-> self root-override root-prim))) + (set! (-> v1-25 prim-core collide-as) (-> self root-override backup-collide-as)) + (set! (-> v1-25 prim-core collide-with) (-> self root-override backup-collide-with)) + ) + ) + (case (-> self stage) + ((2) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f)) + '(want-anim "nest-kor-boss-fight-mid") + ) + ) + ((3) + (eval! + (new 'stack 'script-context (the-as basic (process->ppointer self)) self (the-as vector #f)) + '(want-anim "outro-nest") + ) + ) + ) + (when (nonzero? (-> self neck)) + (let* ((gp-0 *target*) + (a0-20 (if (type? gp-0 process-focusable) + gp-0 + ) + ) + ) + (if a0-20 + (target-set! (-> self neck) (get-trans a0-20 2)) + ) + ) + ) + (set! (-> self trackable) #t) + (let ((t0-2 (new 'static 'vector))) + (set! (-> t0-2 quad) (-> self root-override trans quad)) + (set! (-> t0-2 y) (+ 16384.0 (-> t0-2 y))) + (set-setting! 'point-of-interest 'abs t0-2 0) + ) + (set! (-> self live-flitters) 0) + (dotimes (gp-2 10) + (let ((a0-24 (handle->process (-> self flitters gp-2)))) + (when a0-24 + (if (< (-> (the-as process-drawable a0-24) root trans y) (+ -204800.0 (-> self root-override trans y))) + (send-event a0-24 'die-fast) + (+! (-> self live-flitters) 1) + ) + ) + ) + ) + (set! (-> self live-wasps) 0) + (dotimes (v1-65 3) + (if (handle->process (-> self wasps v1-65)) + (+! (-> self live-wasps) 1) + ) + ) + (metalkor-ja-float-children) + (none) + ) + +;; definition for method 10 of type metalkor +(defmethod deactivate metalkor ((obj metalkor)) + (if (-> obj wing-sound-playing) + (sound-stop (-> obj wing-sound)) + ) + ((method-of-type process-focusable deactivate) obj) + (none) + ) + +;; definition for method 7 of type metalkor +;; WARN: Return type mismatch process-focusable vs metalkor. +(defmethod relocate metalkor ((obj metalkor) (arg0 int)) + (if (nonzero? (-> obj shot-anticipate)) + (&+! (-> obj shot-anticipate) arg0) + ) + (if (nonzero? (-> obj neck)) + (&+! (-> obj neck) arg0) + ) + (the-as metalkor ((method-of-type process-focusable relocate) obj arg0)) + ) + +;; definition for method 20 of type metalkor +;; INFO: Used lq/sq +(defmethod get-trans metalkor ((obj metalkor) (arg0 int)) + "@returns the `trans` [[vector]] from the process's `root` (typically either a [[trsqv]] or a [[collide-shape]])" + (local-vars (s5-0 vector)) + (cond + ((or (= arg0 2) (= arg0 3)) + (set! s5-0 (new 'static 'vector)) + (set! (-> s5-0 quad) + (-> (the-as collide-shape-prim-group (-> obj root-override root-prim)) child 0 prim-core world-sphere quad) + ) + (set! (-> s5-0 w) 61440.0) + s5-0 + ) + ((= arg0 4) + (set! s5-0 (new 'static 'vector)) + (cond + ((zero? (-> obj skel active-channels)) + ) + ((or (and (-> obj next-state) (= (-> obj next-state name) 'explode)) + (and (and (-> obj next-state) (= (-> obj next-state name) 'fly-to-ring)) (-> obj been-to-entity)) + ) + (vector<-cspace! s5-0 (-> obj node-list data 3)) + ) + (else + (set! (-> s5-0 quad) (-> obj root-override trans quad)) + (set! (-> s5-0 y) (+ 8192.0 (-> s5-0 y))) + ) + ) + (when (< 0.0 (-> obj ring-cam-pos value)) + (let ((a0-15 (metalkor-get-ring obj)) + (a2-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> a2-0 quad) (-> a0-15 trans quad)) + (set! (-> a2-0 y) (+ -65536.0 (-> a2-0 y))) + (vector-lerp! s5-0 s5-0 a2-0 (-> obj ring-cam-pos value)) + ) + ) + s5-0 + ) + (else + ((method-of-type process-focusable get-trans) obj arg0) + ) + ) + ) + +;; definition for function set-countdown-to-roar +;; WARN: Return type mismatch int vs none. +(defbehavior set-countdown-to-roar metalkor () + (case (-> self stage) + ((1) + (set! (-> self countdown-to-roar) (rand-vu-int-range 2 5)) + ) + (else + (set! (-> self countdown-to-roar) (rand-vu-int-range 1 3)) + ) + ) + (none) + ) + +;; definition for function metalkor-go-next-stage +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +(defbehavior metalkor-go-next-stage metalkor () + (let ((v1-1 (-> self skel effect))) + (set! (-> v1-1 channel-offset) 0) + ) + 0 + (set! (-> self stage) (min 5 (+ (-> self stage) 1))) + (if (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status subtask-complete))) + (set! (-> self stage) (max 3 (-> self stage))) + ) + (if (task-node-closed? (game-task-node nest-boss-resolution)) + (set! (-> self stage) (max 5 (-> self stage))) + ) + (set! (-> self stage-hit-points) 1.0) + (set! (-> self next-stage-timer) 0) + (init (-> self ring-cam-pos) 0.0 0.01 0.1 0.9) + (when (not (handle->process (-> self rift-occlude))) + (if (metalkor-get-ring self) + (set! (-> self rift-occlude) + (ppointer->handle (process-spawn rift-occlude (metalkor-get-ring self) :to self)) + ) + ) + ) + (let ((v1-28 (-> self stage))) + (cond + ((zero? v1-28) + (set! (-> self root-override trans y) (+ -12288.0 (-> self entity trans y))) + (go-virtual hidden) + ) + ((= v1-28 1) + (set-setting! 'music 'danger4 0 0) + (set! (-> self hud) (ppointer->handle (process-spawn hud-metalkor :init hud-init-by-other :to self))) + (metalkor-update-hud) + (set! (-> self lowtorso) + (ppointer->handle (process-spawn metalkor-lowtorso "" (-> self root-override trans) :to self)) + ) + (set! (-> self kid) (ppointer->handle (process-spawn metalkor-kid (-> self entity trans) :to self))) + (let ((gp-4 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (dotimes (s5-1 4) + (metalkor-start-spinner s5-1 (-> gp-4 vector 2)) + ) + ) + (dotimes (gp-5 4) + (let ((a0-44 (handle->process (-> self lowtorso)))) + (if a0-44 + (send-event a0-44 'spinner gp-5) + ) + ) + ) + (set-countdown-to-roar) + (set-setting! 'fov 'abs #x466eeeef 0) + (ja :group! (-> self draw art-group data 9) :num! min) + (go-virtual hang-shoot-n-launch) + ) + ((= v1-28 2) + (set-setting! 'music 'danger4 0 0) + (set-countdown-to-roar) + (go-virtual start-second-stage) + ) + ((= v1-28 3) + (set-setting! 'music 'danger4 0 0) + (set! (-> self last-close-attack) 0) + (set! (-> self last-standing-attack) 0) + (cond + ((not (and (-> self entity) (logtest? (-> self entity extra perm status) (entity-perm-status subtask-complete))) + ) + (go-virtual play-drop-movie) + ) + ((zero? (-> self nav)) + (format 0 "ERROR: metalkor nav mesh not found~%") + (go-virtual beaten (not (task-node-closed? (game-task-node nest-boss-resolution)))) + ) + (else + (metalkor-spinners-off) + (metalkor-lowtorso-spinners-off) + (dotimes (gp-8 3) + (let ((a0-61 (handle->process (-> self wasps gp-8)))) + (if a0-61 + (send-event a0-61 'die-fast) + ) + ) + ) + (let ((v1-106 (new 'stack-no-clear 'vector))) + (set! (-> v1-106 quad) (-> self entity trans quad)) + (set! (-> v1-106 x) (+ 90112.0 (-> v1-106 x))) + (set! (-> v1-106 z) (+ -90112.0 (-> v1-106 z))) + (set! (-> self root-override trans quad) (-> v1-106 quad)) + ) + (when (not (handle->process (-> self hud))) + (set! (-> self hud) (ppointer->handle (process-spawn hud-metalkor :init hud-init-by-other :to self))) + (metalkor-update-hud) + ) + (if (not (handle->process (-> self lowtorso))) + (set! (-> self lowtorso) + (ppointer->handle (process-spawn metalkor-lowtorso "" (-> self root-override trans) :to self)) + ) + ) + (if (not (handle->process (-> self kid))) + (set! (-> self kid) (ppointer->handle (process-spawn metalkor-kid (-> self entity trans) :to self))) + ) + (set! (-> self legs) + (ppointer->handle (process-spawn metalkor-legs "" (-> self root-override trans) :to self)) + ) + (set-setting! 'fov 'abs #x466eeeef 0) + (go-virtual chase-target) + ) + ) + ) + ((= v1-28 4) + (set-setting! 'music 'danger4 0 0) + (set! (-> self wings) + (ppointer->handle (process-spawn metalkor-wings "" (-> self root-override trans) :to self)) + ) + (send-event (handle->process (-> self hud)) 'hide-and-die) + (go-virtual last-gasp) + ) + (else + (go-virtual beaten (not (task-node-closed? (game-task-node nest-boss-resolution)))) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-setup-hit-anim +;; WARN: Return type mismatch float vs none. +(defbehavior metalkor-setup-hit-anim metalkor ((arg0 attack-info) (arg1 process-drawable) (arg2 art-element) (arg3 art-element) (arg4 float)) + (ja-channel-push! 2 0) + (ja :group! arg2 :num! min) + (let* ((f30-0 -0.5) + (v1-5 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-6 (the-as number (logior #x3f800000 v1-5))) + (f30-1 (+ f30-0 (+ -1.0 (the-as float v1-6)))) + (s2-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s1-1 (new 'stack-no-clear 'attack-info)) + ) + (attack-info-method-9 arg0 s1-1 arg1 self) + (vector-flatten! (-> s1-1 trans) (-> s1-1 trans) (-> s2-1 vector 1)) + (let ((f30-2 (fmax -1.0 (fmin 1.0 (+ f30-1 (vector-dot (-> s1-1 trans) (the-as vector (-> s2-1 vector)))))))) + (set! f30-2 (cond + ((>= f30-2 0.0) + (ja :chan 1 :group! arg3 :num! min) + f30-2 + ) + (else + (ja :chan 1 :group! arg4 :num! min) + (- f30-2) + ) + ) + ) + (let ((v1-24 (-> self skel root-channel 1))) + (set! (-> v1-24 frame-interp 1) f30-2) + (set! (-> v1-24 frame-interp 0) f30-2) + ) + ) + ) + (none) + ) + +;; definition for function metalkor-get-gem-tracker +;; WARN: Return type mismatch process vs none. +(defbehavior metalkor-get-gem-tracker metalkor ((arg0 process-focusable)) + (cond + ((type? arg0 metalkor-wasp) + (handle->process (-> self wasp-gem-tracker)) + ) + ((type? arg0 metalkor-flitter) + (handle->process (-> self flitter-gem-tracker)) + ) + (else + ) + ) + (none) + ) + +;; definition for function metalkor-handler +;; INFO: Used lq/sq +;; WARN: Return type mismatch none vs object. +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 72] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 107] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 143] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 173] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 254] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 266] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 291] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 489] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 571] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 580] +;; WARN: rewrite_to_get_var got a none typed variable. Is there unreachable code? [OP: 666] +(defbehavior metalkor-handler metalkor ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block)) + (local-vars (v0-2 none)) + (the-as + object + (case arg2 + (('skip) + (dotimes (gp-1 10) + (let ((a0-4 (handle->process (-> self flitters gp-1)))) + (if a0-4 + (send-event a0-4 'die-fast) + ) + ) + ) + (dotimes (gp-2 3) + (let ((a0-8 (handle->process (-> self wasps gp-2)))) + (if a0-8 + (send-event a0-8 'die-fast) + ) + ) + ) + (metalkor-go-next-stage) + ) + (('track) + (-> self trackable) + ) + (('flitter-change-gem) + (let ((v1-23 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-23 from) (process->ppointer arg0)) + (set! (-> v1-23 num-params) arg1) + (set! (-> v1-23 message) arg2) + (set! (-> v1-23 param 0) (-> arg3 param 0)) + (set! (-> v1-23 param 1) (-> arg3 param 1)) + (set! (-> v1-23 param 2) (-> arg3 param 2)) + (set! (-> v1-23 param 3) (-> arg3 param 3)) + (set! (-> v1-23 param 4) (-> arg3 param 4)) + (set! (-> v1-23 param 5) (-> arg3 param 5)) + (send-event-function (handle->process (-> self flitter-gem-tracker)) v1-23) + ) + ) + (('wasp-change-gem) + (let ((v1-24 (new 'stack-no-clear 'event-message-block))) + (set! (-> v1-24 from) (process->ppointer arg0)) + (set! (-> v1-24 num-params) arg1) + (set! (-> v1-24 message) arg2) + (set! (-> v1-24 param 0) (-> arg3 param 0)) + (set! (-> v1-24 param 1) (-> arg3 param 1)) + (set! (-> v1-24 param 2) (-> arg3 param 2)) + (set! (-> v1-24 param 3) (-> arg3 param 3)) + (set! (-> v1-24 param 4) (-> arg3 param 4)) + (set! (-> v1-24 param 5) (-> arg3 param 5)) + (send-event-function (handle->process (-> self wasp-gem-tracker)) v1-24) + ) + ) + (('have-gem?) + (let ((s4-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> s4-0 from) (process->ppointer arg0)) + (set! (-> s4-0 num-params) arg1) + (set! (-> s4-0 message) arg2) + (set! (-> s4-0 param 0) (-> arg3 param 0)) + (set! (-> s4-0 param 1) (-> arg3 param 1)) + (set! (-> s4-0 param 2) (-> arg3 param 2)) + (set! (-> s4-0 param 3) (-> arg3 param 3)) + (set! (-> s4-0 param 4) (-> arg3 param 4)) + (set! (-> s4-0 param 5) (-> arg3 param 5)) + (send-event-function (the-as process-tree (metalkor-get-gem-tracker (the-as process-focusable arg0))) s4-0) + ) + ) + (('setup-flitter-gem) + (let ((gp-3 (-> self entity extra))) + (cond + ((send-event (handle->process (-> self flitter-gem-tracker)) 'spawn-with-gem?) + (set! v0-2 (the-as none (logclear (-> gp-3 perm status) (entity-perm-status save)))) + (set! (-> gp-3 perm status) (the-as entity-perm-status v0-2)) + ) + (else + (set! v0-2 (the-as none (logior (-> gp-3 perm status) (entity-perm-status save)))) + (set! (-> gp-3 perm status) (the-as entity-perm-status v0-2)) + ) + ) + ) + v0-2 + ) + (('hatch) + (let ((v1-41 (-> arg3 param 0))) + (set! (-> self flitters v1-41) (the-as handle (-> arg3 param 1))) + (send-event + (handle->process (-> self flitter-gem-tracker)) + 'change-gem + #f + (handle->process (-> self flitters v1-41)) + ) + ) + ) + (('child-die) + (cond + ((not (and (-> self next-state) (= (-> self next-state name) 'hang-shoot-n-launch))) + #f + ) + ((>= 1 (-> self countdown-to-roar)) + (set-countdown-to-roar) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 21) :num! min) + (metalkor-all-spinners-on) + ) + (else + (set! v0-2 (the-as none (+ (-> self countdown-to-roar) -1))) + (set! (-> self countdown-to-roar) (the-as int v0-2)) + v0-2 + ) + ) + ) + (('attack) + (let ((f28-0 1.0) + (s5-2 (the-as object (-> arg3 param 1))) + (f30-0 (* 0.2 (the float (the int (* 4.99 (-> self stage-hit-points)))))) + ) + (when (!= (-> self stage-hit-points) 0.0) + (when (or (not (logtest? (-> (the-as attack-info s5-2) mask) (attack-info-mask id))) + (!= (-> self last-attack-id) (-> (the-as attack-info s5-2) id)) + ) + (if (logtest? (-> (the-as attack-info s5-2) mask) (attack-info-mask id)) + (set! (-> self last-attack-id) (-> (the-as attack-info s5-2) id)) + ) + (if (logtest? (attack-info-mask damage) (-> (the-as attack-info s5-2) mask)) + (set! f28-0 (-> (the-as attack-info s5-2) damage)) + ) + (let* ((s4-1 arg0) + (f0-4 (cond + ((if (type? s4-1 gun-blue-shot) + s4-1 + ) + (if (= (-> self stage) 3) + (* 0.0012 f28-0) + (* 0.0024 f28-0) + ) + ) + (else + (let ((s4-2 arg0)) + (cond + ((if (type? s4-2 gun-dark-shot) + s4-2 + ) + (if (= (-> self stage) 3) + (* 0.003 f28-0) + (* 0.006 f28-0) + ) + ) + ((= (-> self stage) 3) + (* 0.004 f28-0) + ) + (else + (* 0.008 f28-0) + ) + ) + ) + ) + ) + ) + ) + (if (and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info s5-2) mask)) + (logtest? (penetrate dark-bomb) (-> (the-as attack-info s5-2) penetrate-using)) + ) + (set! f0-4 0.5) + ) + (if (logtest? (-> *game-info* secrets) (game-secrets hero-mode)) + (set! f0-4 (* 0.6666667 f0-4)) + ) + (if (not (and (-> self next-state) (let ((v1-109 (-> self next-state name))) + (or (= v1-109 'fall-down) + (= v1-109 'overload-recover) + (= v1-109 'tail-attack) + (= v1-109 'foot-attack) + (= v1-109 'start-second-stage) + ) + ) + ) + ) + (set! (-> self stage-hit-points) (fmax 0.0 (- (-> self stage-hit-points) f0-4))) + ) + ) + (metalkor-update-hud) + (cond + ((and (logtest? (attack-info-mask penetrate-using) (-> (the-as attack-info s5-2) mask)) + (logtest? (penetrate dark-bomb) (-> (the-as attack-info s5-2) penetrate-using)) + (= (-> self stage-hit-points) 0.0) + ) + (set! v0-2 (the-as none (+ (-> self clock frame-counter) (seconds 1)))) + (set! (-> self next-stage-timer) (the-as time-frame v0-2)) + v0-2 + ) + ((= (-> self stage-hit-points) 0.0) + (metalkor-go-next-stage) + ) + ((and (-> self next-state) (= (-> self next-state name) 'hang-shoot-n-launch)) + (metalkor-setup-hit-anim + (the-as attack-info s5-2) + (the-as process-drawable arg0) + (-> self draw art-group data 18) + (-> self draw art-group data 20) + (the-as float (-> self draw art-group data 19)) + ) + (metalkor-all-spinners-on) + ) + ((and (and (-> self next-state) (= (-> self next-state name) 'fall-down)) + (let ((v1-139 (ja-group))) + (or (not (and v1-139 (= v1-139 (-> self draw art-group data 7)))) (>= (ja-aframe-num 0) 10.0)) + ) + ) + (metalkor-setup-hit-anim + (the-as attack-info s5-2) + (the-as process-drawable arg0) + (-> self draw art-group data 25) + (-> self draw art-group data 27) + (the-as float (-> self draw art-group data 26)) + ) + ) + ((and (-> self next-state) (let ((v1-153 (-> self next-state name))) + (or (= v1-153 'chase-target) + (= v1-153 'standing-shot) + (= v1-153 'overload-recover) + (= v1-153 'tail-attack) + (= v1-153 'foot-attack) + (= v1-153 'get-close) + ) + ) + ) + (if (< (-> self stage-hit-points) f30-0) + (go-virtual fall-down) + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 34)) 1.0 0.25 2.0) + ) + ) + ) + ) + ) + ) + ) + (('touch) + (when ((method-of-type touching-shapes-entry prims-touching?) + (the-as touching-shapes-entry (-> arg3 param 0)) + (-> self root-override) + (the-as uint 1) + ) + (let* ((s4-3 arg0) + (gp-5 (if (type? s4-3 process-focusable) + s4-3 + ) + ) + ) + (when gp-5 + (let ((s3-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s4-4 (new 'stack-no-clear 'vector)) + ) + (if (>= (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 42))) 0) + (vector+! s4-4 (-> s3-0 vector 2) (the-as vector (-> s3-0 vector))) + (vector-! s4-4 (-> s3-0 vector 2) (the-as vector (-> s3-0 vector))) + ) + (set! (-> s4-4 y) 0.0) + (vector-normalize! s4-4 32768.0) + (set! (-> s4-4 y) 24576.0) + (let ((a1-43 (new 'stack-no-clear 'event-message-block))) + (set! (-> a1-43 from) (process->ppointer self)) + (set! (-> a1-43 num-params) 2) + (set! (-> a1-43 message) 'attack) + (set! (-> a1-43 param 0) (-> arg3 param 0)) + (let ((v1-170 (new 'static 'attack-info :mask (attack-info-mask vector shove-up id)))) + (let* ((a0-116 *game-info*) + (a2-15 (+ (-> a0-116 attack-id) 1)) + ) + (set! (-> a0-116 attack-id) a2-15) + (set! (-> v1-170 id) a2-15) + ) + (set! (-> v1-170 vector quad) (-> s4-4 quad)) + (set! (-> v1-170 shove-up) 24576.0) + (set! (-> a1-43 param 1) (the-as uint v1-170)) + ) + (when (send-event-function gp-5 a1-43) + (set! (-> self no-collision-timer) (-> self clock frame-counter)) + (let ((v1-175 (-> self root-override root-prim))) + (set! (-> v1-175 prim-core collide-as) (collide-spec)) + (set! (-> v1-175 prim-core collide-with) (collide-spec)) + ) + 0 + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + +;; definition for function metalkor-start-egg +(defbehavior metalkor-start-egg metalkor () + (if (nonzero? (-> self egg-timer)) + (return #f) + ) + (dotimes (v1-3 10) + (when (not (handle->process (-> self flitters v1-3))) + (new 'stack-no-clear 'vector) + (let ((f0-1 (* 182.04445 (rand-vu-float-range 70.0 290.0)))) + (set! (-> self egg-timer) (-> self clock frame-counter)) + (set! (-> self egg-angle) f0-1) + (if (< 32768.0 f0-1) + (send-event (handle->process (-> self lowtorso)) 'egg-toss 1.0) + (send-event (handle->process (-> self lowtorso)) 'egg-toss -1.0) + ) + ) + (return #f) + ) + ) + #f + ) + +;; definition for function metalkor-check-egg +;; INFO: Used lq/sq +(defbehavior metalkor-check-egg metalkor () + (local-vars (v0-0 symbol)) + (if (zero? (-> self egg-timer)) + (return #f) + ) + (if (< (- (-> self clock frame-counter) (-> self egg-timer)) (seconds 0.2)) + (return #t) + ) + (dotimes (gp-0 10) + (when (not (handle->process (-> self flitters gp-0))) + (let ((s4-0 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s5-0 quad) (-> self root-override trans quad)) + (let ((v1-19 (handle->process (-> self lowtorso)))) + (if v1-19 + (vector<-cspace! s5-0 (-> (the-as process-focusable v1-19) node-list data 11)) + ) + ) + (let ((s2-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (set-vector! s4-0 (* 102400.0 (sin (-> self egg-angle))) 81920.0 (* 102400.0 (cos (-> self egg-angle))) 1.0) + (vector-matrix*! s4-0 s4-0 s2-0) + ) + (when (-> self entity) + (let ((v1-31 (-> self entity extra))) + (logior! (-> v1-31 perm status) (entity-perm-status save)) + ) + ) + (sound-play "nboss-spawn") + (set! (-> self flitters gp-0) (ppointer->handle (process-spawn metalkor-egg s5-0 s4-0 gp-0 :to self))) + ) + (send-event (handle->process (-> self lowtorso)) 'egg-toss 0) + (set! (-> self egg-timer) 0) + (return #f) + ) + ) + (return #f) + v0-0 + ) + +;; definition for function metalkor-shoot-projectile +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-shoot-projectile metalkor () + (let ((gp-0 (new 'stack-no-clear 'projectile-init-by-other-params))) + (set! (-> gp-0 ent) (-> self entity)) + (set! (-> gp-0 charge) 1.0) + (set! (-> gp-0 options) (projectile-options)) + (set! (-> gp-0 notify-handle) (the-as handle #f)) + (set! (-> gp-0 owner-handle) (the-as handle #f)) + (set! (-> gp-0 ignore-handle) (process->handle self)) + (let* ((v1-5 *game-info*) + (a0-5 (+ (-> v1-5 attack-id) 1)) + ) + (set! (-> v1-5 attack-id) a0-5) + (set! (-> gp-0 attack-id) a0-5) + ) + (set! (-> gp-0 timeout) (seconds 4)) + (vector<-cspace! (-> gp-0 pos) (-> self node-list data 7)) + (vector-! (-> gp-0 vel) (target-pos 0) (-> gp-0 pos)) + (vector-normalize! (-> gp-0 vel) 491520.0) + (if (spawn-projectile metalkor-shot gp-0 self *default-dead-pool*) + (+! (-> self shots-fired) 1) + ) + ) + (none) + ) + +;; definition for function metalkor-face-to-vector +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-face-to-vector metalkor ((arg0 vector) (arg1 float) (arg2 float)) + (let ((s4-0 (new 'stack-no-clear 'matrix)) + (s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (gp-0 (new 'stack-no-clear 'matrix)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (vector-! s3-0 arg0 (-> self root-override trans)) + (vector-flatten! s3-0 s3-0 (-> s5-0 vector 1)) + (vector-normalize! s3-0 1.0) + (matrix-from-two-vectors-max-angle-partial! + s4-0 + (-> s5-0 vector 2) + s3-0 + (* arg1 (-> self clock time-adjust-ratio)) + (* arg2 (-> self clock time-adjust-ratio)) + ) + ) + (matrix*! gp-0 s5-0 s4-0) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (set! (-> self last-rotation) (acos (vector-dot (-> s5-0 vector 2) (-> gp-0 vector 2)))) + (if (< (vector-dot (-> gp-0 vector 2) (the-as vector (-> s5-0 vector))) 0.0) + (set! (-> self last-rotation) (- (-> self last-rotation))) + ) + (cond + ((< (fabs (-> self last-rotation)) 20.024889) + (set! (-> self last-rotation) 0.0) + ) + (else + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + ) + ) + ) + 0 + (none) + ) + +;; definition for function update-walk-anim +;; WARN: Return type mismatch float vs none. +(defbehavior update-walk-anim metalkor ((arg0 vector) (arg1 symbol)) + (local-vars (f24-0 float)) + (let ((v1-2 (ja-group))) + (cond + ((and (and v1-2 (= v1-2 (-> self draw art-group data 33))) (begin (ja :num! (seek!)) (not (ja-done? 0)))) + ) + (else + (let* ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) arg0)) + (v1-16 s5-1) + (f26-0 (sqrtf (+ (* (-> v1-16 x) (-> v1-16 x)) (* (-> v1-16 z) (-> v1-16 z))))) + (v1-19 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + 0.0 + (let ((f30-0 0.0) + (f28-0 0.0) + ) + 0.0 + (let ((f0-11 (* 0.000024414063 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 5)) frames num-frames)) + f26-0 + ) + ) + (f26-1 (* 0.000015258789 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 6)) frames num-frames)) + f26-0 + ) + ) + ) + (cond + ((or (< 1.0 f26-1) arg1) + (set! f24-0 0.0) + ) + ((< f0-11 1.0) + (set! f24-0 1.0) + (set! f26-1 f0-11) + ) + (else + (set! f24-0 (/ (- 1.0 f26-1) (- f0-11 f26-1))) + (set! f26-1 1.0) + ) + ) + (let ((f0-15 (* 0.000045776367 + (the float (-> (the-as art-joint-anim (-> self draw art-group data 37)) frames num-frames)) + (-> self last-rotation) + ) + ) + ) + (when (and (< (vector-dot s5-1 (-> v1-19 vector 2)) 0.0) (not arg1)) + (set! f26-1 (- f26-1)) + (set! f0-15 (- f0-15)) + ) + (if (< f0-15 0.0) + (set! f30-0 1.0) + ) + (when (and (< (fabs f26-1) (fabs f0-15)) (not arg1)) + (set! f26-1 f0-15) + (set! f28-0 1.0) + ) + ) + (let ((f22-0 (if (and (= f26-1 0.0) (not arg1)) + 1.0 + 0.0 + ) + ) + ) + (let ((v1-41 (ja-group))) + (cond + ((not (and v1-41 (= v1-41 (-> self draw art-group data 6)))) + (ja-channel-push! 9 (seconds 0.5)) + (ja :group! (-> self draw art-group data 6) :num! min) + (ja :chan 1 :group! (-> self draw art-group data 40) :num! min) + (set! (-> self skel root-channel 2 command) (joint-control-command push)) + (ja :chan 2 :group! (-> self draw art-group data 5) :num! min) + (ja :chan 3 :group! (-> self draw art-group data 39) :num! min) + (set! (-> self skel root-channel 4 command) (joint-control-command stack)) + (set! (-> self skel root-channel 5 command) (joint-control-command push)) + (ja :chan 5 :group! (-> self draw art-group data 37) :num! min) + (ja :chan 6 :group! (-> self draw art-group data 38) :num! min) + (set! (-> self skel root-channel 7 command) (joint-control-command stack)) + (let* ((v1-79 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-80 (the-as number (logior #x3f800000 v1-79))) + ) + (cond + ((< (+ -1.0 (the-as float v1-80)) 0.2) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + (else + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 0 1)) + ) + ) + ) + (init + (-> self for-back-interp) + (if (< f26-1 0.0) + 1.0 + 0.0 + ) + 0.01 + 0.1 + 0.9 + ) + (init (-> self run-walk-interp) f24-0 0.01 0.1 0.9) + (init (-> self left-right-interp) f30-0 0.01 0.1 0.9) + (init (-> self walk-turn-interp) f28-0 0.01 0.1 0.9) + (init (-> self idle-interp) f22-0 0.01 0.1 0.9) + ) + ((= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 41) + ) + (ja :chan 8 :num! (seek!)) + (when (ja-done? 8) + (let* ((v1-117 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-118 (the-as number (logior #x3f800000 v1-117))) + ) + (cond + ((< (+ -1.0 (the-as float v1-118)) 0.2) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + (else + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 0 1)) + ) + ) + ) + ) + ) + ((= (if (> (-> self skel active-channels) 0) + (-> self skel root-channel 8 frame-group) + ) + (-> self draw art-group data 4) + ) + (ja :chan 8 :num! (seek!)) + (when (ja-done? 8) + (ja :chan 8 :group! (-> self draw art-group data 3) :num! min) + (set! (-> self reps-till-idle-alt) (rand-vu-int-range 2 4)) + ) + ) + ((zero? (-> self reps-till-idle-alt)) + (ja :chan 8 :num! (seek!)) + (if (ja-done? 8) + (ja :chan 8 :group! (-> self draw art-group data 4) :num! min) + ) + ) + (else + (let ((f20-0 (ja-aframe-num 8))) + (ja :chan 8 :num! (loop!)) + (if (< (ja-aframe-num 8) f20-0) + (+! (-> self reps-till-idle-alt) -1) + ) + ) + ) + ) + ) + (let ((a0-94 (-> self skel root-channel 0))) + (set! (-> a0-94 param 0) f26-1) + (joint-control-channel-group-eval! a0-94 (the-as art-joint-anim #f) num-func-loop-speedless!) + ) + (ja :chan 1 :num! (chan 0)) + (ja :chan 2 :num! (chan 0)) + (ja :chan 3 :num! (chan 0)) + (ja :chan 5 :num! (chan 0)) + (ja :chan 6 :num! (chan 0)) + (set! (-> self for-back-interp target) (if (< f26-1 0.0) + 1.0 + 0.0 + ) + ) + (set! (-> self run-walk-interp target) f24-0) + (set! (-> self left-right-interp target) f30-0) + (set! (-> self walk-turn-interp target) f28-0) + (cond + ((or (< 0.5 (-> self idle-interp target)) (< f22-0 0.5)) + (set! (-> self idle-interp target) f22-0) + ) + ((< (-> self idle-interp value) 0.01) + (ja :chan 8 :group! (-> self draw art-group data 41) :num! min) + (set! (-> self idle-interp target) f22-0) + ) + ) + ) + ) + ) + ) + (update! (-> self for-back-interp) 0.0) + (update! (-> self run-walk-interp) 0.0) + (update! (-> self left-right-interp) 0.0) + (update! (-> self walk-turn-interp) 0.0) + (update! (-> self idle-interp) 0.0) + (let ((v1-217 (-> self skel root-channel 1)) + (f0-58 (-> self for-back-interp value)) + ) + (set! (-> v1-217 frame-interp 1) f0-58) + (set! (-> v1-217 frame-interp 0) f0-58) + ) + (let ((v1-221 (-> self skel root-channel 3)) + (f0-59 (-> self for-back-interp value)) + ) + (set! (-> v1-221 frame-interp 1) f0-59) + (set! (-> v1-221 frame-interp 0) f0-59) + ) + (let ((v1-225 (-> self skel root-channel 4)) + (f0-60 (-> self run-walk-interp value)) + ) + (set! (-> v1-225 frame-interp 1) f0-60) + (set! (-> v1-225 frame-interp 0) f0-60) + ) + (let ((v1-229 (-> self skel root-channel 6)) + (f0-61 (-> self left-right-interp value)) + ) + (set! (-> v1-229 frame-interp 1) f0-61) + (set! (-> v1-229 frame-interp 0) f0-61) + ) + (let ((v1-233 (-> self skel root-channel 7)) + (f0-62 (-> self walk-turn-interp value)) + ) + (set! (-> v1-233 frame-interp 1) f0-62) + (set! (-> v1-233 frame-interp 0) f0-62) + ) + (let ((v1-237 (-> self skel root-channel 8)) + (f0-63 (-> self idle-interp value)) + ) + (set! (-> v1-237 frame-interp 1) f0-63) + (set! (-> v1-237 frame-interp 0) f0-63) + ) + ) + ) + ) + (none) + ) + +;; definition for function rotate-and-update-hang-anim +;; INFO: Used lq/sq +;; WARN: Return type mismatch symbol vs none. +(defbehavior rotate-and-update-hang-anim metalkor () + (let ((s5-0 (new 'stack-no-clear 'matrix)) + (gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (set! (-> s3-0 quad) (-> (target-pos 0) quad)) + (vector-! s4-0 s3-0 (-> self root-override trans)) + ) + (vector-flatten! s4-0 s4-0 (-> gp-0 vector 1)) + (vector-normalize! s4-0 1.0) + (let ((f26-0 (acos (vector-dot s4-0 (-> gp-0 vector 2)))) + (f30-0 0.0) + ) + (let ((f28-0 (ja-aframe-num 0))) + (set! (-> self target-angle) f26-0) + (if (< 0.0 (vector-dot s4-0 (the-as vector (-> gp-0 vector)))) + (set! f26-0 (- f26-0)) + ) + (let ((v1-12 (ja-group))) + (cond + ((and (and v1-12 (or (= v1-12 (-> self draw art-group data 18)) + (= v1-12 (-> self draw art-group data 21)) + (= v1-12 (-> self draw art-group data 24)) + ) + ) + (begin (ja :num! (seek!)) (not (ja-done? 0))) + ) + ) + ((and (< 8738.134 f26-0) + (let ((v1-30 (ja-group))) + (not (and v1-30 (or (= v1-30 (-> self draw art-group data 10)) (= v1-30 (-> self draw art-group data 11))))) + ) + ) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 10) :num! min) + (metalkor-spinners-off) + ) + ((and (< f26-0 -8738.134) + (let ((v1-44 (ja-group))) + (not (and v1-44 (or (= v1-44 (-> self draw art-group data 13)) (= v1-44 (-> self draw art-group data 14))))) + ) + ) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 13) :num! min) + (metalkor-spinners-off) + ) + (else + (let ((v1-55 (ja-group))) + (cond + ((and v1-55 (= v1-55 (-> self draw art-group data 10))) + (ja :num! (seek!)) + (metalkor-spinner-check 0 10.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 11.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 12.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 13.0 (-> gp-0 vector 2)) + (if (and (>= 20.0 f28-0) (< 20.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 30.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 31.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 32.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 33.0 f28-0) + (set! f30-0 (/ 12288.0 (the float (ja-num-frames 0)))) + (cond + ((not (ja-done? 0)) + ) + ((< 8738.134 f26-0) + (ja :group! (-> self draw art-group data 11) :num! min) + ) + (else + (ja :group! (-> self draw art-group data 12) :num! min) + ) + ) + ) + ((let ((v1-87 (ja-group))) + (and v1-87 (= v1-87 (-> self draw art-group data 11))) + ) + (if (< 8738.134 f26-0) + (ja :num! (loop!)) + (ja :num! (seek!)) + ) + (if (and (>= 40.0 f28-0) (< 40.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 0 50.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 51.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 52.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 53.0 (-> gp-0 vector 2)) + (if (and (>= 60.0 f28-0) (< 60.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 70.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 71.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 72.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 73.0 f28-0) + (set! f30-0 (/ 16384.0 (the float (ja-num-frames 0)))) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 12) :num! min) + ) + ) + ((let ((v1-124 (ja-group))) + (and v1-124 (= v1-124 (-> self draw art-group data 12))) + ) + (ja :num! (seek!)) + (if (and (>= 80.0 f28-0) (< 80.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 0 90.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 91.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 92.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 2 93.0 (-> gp-0 vector 2)) + (if (< (ja-aframe-num 0) 100.0) + (set! f30-0 (/ 4096.0 (the float (/ (ja-num-frames 0) 2)))) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + ((let ((v1-154 (ja-group))) + (and v1-154 (= v1-154 (-> self draw art-group data 13))) + ) + (ja :num! (seek!)) + (metalkor-spinner-check 2 10.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 11.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 12.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 13.0 (-> gp-0 vector 2)) + (if (and (>= 20.0 f28-0) (< 20.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 30.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 31.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 32.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 33.0 f28-0) + (set! f30-0 (/ -12288.0 (the float (ja-num-frames 0)))) + (cond + ((not (ja-done? 0)) + ) + ((< f26-0 -8738.134) + (ja :group! (-> self draw art-group data 14) :num! min) + ) + (else + (ja :group! (-> self draw art-group data 15) :num! min) + ) + ) + ) + ((let ((v1-186 (ja-group))) + (and v1-186 (= v1-186 (-> self draw art-group data 14))) + ) + (if (< f26-0 -8738.134) + (ja :num! (loop!)) + (ja :num! (seek!)) + ) + (if (and (>= 40.0 f28-0) (< 40.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 2 50.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 51.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 52.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 53.0 (-> gp-0 vector 2)) + (if (and (>= 60.0 f28-0) (< 60.0 (ja-aframe-num 0))) + (metalkor-lowtorso-spinners-off) + ) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 0) 70.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 1) 71.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 3) 72.0 f28-0) + (metalkor-lowtorso-spinner-check (the-as metalkor-lowtorso 2) 73.0 f28-0) + (set! f30-0 (/ -16384.0 (the float (ja-num-frames 0)))) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 15) :num! min) + ) + ) + ((let ((v1-223 (ja-group))) + (and v1-223 (= v1-223 (-> self draw art-group data 15))) + ) + (ja :num! (seek!)) + (if (and (>= 80.0 f28-0) (< 80.0 (ja-aframe-num 0))) + (metalkor-spinners-off) + ) + (metalkor-spinner-check 2 90.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 3 91.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 1 92.0 (-> gp-0 vector 2)) + (metalkor-spinner-check 0 93.0 (-> gp-0 vector 2)) + (if (< (ja-aframe-num 0) 80.0) + (set! f30-0 (/ -4096.0 (the float (/ (ja-num-frames 0) 2)))) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + (else + (let ((v1-253 (ja-group))) + (cond + ((and v1-253 (= v1-253 (-> self draw art-group data 9))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 9) :num! min) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (when (!= f30-0 0.0) + (matrix-axis-angle! s5-0 (-> gp-0 vector 1) (* 0.5 (-> self clock time-adjust-ratio) f30-0)) + (matrix*! gp-0 gp-0 s5-0) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + ) + ) + ) + (dotimes (gp-1 (ja-group-size)) + (if (nonzero? gp-1) + (ja :chan gp-1 :num! (loop!)) + ) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate beaten (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('occlude-off) + (let ((a0-3 (handle->process (-> self rift-occlude)))) + (if a0-3 + (the-as symbol (deactivate a0-3)) + ) + ) + ) + ) + ) + ) + :enter (behavior ((arg0 symbol)) + (ja-channel-set! 0) + (ja-post) + (send-event (handle->process (-> self hud)) 'hide-and-die) + (set! (-> self hud) (the-as handle #f)) + (remove-setting! 'point-of-interest) + (remove-setting! 'fov) + (when arg0 + (remove-setting! 'music) + (send-event (handle->process (-> self rift-occlude)) 'movie-pos) + (outro-play) + ) + (none) + ) + :exit (behavior () + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3) :num! min) + (none) + ) + :code (the-as (function symbol none :behavior metalkor) sleep-code) + ) + +;; failed to figure out what this is: +(defstate explode (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('exploding) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 1) + (set! (-> gp-0 message) 'stutter) + (set! (-> gp-0 param 0) (the-as uint #f)) + (let ((s5-0 send-event-function) + (v1-4 (metalkor-get-ring self)) + ) + (s5-0 + (if v1-4 + (-> v1-4 extra process) + ) + gp-0 + ) + ) + ) + ) + (('explode-done) + (the-as object (metalkor-go-next-stage)) + ) + ) + ) + ) + :enter (behavior () + (process-grab? *target* #f) + (set-setting! 'entity-name "camera-271" 0 0) + (send-event *camera* 'change-target self) + (none) + ) + :exit (behavior () + (process-release? *target*) + (let ((gp-0 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-0 from) (process->ppointer self)) + (set! (-> gp-0 num-params) 1) + (set! (-> gp-0 message) 'stutter) + (set! (-> gp-0 param 0) (the-as uint #f)) + (let ((s5-0 send-event-function) + (v1-3 (metalkor-get-ring self)) + ) + (s5-0 + (if v1-3 + (-> v1-3 extra process) + ) + gp-0 + ) + ) + ) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 3) :num! min) + (let ((a0-7 (handle->process (-> self explode)))) + (if a0-7 + (deactivate a0-7) + ) + ) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (none) + ) + :trans (behavior () + (when (not (handle->process (-> self explode))) + (let ((v1-4 (the-as entity-actor (metalkor-get-ring self)))) + (when v1-4 + (let ((s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> v1-4 quat))) + (gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + ) + (let ((s4-0 (new 'stack-no-clear 'matrix))) + (vector-negate! (-> s5-0 vector 2) (-> s5-0 vector 2)) + (matrix-from-two-vectors-max-angle-partial! s4-0 (-> gp-0 vector 2) (-> s5-0 vector 2) 273.06668 0.75) + (matrix*! gp-0 gp-0 s4-0) + ) + (matrix-remove-z-rot gp-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) gp-0) + (quaternion-normalize! (-> self root-override quat)) + (let ((f0-1 (vector-dot (-> gp-0 vector 1) (new 'static 'vector :y 1.0)))) + (let* ((f1-0 1.0) + (f2-0 f0-1) + (f1-2 (sqrtf (- f1-0 (* f2-0 f2-0)))) + ) + (vector+float*! + (-> self root-override trans) + (-> self hit-ring-trans) + (-> self hit-ring-offset) + (* 73728.0 f1-2) + ) + ) + (+! (-> self root-override trans y) (* 73728.0 (- 1.0 f0-1))) + ) + ) + ) + ) + (let ((v1-21 (ja-group))) + (cond + ((and v1-21 (= v1-21 (-> self draw art-group data 47))) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (if (and (< f30-0 16.0) (>= (ja-aframe-num 0) 16.0)) + (set-action! + *gui-control* + (gui-action play) + (-> self explode-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + ) + (when (ja-done? 0) + (ja-channel-set! 0) + (set! (-> self explode) (ppointer->handle (process-spawn + metalkor-explode + (-> self root-override trans) + (-> self root-override quat) + (process->handle (-> (metalkor-get-ring self) extra process)) + :to self + ) + ) + ) + ) + ) + (else + (ja :group! (-> self draw art-group data 47) :num! min) + (let ((gp-3 (new 'stack-no-clear 'event-message-block))) + (set! (-> gp-3 from) (process->ppointer self)) + (set! (-> gp-3 num-params) 1) + (set! (-> gp-3 message) 'stutter) + (set! (-> gp-3 param 0) (the-as uint #t)) + (let ((s5-2 send-event-function) + (v1-61 (metalkor-get-ring self)) + ) + (s5-2 + (if v1-61 + (-> v1-61 extra process) + ) + gp-3 + ) + ) + ) + (process-spawn metalkor-distort (-> self root-override trans) (-> self root-override quat) :to self) + ) + ) + ) + ) + (update! (-> self ring-cam-pos) 0.0) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate fly-to-ring (metalkor) + :virtual #t + :enter (behavior () + (process-grab? *target* #f) + (set! (-> self been-to-entity) #f) + (sound-play "nboss-hover" :id (-> self wing-sound) :position (-> self root-override trans)) + (set! (-> self wing-sound-playing) #t) + (init (-> self flying-speed) 0.0 0.01 0.1 0.9) + (set! (-> self flying-speed target) 1.0) + (let ((a0-6 (metalkor-get-ring self))) + (cond + (a0-6 + (set! (-> self hit-ring-trans quad) (-> a0-6 trans quad)) + (set! (-> self hit-ring-trans y) (+ -110592.0 (-> self hit-ring-trans y))) + (vector-! (-> self hit-ring-offset) (-> self hit-ring-trans) (-> self entity trans)) + (set! (-> self hit-ring-offset y) 0.0) + (vector-normalize! (-> self hit-ring-offset) 1.0) + (vector+float*! (-> self hit-ring-trans) (-> self hit-ring-trans) (-> self hit-ring-offset) -16384.0) + ) + (else + (set! (-> self hit-ring-trans quad) (-> self entity trans quad)) + (set-vector! (-> self hit-ring-offset) 1.0 0.0 0.0 1.0) + ) + ) + ) + (set-setting! 'entity-name "camera-272" 0 0) + (send-event *camera* 'change-target self) + (set! (-> self need-teleport) #f) + (set-setting! 'teleport-on-entity-change 'abs #t 0) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 1.0) + ) + (set! (-> self explode-sound) + (add-process *gui-control* self (gui-channel jak) (gui-action queue) "nbexplo" -99.0 0) + ) + (none) + ) + :exit (behavior () + (process-release? *target*) + (when (-> self wing-sound-playing) + (sound-stop (-> self wing-sound)) + (set! (-> self wing-sound-playing) #f) + ) + (vector+float*! (-> self hit-ring-trans) (-> self hit-ring-trans) (-> self hit-ring-offset) 32768.0) + (set! (-> self root-override trans quad) (-> self hit-ring-trans quad)) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (remove-setting! 'teleport-on-entity-change) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 46))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 46) :num! min) + ) + ) + ) + (update! (-> self flying-speed) 0.0) + (metalkor-face-to-vector (-> self hit-ring-trans) 728.1778 0.005) + (cond + ((-> self been-to-entity) + (vector-seek-3d-smooth! + (-> self root-override trans) + (-> self hit-ring-trans) + (* 3072.0 (-> self flying-speed value)) + 0.5 + ) + (let ((f0-4 (vector-vector-distance-squared (-> self root-override trans) (-> self hit-ring-trans))) + (f1-1 4096.0) + ) + (cond + ((< f0-4 (* f1-1 f1-1)) + (go-virtual explode) + ) + ((let ((f1-4 40960.0)) + (< f0-4 (* f1-4 f1-4)) + ) + (set! (-> self ring-cam-pos target) 1.0) + ) + ) + ) + ) + (else + (let ((gp-1 (new 'stack-no-clear 'vector))) + (set! (-> gp-1 quad) (-> self entity trans quad)) + (set! (-> gp-1 y) (+ -61440.0 (-> gp-1 y))) + (vector-seek-3d-smooth! (-> self root-override trans) gp-1 (* 3072.0 (-> self flying-speed value)) 0.5) + (let ((f0-10 (vector-vector-distance-squared (-> self root-override trans) gp-1)) + (f1-9 12288.0) + ) + (when (< f0-10 (* f1-9 f1-9)) + (set! (-> self been-to-entity) #t) + (set-setting! 'entity-name "camera-271" 0 0) + ) + ) + ) + ) + ) + (when (nonzero? (-> self neck)) + (let ((v1-46 (metalkor-get-ring self))) + (if v1-46 + (target-set! (-> self neck) (-> v1-46 trans)) + ) + ) + ) + (update! (-> self ring-cam-pos) 0.0) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate last-gasp (metalkor) + :virtual #t + :enter (behavior () + (set-setting! 'music #f 0 0) + (process-grab? *target* #f) + (set-setting! 'entity-name "camera-272" 0 0) + (remove-setting! 'point-of-interest) + (send-event *camera* 'change-target self) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (none) + ) + :exit (behavior () + (process-release? *target*) + (remove-setting! 'entity-name) + (send-event *camera* 'change-target #f) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 7))) + (ja :num! (seek! max 0.5)) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 45) :num! min) + ) + ) + ((let ((v1-21 (ja-group))) + (and v1-21 (= v1-21 (-> self draw art-group data 45))) + ) + (ja :num! (seek!)) + (if (and (< 218.0 (ja-aframe-num 0)) (nonzero? (-> self neck))) + (set! (-> self neck flex-blend) 1.0) + ) + (if (ja-done? 0) + (go-virtual fly-to-ring) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 7) :num! min) + ) + ) + ) + (when (nonzero? (-> self neck)) + (let ((v1-50 (metalkor-get-ring self))) + (if v1-50 + (target-set! (-> self neck) (-> v1-50 trans)) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate overload-recover (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (ja-channel-push! 1 (seconds 0.1)) + (ja :group! (-> self draw art-group data 30) :num! min) + (none) + ) + :exit (behavior () + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 1.0) + ) + (none) + ) + :trans (behavior () + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual get-close) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition for function set-color-vectors +;; WARN: Return type mismatch object vs none. +(defbehavior set-color-vectors metalkor ((arg0 float)) + (vector-lerp! + (-> self draw color-mult) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) + (new 'static 'vector) + (fmin 1.0 arg0) + ) + (set! (-> self draw color-mult w) 1.0) + (vector-lerp! + (-> self draw color-emissive) + (new 'static 'vector) + (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) + arg0 + ) + (send-event (handle->process (-> self legs)) 'color (-> self draw color-mult) (-> self draw color-emissive)) + (send-event + (handle->process (-> self lowtorso)) + 'color + (-> self draw color-mult) + (-> self draw color-emissive) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate fall-down (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self min-state-hit-points) (+ -0.34 (-> self stage-hit-points))) + (if (nonzero? (-> self neck)) + (set! (-> self neck flex-blend) 0.0) + ) + (set! (-> self bomb-sound) + (add-process *gui-control* self (gui-channel jak) (gui-action queue) "nbshock" -99.0 0) + ) + (set! (-> self stop-bomb-sound) #t) + (none) + ) + :exit (behavior () + (if (-> self stop-bomb-sound) + (set-action! + *gui-control* + (gui-action stop) + (-> self bomb-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + ) + (none) + ) + :trans (behavior () + (if (or (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1)) + (>= (-> self min-state-hit-points) (-> self stage-hit-points)) + ) + (go-virtual overload-recover) + ) + (let ((v1-10 (ja-group))) + (cond + ((and v1-10 (or (= v1-10 (-> self draw art-group data 7)) (= v1-10 (-> self draw art-group data 25)))) + (let ((f30-0 (ja-aframe-num 0))) + (let ((a0-10 (-> self skel root-channel 0))) + (set! (-> a0-10 param 0) (the float (+ (-> a0-10 frame-group frames num-frames) -1))) + (let ((v1-21 (ja-group))) + (set! (-> a0-10 param 1) (if (and v1-21 (= v1-21 (-> self draw art-group data 7))) + 0.5 + 1.0 + ) + ) + ) + (joint-control-channel-group-eval! a0-10 (the-as art-joint-anim #f) num-func-seek!) + ) + (when (and (< f30-0 6.0) (>= (ja-aframe-num 0) 6.0)) + (process-spawn metalkor-bomb (-> self root-override trans) (-> self entity) :to self :stack-size #x6000) + (set-action! + *gui-control* + (gui-action play) + (-> self bomb-sound) + (gui-channel none) + (gui-action none) + (the-as string #f) + (the-as (function gui-connection symbol) #f) + (the-as process #f) + ) + (set! (-> self stop-bomb-sound) #f) + ) + ) + (if (ja-done? 0) + (ja :group! (-> self draw art-group data 8) :num! min) + ) + ) + (else + (let ((v1-49 (ja-group))) + (cond + ((and v1-49 (= v1-49 (-> self draw art-group data 8))) + (ja :num! (loop!)) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 7) :num! min) + ) + ) + ) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate play-drop-movie (metalkor) + :virtual #t + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (process-entity-status! self (entity-perm-status subtask-complete) #t) + (process-spawn scene-player :init scene-player-init "nest-kor-boss-fight-mid" #t "nestb-boss") + (none) + ) + :trans (behavior () + (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.5)) + (deactivate self) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition for function metalkor-walk-the-walk +;; INFO: Used lq/sq +;; WARN: Return type mismatch object vs none. +;; WARN: Function metalkor-walk-the-walk has a return type of none, but the expression builder found a return statement. +(defbehavior metalkor-walk-the-walk metalkor ((arg0 float) (arg1 symbol)) + (local-vars (v1-32 float) (v1-38 float) (v1-80 float) (sv-864 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (let ((v1-2 (ja-group))) + (if (and (and v1-2 (= v1-2 (-> self draw art-group data 33))) (begin (ja :num! (seek!)) (not (ja-done? 0)))) + (return #f) + ) + ) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (set! (-> s5-0 quad) (-> self root-override trans quad)) + (set! sv-864 (target-pos 0)) + (metalkor-face-to-vector sv-864 546.13336 0.005) + (when (and (nonzero? (-> self previous-flat-travel-long-timer)) + (>= (+ (-> self clock frame-counter) (seconds -1.2)) (-> self previous-flat-travel-long-timer)) + ) + (set! (-> self previous-flat-travel-long-timer) 0) + (set! (-> self previous-flat-travel-timer) 0) + 0 + ) + (let ((s2-0 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (let ((s3-0 (new 'stack-no-clear 'vector))) + (let ((f30-0 (* 4096.0 (* 0.25 (-> self clock time-adjust-ratio)))) + (s1-0 #f) + ) + (set! (-> s3-0 quad) (-> self root-override trans quad)) + (vector-! s4-0 s3-0 sv-864) + (set! (-> s4-0 y) 0.0) + (let* ((f0-5 arg0) + (f0-7 (* f0-5 f0-5)) + ) + (.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-32 vf1) + (if (< f0-7 v1-32) + (set! s1-0 #t) + ) + ) + (vector-normalize! s4-0 arg0) + (let ((v1-35 s4-0)) + (let ((a0-15 s4-0)) + (.mov.vf vf6 vf0 :mask #b1000) + (.lvf vf4 (&-> a0-15 quad)) + ) + (.lvf vf5 (&-> sv-864 quad)) + (.add.vf vf6 vf4 vf5 :mask #b111) + (.svf (&-> v1-35 quad) vf6) + ) + (vector-! s4-0 s4-0 s3-0) + (set! (-> s4-0 y) 0.0) + (.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-38 vf1) + (let ((f0-9 v1-38) + (f1-3 f30-0) + ) + (if (< (* f1-3 f1-3) f0-9) + (vector-float*! s4-0 s4-0 (/ f30-0 (sqrtf f0-9))) + ) + ) + (set! (-> s2-0 poly) (-> self current-nav-poly)) + (dotimes (s0-1 5) + (let ((f30-1 (vector-length s4-0))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) s3-0 (-> s2-0 poly) s4-0 s2-0) + (cond + ((-> s2-0 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s2-0) + (let ((f28-0 (vector-length s4-0))) + (vector-flatten! s4-0 s4-0 (-> s2-0 boundary-normal)) + (let ((f0-12 (- f30-1 f28-0))) + (vector-normalize! s4-0 f0-12) + ) + ) + (if (and (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer)) + (< (vector-dot s4-0 (-> self previous-flat-travel)) 0.0) + ) + (vector-negate! s4-0 s4-0) + ) + (set! (-> s3-0 x) (-> s2-0 intersection x)) + (set! (-> s3-0 z) (-> s2-0 intersection z)) + (vector-! s3-0 s3-0 (-> s2-0 boundary-normal)) + (when (or s1-0 (> s0-1 0) (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer))) + (set! (-> self previous-flat-travel quad) (-> s4-0 quad)) + (set! (-> self previous-flat-travel-timer) (-> self clock frame-counter)) + (if (zero? (-> self previous-flat-travel-long-timer)) + (set! (-> self previous-flat-travel-long-timer) (-> self clock frame-counter)) + ) + ) + ) + (else + (goto cfg-43) + ) + ) + ) + ) + ) + (label cfg-43) + (vector+! s4-0 s3-0 s4-0) + ) + (vector-! s4-0 s4-0 (-> self root-override 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-80 vf1) + (let ((f0-17 v1-80) + (f1-7 40.96) + ) + (if (< f0-17 (* f1-7 f1-7)) + (vector-reset! s4-0) + ) + ) + (vector+! (-> self root-override trans) (-> self root-override trans) s4-0) + ) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (let ((s4-1 (new 'stack 'collide-query))) + (if (above-ground? + (-> self root-override) + s4-1 + (-> self root-override trans) + (collide-spec backgnd) + 12288.0 + 122880.0 + 1024.0 + ) + (set! (-> self root-override trans y) (-> s4-1 best-other-tri intersect y)) + ) + ) + (update-walk-anim s5-0 arg1) + (let ((v1-98 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) s5-0))) + (vector-float*! v1-98 v1-98 0.5) + (set! (-> v1-98 y) 0.0) + (send-event (handle->process (-> self lowtorso)) 'move-chain v1-98) + ) + ) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate tail-attack (metalkor) + :virtual #t + :event metalkor-handler + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 31))) + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual chase-target) + ) + ) + (else + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 31) :num! min) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; definition for function metalkor-set-deadly +;; WARN: Return type mismatch int vs none. +(defbehavior metalkor-set-deadly metalkor ((arg0 metalkor) (arg1 symbol) (arg2 int)) + (let ((v1-3 (-> (the-as collide-shape-prim-group (-> self root-override root-prim)) child arg2))) + (cond + (arg1 + (set! (-> v1-3 prim-core collide-as) (collide-spec enemy)) + (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot player-list)) + ) + (else + (set! (-> v1-3 prim-core collide-as) (collide-spec)) + (set! (-> v1-3 prim-core collide-with) (collide-spec)) + 0 + ) + ) + ) + (none) + ) + +;; failed to figure out what this is: +(defstate foot-attack (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (let ((s5-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (gp-1 (vector-! (new 'stack-no-clear 'vector) (-> self root-override trans) (-> self entity trans))) + ) + (vector-flatten! gp-1 gp-1 (-> s5-0 vector 1)) + (cond + ((< (vector-dot gp-1 (the-as vector (-> s5-0 vector))) 0.0) + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 43)) 1.0 1.0 4.0) + (metalkor-set-deadly self #t 2) + ) + (else + (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 42)) 1.0 1.0 4.0) + (metalkor-set-deadly self #t 3) + ) + ) + ) + (set! (-> self arm-frame) -1000.0) + (none) + ) + :exit (behavior () + (metalkor-set-deadly self #f 2) + (metalkor-set-deadly self #f 3) + (none) + ) + :trans (behavior () + (local-vars (a0-10 int)) + -1 + (let ((a0-1 (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 42))))) + (cond + ((>= a0-1 0) + (let ((f30-0 (ja-aframe-num a0-1))) + (if (< f30-0 10.0) + (metalkor-walk-the-walk 36864.0 #t) + ) + (cond + ((and (< (-> self arm-frame) 12.9) (>= f30-0 12.9)) + (sound-play "nboss-arm") + ) + ((and (< (-> self arm-frame) 15.9) (>= f30-0 15.9)) + (sound-play "nboss-growl") + ) + ) + (set! (-> self arm-frame) f30-0) + ) + ) + ((begin + (set! a0-10 (metalkor-ja-float-group? (the-as art-joint-anim (-> self draw art-group data 43)))) + (>= a0-10 0) + ) + (let ((f30-1 (ja-aframe-num a0-10))) + (if (< f30-1 52.0) + (metalkor-walk-the-walk 36864.0 #t) + ) + (cond + ((and (< (-> self arm-frame) 54.4) (>= f30-1 54.4)) + (sound-play "nboss-arm") + ) + ((and (< (-> self arm-frame) 56.9) (>= f30-1 56.9)) + (sound-play "nboss-growl") + ) + ) + (set! (-> self arm-frame) f30-1) + ) + ) + (else + (go-virtual chase-target) + ) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate get-close (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (none) + ) + :trans (behavior () + (cond + ((>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 4)) + (go-virtual chase-target) + ) + ((let ((f0-0 57344.0)) + (< (* f0-0 f0-0) (vector-vector-xz-distance-squared (-> self root-override trans) (target-pos 0))) + ) + ) + ((or (< (-> self last-close-attack) -1) + (and (< (-> self last-close-attack) 2) + (let* ((v1-14 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-15 (the-as number (logior #x3f800000 v1-14))) + ) + (< (+ -1.0 (the-as float v1-15)) 0.5) + ) + ) + ) + (set! (-> self last-close-attack) (max 1 (+ (-> self last-close-attack) 1))) + (go-virtual foot-attack) + ) + (else + (set! (-> self last-close-attack) (min -1 (+ (-> self last-close-attack) -1))) + (go-virtual tail-attack) + ) + ) + (metalkor-walk-the-walk 53248.0 #f) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate standing-shot (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self shots-fired) 0) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (none) + ) + :exit (behavior () + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 32))) + (none) + ) + :trans (behavior () + (if (>= (-> self shots-fired) (-> self stage)) + (go-virtual chase-target) + ) + (metalkor-walk-the-walk 122880.0 #f) + (spawn (-> self shot-anticipate) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 7))) + (let* ((a0-4 (-> self draw art-group data 32)) + (f0-2 + (/ (the float (-> (the-as art-joint-anim a0-4) frames num-frames)) (-> (the-as art-joint-anim a0-4) speed)) + ) + (f1-1 45.0) + ) + (if (zero? (-> self shots-fired)) + (set! f1-1 75.0) + ) + (if (metalkor-ja-float (the-as art-joint-anim a0-4) (/ f0-2 f1-1) 1.0 f0-2) + (sound-play "nboss-pre-shot") + ) + ) + (when (or (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 1.25)) + (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.75)) + (nonzero? (-> self shots-fired)) + ) + ) + (set! (-> self state-time) (-> self clock frame-counter)) + (metalkor-shoot-projectile) + (set-nestb-purple! (fmax 1.0 (get-nestb-purple))) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 32))) + (ja-channel-push! 1 (seconds 0.05)) + (ja :group! (-> self draw art-group data 33) :num! min) + ) + (if (zero? (-> self shots-fired)) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0013333333 (the float (- (-> self clock frame-counter) (-> self state-time))))) + ) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0022222223 (the float (- (-> self clock frame-counter) (-> self state-time))))) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate chase-target (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (when (and (not (and v1-2 (= v1-2 (-> self draw art-group data 33)))) + (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 3)) + ) + (cond + ((or (< (-> self last-standing-attack) -1) + (and (< (-> self last-standing-attack) 2) + (let* ((v1-14 (/ (the-as int (rand-uint31-gen *random-generator*)) 256)) + (v1-15 (the-as number (logior #x3f800000 v1-14))) + ) + (< (+ -1.0 (the-as float v1-15)) 0.5) + ) + ) + ) + (set! (-> self last-standing-attack) (max 1 (+ (-> self last-standing-attack) 1))) + (go-virtual get-close) + ) + (else + (set! (-> self last-standing-attack) (min -1 (+ (-> self last-standing-attack) -1))) + (go-virtual standing-shot) + ) + ) + ) + ) + (metalkor-walk-the-walk 122880.0 #f) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate start-second-stage (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 44) :num! min) + (metalkor-spinners-off) + (dotimes (gp-1 4) + (let ((a0-3 (handle->process (-> self lowtorso)))) + (if a0-3 + (send-event a0-3 'spinner gp-1) + ) + ) + ) + (none) + ) + :trans (behavior () + (let ((v1-2 (ja-group))) + (cond + ((and v1-2 (= v1-2 (-> self draw art-group data 21))) + (ja :num! (seek!)) + (if (ja-done? 0) + (go-virtual hang-shoot-n-launch) + ) + ) + ((let ((v1-17 (ja-group))) + (and v1-17 (= v1-17 (-> self draw art-group data 44))) + ) + (let ((f30-0 (ja-aframe-num 0))) + (ja :num! (seek!)) + (cond + ((and (< f30-0 84.0) (>= (ja-aframe-num 0) 84.0)) + (let ((gp-0 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (metalkor-start-spinner 1 (-> gp-0 vector 2)) + (metalkor-start-spinner 3 (-> gp-0 vector 2)) + ) + ) + ((and (< f30-0 85.0) (>= (ja-aframe-num 0) 85.0)) + (let ((gp-1 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat)))) + (metalkor-start-spinner 0 (-> gp-1 vector 2)) + (metalkor-start-spinner 2 (-> gp-1 vector 2)) + ) + ) + ) + ) + (when (ja-done? 0) + (ja-channel-push! 1 (seconds 0.2)) + (ja :group! (-> self draw art-group data 21) :num! min) + ) + ) + (else + (ja :group! (-> self draw art-group data 44) :num! min) + ) + ) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate hang-shoot-n-launch (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (set! (-> self shots-fired) 0) + (set! (-> self wave-timer) 0) + (set! (-> self in-wave) #f) + (set! (-> self flitter-timer) 0) + (set! (-> self wasp-timer) 0) + (set! (-> self launching-flitters) #f) + (set! (-> self launching-wasps) #f) + (set! (-> self egg-timer) 0) + 0 + (none) + ) + :exit (behavior () + (send-event (handle->process (-> self lowtorso)) 'egg-toss 0) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 23))) + (none) + ) + :trans (behavior () + (local-vars (sv-16 res-tag)) + (let ((v1-0 7500)) + (if (and (-> self in-wave) (= (-> self stage) 1)) + (set! v1-0 3000) + ) + (when (>= (- (-> self clock frame-counter) (-> self wave-timer)) v1-0) + (set! (-> self in-wave) (not (-> self in-wave))) + (set! (-> self wave-timer) (-> self clock frame-counter)) + ) + ) + (cond + ((or (!= (-> self stage) 2) (not (-> self in-wave)) (>= (-> self live-wasps) 3)) + (set! (-> self launching-wasps) #f) + ) + ((< (-> self live-wasps) 2) + (set! (-> self launching-wasps) #t) + ) + ) + (when (and (-> self launching-wasps) (>= (- (-> self clock frame-counter) (-> self wasp-timer)) (seconds 1.5))) + (set! (-> self wasp-timer) (-> self clock frame-counter)) + (dotimes (gp-0 3) + (when (not (handle->process (-> self wasps gp-0))) + (set! sv-16 (new 'static 'res-tag)) + (let ((v1-31 (res-lump-data (-> self entity) 'actor-groups (pointer actor-group) :tag-ptr (& sv-16)))) + (when (and v1-31 (< (the-as uint 1) (-> sv-16 elt-count))) + (let ((v1-32 (-> v1-31 1))) + (+! (-> self last-wasp-launched) 1) + (when (>= (-> self last-wasp-launched) (-> v1-32 length)) + (set! (-> self last-wasp-launched) 0) + 0 + ) + (when (< (-> self last-wasp-launched) (-> v1-32 length)) + (let ((s4-0 (-> v1-32 data (-> self last-wasp-launched) actor)) + (s5-0 (new 'stack-no-clear 'enemy-init-by-other-params)) + ) + (when (not (-> s4-0 extra process)) + (let ((s3-0 (-> s4-0 extra))) + (if (send-event (handle->process (-> self wasp-gem-tracker)) 'spawn-with-gem?) + (logclear! (-> s3-0 perm status) (entity-perm-status save)) + (logior! (-> s3-0 perm status) (entity-perm-status save)) + ) + ) + (set! (-> s5-0 trans quad) (-> s4-0 trans quad)) + (quaternion-copy! (-> s5-0 quat) (-> self root-override quat)) + (set! (-> s5-0 entity) s4-0) + (set! (-> s5-0 directed?) #f) + (set! (-> s5-0 no-initial-move-to-ground?) #f) + (let ((s4-1 (get-process *default-dead-pool* metalkor-wasp #x4000))) + (set! (-> self wasps gp-0) + (ppointer->handle (when s4-1 + (let ((t9-4 (method-of-type process activate))) + (t9-4 s4-1 self (symbol->string (-> metalkor-wasp symbol)) (the-as pointer #x70004000)) + ) + (run-now-in-process s4-1 enemy-init-by-other self s5-0) + (-> s4-1 ppointer) + ) + ) + ) + ) + (send-event + (handle->process (-> self wasp-gem-tracker)) + 'change-gem + #f + (handle->process (-> self wasps gp-0)) + ) + (goto cfg-69) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (label cfg-69) + (cond + ((< (-> self live-flitters) 3) + (set! (-> self launching-flitters) #t) + ) + ((or (!= (-> self stage) 1) (not (-> self in-wave)) (>= (-> self live-flitters) 10)) + (set! (-> self launching-flitters) #f) + ) + ((< (-> self live-flitters) 5) + (set! (-> self launching-flitters) #t) + ) + ) + (rotate-and-update-hang-anim) + (if (and (< 10922.667 (-> self target-angle)) + (< (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 3.75)) + (zero? (mod (-> self shots-fired) (-> self stage))) + ) + (set! (-> self shoot-timer) + (the-as time-frame (max (-> self shoot-timer) (+ (-> self clock frame-counter) (seconds -2.75)))) + ) + ) + (cond + ((metalkor-check-egg) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + ) + ((or (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 3.75)) + (nonzero? (mod (-> self shots-fired) (-> self stage))) + ) + (set! (-> self flitter-timer) (-> self clock frame-counter)) + (spawn (-> self shot-anticipate) (vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data 7))) + (if (zero? (mod (-> self shots-fired) (-> self stage))) + (set-nestb-purple! + (fmax + (get-nestb-purple) + (* 0.0013333333 (the float (+ (- (seconds -3.75) (-> self shoot-timer)) (-> self clock frame-counter)))) + ) + ) + (set-nestb-purple! + (fmax (get-nestb-purple) (* 0.0022222223 (the float (- (-> self clock frame-counter) (-> self shoot-timer))))) + ) + ) + (let* ((v1-123 (the-as art-joint-anim (-> self draw art-group data 23))) + (f0-7 (/ (the float (-> v1-123 frames num-frames)) (-> v1-123 speed))) + (f1-6 45.0) + ) + (if (zero? (mod (-> self shots-fired) (-> self stage))) + (set! f1-6 75.0) + ) + (if (metalkor-ja-float (the-as art-joint-anim (-> self draw art-group data 23)) (/ f0-7 f1-6) 1.0 f0-7) + (sound-play "nboss-pre-shot") + ) + ) + (when (or (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 5)) + (and (>= (- (-> self clock frame-counter) (-> self shoot-timer)) (seconds 0.75)) + (nonzero? (mod (-> self shots-fired) (-> self stage))) + ) + ) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (metalkor-shoot-projectile) + (set-nestb-purple! (fmax 1.0 (get-nestb-purple))) + (metalkor-ja-float-stop (the-as art-joint-anim (-> self draw art-group data 23))) + (ja-channel-push! 1 (seconds 0.05)) + (ja :group! (-> self draw art-group data 24) :num! min) + (metalkor-all-spinners-on) + ) + ) + ((and (-> self launching-flitters) + (>= (+ (-> self clock frame-counter) (seconds -0.5)) (-> self flitter-timer)) + ) + (set! (-> self flitter-timer) (-> self clock frame-counter)) + (set! (-> self shoot-timer) (-> self clock frame-counter)) + (metalkor-start-egg) + ) + ) + (metalkor-common) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + +;; failed to figure out what this is: +(defstate hidden (metalkor) + :virtual #t + :event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block)) + (the-as object (case event-type + (('occlude-off) + (let ((a0-3 (handle->process (-> self rift-occlude)))) + (if a0-3 + (the-as symbol (deactivate a0-3)) + ) + ) + ) + ) + ) + ) + :trans (behavior () + (if (task-node-closed? (game-task-node nest-boss-introduction)) + (metalkor-go-next-stage) + ) + (none) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + ) + +;; failed to figure out what this is: +(defstate test (metalkor) + :virtual #t + :event metalkor-handler + :enter (behavior () + (set! (-> self state-time) (-> self clock frame-counter)) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (ja :group! (-> self draw art-group data 5)) + (none) + ) + :trans (behavior () + (local-vars (v1-72 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (if (and (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.017)) (cpad-hold? 1 x)) + (go-virtual test) + ) + (let ((s4-0 (new-stack-vector0)) + (s2-0 (new-stack-vector0)) + (s5-0 (new 'stack-no-clear 'matrix)) + (s1-0 (new 'stack-no-clear 'matrix)) + (gp-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> gp-0 quad) (-> self root-override trans quad)) + (set! (-> s4-0 y) (analog-input (the-as int (-> *cpad-list* cpads 1 rightx)) 128.0 48.0 110.0 1.0)) + (set! (-> s2-0 z) (analog-input (the-as int (-> *cpad-list* cpads 1 lefty)) 128.0 48.0 110.0 1.0)) + (vector-float*! s4-0 s4-0 -364.0889) + (quaternion->matrix s1-0 (-> self root-override quat)) + (matrix-rotate-y! s5-0 (-> s4-0 y)) + (set! (-> self last-rotation) (-> s4-0 y)) + (matrix*! s1-0 s5-0 s1-0) + (matrix-remove-z-rot s1-0 (new 'static 'vector :y -1.0)) + (matrix->quaternion (-> self root-override quat) s1-0) + (quaternion-normalize! (-> self root-override quat)) + (when (and (nonzero? (-> self previous-flat-travel-long-timer)) + (>= (+ (-> self clock frame-counter) (seconds -1.2)) (-> self previous-flat-travel-long-timer)) + ) + (set! (-> self previous-flat-travel-long-timer) 0) + (set! (-> self previous-flat-travel-timer) 0) + 0 + ) + (let ((s3-0 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (s5-1 (new 'stack-no-clear 'vector)) + ) + (let ((s4-1 (new 'stack-no-clear 'vector))) + (let ((f0-5 2048.0)) + (set! (-> s4-1 quad) (-> self root-override trans quad)) + (vector-float*! s5-1 (-> s1-0 vector 2) (* (-> s2-0 z) (- f0-5))) + ) + (set! (-> s5-1 y) 0.0) + (set! (-> s3-0 poly) (-> self current-nav-poly)) + (dotimes (s2-1 5) + (let ((f30-0 (vector-length s5-1))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) s4-1 (-> s3-0 poly) s5-1 s3-0) + (cond + ((-> s3-0 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s3-0) + (let ((f28-0 (vector-length s5-1))) + (vector-flatten! s5-1 s5-1 (-> s3-0 boundary-normal)) + (let ((f0-9 (- f30-0 f28-0))) + (vector-normalize! s5-1 f0-9) + ) + ) + (if (and (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer)) + (< (vector-dot s5-1 (-> self previous-flat-travel)) 0.0) + ) + (vector-negate! s5-1 s5-1) + ) + (set! (-> s4-1 x) (-> s3-0 intersection x)) + (set! (-> s4-1 z) (-> s3-0 intersection z)) + (vector-! s4-1 s4-1 (-> s3-0 boundary-normal)) + (when (or (> s2-1 0) (< (+ (-> self clock frame-counter) (seconds -0.1)) (-> self previous-flat-travel-timer))) + (set! (-> self previous-flat-travel quad) (-> s5-1 quad)) + (set! (-> self previous-flat-travel-timer) (-> self clock frame-counter)) + (if (zero? (-> self previous-flat-travel-long-timer)) + (set! (-> self previous-flat-travel-long-timer) (-> self clock frame-counter)) + ) + ) + ) + (else + (goto cfg-30) + ) + ) + ) + ) + (label cfg-30) + (vector+! s5-1 s4-1 s5-1) + ) + (vector-! s5-1 s5-1 (-> self root-override trans)) + (.lvf vf1 (&-> s5-1 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-72 vf1) + (let ((f0-14 v1-72) + (f1-2 1024.0) + ) + (if (< (* f1-2 f1-2) f0-14) + (vector-float*! s5-1 s5-1 (/ 1024.0 (sqrtf f0-14))) + ) + ) + (vector+! (-> self root-override trans) (-> self root-override trans) s5-1) + ) + (set! (-> self current-nav-poly) (cloest-point-on-mesh + (-> self nav) + (-> self root-override trans) + (-> self root-override trans) + (-> self current-nav-poly) + ) + ) + (let ((s5-2 (new 'stack 'collide-query))) + (if (above-ground? + (-> self root-override) + s5-2 + (-> self root-override trans) + (collide-spec backgnd) + 12288.0 + 122880.0 + 1024.0 + ) + (set! (-> self root-override trans y) (-> s5-2 best-other-tri intersect y)) + ) + ) + (update-walk-anim gp-0 #f) + ) + (let ((s4-2 (new 'stack-no-clear 'clamp-travel-vector-to-mesh-return-info)) + (v1-94 (quaternion->matrix (new 'stack-no-clear 'matrix) (-> self root-override quat))) + (s3-1 (new 'stack-no-clear 'vector)) + (s5-3 (new 'stack-no-clear 'vector)) + (gp-1 (new 'stack-no-clear 'vector)) + ) + (let ((f0-18 81920.0)) + (set! (-> gp-1 quad) (-> self root-override trans quad)) + (set! (-> s5-3 quad) (-> v1-94 vector 2 quad)) + (set! (-> s5-3 y) 0.0) + (vector-normalize! s5-3 f0-18) + ) + (set! (-> s4-2 poly) (-> self current-nav-poly)) + (dotimes (s2-2 5) + (let ((f30-1 (vector-length s5-3))) + (clamp-vector-to-mesh-no-gaps (-> self nav state mesh) gp-1 (-> s4-2 poly) s5-3 s4-2) + (cond + ((-> s4-2 found-boundary) + (set-normals-from-adjacent-bounds (-> self nav state mesh) s4-2) + (camera-line (-> s4-2 vert-prev) (-> s4-2 vert-0) (new 'static 'vector4w :x #xff :w #x80)) + (camera-line (-> s4-2 vert-0) (-> s4-2 vert-1) (new 'static 'vector4w :y #xff :w #x80)) + (camera-line (-> s4-2 vert-1) (-> s4-2 vert-next) (new 'static 'vector4w :z #xff :w #x80)) + (camera-line-rel gp-1 s5-3 (new 'static 'vector4w :x #xff :w #x80)) + (let ((f28-1 (vector-length s5-3))) + (vector-flatten! s5-3 s5-3 (-> s4-2 boundary-normal)) + (let ((f0-19 (- f30-1 f28-1))) + (vector-normalize! s5-3 f0-19) + ) + ) + (set! (-> gp-1 x) (-> s4-2 intersection x)) + (set! (-> gp-1 z) (-> s4-2 intersection z)) + (vector-! gp-1 gp-1 (-> s4-2 boundary-normal)) + (vector+! s3-1 (-> s4-2 vert-prev) (-> s4-2 vert-0)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 prev-normal) 12288.0 (new 'static 'vector4w :x #xff :w #x80)) + (vector+! s3-1 (-> s4-2 vert-0) (-> s4-2 vert-1)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 boundary-normal) 12288.0 (new 'static 'vector4w :y #xff :w #x80)) + (vector+! s3-1 (-> s4-2 vert-1) (-> s4-2 vert-next)) + (vector-float*! s3-1 s3-1 0.5) + (camera-line-rel-len s3-1 (-> s4-2 next-normal) 12288.0 (new 'static 'vector4w :z #xff :w #x80)) + ) + (else + (goto cfg-42) + ) + ) + ) + ) + (label cfg-42) + (camera-line-rel gp-1 s5-3 (new 'static 'vector4w :x #xff :w #x80)) + ) + (metalkor-common) + (none) + ) + ) + :code (the-as (function none :behavior metalkor) sleep-code) + :post (behavior () + (transform-post) + (do-push-aways (-> self root-override)) + (none) + ) + ) + + + + diff --git a/test/offline/config/jak2/config.jsonc b/test/offline/config/jak2/config.jsonc index d91b389e48..2bf47a9a5b 100644 --- a/test/offline/config/jak2/config.jsonc +++ b/test/offline/config/jak2/config.jsonc @@ -301,7 +301,8 @@ "(method 49 traffic-engine)", // float stuff "(method 14 nav-graph)", "target-pilot-init", - "(method 224 crimson-guard)" // .mula.s + "(method 224 crimson-guard)", // .mula.s + "metalkor-egg-reaction" // .mula.s ], "skip_compile_states": {