Archive/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project.git synced 2024-10-20 00:57:44 -04:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

decomp: mech, mech-states, target-mech (#2091)

Browse source 
Everything relating to IK in `target-mech` was commented out as I
couldn't get a lambda to decompile properly, but the mech still seems to
work fine without it.

Co-authored-by: water <awaterford111445@gmail.com>
This commit is contained in:
Hat Kid 2023-01-05 01:42:26 +01:00 committed by GitHub
parent dfcd203aad
commit 09d555b4a0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 8767 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
decompiler/config/jak2/all-types.gc
View file

@ -44291,13 +44291,12 @@
(:methods
(wait-for-start () _type_ :state 20)
(idle () _type_ :state 21)
(pickup () _type_ :state 22)
(pickup ((state mech)) _type_ :state 22)
(wait-for-return () _type_ :state 23)
(mech-method-24 () none 24)
(mech-method-24 (_type_) none 24)
)
)
#|
(deftype mech-target (process-drawable)
()
:method-count-assert 22
@ -44308,71 +44307,70 @@
(active () _type_ :state 21)
)
)
|#
;; (define-extern *kernel-packages* object) ;; pair
(define-extern mech-init (function entity-actor matrix3 handle float none :behavior mech))
;; (define-extern mech-target-init function)
;; (define-extern mech-target-spawn function)
(define-extern mech-target-init (function vector quaternion entity-actor none :behavior mech))
(define-extern mech-target-spawn (function vector target quaternion entity-actor (pointer mech-target)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; target-mech ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (define-extern *mech-stance-mods* surface)
;; (define-extern *mech-walk-mods* surface)
;; (define-extern *mech-jump-mods* surface)
;; (define-extern *mech-punch-mods* surface)
;; (define-extern *mech-pickup-mods* surface)
;; (define-extern *mech-carry-walk-mods* surface)
;; (define-extern *mech-carry-drag-mods* surface)
;; (define-extern *mech-carry-jump-mods* surface)
;; (define-extern target-mech-falling-anim-trans function)
;; (define-extern target-mech-mech-effect function)
;; (define-extern mech-on-ground? function)
;; (define-extern target-mech-get-off? function)
;; (define-extern target-mech-handler function)
;; (define-extern target-mech-bonk-event-handler function)
;; (define-extern mech-leg-ik-callback function)
;; (define-extern mech-update-ik function)
;; (define-extern target-mech-init function)
;; (define-extern target-mech-exit function)
;; (define-extern target-mech-effect function)
;; (define-extern target-mech-add-thrust function)
;; (define-extern target-mech-collision function)
;; (define-extern target-mech-real-post function)
;; (define-extern target-mech-post function)
(define-extern *mech-stance-mods* surface)
(define-extern *mech-walk-mods* surface)
(define-extern *mech-jump-mods* surface)
(define-extern *mech-punch-mods* surface)
(define-extern *mech-pickup-mods* surface)
(define-extern *mech-carry-walk-mods* surface)
(define-extern *mech-carry-drag-mods* surface)
(define-extern *mech-carry-jump-mods* surface)
(define-extern target-mech-falling-anim-trans (function none :behavior target))
(define-extern target-mech-mech-effect (function target none :behavior mech))
(define-extern mech-on-ground? (function symbol :behavior target))
(define-extern target-mech-get-off? (function symbol :behavior target))
(define-extern target-mech-handler (function process int symbol event-message-block object :behavior target))
(define-extern target-mech-bonk-event-handler (function process int symbol event-message-block object :behavior target))
(define-extern mech-leg-ik-callback (function joint-mod-ik matrix matrix vector object :behavior target))
(define-extern mech-update-ik (function none :behavior target))
(define-extern target-mech-init (function handle float symbol none :behavior target))
(define-extern target-mech-exit (function none :behavior target))
(define-extern target-mech-effect (function none :behavior target))
(define-extern target-mech-add-thrust (function none :behavior target))
(define-extern target-mech-collision (function none :behavior target))
(define-extern target-mech-real-post (function none :behavior target))
(define-extern target-mech-post (function none :behavior target))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; mech-states ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; (define-extern *mech-exploder-params* joint-exploder-static-params)
(define-extern *mech-exploder-params* joint-exploder-static-params)
(define-extern target-mech-start (state handle target))
;; (define-extern target-mech-stance state)
;; (define-extern target-mech-walk state)
;; (define-extern target-mech-punch-pick function)
;; (define-extern target-mech-punch state)
;; (define-extern target-mech-falling state)
;; (define-extern target-mech-jump state)
;; (define-extern target-mech-hit-ground state)
;; (define-extern target-mech-hit state)
;; (define-extern target-mech-death state)
;; (define-extern target-mech-carry-update function)
;; (define-extern target-mech-carry-post function)
;; (define-extern target-mech-carry-pickup state)
;; (define-extern target-mech-carry-drop state)
;; (define-extern target-mech-carry-stance state)
;; (define-extern target-mech-carry-walk state)
;; (define-extern target-mech-carry-drag state)
;; (define-extern target-mech-carry-falling state)
;; (define-extern target-mech-carry-hit-ground state)
;; (define-extern target-mech-carry-jump state)
;; (define-extern target-mech-carry-throw state)
;; (define-extern target-mech-get-on state)
;; (define-extern target-mech-get-off state)
;; (define-extern target-mech-grab state)
;; (define-extern target-mech-clone-anim state)
(define-extern target-mech-stance (state target))
(define-extern target-mech-walk (state target))
(define-extern target-mech-punch-pick (function symbol int :behavior target))
(define-extern target-mech-punch (state target))
(define-extern target-mech-falling (state symbol target))
(define-extern target-mech-jump (state float float surface target))
(define-extern target-mech-hit-ground (state symbol target))
(define-extern target-mech-hit (state symbol attack-info target))
(define-extern target-mech-death (state symbol target))
(define-extern target-mech-carry-update (function none :behavior target))
(define-extern target-mech-carry-post (function none :behavior target))
(define-extern target-mech-carry-pickup (state target))
(define-extern target-mech-carry-drop (state target))
(define-extern target-mech-carry-stance (state target))
(define-extern target-mech-carry-walk (state target))
(define-extern target-mech-carry-drag (state target))
(define-extern target-mech-carry-falling (state target))
(define-extern target-mech-carry-hit-ground (state symbol target))
(define-extern target-mech-carry-jump (state float float target))
(define-extern target-mech-carry-throw (state target))
(define-extern target-mech-get-on (state handle target))
(define-extern target-mech-get-off (state target))
(define-extern target-mech-grab (state target))
(define-extern target-mech-clone-anim (state handle target))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; grunt-mech ;;

10
decompiler/config/jak2/anonymous_function_types.jsonc
View file

@ -650,5 +650,13 @@
[1, "(function float)"],
[3, "(function none :behavior scene-player)"]
],
"collectables": [[69, "(function part-tracker vector)"]]
"collectables": [[69, "(function part-tracker vector)"]],
"mech-states": [[50, "(function none :behavior target)"]],
"target-mech": [
[7, "(function none :behavior target)"],
[8, "(function none :behavior mech)"],
[9, "(function none :behavior target)"],
[18, "(function surface object surface int none :behavior target)"],
[19, "(function surface object surface int none :behavior target)"]
]
}

29
decompiler/config/jak2/label_types.jsonc
View file

@ -802,5 +802,32 @@
["L802", "uint64", true],
["L803", "uint64", true]
],
"hud": [["L217", "vector"]]
"hud": [["L217", "vector"]],
"mech-states": [
["L601", "uint64", true],
["L602", "uint64", true],
["L603", "uint64", true],
["L604", "uint64", true],
["L605", "uint64", true],
["L606", "uint64", true],
["L607", "uint64", true],
["L608", "uint64", true],
["L609", "uint64", true],
["L610", "uint64", true],
["L611", "uint64", true],
["L612", "uint64", true],
["L613", "uint64", true],
["L614", "uint64", true],
["L615", "uint64", true],
["L616", "uint64", true],
["L617", "uint64", true],
["L618", "uint64", true],
["L619", "uint64", true],
["L620", "uint64", true],
["L621", "uint64", true],
["L622", "uint64", true],
["L578", "attack-info"]
],
"mech": [["L106", "attack-info"]],
"target-mech": [["L210", "attack-info"]]
}

30
decompiler/config/jak2/stack_structures.jsonc
View file

@ -1274,5 +1274,33 @@
"(post idle gun-dummy)": [[16, "event-message-block"]],
"(method 23 training-manager)": [[16, "vector"]],
"birth-pickup-at-point": [[16, "vector"]],
"(code notice fodder)": [[112, "vector"]]
"(code notice fodder)": [[112, "vector"]],
"target-mech-collision": [
[704, "vector"],
[16, "vector"],
[32, "vector"],
[48, "event-message-block"],
[144, "vector"],
[160, "collide-query"],
[128, "vector"]
],
"target-mech-add-thrust": [[16, "vector"]],
"target-mech-get-off?": [[560, "sphere"]],
"mech-update-ik": [
[16, "collide-query"],
[592, "vector"],
[608, "vector"],
[624, "vector"],
[624, "vector"],
[640, "vector"],
[656, "vector"]
],
"target-mech-carry-update": [[560, "sphere"]],
"(code target-mech-carry-throw)": [[640, "sphere"]],
"(code target-mech-carry-drop)": [
[96, "vector"],
[672, "sphere"]
],
"(code target-mech-carry-pickup)": [[16, "event-message-block"]],
"(trans target-mech-carry-drag)": [[560, "sphere"]]
}

113
decompiler/config/jak2/type_casts.jsonc
View file

@ -3711,7 +3711,11 @@
"connection-list-validate": [[5, "gp", "connection"]],
"point-poly-distance-min": [[94, "f0", "float"]],
"(method 26 nav-mesh)": [[[23, 78], "s4", "nav-engine"]],
"compute-dir-parm": [[10, "v1", "float"]],
"compute-dir-parm": [
[18, "f0", "float"],
[8, "a2", "uint"],
[10, "v1", "float"]
],
"(trans idle fma-sphere)": [[39, "a2", "process-drawable"]],
"(method 10 talker)": [[29, "t9", "(function process none)"]],
"(exit active talker)": [[19, "s5", "process-drawable"]],
@ -5412,11 +5416,6 @@
[90, "v1", "collide-shape-prim-group"],
[110, "s2", "collide-shape-prim-sphere"]
],
"compute-dir-parm": [
[18, "f0", "float"],
[8, "a2", "uint"],
[10, "v1", "float"]
],
"(method 11 nav-state)": [[37, "v1", "float"]],
"(method 18 nav-control)": [[252, "a2", "float"]],
"(method 23 nav-mesh)": [["_stack_", 16, "res-tag"]],
@ -5617,5 +5616,105 @@
[[9, 13], "a0", "hud"]
],
"(method 15 hud-dark-eco-symbol)": [[[9, 14], "v1", "hud-health"]],
"(method 15 hud-gun)": [[[251, 256], "v1", "dma-packet"]]
"(method 15 hud-gun)": [[[251, 256], "v1", "dma-packet"]],
"target-mech-collision": [[108, "v0", "carry-info"]],
"target-mech-exit": [[[235, 242], "v1", "handle"]],
"mech-update-ik": [
[3, "v1", "process-drawable"],
[36, "s5", "collide-shape-moving"],
[41, "s5", "collide-shape-moving"],
[55, "s3", "joint-mod-ik"],
[72, "s3", "joint-mod-ik"],
[85, "s5", "collide-shape-moving"],
[93, "s3", "joint-mod-ik"],
[104, "s3", "joint-mod-ik"],
[52, "v1", "(array joint-mod-ik)"]
],
"target-mech-punch-pick": [
[29, "v0", "process-focusable"],
[222, "s5", "art-joint-anim"],
[241, "s5", "art-joint-anim"]
],
"(code target-mech-walk)": [[91, "f0", "float"]],
"(code target-mech-punch)": [
[107, "v1", "art-joint-anim"],
[135, "v1", "art-joint-anim"],
[163, "v1", "art-joint-anim"],
[191, "v1", "art-joint-anim"],
[231, "v1", "art-joint-anim"],
[259, "v1", "art-joint-anim"],
[287, "v1", "art-joint-anim"],
[315, "v1", "art-joint-anim"]
],
"(code target-mech-jump)": [[26, "t9", "(function none)"]],
"(code target-mech-death)": [
[379, "gp", "art-joint-anim"],
[643, "v1", "art-joint-anim"]
],
"(code target-mech-get-off)": [[67, "v1", "art-joint-anim"]],
"(code target-mech-get-on)": [
[74, "v1", "process-drawable"],
[80, "v1", "process-drawable"],
[115, "v1", "art-joint-anim"]
],
"(code target-mech-carry-throw)": [
[51, "v0", "carry-info"],
[112, "v0", "carry-info"],
[135, "v1", "sphere"]
],
"(code target-mech-carry-drop)": [
[42, "v0", "carry-info"],
[110, "v1", "art-joint-anim"],
[176, "v0", "carry-info"],
[262, "v0", "sound-rpc-set-param"],
[295, "v0", "sound-rpc-set-param"],
[220, "v1", "sphere"]
],
"(code target-mech-carry-pickup)": [
[137, "v0", "carry-info"],
[377, "v1", "art-joint-anim"],
[541, "v0", "carry-info"],
[574, "f0", "float"]
],
"(code target-mech-carry-walk)": [[80, "f0", "float"]],
"(event target-mech-punch)": [
[45, "gp", "collide-query"],
[51, "s5", "collide-shape-prim"],
[68, "s5", "process-focusable"],
[95, "gp", "collide-query"],
[128, "s5", "process-focusable"],
[180, "gp", "collide-query"]
],
"(exit idle mech)": [[[9, 17], "v1", "handle"]],
"(anon-function 8 target-mech)": [
[4, "gp", "target"],
[10, "gp", "target"],
[14, "gp", "target"]
],
"(anon-function 9 target-mech)": [
[[3, 33], "v1", "target"],
[43, "a0", "joint-mod-ik"],
[42, "v1", "(array joint-mod-ik)"]
],
"target-mech-handler": [
[91, "a0", "process"],
[213, "a3", "vector"],
[225, "s2", "vector"],
[305, "a3", "vector"],
[317, "s2", "vector"],
[164, "v0", "attack-info"]
],
"(enter target-mech-carry-hit-ground)": [[3, "v0", "sound-rpc-set-param"]],
"(event target-mech-grab)": [[24, "a0", "process"]],
"(anon-function 7 target-mech)": [
[32, "a0", "joint-mod-ik"],
[26, "a0", "(array joint-mod-ik)"]
],
"(enter target-mech-hit-ground)": [[3, "v0", "sound-rpc-set-param"]],
"(exit target-mech-carry-drag)": [
[11, "v0", "sound-rpc-set-param"],
[28, "v0", "sound-rpc-set-param"]
],
"(trans target-mech-carry-drag)": [[73, "v1", "sphere"]],
"target-mech-carry-update": [[50, "v1", "sphere"]]
}

2837
goal_src/jak2/engine/target/mech_suit/mech-states.gc
View file

File diff suppressed because it is too large Load diff

509
goal_src/jak2/engine/target/mech_suit/mech.gc
View file

@ -10,24 +10,513 @@
;; DECOMP BEGINS
(if (not (nmember "mechp" *kernel-packages*))
(set! *kernel-packages* (cons "mechp" *kernel-packages*))
)
(deftype mech (process-drawable)
((root-override collide-shape-moving :offset 128 :score 1)
(extra-trans vector :inline :offset-assert 208)
(condition int32 :offset-assert 224)
(shadow-backup basic :offset-assert 228)
(rider uint64 :offset-assert 232)
(shield-value float :offset-assert 240)
(nav-sphere-handle uint64 :offset-assert 248)
(probe-time time-frame :offset-assert 256)
((root-override collide-shape-moving :offset 128)
(extra-trans vector :inline :offset-assert 208)
(condition int32 :offset-assert 224)
(shadow-backup basic :offset-assert 228)
(rider uint64 :offset-assert 232)
(shield-value float :offset-assert 240)
(nav-sphere-handle uint64 :offset-assert 248)
(probe-time time-frame :offset-assert 256)
)
:heap-base #x90
:method-count-assert 25
:size-assert #x108
:flag-assert #x1900900108
(:methods
(wait-for-start () _type_ :state 20)
(idle () _type_ :state 21)
(pickup () _type_ :state 22)
(pickup ((state mech)) _type_ :state 22)
(wait-for-return () _type_ :state 23)
(mech-method-24 () none 24)
(mech-method-24 (_type_) none 24)
)
)
(defmethod mech-method-24 mech ((obj mech))
(if (nonzero? (-> obj part))
(spawn (-> obj part) (-> obj root-override trans))
)
(update! (-> obj sound))
0
(none)
)
(defstate wait-for-start (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(the-as
object
(case event-type
(('attack 'bonk)
(send-event proc 'target-mech-get-off 90)
(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) 'shove)
(set! (-> a1-3 param 0) (the-as uint #f))
(let ((v1-9 (new 'static 'attack-info :mask (attack-info-mask shove-back shove-up id))))
(let* ((a0-8 *game-info*)
(a2-2 (+ (-> a0-8 attack-id) 1))
)
(set! (-> a0-8 attack-id) a2-2)
(set! (-> v1-9 id) a2-2)
)
(set! (-> v1-9 shove-back) 12288.0)
(set! (-> v1-9 shove-up) 4096.0)
(set! (-> a1-3 param 1) (the-as uint v1-9))
)
(send-event-function proc a1-3)
)
(the-as structure #f)
)
(('touch)
(send-event proc 'target-mech-get-off 90)
(send-shoves
(-> self root-override)
proc
(the-as touching-shapes-entry (-> event param 0))
0.7
6144.0
16384.0
)
(the-as structure #f)
)
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-2 (the-as structure (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-2))
v0-2
)
)
(else
(set! (-> self draw shadow) #f)
(the-as structure #f)
)
)
)
)
)
)
:exit (behavior ()
(set! (-> self root-override root-prim prim-core action) (collide-action))
(set! (-> self root-override penetrated-by) (the-as penetrate -1))
(none)
)
:code (behavior ()
(go-virtual idle)
(none)
)
)
(defstate idle (mech)
:virtual #t
:event (-> (method-of-type mech wait-for-start) event)
:enter (behavior ()
(set! (-> self nav-sphere-handle) (the-as uint #f))
(let ((s5-0 (find-nearest-nav-mesh (-> self root-override trans) 8192.0)))
(when s5-0
(let ((gp-0 (new 'stack-no-clear 'vector)))
(vector-z-quaternion! gp-0 (-> self root-override quat))
(vector-normalize! gp-0 5120.0)
(vector+! gp-0 gp-0 (-> self root-override trans))
(set! (-> self nav-sphere-handle)
(the-as uint (ppointer->handle (process-spawn simple-nav-sphere #x46266666 gp-0 s5-0 -1 :to self)))
)
)
)
)
(none)
)
:exit (behavior ()
(send-event (handle->process (-> self nav-sphere-handle)) 'die-fast)
((-> (method-of-type mech wait-for-start) exit))
(none)
)
:code (behavior ()
(change-parent self *entity-pool*)
(ja-channel-set! 1)
(ja :group! mech-mech-idle-ja)
(set! (-> self root-override root-prim prim-core action) (collide-action solid can-ride no-standon))
(set! (-> self root-override penetrated-by) (penetrate))
0.0
(let ((f30-0 20480.0))
(until #f
(when (and (logtest? (-> self draw status) (draw-control-status on-screen))
(>= (- (-> self clock frame-counter) (-> self probe-time)) (seconds 1))
)
(move-to-ground
(-> self root-override)
8192.0
40960.0
#t
(collide-spec backgnd obstacle hit-by-player-list hit-by-others-list pusher)
)
(set! (-> self probe-time) (-> self clock frame-counter))
)
(when (and (and *target*
(and (>= f30-0 (vector-vector-distance (-> self root-override trans) (-> *target* control trans)))
(zero? (logand (focus-status teleporting) (-> *target* focus-status)))
)
)
(not (logtest? (focus-status in-head pole board mech dark) (-> *target* focus-status)))
(can-display-query? self (the-as string #f) -99.0)
(-> *setting-control* user-current pilot)
)
(let ((gp-0 (new
'stack
'font-context
*font-default-matrix*
32
320
0.0
(font-color default-#cddbcd)
(font-flags shadow kerning)
)
)
)
(let ((v1-31 gp-0))
(set! (-> v1-31 width) (the float 340))
)
(let ((v1-32 gp-0))
(set! (-> v1-32 height) (the float 80))
)
(let ((v1-33 gp-0))
(set! (-> v1-33 scale) 0.9)
)
(set! (-> gp-0 flags) (font-flags shadow kerning large))
(print-game-text (lookup-text! *common-text* (game-text-id text-x182) #f) gp-0 #f 44 (bucket-id progress))
)
(if (and (cpad-pressed? 0 triangle) (send-event *target* 'change-mode 'mech self (-> self shield-value)))
(go-virtual pickup (method-of-object self wait-for-return))
)
)
(if *target*
(look-at!
(-> *target* neck)
(vector+!
(new 'stack-no-clear 'vector)
(the-as vector (-> self root-override root-prim prim-core))
(new 'static 'vector :y 2048.0 :w 1.0)
)
'nothing-special
self
)
)
(mech-method-24 self)
(suspend)
)
)
#f
(none)
)
:post (the-as (function none :behavior mech) ja-post)
)
(defstate pickup (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(case event-type
(('draw)
(ja-channel-set! 1)
(ja :group! mech-mech-idle-ja)
(set! (-> self root-override root-prim prim-core action) (collide-action solid can-ride no-standon))
(set! (-> self root-override penetrated-by) (penetrate))
(transform-post)
)
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('touch 'attack 'bonk)
#f
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-1 (the-as object (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-1))
v0-1
)
)
(else
(set! (-> self draw shadow) #f)
#f
)
)
)
)
)
:enter (behavior ((arg0 (state mech)))
(let ((t9-0 (-> arg0 enter)))
(if t9-0
(t9-0)
)
)
(none)
)
:code (behavior ((arg0 (state mech)))
(ja-channel-set! 0)
(ja-post)
(while (zero? (ja-group-size))
(if (or (not *target*)
(or (< 24576.0 (vector-vector-distance (-> self root-override trans) (-> *target* control trans)))
(logtest? (focus-status teleporting) (-> *target* focus-status))
)
)
(go arg0)
)
(mech-method-24 self)
(suspend)
)
(while (and *target* (logtest? (focus-status mech) (-> *target* focus-status)))
(mech-method-24 self)
(suspend)
)
(let ((s5-0 (-> self clock frame-counter)))
(until (>= (- (-> self clock frame-counter) s5-0) (seconds 1))
(mech-method-24 self)
(suspend)
)
)
(go arg0)
(none)
)
)
(defstate wait-for-return (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(the-as
object
(case event-type
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-1 (the-as structure (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-1))
v0-1
)
)
(else
(set! (-> self draw shadow) #f)
(the-as structure #f)
)
)
)
)
)
)
:code (behavior ()
(ja-channel-set! 0)
(ja-post)
(cleanup-for-death self)
(none)
)
)
;; WARN: Return type mismatch object vs none.
(defbehavior mech-init mech ((arg0 entity-actor) (arg1 matrix3) (arg2 handle) (arg3 float))
(let ((s2-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
(set! (-> s2-0 dynam) (copy *standard-dynamics* 'process))
(set! (-> s2-0 reaction) cshape-reaction-default)
(set! (-> s2-0 no-reaction)
(the-as (function collide-shape-moving collide-query vector vector object) nothing)
)
(let ((v1-6 (new 'process 'collide-shape-prim-sphere s2-0 (the-as uint 0))))
(set! (-> v1-6 prim-core collide-as) (collide-spec obstacle obstacle-for-jak))
(set! (-> v1-6 prim-core collide-with) (collide-spec jak player-list))
(set! (-> v1-6 prim-core action) (collide-action solid can-ride no-standon))
(set! (-> v1-6 transform-index) 0)
(set-vector! (-> v1-6 local-sphere) 0.0 6553.6 5324.8 6553.6)
(set! (-> s2-0 total-prims) (the-as uint 1))
(set! (-> s2-0 root-prim) v1-6)
)
(set! (-> s2-0 nav-radius) (* 0.75 (-> s2-0 root-prim local-sphere w)))
(let ((v1-9 (-> s2-0 root-prim)))
(set! (-> s2-0 backup-collide-as) (-> v1-9 prim-core collide-as))
(set! (-> s2-0 backup-collide-with) (-> v1-9 prim-core collide-with))
)
(set! (-> self root-override) s2-0)
)
(set! (-> self rider) (the-as uint arg2))
(when arg0
(process-entity-set! self arg0)
(process-drawable-from-entity! self arg0)
(set-yaw-angle-clear-roll-pitch! (-> self root-override) (res-lump-float arg0 'rotoffset))
)
(when arg1
(set! (-> self root-override trans quad) (-> arg1 vector 0 quad))
(quaternion-copy! (-> self root-override quat) (the-as quaternion (-> arg1 vector 1)))
)
(initialize-skeleton
self
(the-as skeleton-group (art-group-get-by-name *level* "skel-mech" (the-as (pointer uint32) #f)))
(the-as pair 0)
)
(set! (-> self shadow-backup) (-> self draw shadow))
(set! (-> self draw shadow-ctrl) *mech-shadow-control*)
(let ((v1-27 (-> self node-list data)))
(set! (-> v1-27 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
(set! (-> v1-27 0 param1) (the-as basic (-> self root-override trans)))
(set! (-> v1-27 0 param2) (the-as basic (-> self extra-trans)))
)
(set! (-> self condition) (res-lump-value arg0 'index int :time -1000000000.0))
(set! (-> self fact)
(new 'process 'fact-info self (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
)
(set! (-> self shield-value) arg3)
(set! (-> self nav-sphere-handle) (the-as uint #f))
(if (-> self entity)
(move-to-ground
(-> self root-override)
8192.0
40960.0
#t
(collide-spec backgnd obstacle hit-by-player-list hit-by-others-list pusher)
)
)
(set! (-> self sound)
(new 'process 'ambient-sound (static-sound-spec "zoom-teleport" :fo-max 30) (-> self root-override trans))
)
(set! (-> self draw light-index) (the-as uint 30))
(if (handle->process arg2)
(go-virtual idle)
(go-virtual wait-for-start)
)
(none)
)
(defmethod init-from-entity! mech ((obj mech) (arg0 entity-actor))
(mech-init arg0 (the-as matrix3 #f) (the-as handle #f) 100.0)
(none)
)
(deftype mech-target (process-drawable)
()
:heap-base #x50
:method-count-assert 22
:size-assert #xc8
:flag-assert #x16005000c8
(:methods
(idle () _type_ :state 20)
(active () _type_ :state 21)
)
)
(defskelgroup skel-mech-target mech mech-target-lod0-jg mech-target-idle-ja
((mech-target-lod0-mg (meters 999999)))
:bounds (static-spherem 0 0 0 4)
)
(defstate idle (mech-target)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(case event-type
(('look-at-point)
(set! (-> self state-time) (-> self clock frame-counter))
(go-virtual active)
)
)
)
:trans (behavior ()
(if (and (and *target* (and (>= 98304.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
(zero? (logand (focus-status teleporting) (-> *target* focus-status)))
)
)
(logtest? (focus-status mech) (-> *target* focus-status))
)
(go-virtual active)
)
(none)
)
:code (behavior ()
(while (< 0.0 (-> self root scale x))
(seek! (-> self root scale x) 0.0 (* 8.0 (-> self clock seconds-per-frame)))
(set! (-> self root scale y) (-> self root scale x))
(ja-post)
(suspend)
)
(logior! (-> self draw status) (draw-control-status no-draw))
(ja-post)
(sleep-code)
(none)
)
)
(defstate active (mech-target)
:virtual #t
:event (-> (method-of-type mech-target idle) event)
:enter (behavior ()
(set! (-> self state-time) (-> self clock frame-counter))
(none)
)
:trans (behavior ()
(if (and (or (or (not *target*) (or (< 106496.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
(logtest? (focus-status teleporting) (-> *target* focus-status))
)
)
(zero? (logand (focus-status mech) (-> *target* focus-status)))
)
(>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 10))
)
(go-virtual idle)
)
(none)
)
:code (behavior ()
(sound-play "mech-target")
(let ((f30-0 0.0))
(logclear! (-> self draw status) (draw-control-status no-draw))
(while (< (-> self root scale x) 1.0)
(seek! (-> self root scale x) 1.0 (* 8.0 (-> self clock seconds-per-frame)))
(set! (-> self root scale y) (-> self root scale x))
(set! f30-0 (seek f30-0 1.0 (* 2.0 (-> self clock seconds-per-frame))))
(ja :num! (loop! f30-0))
(ja-post)
(suspend)
)
(until #f
(set! f30-0 (seek f30-0 1.0 (* 0.25 (-> self clock seconds-per-frame))))
(ja :num! (loop! f30-0))
(ja-post)
(suspend)
)
)
#f
(none)
)
)
;; WARN: Return type mismatch object vs none.
(defbehavior mech-target-init mech ((arg0 vector) (arg1 quaternion) (arg2 entity-actor))
(process-entity-set! self arg2)
(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)
(set! (-> self root-override scale x) 0.0)
(set! (-> self root-override scale y) 0.0)
(initialize-skeleton
self
(the-as skeleton-group (art-group-get-by-name *level* "skel-mech-target" (the-as (pointer uint32) #f)))
(the-as pair 0)
)
(go-virtual wait-for-start)
(none)
)
(defun mech-target-spawn ((arg0 vector) (arg1 target) (arg2 quaternion) (arg3 entity-actor))
(process-spawn mech-target :init mech-target-init arg0 arg2 arg3 :to arg1)
)

1771
goal_src/jak2/engine/target/mech_suit/target-mech.gc
View file

File diff suppressed because it is too large Load diff

2872
test/decompiler/reference/jak2/engine/target/mech_suit/mech-states_REF.gc generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

564
test/decompiler/reference/jak2/engine/target/mech_suit/mech_REF.gc generated vendored Normal file
View file

@ -0,0 +1,564 @@
;;-*-Lisp-*-
(in-package goal)
;; failed to figure out what this is:
(if (not (nmember "mechp" *kernel-packages*))
(set! *kernel-packages* (cons "mechp" *kernel-packages*))
)
;; definition of type mech
(deftype mech (process-drawable)
((root-override collide-shape-moving :offset 128)
(extra-trans vector :inline :offset-assert 208)
(condition int32 :offset-assert 224)
(shadow-backup basic :offset-assert 228)
(rider uint64 :offset-assert 232)
(shield-value float :offset-assert 240)
(nav-sphere-handle uint64 :offset-assert 248)
(probe-time time-frame :offset-assert 256)
)
:heap-base #x90
:method-count-assert 25
:size-assert #x108
:flag-assert #x1900900108
(:methods
(wait-for-start () _type_ :state 20)
(idle () _type_ :state 21)
(pickup ((state mech)) _type_ :state 22)
(wait-for-return () _type_ :state 23)
(mech-method-24 (_type_) none 24)
)
)
;; definition for method 3 of type mech
(defmethod inspect mech ((obj mech))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process-drawable inspect)))
(t9-0 obj)
)
(format #t "~2Textra-trans: ~`vector`P~%" (-> obj extra-trans))
(format #t "~2Tcondition: ~D~%" (-> obj condition))
(format #t "~2Tshadow-backup: ~A~%" (-> obj shadow-backup))
(format #t "~2Trider: ~D~%" (-> obj rider))
(format #t "~2Tshield-value: ~f~%" (-> obj shield-value))
(format #t "~2Tnav-sphere-handle: ~D~%" (-> obj nav-sphere-handle))
(format #t "~2Tprobe-time: ~D~%" (-> obj probe-time))
(label cfg-4)
obj
)
;; definition for method 24 of type mech
;; WARN: Return type mismatch int vs none.
(defmethod mech-method-24 mech ((obj mech))
(if (nonzero? (-> obj part))
(spawn (-> obj part) (-> obj root-override trans))
)
(update! (-> obj sound))
0
(none)
)
;; failed to figure out what this is:
(defstate wait-for-start (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(the-as
object
(case event-type
(('attack 'bonk)
(send-event proc 'target-mech-get-off 90)
(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) 'shove)
(set! (-> a1-3 param 0) (the-as uint #f))
(let ((v1-9 (new 'static 'attack-info :mask (attack-info-mask shove-back shove-up id))))
(let* ((a0-8 *game-info*)
(a2-2 (+ (-> a0-8 attack-id) 1))
)
(set! (-> a0-8 attack-id) a2-2)
(set! (-> v1-9 id) a2-2)
)
(set! (-> v1-9 shove-back) 12288.0)
(set! (-> v1-9 shove-up) 4096.0)
(set! (-> a1-3 param 1) (the-as uint v1-9))
)
(send-event-function proc a1-3)
)
(the-as structure #f)
)
(('touch)
(send-event proc 'target-mech-get-off 90)
(send-shoves
(-> self root-override)
proc
(the-as touching-shapes-entry (-> event param 0))
0.7
6144.0
16384.0
)
(the-as structure #f)
)
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-2 (the-as structure (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-2))
v0-2
)
)
(else
(set! (-> self draw shadow) #f)
(the-as structure #f)
)
)
)
)
)
)
:exit (behavior ()
(set! (-> self root-override root-prim prim-core action) (collide-action))
(set! (-> self root-override penetrated-by) (the-as penetrate -1))
(none)
)
:code (behavior ()
(go-virtual idle)
(none)
)
)
;; failed to figure out what this is:
(defstate idle (mech)
:virtual #t
:event (-> (method-of-type mech wait-for-start) event)
:enter (behavior ()
(set! (-> self nav-sphere-handle) (the-as uint #f))
(let ((s5-0 (find-nearest-nav-mesh (-> self root-override trans) 8192.0)))
(when s5-0
(let ((gp-0 (new 'stack-no-clear 'vector)))
(vector-z-quaternion! gp-0 (-> self root-override quat))
(vector-normalize! gp-0 5120.0)
(vector+! gp-0 gp-0 (-> self root-override trans))
(set! (-> self nav-sphere-handle)
(the-as uint (ppointer->handle (process-spawn simple-nav-sphere #x46266666 gp-0 s5-0 -1 :to self)))
)
)
)
)
(none)
)
:exit (behavior ()
(send-event (handle->process (-> self nav-sphere-handle)) 'die-fast)
((-> (method-of-type mech wait-for-start) exit))
(none)
)
:code (behavior ()
(change-parent self *entity-pool*)
(ja-channel-set! 1)
(ja :group! (-> self draw art-group data 3))
(set! (-> self root-override root-prim prim-core action) (collide-action solid can-ride no-standon))
(set! (-> self root-override penetrated-by) (penetrate))
0.0
(let ((f30-0 20480.0))
(until #f
(when (and (logtest? (-> self draw status) (draw-control-status on-screen))
(>= (- (-> self clock frame-counter) (-> self probe-time)) (seconds 1))
)
(move-to-ground
(-> self root-override)
8192.0
40960.0
#t
(collide-spec backgnd obstacle hit-by-player-list hit-by-others-list pusher)
)
(set! (-> self probe-time) (-> self clock frame-counter))
)
(when (and (and *target*
(and (>= f30-0 (vector-vector-distance (-> self root-override trans) (-> *target* control trans)))
(zero? (logand (focus-status teleporting) (-> *target* focus-status)))
)
)
(not (logtest? (focus-status in-head pole board mech dark) (-> *target* focus-status)))
(can-display-query? self (the-as string #f) -99.0)
(-> *setting-control* user-current pilot)
)
(let ((gp-0 (new
'stack
'font-context
*font-default-matrix*
32
320
0.0
(font-color default-#cddbcd)
(font-flags shadow kerning)
)
)
)
(let ((v1-31 gp-0))
(set! (-> v1-31 width) (the float 340))
)
(let ((v1-32 gp-0))
(set! (-> v1-32 height) (the float 80))
)
(let ((v1-33 gp-0))
(set! (-> v1-33 scale) 0.9)
)
(set! (-> gp-0 flags) (font-flags shadow kerning large))
(print-game-text (lookup-text! *common-text* (game-text-id text-x182) #f) gp-0 #f 44 (bucket-id progress))
)
(if (and (cpad-pressed? 0 triangle) (send-event *target* 'change-mode 'mech self (-> self shield-value)))
(go-virtual pickup (method-of-object self wait-for-return))
)
)
(if *target*
(look-at!
(-> *target* neck)
(vector+!
(new 'stack-no-clear 'vector)
(the-as vector (-> self root-override root-prim prim-core))
(new 'static 'vector :y 2048.0 :w 1.0)
)
'nothing-special
self
)
)
(mech-method-24 self)
(suspend)
)
)
#f
(none)
)
:post (the-as (function none :behavior mech) ja-post)
)
;; failed to figure out what this is:
(defstate pickup (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(case event-type
(('draw)
(ja-channel-set! 1)
(ja :group! (-> self draw art-group data 3))
(set! (-> self root-override root-prim prim-core action) (collide-action solid can-ride no-standon))
(set! (-> self root-override penetrated-by) (penetrate))
(transform-post)
)
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('touch 'attack 'bonk)
#f
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-1 (the-as object (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-1))
v0-1
)
)
(else
(set! (-> self draw shadow) #f)
#f
)
)
)
)
)
:enter (behavior ((arg0 (state mech)))
(let ((t9-0 (-> arg0 enter)))
(if t9-0
(t9-0)
)
)
(none)
)
:code (behavior ((arg0 (state mech)))
(ja-channel-set! 0)
(ja-post)
(while (zero? (ja-group-size))
(if (or (not *target*)
(or (< 24576.0 (vector-vector-distance (-> self root-override trans) (-> *target* control trans)))
(logtest? (focus-status teleporting) (-> *target* focus-status))
)
)
(go arg0)
)
(mech-method-24 self)
(suspend)
)
(while (and *target* (logtest? (focus-status mech) (-> *target* focus-status)))
(mech-method-24 self)
(suspend)
)
(let ((s5-0 (-> self clock frame-counter)))
(until (>= (- (-> self clock frame-counter) s5-0) (seconds 1))
(mech-method-24 self)
(suspend)
)
)
(go arg0)
(none)
)
)
;; failed to figure out what this is:
(defstate wait-for-return (mech)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(the-as
object
(case event-type
(('trans)
(vector+! (the-as vector (-> event param 0)) (-> self root-override trans) (-> self extra-trans))
)
(('shadow)
(cond
((-> event param 0)
(let ((v0-1 (the-as structure (-> self shadow-backup))))
(set! (-> self draw shadow) (the-as shadow-geo v0-1))
v0-1
)
)
(else
(set! (-> self draw shadow) #f)
(the-as structure #f)
)
)
)
)
)
)
:code (behavior ()
(ja-channel-set! 0)
(ja-post)
(cleanup-for-death self)
(none)
)
)
;; definition for function mech-init
;; INFO: Used lq/sq
;; WARN: Return type mismatch object vs none.
(defbehavior mech-init mech ((arg0 entity-actor) (arg1 matrix3) (arg2 handle) (arg3 float))
(let ((s2-0 (new 'process 'collide-shape-moving self (collide-list-enum usually-hit-by-player))))
(set! (-> s2-0 dynam) (copy *standard-dynamics* 'process))
(set! (-> s2-0 reaction) cshape-reaction-default)
(set! (-> s2-0 no-reaction)
(the-as (function collide-shape-moving collide-query vector vector object) nothing)
)
(let ((v1-6 (new 'process 'collide-shape-prim-sphere s2-0 (the-as uint 0))))
(set! (-> v1-6 prim-core collide-as) (collide-spec obstacle obstacle-for-jak))
(set! (-> v1-6 prim-core collide-with) (collide-spec jak player-list))
(set! (-> v1-6 prim-core action) (collide-action solid can-ride no-standon))
(set! (-> v1-6 transform-index) 0)
(set-vector! (-> v1-6 local-sphere) 0.0 6553.6 5324.8 6553.6)
(set! (-> s2-0 total-prims) (the-as uint 1))
(set! (-> s2-0 root-prim) v1-6)
)
(set! (-> s2-0 nav-radius) (* 0.75 (-> s2-0 root-prim local-sphere w)))
(let ((v1-9 (-> s2-0 root-prim)))
(set! (-> s2-0 backup-collide-as) (-> v1-9 prim-core collide-as))
(set! (-> s2-0 backup-collide-with) (-> v1-9 prim-core collide-with))
)
(set! (-> self root-override) s2-0)
)
(set! (-> self rider) (the-as uint arg2))
(when arg0
(process-entity-set! self arg0)
(process-drawable-from-entity! self arg0)
(set-yaw-angle-clear-roll-pitch! (-> self root-override) (res-lump-float arg0 'rotoffset))
)
(when arg1
(set! (-> self root-override trans quad) (-> arg1 vector 0 quad))
(quaternion-copy! (-> self root-override quat) (the-as quaternion (-> arg1 vector 1)))
)
(initialize-skeleton
self
(the-as skeleton-group (art-group-get-by-name *level* "skel-mech" (the-as (pointer uint32) #f)))
(the-as pair 0)
)
(set! (-> self shadow-backup) (-> self draw shadow))
(set! (-> self draw shadow-ctrl) *mech-shadow-control*)
(let ((v1-27 (-> self node-list data)))
(set! (-> v1-27 0 param0) (the-as (function cspace matrix none) cspace<-transformq+trans!))
(set! (-> v1-27 0 param1) (the-as basic (-> self root-override trans)))
(set! (-> v1-27 0 param2) (the-as basic (-> self extra-trans)))
)
(set! (-> self condition) (res-lump-value arg0 'index int :time -1000000000.0))
(set! (-> self fact)
(new 'process 'fact-info self (pickup-type eco-pill-random) (-> *FACT-bank* default-eco-pill-green-inc))
)
(set! (-> self shield-value) arg3)
(set! (-> self nav-sphere-handle) (the-as uint #f))
(if (-> self entity)
(move-to-ground
(-> self root-override)
8192.0
40960.0
#t
(collide-spec backgnd obstacle hit-by-player-list hit-by-others-list pusher)
)
)
(set! (-> self sound)
(new 'process 'ambient-sound (static-sound-spec "zoom-teleport" :fo-max 30) (-> self root-override trans))
)
(set! (-> self draw light-index) (the-as uint 30))
(if (handle->process arg2)
(go-virtual idle)
(go-virtual wait-for-start)
)
(none)
)
;; definition for method 11 of type mech
(defmethod init-from-entity! mech ((obj mech) (arg0 entity-actor))
(mech-init arg0 (the-as matrix3 #f) (the-as handle #f) 100.0)
(none)
)
;; definition of type mech-target
(deftype mech-target (process-drawable)
()
:heap-base #x50
:method-count-assert 22
:size-assert #xc8
:flag-assert #x16005000c8
(:methods
(idle () _type_ :state 20)
(active () _type_ :state 21)
)
)
;; definition for method 3 of type mech-target
(defmethod inspect mech-target ((obj mech-target))
(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:
(defskelgroup skel-mech-target mech 42 44 ((43 (meters 999999))) :bounds (static-spherem 0 0 0 4))
;; failed to figure out what this is:
(defstate idle (mech-target)
:virtual #t
:event (behavior ((proc process) (arg1 int) (event-type symbol) (event event-message-block))
(case event-type
(('look-at-point)
(set! (-> self state-time) (-> self clock frame-counter))
(go-virtual active)
)
)
)
:trans (behavior ()
(if (and (and *target* (and (>= 98304.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
(zero? (logand (focus-status teleporting) (-> *target* focus-status)))
)
)
(logtest? (focus-status mech) (-> *target* focus-status))
)
(go-virtual active)
)
(none)
)
:code (behavior ()
(while (< 0.0 (-> self root scale x))
(seek! (-> self root scale x) 0.0 (* 8.0 (-> self clock seconds-per-frame)))
(set! (-> self root scale y) (-> self root scale x))
(ja-post)
(suspend)
)
(logior! (-> self draw status) (draw-control-status no-draw))
(ja-post)
(sleep-code)
(none)
)
)
;; failed to figure out what this is:
(defstate active (mech-target)
:virtual #t
:event (-> (method-of-type mech-target idle) event)
:enter (behavior ()
(set! (-> self state-time) (-> self clock frame-counter))
(none)
)
:trans (behavior ()
(if (and (or (or (not *target*) (or (< 106496.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
(logtest? (focus-status teleporting) (-> *target* focus-status))
)
)
(zero? (logand (focus-status mech) (-> *target* focus-status)))
)
(>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 10))
)
(go-virtual idle)
)
(none)
)
:code (behavior ()
(sound-play "mech-target")
(let ((f30-0 0.0))
(logclear! (-> self draw status) (draw-control-status no-draw))
(while (< (-> self root scale x) 1.0)
(seek! (-> self root scale x) 1.0 (* 8.0 (-> self clock seconds-per-frame)))
(set! (-> self root scale y) (-> self root scale x))
(set! f30-0 (seek f30-0 1.0 (* 2.0 (-> self clock seconds-per-frame))))
(ja :num! (loop! f30-0))
(ja-post)
(suspend)
)
(until #f
(set! f30-0 (seek f30-0 1.0 (* 0.25 (-> self clock seconds-per-frame))))
(ja :num! (loop! f30-0))
(ja-post)
(suspend)
)
)
#f
(none)
)
)
;; definition for function mech-target-init
;; INFO: Used lq/sq
;; WARN: Return type mismatch object vs none.
(defbehavior mech-target-init mech ((arg0 vector) (arg1 quaternion) (arg2 entity-actor))
(process-entity-set! self arg2)
(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)
(set! (-> self root-override scale x) 0.0)
(set! (-> self root-override scale y) 0.0)
(initialize-skeleton
self
(the-as skeleton-group (art-group-get-by-name *level* "skel-mech-target" (the-as (pointer uint32) #f)))
(the-as pair 0)
)
(go-virtual wait-for-start)
(none)
)
;; definition for function mech-target-spawn
;; WARN: Return type mismatch (pointer process) vs (pointer mech-target).
(defun mech-target-spawn ((arg0 vector) (arg1 target) (arg2 quaternion) (arg3 entity-actor))
(process-spawn mech-target :init mech-target-init arg0 arg2 arg3 :to arg1)
)