mirror of
https://github.com/open-goal/jak-project
synced 2026-07-07 14:13:45 -04:00
water111
13def9a8b2
Small fix to decompiler when the original compiler uses `ra` register. This seems to happen in "normal" code very rarely - perhaps they manually specified this in an `rlet`. Start figuring out buckets/textures for Jak 3. The foreground code is not yet modified for PC - I want to wait until the game is running, since it is too hard to do it now.
4769 lines
165 KiB
Common Lisp
Vendored
Generated
4769 lines
165 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition for symbol *part-tracker-params-default*, type part-tracker-init-params
|
|
(define *part-tracker-params-default* (new 'static 'part-tracker-init-params))
|
|
|
|
;; definition for symbol *part-tracker-subsampler-params-default*, type part-tracker-subsampler-init-params
|
|
(define *part-tracker-subsampler-params-default* (new 'static 'part-tracker-subsampler-init-params))
|
|
|
|
;; failed to figure out what this is:
|
|
(defskelgroup skel-spotlight spotlight spotlight-lod0-jg -1
|
|
((spotlight-lod0-mg (meters 999999)))
|
|
:bounds (static-spherem 0 0 0 10)
|
|
:shadow-joint-index 5
|
|
)
|
|
|
|
;; definition for function entity-lookup-part-group
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs (pointer sparticle-launch-group).
|
|
(defun entity-lookup-part-group ((arg0 entity-actor) (arg1 (pointer string)) (arg2 symbol))
|
|
(local-vars (sv-16 res-tag))
|
|
(let ((gp-0 (the-as object #f)))
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((s4-0 (res-lump-data arg0 arg2 pointer :tag-ptr (& sv-16))))
|
|
(if (not s4-0)
|
|
(go process-drawable-art-error (the-as string #f))
|
|
)
|
|
(let ((s3-0 (the-as object (-> (the-as (pointer uint32) s4-0)))))
|
|
(cond
|
|
((part-group-pointer? (the-as pointer s3-0))
|
|
(set! gp-0 (-> (the-as (pointer uint32) s4-0)))
|
|
)
|
|
((= (-> (the-as string s3-0) type) string)
|
|
(if arg1
|
|
(set! (-> arg1 0) (the-as string s3-0))
|
|
)
|
|
(set! gp-0 (lookup-part-group-pointer-by-name (the-as string s3-0)))
|
|
(if (the-as (pointer object) gp-0)
|
|
(set! (-> (the-as (pointer int32) s4-0)) (the-as int gp-0))
|
|
)
|
|
)
|
|
(else
|
|
(go process-drawable-art-error (the-as string s3-0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(the-as (pointer sparticle-launch-group) gp-0)
|
|
)
|
|
)
|
|
|
|
;; definition for function clone-anim-once
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defbehavior clone-anim-once process-drawable ((arg0 handle) (arg1 symbol) (arg2 string))
|
|
(logclear! (-> self skel status) (joint-control-status valid-spooled-frame))
|
|
(let ((gp-0 (handle->process arg0)))
|
|
(if gp-0
|
|
(joint-control-copy! (-> self skel) (-> (the-as process-drawable gp-0) skel))
|
|
)
|
|
(cond
|
|
((and gp-0 (joint-control-remap!
|
|
(-> self skel)
|
|
(-> self draw art-group)
|
|
(-> (the-as process-drawable gp-0) draw art-group)
|
|
'()
|
|
0
|
|
arg2
|
|
)
|
|
)
|
|
(when arg1
|
|
(let* ((s5-1 (-> self root))
|
|
(a0-7 (if (type? s5-1 collide-shape)
|
|
s5-1
|
|
)
|
|
)
|
|
)
|
|
(if a0-7
|
|
(move-to-point! (the-as collide-shape a0-7) (-> (the-as process-drawable gp-0) root trans))
|
|
(set! (-> self root trans quad) (-> (the-as process-drawable gp-0) root trans quad))
|
|
)
|
|
)
|
|
(quaternion-copy! (-> self root quat) (-> (the-as process-drawable gp-0) root quat))
|
|
)
|
|
(if (logtest? (-> (the-as process-drawable gp-0) skel status) (joint-control-status valid-spooled-frame))
|
|
(logior! (-> self skel status) (joint-control-status valid-spooled-frame))
|
|
)
|
|
(logclear! (-> self draw status) (draw-control-status no-draw no-draw-temp uninited))
|
|
(if (or (zero? (-> self skel active-channels)) (not (-> self skel root-channel 0 frame-group)))
|
|
(logior! (-> self draw status) (draw-control-status no-draw-temp))
|
|
)
|
|
(let* ((gp-1 self)
|
|
(v1-38 (if (type? gp-1 manipy)
|
|
gp-1
|
|
)
|
|
)
|
|
)
|
|
(if (and v1-38 (not (-> (the-as manipy v1-38) draw?)))
|
|
(logior! (-> self draw status) (draw-control-status no-draw-temp))
|
|
)
|
|
)
|
|
(update-anim-data (-> self skel))
|
|
(do-joint-math (-> self draw) (-> self node-list) (-> self skel))
|
|
(let ((a0-22 (-> self skel effect)))
|
|
(if a0-22
|
|
(effect-control-method-9 a0-22)
|
|
)
|
|
)
|
|
(if (logtest? (-> self skel status) (joint-control-status blend-shape blend-shape-valid))
|
|
(merc-blend-shape self)
|
|
)
|
|
(if (logtest? (-> self skel status) (joint-control-status eye-anim-valid eye-anim))
|
|
(merc-eye-anim self)
|
|
)
|
|
(cloth-post)
|
|
)
|
|
(else
|
|
(set! (-> self skel active-channels) (the-as uint 0))
|
|
(logior! (-> self draw status) (draw-control-status no-draw))
|
|
(ja-post)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function clone-anim
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defbehavior clone-anim process-drawable ((arg0 handle) (arg1 symbol) (arg2 string))
|
|
(ja-post)
|
|
(while (handle->process arg0)
|
|
(clone-anim-once arg0 #t arg2)
|
|
(suspend)
|
|
)
|
|
(logclear! (-> self skel status) (joint-control-status valid-spooled-frame))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 22 of type swingpole
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod swingpole-method-22 ((this swingpole))
|
|
(with-pp
|
|
(if (nonzero? (-> this draw))
|
|
(ja-post)
|
|
)
|
|
(cond
|
|
((nonzero? (-> this path))
|
|
(set! (-> this path-pos) (get-norm! (-> this sync) 0))
|
|
(let ((s5-0 (new 'stack-no-clear 'vector)))
|
|
(get-point-at-percent-along-path! (-> this path) s5-0 (-> this path-pos) 'interp)
|
|
(set! (-> this speed) (* (vector-vector-distance s5-0 (-> this root trans)) (-> pp clock frames-per-second)))
|
|
(move-to-point! (the-as collide-shape (-> this root)) s5-0)
|
|
)
|
|
)
|
|
((>= (-> this joint-track) 0)
|
|
(let ((v1-15 (ppointer->process (-> this parent)))
|
|
(s5-1 (new 'stack-no-clear 'vector))
|
|
)
|
|
(let ((s4-0 (-> (the-as process-drawable v1-15) node-list data (-> this joint-track))))
|
|
(vector<-cspace! s5-1 s4-0)
|
|
(vector-normalize-copy! (-> this dir) (the-as vector (-> s4-0 bone transform)) 1.0)
|
|
)
|
|
(move-to-point! (the-as collide-shape (-> this root)) s5-1)
|
|
)
|
|
)
|
|
)
|
|
(when (nonzero? (-> this sound))
|
|
(set! (-> this sound trans quad) (-> this root trans quad))
|
|
(let ((f30-0 (lerp-scale -0.1 -0.05 (-> this speed) 8192.0 20480.0))
|
|
(f0-6 (lerp-scale 0.7 1.0 (-> this speed) 8192.0 20480.0))
|
|
)
|
|
(set! (-> this sound pitch) (the int (* 1524.0 f30-0)))
|
|
(set! (-> this sound volume) (the int (* 1024.0 f0-6)))
|
|
)
|
|
(update! (-> this sound))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (swingpole)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('touch 'attack)
|
|
(if (send-event proc 'pole-grab (-> block param 0))
|
|
(go-virtual active (process->handle proc))
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(if (nonzero? (-> self draw))
|
|
(ja-post)
|
|
)
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
(cond
|
|
((or (nonzero? (-> self path)) (>= (-> self joint-track) 0))
|
|
(until #f
|
|
(swingpole-method-22 self)
|
|
(suspend)
|
|
)
|
|
#f
|
|
)
|
|
(else
|
|
(logior! (-> self mask) (process-mask sleep))
|
|
(suspend)
|
|
0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (swingpole)
|
|
:virtual #t
|
|
:code (behavior ((arg0 handle))
|
|
(swingpole-method-22 self)
|
|
(suspend)
|
|
(while (let* ((s5-0 (handle->process arg0))
|
|
(a0-7 (if (type? s5-0 process-focusable)
|
|
s5-0
|
|
)
|
|
)
|
|
)
|
|
(and a0-7 (focus-test? (the-as process-focusable a0-7) pole))
|
|
)
|
|
(swingpole-method-22 self)
|
|
(suspend)
|
|
)
|
|
(let ((gp-1 (current-time)))
|
|
(until (time-elapsed? gp-1 (seconds 0.5))
|
|
(swingpole-method-22 self)
|
|
(suspend)
|
|
)
|
|
)
|
|
(go-virtual idle)
|
|
)
|
|
)
|
|
|
|
;; definition for method 24 of type swingpole
|
|
(defmethod get-trans ((this swingpole))
|
|
(-> this root trans)
|
|
)
|
|
|
|
;; definition for method 23 of type swingpole
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init-collision! ((this swingpole))
|
|
(let ((s5-0 (new 'process 'collide-shape this (collide-list-enum hit-by-player))))
|
|
(let ((v1-2 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
|
|
(set! (-> v1-2 prim-core collide-as) (collide-spec collectable))
|
|
(set! (-> v1-2 prim-core collide-with) (collide-spec jak player-list tobot))
|
|
(set-vector! (-> v1-2 local-sphere) 0.0 0.0 0.0 12288.0)
|
|
(set! (-> s5-0 total-prims) (the-as uint 1))
|
|
(set! (-> s5-0 root-prim) v1-2)
|
|
)
|
|
(set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
|
|
(let ((v1-5 (-> s5-0 root-prim)))
|
|
(set! (-> s5-0 backup-collide-as) (-> v1-5 prim-core collide-as))
|
|
(set! (-> s5-0 backup-collide-with) (-> v1-5 prim-core collide-with))
|
|
)
|
|
(set! (-> this root) s5-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type swingpole
|
|
;; INFO: Used lq/sq
|
|
(defmethod init-from-entity! ((this swingpole) (arg0 entity-actor))
|
|
"Copy defaults from the entity."
|
|
(stack-size-set! (-> this main-thread) 128)
|
|
(init-collision! this)
|
|
(set! (-> this root trans quad) (-> arg0 extra trans quad))
|
|
(quaternion-copy! (-> this root quat) (-> arg0 quat))
|
|
(vector-identity! (-> this root scale))
|
|
(vector-y-quaternion! (-> this dir) (-> this root quat))
|
|
(set! (-> this joint-track) -1)
|
|
(let ((a1-5 (res-lump-struct (-> this entity) 'art-name structure)))
|
|
(if a1-5
|
|
(initialize-skeleton-by-name this (the-as string a1-5))
|
|
)
|
|
)
|
|
(set! (-> this dir y) 0.0)
|
|
(vector-normalize! (-> this dir) 1.0)
|
|
(set! (-> this edge-length) 8192.0)
|
|
(let ((s4-0 (new 'stack-no-clear 'sync-info-params)))
|
|
(let ((a0-13 (res-lump-value arg0 'options uint128 :time -1000000000.0))
|
|
(v1-17 0)
|
|
)
|
|
(if (not (logtest? (the-as int a0-13) 8))
|
|
(set! v1-17 (logior v1-17 1))
|
|
)
|
|
(set! (-> s4-0 sync-type) 'sync-eased)
|
|
(set! (-> s4-0 sync-flags) (the-as sync-flags v1-17))
|
|
)
|
|
(set! (-> s4-0 period) (the-as uint 0))
|
|
(set! (-> s4-0 entity) arg0)
|
|
(set! (-> s4-0 percent) 0.0)
|
|
(set! (-> s4-0 ease-in) 0.2)
|
|
(set! (-> s4-0 ease-out) 0.2)
|
|
(set! (-> s4-0 pause-in) 0.0)
|
|
(set! (-> s4-0 pause-out) 0.0)
|
|
(initialize! (-> this sync) s4-0)
|
|
)
|
|
(when (nonzero? (-> this sync period))
|
|
(set! (-> this path) (new 'process 'curve-control this 'path -1000000000.0))
|
|
(logior! (-> this path flags) (path-control-flag display draw-line draw-point draw-text))
|
|
)
|
|
(set! (-> this sound) (new 'process 'ambient-sound (-> this entity) (-> this root trans) 0.0))
|
|
(go (method-of-object this idle))
|
|
)
|
|
|
|
;; definition for function swingpole-init
|
|
;; INFO: Used lq/sq
|
|
(defbehavior swingpole-init swingpole ((arg0 int))
|
|
(stack-size-set! (-> self main-thread) 128)
|
|
(let ((s5-0 (new 'process 'collide-shape self (collide-list-enum hit-by-player))))
|
|
(let ((v1-4 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
|
|
(set! (-> v1-4 prim-core collide-as) (collide-spec collectable))
|
|
(set! (-> v1-4 prim-core collide-with) (collide-spec jak player-list tobot))
|
|
(set-vector! (-> v1-4 local-sphere) 0.0 0.0 0.0 12288.0)
|
|
(set! (-> s5-0 total-prims) (the-as uint 1))
|
|
(set! (-> s5-0 root-prim) v1-4)
|
|
)
|
|
(set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
|
|
(let ((v1-7 (-> s5-0 root-prim)))
|
|
(set! (-> s5-0 backup-collide-as) (-> v1-7 prim-core collide-as))
|
|
(set! (-> s5-0 backup-collide-with) (-> v1-7 prim-core collide-with))
|
|
)
|
|
(set! (-> self root) s5-0)
|
|
)
|
|
(set! (-> self root trans quad) (-> (the-as process-drawable (-> self parent 0)) root trans quad))
|
|
(quaternion-identity! (-> self root quat))
|
|
(vector-identity! (-> self root scale))
|
|
(set! (-> self joint-track) arg0)
|
|
(set-vector! (-> self dir) 0.0 0.0 1.0 1.0)
|
|
(set! (-> self edge-length) 8192.0)
|
|
(go-virtual idle)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (process-hidden)
|
|
:virtual #t
|
|
:code nothing
|
|
)
|
|
|
|
;; definition for method 11 of type process-hidden
|
|
(defmethod init-from-entity! ((this process-hidden) (arg0 entity-actor))
|
|
"Copy defaults from the entity."
|
|
(process-entity-status! this (entity-perm-status dead) #t)
|
|
(go (method-of-object this die))
|
|
)
|
|
|
|
;; definition of type target-start
|
|
(deftype target-start (process-hidden)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type target-start
|
|
(defmethod inspect ((this target-start))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-68)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tname: ~A~%" (-> this name))
|
|
(format #t "~1Tmask: #x~X : (process-mask " (-> this mask))
|
|
(let ((s5-0 (-> this mask)))
|
|
(if (= (logand s5-0 (process-mask process-tree)) (process-mask process-tree))
|
|
(format #t "process-tree ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask target)) (process-mask target))
|
|
(format #t "target ")
|
|
)
|
|
(if (= (logand (process-mask collectable) s5-0) (process-mask collectable))
|
|
(format #t "collectable ")
|
|
)
|
|
(if (= (logand (process-mask projectile) s5-0) (process-mask projectile))
|
|
(format #t "projectile ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep-code)) (process-mask sleep-code))
|
|
(format #t "sleep-code ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask actor-pause)) (process-mask actor-pause))
|
|
(format #t "actor-pause ")
|
|
)
|
|
(if (= (logand (process-mask metalhead) s5-0) (shl #x8000 16))
|
|
(format #t "metalhead ")
|
|
)
|
|
(if (= (logand (process-mask bot) s5-0) (process-mask bot))
|
|
(format #t "bot ")
|
|
)
|
|
(if (= (logand (process-mask vehicle) s5-0) (process-mask vehicle))
|
|
(format #t "vehicle ")
|
|
)
|
|
(if (= (logand (process-mask enemy) s5-0) (process-mask enemy))
|
|
(format #t "enemy ")
|
|
)
|
|
(if (= (logand (process-mask entity) s5-0) (process-mask entity))
|
|
(format #t "entity ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask heap-shrunk)) (process-mask heap-shrunk))
|
|
(format #t "heap-shrunk ")
|
|
)
|
|
(if (= (logand (process-mask sidekick) s5-0) (process-mask sidekick))
|
|
(format #t "sidekick ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask going)) (process-mask going))
|
|
(format #t "going ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask execute)) (process-mask execute))
|
|
(format #t "execute ")
|
|
)
|
|
(if (= (logand (process-mask civilian) s5-0) (process-mask civilian))
|
|
(format #t "civilian ")
|
|
)
|
|
(if (= (logand (process-mask death) s5-0) (process-mask death))
|
|
(format #t "death ")
|
|
)
|
|
(if (= (logand (process-mask guard) s5-0) (process-mask guard))
|
|
(format #t "guard ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask no-kill)) (process-mask no-kill))
|
|
(format #t "no-kill ")
|
|
)
|
|
(if (= (logand (process-mask kg-robot) s5-0) (process-mask kg-robot))
|
|
(format #t "kg-robot ")
|
|
)
|
|
(if (= (logand (process-mask platform) s5-0) (process-mask platform))
|
|
(format #t "platform ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask freeze)) (process-mask freeze))
|
|
(format #t "freeze ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep)) (process-mask sleep))
|
|
(format #t "sleep ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask progress)) (process-mask progress))
|
|
(format #t "progress ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask menu)) (process-mask menu))
|
|
(format #t "menu ")
|
|
)
|
|
(if (= (logand (process-mask camera) s5-0) (process-mask camera))
|
|
(format #t "camera ")
|
|
)
|
|
(if (= (logand (process-mask ambient) s5-0) (process-mask ambient))
|
|
(format #t "ambient ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask dark-effect)) (process-mask dark-effect))
|
|
(format #t "dark-effect ")
|
|
)
|
|
(if (= (logand (process-mask crate) s5-0) (process-mask crate))
|
|
(format #t "crate ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask kernel-run)) (process-mask kernel-run))
|
|
(format #t "kernel-run ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask movie)) (process-mask movie))
|
|
(format #t "movie ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask pause)) (process-mask pause))
|
|
(format #t "pause ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tclock: ~A~%" (-> this clock))
|
|
(format #t "~1Tparent: #x~X~%" (-> this parent))
|
|
(format #t "~1Tbrother: #x~X~%" (-> this brother))
|
|
(format #t "~1Tchild: #x~X~%" (-> this child))
|
|
(format #t "~1Tppointer: #x~X~%" (-> this ppointer))
|
|
(format #t "~1Tself: ~A~%" (-> this self))
|
|
(format #t "~1Tpool: ~A~%" (-> this pool))
|
|
(format #t "~1Tstatus: ~A~%" (-> this status))
|
|
(format #t "~1Tpid: ~D~%" (-> this pid))
|
|
(format #t "~1Tmain-thread: ~A~%" (-> this main-thread))
|
|
(format #t "~1Ttop-thread: ~A~%" (-> this top-thread))
|
|
(format #t "~1Tentity: ~A~%" (-> this entity))
|
|
(format #t "~1Tlevel: ~A~%" (-> this level))
|
|
(format #t "~1Tstate: ~A~%" (-> this state))
|
|
(format #t "~1Tprev-state: ~A~%" (-> this prev-state))
|
|
(format #t "~1Tnext-state: ~A~%" (-> this next-state))
|
|
(format #t "~1Tstate-stack: ~A~%" (-> this state-stack))
|
|
(format #t "~1Ttrans-hook: ~A~%" (-> this trans-hook))
|
|
(format #t "~1Tpost-hook: ~A~%" (-> this post-hook))
|
|
(format #t "~1Tevent-hook: ~A~%" (-> this event-hook))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
|
|
(format #t "~1Theap-base: #x~X~%" (-> this heap-base))
|
|
(format #t "~1Theap-top: #x~X~%" (-> this heap-top))
|
|
(format #t "~1Theap-cur: #x~X~%" (-> this heap-cur))
|
|
(format #t "~1Tstack-frame-top: ~A~%" (-> this stack-frame-top))
|
|
(format #t "~1Theap: #<kheap @ #x~X>~%" (&-> this heap-base))
|
|
(format #t "~1Tconnection-list: ~`connectable`P~%" (-> this connection-list))
|
|
(format #t "~1Tstack[0] @ #x~X~%" (-> this stack))
|
|
(label cfg-68)
|
|
this
|
|
)
|
|
|
|
;; definition of type camera-start
|
|
(deftype camera-start (process-hidden)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type camera-start
|
|
(defmethod inspect ((this camera-start))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-68)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tname: ~A~%" (-> this name))
|
|
(format #t "~1Tmask: #x~X : (process-mask " (-> this mask))
|
|
(let ((s5-0 (-> this mask)))
|
|
(if (= (logand s5-0 (process-mask process-tree)) (process-mask process-tree))
|
|
(format #t "process-tree ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask target)) (process-mask target))
|
|
(format #t "target ")
|
|
)
|
|
(if (= (logand (process-mask collectable) s5-0) (process-mask collectable))
|
|
(format #t "collectable ")
|
|
)
|
|
(if (= (logand (process-mask projectile) s5-0) (process-mask projectile))
|
|
(format #t "projectile ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep-code)) (process-mask sleep-code))
|
|
(format #t "sleep-code ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask actor-pause)) (process-mask actor-pause))
|
|
(format #t "actor-pause ")
|
|
)
|
|
(if (= (logand (process-mask metalhead) s5-0) (shl #x8000 16))
|
|
(format #t "metalhead ")
|
|
)
|
|
(if (= (logand (process-mask bot) s5-0) (process-mask bot))
|
|
(format #t "bot ")
|
|
)
|
|
(if (= (logand (process-mask vehicle) s5-0) (process-mask vehicle))
|
|
(format #t "vehicle ")
|
|
)
|
|
(if (= (logand (process-mask enemy) s5-0) (process-mask enemy))
|
|
(format #t "enemy ")
|
|
)
|
|
(if (= (logand (process-mask entity) s5-0) (process-mask entity))
|
|
(format #t "entity ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask heap-shrunk)) (process-mask heap-shrunk))
|
|
(format #t "heap-shrunk ")
|
|
)
|
|
(if (= (logand (process-mask sidekick) s5-0) (process-mask sidekick))
|
|
(format #t "sidekick ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask going)) (process-mask going))
|
|
(format #t "going ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask execute)) (process-mask execute))
|
|
(format #t "execute ")
|
|
)
|
|
(if (= (logand (process-mask civilian) s5-0) (process-mask civilian))
|
|
(format #t "civilian ")
|
|
)
|
|
(if (= (logand (process-mask death) s5-0) (process-mask death))
|
|
(format #t "death ")
|
|
)
|
|
(if (= (logand (process-mask guard) s5-0) (process-mask guard))
|
|
(format #t "guard ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask no-kill)) (process-mask no-kill))
|
|
(format #t "no-kill ")
|
|
)
|
|
(if (= (logand (process-mask kg-robot) s5-0) (process-mask kg-robot))
|
|
(format #t "kg-robot ")
|
|
)
|
|
(if (= (logand (process-mask platform) s5-0) (process-mask platform))
|
|
(format #t "platform ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask freeze)) (process-mask freeze))
|
|
(format #t "freeze ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep)) (process-mask sleep))
|
|
(format #t "sleep ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask progress)) (process-mask progress))
|
|
(format #t "progress ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask menu)) (process-mask menu))
|
|
(format #t "menu ")
|
|
)
|
|
(if (= (logand (process-mask camera) s5-0) (process-mask camera))
|
|
(format #t "camera ")
|
|
)
|
|
(if (= (logand (process-mask ambient) s5-0) (process-mask ambient))
|
|
(format #t "ambient ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask dark-effect)) (process-mask dark-effect))
|
|
(format #t "dark-effect ")
|
|
)
|
|
(if (= (logand (process-mask crate) s5-0) (process-mask crate))
|
|
(format #t "crate ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask kernel-run)) (process-mask kernel-run))
|
|
(format #t "kernel-run ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask movie)) (process-mask movie))
|
|
(format #t "movie ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask pause)) (process-mask pause))
|
|
(format #t "pause ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tclock: ~A~%" (-> this clock))
|
|
(format #t "~1Tparent: #x~X~%" (-> this parent))
|
|
(format #t "~1Tbrother: #x~X~%" (-> this brother))
|
|
(format #t "~1Tchild: #x~X~%" (-> this child))
|
|
(format #t "~1Tppointer: #x~X~%" (-> this ppointer))
|
|
(format #t "~1Tself: ~A~%" (-> this self))
|
|
(format #t "~1Tpool: ~A~%" (-> this pool))
|
|
(format #t "~1Tstatus: ~A~%" (-> this status))
|
|
(format #t "~1Tpid: ~D~%" (-> this pid))
|
|
(format #t "~1Tmain-thread: ~A~%" (-> this main-thread))
|
|
(format #t "~1Ttop-thread: ~A~%" (-> this top-thread))
|
|
(format #t "~1Tentity: ~A~%" (-> this entity))
|
|
(format #t "~1Tlevel: ~A~%" (-> this level))
|
|
(format #t "~1Tstate: ~A~%" (-> this state))
|
|
(format #t "~1Tprev-state: ~A~%" (-> this prev-state))
|
|
(format #t "~1Tnext-state: ~A~%" (-> this next-state))
|
|
(format #t "~1Tstate-stack: ~A~%" (-> this state-stack))
|
|
(format #t "~1Ttrans-hook: ~A~%" (-> this trans-hook))
|
|
(format #t "~1Tpost-hook: ~A~%" (-> this post-hook))
|
|
(format #t "~1Tevent-hook: ~A~%" (-> this event-hook))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
|
|
(format #t "~1Theap-base: #x~X~%" (-> this heap-base))
|
|
(format #t "~1Theap-top: #x~X~%" (-> this heap-top))
|
|
(format #t "~1Theap-cur: #x~X~%" (-> this heap-cur))
|
|
(format #t "~1Tstack-frame-top: ~A~%" (-> this stack-frame-top))
|
|
(format #t "~1Theap: #<kheap @ #x~X>~%" (&-> this heap-base))
|
|
(format #t "~1Tconnection-list: ~`connectable`P~%" (-> this connection-list))
|
|
(format #t "~1Tstack[0] @ #x~X~%" (-> this stack))
|
|
(label cfg-68)
|
|
this
|
|
)
|
|
|
|
;; definition of type cam-slope
|
|
(deftype cam-slope (process-hidden)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type cam-slope
|
|
(defmethod inspect ((this cam-slope))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-68)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tname: ~A~%" (-> this name))
|
|
(format #t "~1Tmask: #x~X : (process-mask " (-> this mask))
|
|
(let ((s5-0 (-> this mask)))
|
|
(if (= (logand s5-0 (process-mask process-tree)) (process-mask process-tree))
|
|
(format #t "process-tree ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask target)) (process-mask target))
|
|
(format #t "target ")
|
|
)
|
|
(if (= (logand (process-mask collectable) s5-0) (process-mask collectable))
|
|
(format #t "collectable ")
|
|
)
|
|
(if (= (logand (process-mask projectile) s5-0) (process-mask projectile))
|
|
(format #t "projectile ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep-code)) (process-mask sleep-code))
|
|
(format #t "sleep-code ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask actor-pause)) (process-mask actor-pause))
|
|
(format #t "actor-pause ")
|
|
)
|
|
(if (= (logand (process-mask metalhead) s5-0) (shl #x8000 16))
|
|
(format #t "metalhead ")
|
|
)
|
|
(if (= (logand (process-mask bot) s5-0) (process-mask bot))
|
|
(format #t "bot ")
|
|
)
|
|
(if (= (logand (process-mask vehicle) s5-0) (process-mask vehicle))
|
|
(format #t "vehicle ")
|
|
)
|
|
(if (= (logand (process-mask enemy) s5-0) (process-mask enemy))
|
|
(format #t "enemy ")
|
|
)
|
|
(if (= (logand (process-mask entity) s5-0) (process-mask entity))
|
|
(format #t "entity ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask heap-shrunk)) (process-mask heap-shrunk))
|
|
(format #t "heap-shrunk ")
|
|
)
|
|
(if (= (logand (process-mask sidekick) s5-0) (process-mask sidekick))
|
|
(format #t "sidekick ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask going)) (process-mask going))
|
|
(format #t "going ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask execute)) (process-mask execute))
|
|
(format #t "execute ")
|
|
)
|
|
(if (= (logand (process-mask civilian) s5-0) (process-mask civilian))
|
|
(format #t "civilian ")
|
|
)
|
|
(if (= (logand (process-mask death) s5-0) (process-mask death))
|
|
(format #t "death ")
|
|
)
|
|
(if (= (logand (process-mask guard) s5-0) (process-mask guard))
|
|
(format #t "guard ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask no-kill)) (process-mask no-kill))
|
|
(format #t "no-kill ")
|
|
)
|
|
(if (= (logand (process-mask kg-robot) s5-0) (process-mask kg-robot))
|
|
(format #t "kg-robot ")
|
|
)
|
|
(if (= (logand (process-mask platform) s5-0) (process-mask platform))
|
|
(format #t "platform ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask freeze)) (process-mask freeze))
|
|
(format #t "freeze ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask sleep)) (process-mask sleep))
|
|
(format #t "sleep ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask progress)) (process-mask progress))
|
|
(format #t "progress ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask menu)) (process-mask menu))
|
|
(format #t "menu ")
|
|
)
|
|
(if (= (logand (process-mask camera) s5-0) (process-mask camera))
|
|
(format #t "camera ")
|
|
)
|
|
(if (= (logand (process-mask ambient) s5-0) (process-mask ambient))
|
|
(format #t "ambient ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask dark-effect)) (process-mask dark-effect))
|
|
(format #t "dark-effect ")
|
|
)
|
|
(if (= (logand (process-mask crate) s5-0) (process-mask crate))
|
|
(format #t "crate ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask kernel-run)) (process-mask kernel-run))
|
|
(format #t "kernel-run ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask movie)) (process-mask movie))
|
|
(format #t "movie ")
|
|
)
|
|
(if (= (logand s5-0 (process-mask pause)) (process-mask pause))
|
|
(format #t "pause ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tclock: ~A~%" (-> this clock))
|
|
(format #t "~1Tparent: #x~X~%" (-> this parent))
|
|
(format #t "~1Tbrother: #x~X~%" (-> this brother))
|
|
(format #t "~1Tchild: #x~X~%" (-> this child))
|
|
(format #t "~1Tppointer: #x~X~%" (-> this ppointer))
|
|
(format #t "~1Tself: ~A~%" (-> this self))
|
|
(format #t "~1Tpool: ~A~%" (-> this pool))
|
|
(format #t "~1Tstatus: ~A~%" (-> this status))
|
|
(format #t "~1Tpid: ~D~%" (-> this pid))
|
|
(format #t "~1Tmain-thread: ~A~%" (-> this main-thread))
|
|
(format #t "~1Ttop-thread: ~A~%" (-> this top-thread))
|
|
(format #t "~1Tentity: ~A~%" (-> this entity))
|
|
(format #t "~1Tlevel: ~A~%" (-> this level))
|
|
(format #t "~1Tstate: ~A~%" (-> this state))
|
|
(format #t "~1Tprev-state: ~A~%" (-> this prev-state))
|
|
(format #t "~1Tnext-state: ~A~%" (-> this next-state))
|
|
(format #t "~1Tstate-stack: ~A~%" (-> this state-stack))
|
|
(format #t "~1Ttrans-hook: ~A~%" (-> this trans-hook))
|
|
(format #t "~1Tpost-hook: ~A~%" (-> this post-hook))
|
|
(format #t "~1Tevent-hook: ~A~%" (-> this event-hook))
|
|
(format #t "~1Tallocated-length: ~D~%" (-> this allocated-length))
|
|
(format #t "~1Theap-base: #x~X~%" (-> this heap-base))
|
|
(format #t "~1Theap-top: #x~X~%" (-> this heap-top))
|
|
(format #t "~1Theap-cur: #x~X~%" (-> this heap-cur))
|
|
(format #t "~1Tstack-frame-top: ~A~%" (-> this stack-frame-top))
|
|
(format #t "~1Theap: #<kheap @ #x~X>~%" (&-> this heap-base))
|
|
(format #t "~1Tconnection-list: ~`connectable`P~%" (-> this connection-list))
|
|
(format #t "~1Tstack[0] @ #x~X~%" (-> this stack))
|
|
(label cfg-68)
|
|
this
|
|
)
|
|
|
|
;; definition for function manipy-post
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defbehavior manipy-post manipy ()
|
|
((-> self cur-post-hook))
|
|
(when (and (>= (-> self shadow-volume-joint) 0) (-> self draw shadow-ctrl))
|
|
(let ((a2-0 (-> self node-list data (-> self shadow-volume-joint)))
|
|
(a3-0 (-> self draw shadow-ctrl))
|
|
)
|
|
(format *stdcon* "shadow-volume for ~A ~A~%" a2-0 a3-0)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (manipy)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(local-vars (s4-0 object))
|
|
(case message
|
|
(('blend-shape)
|
|
(when (nonzero? (-> self skel))
|
|
(cond
|
|
((-> block param 0)
|
|
(set! s4-0 (logior (-> self skel status) (joint-control-status blend-shape eye-anim)))
|
|
(set! (-> self skel status) (the-as joint-control-status s4-0))
|
|
)
|
|
(else
|
|
(set! s4-0 (logclear (-> self skel status) (joint-control-status blend-shape eye-anim)))
|
|
(set! (-> self skel status) (the-as joint-control-status s4-0))
|
|
)
|
|
)
|
|
s4-0
|
|
)
|
|
)
|
|
(('shadow)
|
|
(when (nonzero? (-> self draw))
|
|
(cond
|
|
((-> block param 0)
|
|
(set! s4-0 (-> self shadow-backup))
|
|
(set! (-> self draw shadow) (the-as shadow-geo s4-0))
|
|
s4-0
|
|
)
|
|
(else
|
|
(set! (-> self draw shadow) #f)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('shadow-volume)
|
|
(let ((v1-14 (the-as
|
|
joint
|
|
(get-art-by-name-method (-> self draw jgeo) (the-as string (-> block param 0)) (the-as type #f))
|
|
)
|
|
)
|
|
)
|
|
(if v1-14
|
|
(set! (-> self shadow-volume-joint) (+ (-> v1-14 number) 1))
|
|
)
|
|
)
|
|
(when (and (-> self draw shadow-ctrl) (< 1 argc) (>= (the-as int (-> block param 1)) 0))
|
|
(let ((v0-1 (command-get-int (-> block param 1) 0)))
|
|
(set! (-> self draw shadow-ctrl settings flags) (the-as shadow-flags v0-1))
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
(('shadow-type)
|
|
(if (and (-> self draw shadow-ctrl) (> argc 0))
|
|
(set! (-> self draw shadow-ctrl settings shadow-type) (command-get-int (-> block param 0) 0))
|
|
)
|
|
)
|
|
(('shadow-disable-smooth)
|
|
(when (nonzero? (-> self draw))
|
|
(cond
|
|
((-> block param 0)
|
|
(when (-> self draw shadow-ctrl)
|
|
(set! s4-0 (logior (-> self draw shadow-ctrl settings flags) (shadow-flags shdf08)))
|
|
(set! (-> self draw shadow-ctrl settings flags) (the-as shadow-flags s4-0))
|
|
s4-0
|
|
)
|
|
)
|
|
(else
|
|
(when (-> self draw shadow-ctrl)
|
|
(set! s4-0 (logclear (-> self draw shadow-ctrl settings flags) (shadow-flags shdf08)))
|
|
(set! (-> self draw shadow-ctrl settings flags) (the-as shadow-flags s4-0))
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('shadow-dir)
|
|
(when (and (-> self draw shadow-ctrl) (> argc 0))
|
|
(set! s4-0 (-> self draw shadow-ctrl settings shadow-dir))
|
|
(set! (-> (the-as vector s4-0) x) (the-as float (-> block param 0)))
|
|
(set! (-> (the-as vector s4-0) y) (the-as float (-> block param 1)))
|
|
(set! (-> (the-as vector s4-0) z) (the-as float (-> block param 2)))
|
|
(set! (-> (the-as vector s4-0) w) (the-as float (if (< 3 argc)
|
|
(command-get-param (-> block param 3) #f)
|
|
409600.0
|
|
)
|
|
)
|
|
)
|
|
s4-0
|
|
)
|
|
)
|
|
(('shadow-top-plane)
|
|
(when (and (-> self draw shadow-ctrl) (>= argc 4))
|
|
(set! s4-0 (-> self draw shadow-ctrl settings top-plane))
|
|
(set! (-> (the-as plane s4-0) x) (the-as float (-> block param 0)))
|
|
(set! (-> (the-as plane s4-0) y) (the-as float (-> block param 1)))
|
|
(set! (-> (the-as plane s4-0) z) (the-as float (-> block param 2)))
|
|
(set! (-> (the-as plane s4-0) w) (the-as float (-> block param 3)))
|
|
s4-0
|
|
)
|
|
)
|
|
(('shadow-bot-plane)
|
|
(when (and (-> self draw shadow-ctrl) (>= argc 4))
|
|
(set! s4-0 (-> self draw shadow-ctrl settings bot-plane))
|
|
(set! (-> (the-as plane s4-0) x) (the-as float (-> block param 0)))
|
|
(set! (-> (the-as plane s4-0) y) (the-as float (-> block param 1)))
|
|
(set! (-> (the-as plane s4-0) z) (the-as float (-> block param 2)))
|
|
(set! (-> (the-as plane s4-0) w) (the-as float (-> block param 3)))
|
|
s4-0
|
|
)
|
|
)
|
|
(('shadow-fade-dist)
|
|
(if (-> self draw shadow-ctrl)
|
|
(set! (-> self draw shadow-ctrl settings fade-dist) (the-as float (-> block param 0)))
|
|
)
|
|
)
|
|
(('no-fog)
|
|
(set! s4-0 (logior (-> self draw status) (draw-control-status disable-fog)))
|
|
(set! (-> self draw status) (the-as draw-control-status s4-0))
|
|
s4-0
|
|
)
|
|
(('setup-spotlight-shadow)
|
|
(when (-> self draw shadow-ctrl)
|
|
(let ((v1-80 (command-get-process "spotlight" *target*)))
|
|
(when v1-80
|
|
(let ((s5-1 (-> (the-as process-drawable v1-80) node-list data 3)))
|
|
(vector<-cspace! (new 'stack-no-clear 'vector) s5-1)
|
|
(let ((s5-2 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> s5-1 bone transform fvec) -1.0))
|
|
(s4-1
|
|
(vector<-cspace! (new 'stack-no-clear 'vector) (-> self node-list data (-> self draw shadow-joint-index)))
|
|
)
|
|
(f30-0 1638400.0)
|
|
(s3-0 (new 'stack-no-clear 'collide-query))
|
|
(f28-0 122880.0)
|
|
)
|
|
(set! (-> s3-0 start-pos quad) (-> s4-1 quad))
|
|
(vector-normalize-copy! (-> s3-0 move-dist) s5-2 f28-0)
|
|
(let ((v1-91 s3-0))
|
|
(set! (-> v1-91 radius) 1638.4)
|
|
(set! (-> v1-91 collide-with) (collide-spec obstacle hit-by-others-list))
|
|
(set! (-> v1-91 ignore-process0) self)
|
|
(set! (-> v1-91 ignore-process1) #f)
|
|
(set! (-> v1-91 ignore-pat)
|
|
(new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1 :board #x1)
|
|
)
|
|
(set! (-> v1-91 action-mask) (collide-action solid))
|
|
)
|
|
(let* ((f0-14 (fill-and-probe-using-line-sphere *collide-cache* s3-0))
|
|
(f28-1 (if (< 0.0 f0-14)
|
|
(* f0-14 f28-0)
|
|
122880.0
|
|
)
|
|
)
|
|
)
|
|
(shadow-control-method-14
|
|
(-> self draw shadow-ctrl)
|
|
s4-1
|
|
s5-2
|
|
f30-0
|
|
(- f28-1 (command-get-float (-> block param 0) 0.0))
|
|
(+ f28-1 (command-get-float (-> block param 1) 0.0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('color-mult)
|
|
(when (>= argc 4)
|
|
(set! s4-0 (-> self draw color-mult))
|
|
(set! (-> (the-as rgbaf s4-0) x) (command-get-float (-> block param 0) 0.0))
|
|
(set! (-> (the-as rgbaf s4-0) y) (command-get-float (-> block param 1) 0.0))
|
|
(set! (-> (the-as rgbaf s4-0) z) (command-get-float (-> block param 2) 0.0))
|
|
(set! (-> (the-as rgbaf s4-0) w) (command-get-float (-> block param 3) 0.0))
|
|
s4-0
|
|
)
|
|
)
|
|
(('color-mult-vector)
|
|
(set! s4-0 (-> self draw color-mult))
|
|
(set! (-> (the-as rgbaf s4-0) quad) (-> (the-as vector (-> block param 0)) quad))
|
|
s4-0
|
|
)
|
|
(('color-emissive-vector)
|
|
(set! s4-0 (-> self draw color-emissive))
|
|
(set! (-> (the-as rgbaf s4-0) quad) (-> (the-as vector (-> block param 0)) quad))
|
|
s4-0
|
|
)
|
|
(('segment)
|
|
(let ((a1-34 (/ (the-as int (-> block param 0)) 8))
|
|
(a2-5 (/ (the-as int (-> block param 1)) 8))
|
|
)
|
|
(setup-masks (-> self draw) (the-as int a1-34) (the-as int a2-5))
|
|
)
|
|
)
|
|
(('trans-hook)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self new-trans-hook) (the-as (function none) s4-0))
|
|
s4-0
|
|
)
|
|
(('post-hook)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self new-post-hook) (the-as (function none) s4-0))
|
|
s4-0
|
|
)
|
|
(('user-data)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self userdata) (the-as uint s4-0))
|
|
s4-0
|
|
)
|
|
(('eval)
|
|
((the-as (function manipy none) (-> block param 0)) self)
|
|
)
|
|
(('speed)
|
|
(set! (-> self speed) (the-as float (-> block param 0)))
|
|
)
|
|
(('event-hook)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self cur-event-hook) (the-as (function none) s4-0))
|
|
s4-0
|
|
)
|
|
(('art-joint-anim)
|
|
(set! (-> self new-joint-anim)
|
|
(get-art-by-name (-> self draw art-group) (the-as string (-> block param 0)) art-joint-anim)
|
|
)
|
|
(set! (-> self new-joint-anim-blend) (the-as uint (if (>= argc 2)
|
|
(the-as int (-> block param 1))
|
|
0
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self new-joint-anim-frame) (the-as float (if (>= argc 3)
|
|
(-> block param 2)
|
|
0.0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('anim-mode)
|
|
(when (nonzero? (-> self skel))
|
|
(set! (-> self anim-mode) (the-as symbol (-> block param 0)))
|
|
(if (= (-> self anim-mode) 'clone-anim)
|
|
(ja-post)
|
|
)
|
|
(-> self anim-mode)
|
|
)
|
|
)
|
|
(('origin-joint-index 'center-joint)
|
|
(set! (-> self draw origin-joint-index) (-> block param 0))
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self draw shadow-joint-index) (the-as uint s4-0))
|
|
s4-0
|
|
)
|
|
(('max-vis-dist)
|
|
(set! (-> self draw lod-set lod (-> self draw lod-set max-lod) dist) (the-as float (-> block param 0)))
|
|
)
|
|
(('grab)
|
|
(set! (-> self cur-grab-handle) (process->handle (the-as process (-> block param 0))))
|
|
(let ((v1-127 (handle->process (-> self cur-grab-handle))))
|
|
(when v1-127
|
|
(set! s4-0 (-> self old-grab-pos))
|
|
(set! (-> (the-as vector s4-0) quad) (-> (the-as process-drawable v1-127) root trans quad))
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
(('target)
|
|
(set! s4-0 (process->handle (the-as process (-> block param 0))))
|
|
(set! (-> self cur-target-handle) (the-as handle s4-0))
|
|
s4-0
|
|
)
|
|
(('trans)
|
|
(cond
|
|
((type? (-> self root) collide-shape)
|
|
(move-to-point! (-> self root) (the-as vector (-> block param 0)))
|
|
)
|
|
(else
|
|
(set! s4-0 (-> self root trans))
|
|
(set! (-> (the-as vector s4-0) quad) (-> (the-as vector (-> block param 0)) quad))
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
(('scale)
|
|
(set! s4-0 (-> self root scale))
|
|
(set! (-> (the-as vector s4-0) quad) (-> (the-as vector (-> block param 0)) quad))
|
|
s4-0
|
|
)
|
|
(('rot)
|
|
(let ((s5-3 (new 'stack-no-clear 'matrix)))
|
|
(matrix-rotate-y! s5-3 (the-as float (-> block param 0)))
|
|
(matrix->quaternion (-> self root quat) s5-3)
|
|
)
|
|
)
|
|
(('rot-quat)
|
|
(quaternion-copy! (-> self root quat) (the-as quaternion (-> block param 0)))
|
|
)
|
|
(('clone-copy-trans)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self clone-copy-trans) (the-as symbol s4-0))
|
|
s4-0
|
|
)
|
|
(('release)
|
|
(set! (-> self cur-grab-handle) (the-as handle #f))
|
|
#f
|
|
)
|
|
(('draw)
|
|
(set! (-> self draw?) (the-as symbol (-> block param 0)))
|
|
(cond
|
|
((-> block param 0)
|
|
(let ((v1-146 (logtest? (-> self draw status) (draw-control-status no-draw))))
|
|
(logclear! (-> self draw status) (draw-control-status no-draw))
|
|
(when v1-146
|
|
(cond
|
|
((nonzero? (-> self skel))
|
|
(let ((gp-1 (-> self skel status)))
|
|
(logior! (-> self skel status) (joint-control-status sync-math))
|
|
(set! s4-0 (ja-post))
|
|
(set! (-> self skel status) gp-1)
|
|
)
|
|
s4-0
|
|
)
|
|
(else
|
|
(ja-post)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! s4-0 (logior (-> self draw status) (draw-control-status no-draw)))
|
|
(set! (-> self draw status) (the-as draw-control-status s4-0))
|
|
s4-0
|
|
)
|
|
)
|
|
)
|
|
(('sync)
|
|
(when (nonzero? (-> self skel))
|
|
(cond
|
|
((-> block param 0)
|
|
(set! s4-0 (logior (-> self skel status) (joint-control-status sync-math)))
|
|
(set! (-> self skel status) (the-as joint-control-status s4-0))
|
|
)
|
|
(else
|
|
(set! s4-0 (logclear (-> self skel status) (joint-control-status sync-math)))
|
|
(set! (-> self skel status) (the-as joint-control-status s4-0))
|
|
)
|
|
)
|
|
s4-0
|
|
)
|
|
)
|
|
(('query)
|
|
(case (-> block param 0)
|
|
(('grab)
|
|
(handle->process (-> self cur-grab-handle))
|
|
)
|
|
(('done)
|
|
(case (-> self anim-mode)
|
|
(('play1 'play)
|
|
(>= (ja-frame-num 0) (the float (+ (-> (ja-group) frames num-frames) -2)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('set-frame-num)
|
|
(let ((v1-179 (-> self skel root-channel 0)))
|
|
(set! (-> v1-179 num-func) num-func-identity)
|
|
(set! (-> v1-179 frame-num) (the-as float (-> block param 0)))
|
|
)
|
|
)
|
|
(('prefix)
|
|
(set! s4-0 (-> block param 0))
|
|
(set! (-> self prefix) (the-as basic s4-0))
|
|
s4-0
|
|
)
|
|
(('light-index)
|
|
(let ((v0-29 (command-get-int (-> block param 0) 0)))
|
|
(set! (-> self draw light-index) (the-as uint v0-29))
|
|
v0-29
|
|
)
|
|
)
|
|
(('eye-slot)
|
|
(set! (-> self draw mgeo header eye-ctrl eye-slot) (command-get-int (-> block param 0) 0))
|
|
)
|
|
(('shadow-mask)
|
|
(let ((v0-31 (command-get-int (-> block param 0) 0)))
|
|
(set! (-> self draw shadow-mask) (the-as uint v0-31))
|
|
v0-31
|
|
)
|
|
)
|
|
(('shadow-values)
|
|
(let ((v0-32 (command-get-int (-> block param 0) 0)))
|
|
(set! (-> self draw shadow-values) (the-as uint v0-32))
|
|
v0-32
|
|
)
|
|
)
|
|
(('mirror)
|
|
(cond
|
|
((-> block param 0)
|
|
(set! s4-0 (-> self node-list data 2))
|
|
(set! (-> (the-as cspace s4-0) param0)
|
|
(the-as (function cspace transformq none) cspace<-parented-matrix-mirror!)
|
|
)
|
|
(set! (-> (the-as cspace s4-0) param1) (the-as basic (-> *math-camera* mirror-trans)))
|
|
(set! (-> (the-as cspace s4-0) param2) (the-as basic (-> *math-camera* mirror-normal)))
|
|
)
|
|
(else
|
|
(set! s4-0 (-> self node-list data 2))
|
|
(set! (-> (the-as cspace s4-0) param0) #f)
|
|
)
|
|
)
|
|
s4-0
|
|
)
|
|
(('draw-mirror)
|
|
(send-event (ppointer->process (-> self child)) 'draw (-> block param 0))
|
|
)
|
|
(('user)
|
|
(set! s4-0 (-> block param 1))
|
|
(set! (-> self user-uint64 (/ (the-as int (-> block param 0)) 8)) (the-as uint s4-0))
|
|
s4-0
|
|
)
|
|
(('die)
|
|
(deactivate self)
|
|
)
|
|
(('do-effect)
|
|
(if (and (nonzero? (-> self skel)) (-> self skel effect))
|
|
(do-effect (-> self skel effect) (the-as symbol (-> block param 0)) (the-as float (-> block param 1)) -1)
|
|
)
|
|
)
|
|
(('no-actor-pause)
|
|
(set! s4-0 (logclear (-> self mask) (process-mask actor-pause)))
|
|
(set! (-> self mask) (the-as process-mask s4-0))
|
|
s4-0
|
|
)
|
|
(else
|
|
(if (-> self cur-event-hook)
|
|
((-> self cur-event-hook))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(if (!= (-> self cur-trans-hook) (-> self new-trans-hook))
|
|
(set! (-> self cur-trans-hook) (-> self new-trans-hook))
|
|
)
|
|
(if (!= (-> self cur-post-hook) (-> self new-post-hook))
|
|
(set! (-> self cur-post-hook) (-> self new-post-hook))
|
|
)
|
|
(when (and (-> self new-joint-anim)
|
|
(nonzero? (-> self skel))
|
|
(and (!= (ja-group) (-> self new-joint-anim)) (!= (-> self anim-mode) 'clone-anim))
|
|
)
|
|
(ja-channel-push! 1 (the-as time-frame (-> self new-joint-anim-blend)))
|
|
(ja :group! (-> self new-joint-anim) :num! (identity (ja-aframe (-> self new-joint-anim-frame) 0)))
|
|
)
|
|
(let ((v1-20 (handle->process (-> self cur-grab-handle))))
|
|
(when v1-20
|
|
(let ((gp-1 (-> (the-as process-drawable v1-20) root trans)))
|
|
(if (type? (-> self root) collide-shape)
|
|
(move-by-vector! (-> self root) (vector-! (new 'stack-no-clear 'vector) gp-1 (-> self old-grab-pos)))
|
|
(vector+!
|
|
(-> self root trans)
|
|
(-> self root trans)
|
|
(vector-! (new 'stack-no-clear 'vector) gp-1 (-> self old-grab-pos))
|
|
)
|
|
)
|
|
(set! (-> self old-grab-pos quad) (-> gp-1 quad))
|
|
)
|
|
)
|
|
)
|
|
((-> self cur-trans-hook))
|
|
)
|
|
:code (behavior ()
|
|
(logclear! (-> self mask) (process-mask heap-shrunk))
|
|
(until #f
|
|
(case (-> self anim-mode)
|
|
(('loop)
|
|
(ja-post)
|
|
(manipy-post)
|
|
(suspend)
|
|
(ja :num! (loop!))
|
|
)
|
|
(('play)
|
|
(ja-post)
|
|
(manipy-post)
|
|
(suspend)
|
|
(ja :num! (seek!))
|
|
)
|
|
(('copy-parent)
|
|
(let ((v1-17 (-> self skel root-channel 0)))
|
|
(set! (-> v1-17 num-func) num-func-identity)
|
|
(let ((a0-10 (-> self parent)))
|
|
(set! (-> v1-17 frame-num) (-> (the-as process-drawable (if a0-10
|
|
(the-as process-drawable (-> a0-10 0 self))
|
|
)
|
|
)
|
|
skel
|
|
root-channel
|
|
0
|
|
frame-num
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(ja-post)
|
|
(manipy-post)
|
|
(suspend)
|
|
0
|
|
)
|
|
(('clone-parent)
|
|
(let ((gp-0 (ppointer->process (-> self parent))))
|
|
(set! (-> self post-hook) #f)
|
|
(joint-control-copy! (-> self skel) (-> (the-as process-drawable gp-0) skel))
|
|
(joint-control-remap!
|
|
(-> self skel)
|
|
(-> self draw art-group)
|
|
(-> (the-as process-drawable gp-0) draw art-group)
|
|
'()
|
|
0
|
|
""
|
|
)
|
|
)
|
|
(update-anim-data (-> self skel))
|
|
(do-joint-math (-> self draw) (-> self node-list) (-> self skel))
|
|
(manipy-post)
|
|
(suspend)
|
|
0
|
|
)
|
|
(('clone-anim)
|
|
(clone-anim-once
|
|
(if (handle->process (-> self cur-target-handle))
|
|
(the-as handle (-> self cur-target-handle))
|
|
(ppointer->handle (-> self parent))
|
|
)
|
|
(-> self clone-copy-trans)
|
|
(the-as string (-> self prefix))
|
|
)
|
|
(manipy-post)
|
|
(suspend)
|
|
0
|
|
)
|
|
(('mirror)
|
|
(let ((gp-1 (if (handle->process (-> self cur-target-handle))
|
|
(-> self cur-target-handle)
|
|
(ppointer->handle (-> self parent))
|
|
)
|
|
)
|
|
)
|
|
(clone-anim-once gp-1 (-> self clone-copy-trans) (the-as string (-> self prefix)))
|
|
(logior! (-> self draw global-effect) (draw-control-global-effect disable-envmap))
|
|
(set! (-> self draw light-index) (the-as uint 5))
|
|
(if (logtest? (-> (the-as process-drawable (handle->process gp-1)) draw status)
|
|
(draw-control-status no-draw no-draw-temp no-draw-bounds)
|
|
)
|
|
(logior! (-> self draw status) (draw-control-status no-draw-temp))
|
|
)
|
|
)
|
|
(manipy-post)
|
|
(suspend)
|
|
0
|
|
)
|
|
(('still)
|
|
(ja-post)
|
|
(manipy-post)
|
|
(suspend)
|
|
0
|
|
)
|
|
(('play1)
|
|
(ja-post)
|
|
(manipy-post)
|
|
(suspend)
|
|
(ja :num! (seek! max (-> self speed)))
|
|
(if (ja-done? 0)
|
|
(deactivate self)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; definition for function manipy-init
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior manipy-init manipy ((arg0 vector) (arg1 entity-actor) (arg2 skeleton-group) (arg3 vector) (arg4 manipy-options))
|
|
(stack-size-set! (-> self main-thread) 128)
|
|
(logior! (-> self mask) (process-mask heap-shrunk))
|
|
(process-entity-set! self arg1)
|
|
(cond
|
|
((= arg3 'collide-shape-moving)
|
|
(let ((s3-1 (new 'process 'collide-shape-moving self (collide-list-enum hit-by-player))))
|
|
(set! (-> s3-1 dynam) (copy *standard-dynamics* 'process))
|
|
(set! (-> s3-1 reaction) cshape-reaction-default)
|
|
(set! (-> s3-1 no-reaction)
|
|
(the-as (function collide-shape-moving collide-query vector vector object) nothing)
|
|
)
|
|
(let ((v1-11 (new 'process 'collide-shape-prim-sphere s3-1 (the-as uint 0))))
|
|
(set-vector! (-> v1-11 local-sphere) 0.0 0.0 0.0 4096.0)
|
|
(set! (-> s3-1 total-prims) (the-as uint 1))
|
|
(set! (-> s3-1 root-prim) v1-11)
|
|
)
|
|
(set! (-> s3-1 nav-radius) (* 0.75 (-> s3-1 root-prim local-sphere w)))
|
|
(let ((v1-14 (-> s3-1 root-prim)))
|
|
(set! (-> s3-1 backup-collide-as) (-> v1-14 prim-core collide-as))
|
|
(set! (-> s3-1 backup-collide-with) (-> v1-14 prim-core collide-with))
|
|
)
|
|
(set! (-> self root) s3-1)
|
|
)
|
|
)
|
|
(arg3
|
|
(let ((s3-2 (new 'process 'collide-shape self (collide-list-enum hit-by-player))))
|
|
(let ((v1-18 (new 'process 'collide-shape-prim-sphere s3-2 (the-as uint 0))))
|
|
(set! (-> v1-18 prim-core collide-as) (collide-spec collectable notice-blue-eco-powerup))
|
|
(set! (-> v1-18 prim-core collide-with) (collide-spec jak player-list))
|
|
(set-vector! (-> v1-18 local-sphere) (-> arg3 x) (-> arg3 y) (-> arg3 z) (-> arg3 w))
|
|
(set! (-> s3-2 total-prims) (the-as uint 1))
|
|
(set! (-> s3-2 root-prim) v1-18)
|
|
)
|
|
(set! (-> s3-2 nav-radius) (* 0.75 (-> s3-2 root-prim local-sphere w)))
|
|
(let ((v1-21 (-> s3-2 root-prim)))
|
|
(set! (-> s3-2 backup-collide-as) (-> v1-21 prim-core collide-as))
|
|
(set! (-> s3-2 backup-collide-with) (-> v1-21 prim-core collide-with))
|
|
)
|
|
(set! (-> self root) s3-2)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> self root) (the-as collide-shape (new 'process 'trsqv)))
|
|
)
|
|
)
|
|
(set! (-> self root trans quad) (-> arg0 quad))
|
|
(initialize-skeleton self arg2 (the-as pair 0))
|
|
(if (type? (-> self root) collide-shape)
|
|
(update-transforms (-> self root))
|
|
)
|
|
(set! (-> self shadow-backup) (-> self draw shadow))
|
|
(set! (-> self shadow-volume-joint) -1)
|
|
(set! (-> self options) arg4)
|
|
(when (-> self draw shadow)
|
|
(set! (-> self draw shadow-ctrl) (new
|
|
'process
|
|
'shadow-control
|
|
0.0
|
|
0.0
|
|
614400.0
|
|
(the-as vector #f)
|
|
0.000000000000000000000000000000000000000000084
|
|
245760.0
|
|
)
|
|
)
|
|
(quad-copy! (the-as pointer (-> self draw shadow-ctrl settings)) (the-as pointer *default-shadow-settings*) 5)
|
|
)
|
|
(set! (-> self new-trans-hook) nothing)
|
|
(set! (-> self cur-trans-hook) nothing)
|
|
(set! (-> self new-post-hook) nothing)
|
|
(set! (-> self cur-post-hook) nothing)
|
|
(set! (-> self cur-event-hook) #f)
|
|
(set! (-> self cur-grab-handle) (the-as handle #f))
|
|
(set! (-> self cur-target-handle) (the-as handle #f))
|
|
(set! (-> self clone-copy-trans) #t)
|
|
(set! (-> self draw?) #t)
|
|
(set! (-> self prefix) "")
|
|
(set! (-> self speed) 1.0)
|
|
(when (logtest? (-> self options) (manipy-options mo0))
|
|
(let ((v1-56 (the-as joint (get-art-by-name-method (-> self draw jgeo) "neckA" (the-as type #f)))))
|
|
(when v1-56
|
|
(set! (-> self joint 0) (new 'process 'joint-mod (joint-mod-mode flex-blend) self (+ (-> v1-56 number) 1)))
|
|
(set! (-> self joint 0 parented-scale?) #t)
|
|
)
|
|
)
|
|
)
|
|
(when (logtest? (-> self options) (manipy-options mo1))
|
|
(let ((v1-64 (the-as joint (get-art-by-name-method (-> self draw jgeo) "horns" (the-as type #f)))))
|
|
(when v1-64
|
|
(set! (-> self joint 1) (new 'process 'joint-mod (joint-mod-mode joint-set) self (+ (-> v1-64 number) 1)))
|
|
(set! (-> self joint 1 parented-scale?) #t)
|
|
(set! (-> self joint 1 track-mode) (track-mode no-trans no-rotate))
|
|
(trs-set! (-> self joint 1) (the-as vector #f) (the-as quaternion #f) *null-vector*)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((nonzero? (-> self skel))
|
|
(set! (-> self new-joint-anim) (ja-group))
|
|
(set! (-> self new-joint-anim-frame) 0.0)
|
|
(set! (-> self anim-mode) 'loop)
|
|
)
|
|
(else
|
|
(set! (-> self anim-mode) 'still)
|
|
)
|
|
)
|
|
(set! (-> self event-hook) (-> (method-of-object self idle) event))
|
|
(go-virtual idle)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type part-tracker
|
|
(defmethod deactivate ((this part-tracker))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(if (nonzero? (-> this part))
|
|
(kill-particles (-> this part))
|
|
)
|
|
((method-of-type process deactivate) this)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 17 of type part-tracker
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod notify-parent-of-death ((this part-tracker))
|
|
(with-pp
|
|
(let ((gp-0 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> gp-0 from) (process->ppointer pp))
|
|
(set! (-> gp-0 num-params) 1)
|
|
(set! (-> gp-0 message) 'notify)
|
|
(set! (-> gp-0 param 0) (the-as uint 'die))
|
|
(let ((s5-0 send-event-function)
|
|
(s4-0 (ppointer->process (-> this parent)))
|
|
)
|
|
(s5-0
|
|
(if (type? s4-0 process)
|
|
s4-0
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 7 of type part-tracker-subsampler
|
|
;; WARN: Return type mismatch process vs part-tracker-subsampler.
|
|
(defmethod relocate ((this part-tracker-subsampler) (offset int))
|
|
(if (nonzero? (-> this root))
|
|
(&+! (-> this root) offset)
|
|
)
|
|
(if (nonzero? (-> this subsampler))
|
|
(&+! (-> this subsampler) offset)
|
|
)
|
|
(the-as part-tracker-subsampler ((method-of-type process relocate) this offset))
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (part-tracker)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(local-vars (v0-0 object))
|
|
(case message
|
|
(('clock)
|
|
(+! (-> self clock ref-count) -1)
|
|
(+! (-> (the-as process (-> block param 0)) clock ref-count) 1)
|
|
(set! v0-0 (-> (the-as process (-> block param 0)) clock))
|
|
(set! (-> self clock) (the-as clock v0-0))
|
|
v0-0
|
|
)
|
|
(('draw)
|
|
(when (not (-> block param 0))
|
|
(set! v0-0 1)
|
|
(set! (-> self duration) (the-as time-frame v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
(('trans)
|
|
(set! v0-0 (-> self root trans))
|
|
(set! (-> (the-as vector v0-0) quad) (-> (the-as vector (-> block param 0)) quad))
|
|
v0-0
|
|
)
|
|
(('die)
|
|
(deactivate self)
|
|
)
|
|
)
|
|
)
|
|
:enter (behavior ()
|
|
(set-time! (-> self state-time))
|
|
)
|
|
:trans (behavior ()
|
|
(if (and (nonzero? (-> self duration)) (time-elapsed? (-> self state-time) (-> self duration)))
|
|
(go-virtual linger)
|
|
)
|
|
(if (-> self callback)
|
|
((-> self callback) self)
|
|
)
|
|
(let* ((gp-0 (handle->process (-> self target)))
|
|
(v1-15 (if (type? gp-0 process-drawable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((and v1-15
|
|
(nonzero? (-> (the-as process-drawable v1-15) root))
|
|
(nonzero? (-> (the-as process-drawable v1-15) node-list))
|
|
)
|
|
(sparticle-launch-control-method-18
|
|
(-> self part)
|
|
(-> (the-as process-drawable v1-15) node-list data (-> self target-joint))
|
|
)
|
|
(set! (-> self root trans quad) (-> self part origin trans quad))
|
|
)
|
|
(else
|
|
(let ((a0-11 (-> self root trans)))
|
|
(set! (-> self mat trans quad) (-> a0-11 quad))
|
|
)
|
|
(sparticle-launch-control-method-17 (-> self part) (-> self mat))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate linger (part-tracker)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
(set-time! (-> self state-time))
|
|
)
|
|
:trans (behavior ()
|
|
(if (-> self linger-callback)
|
|
((-> self linger-callback) self)
|
|
)
|
|
(if (time-elapsed? (-> self state-time) (-> self linger-duration))
|
|
(go-virtual die)
|
|
)
|
|
(let* ((gp-0 (handle->process (-> self target)))
|
|
(v1-13 (if (type? gp-0 process-drawable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(if (and v1-13
|
|
(nonzero? (-> (the-as process-drawable v1-13) root))
|
|
(nonzero? (-> (the-as process-drawable v1-13) node-list))
|
|
)
|
|
(vector<-cspace!
|
|
(-> self root trans)
|
|
(-> (the-as process-drawable v1-13) node-list data (-> self target-joint))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (part-tracker)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
(notify-parent-of-death self)
|
|
)
|
|
:code (behavior ()
|
|
(suspend)
|
|
0
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (part-tracker-subsampler)
|
|
:virtual #t
|
|
:trans (behavior ()
|
|
(if (and (nonzero? (-> self duration)) (time-elapsed? (-> self state-time) (-> self duration)))
|
|
(go-virtual linger)
|
|
)
|
|
(if (-> self callback)
|
|
((-> self callback) self)
|
|
)
|
|
(let* ((gp-0 (handle->process (-> self target)))
|
|
(v1-15 (if (type? gp-0 process-drawable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((and v1-15
|
|
(nonzero? (-> (the-as process-drawable v1-15) root))
|
|
(nonzero? (-> (the-as process-drawable v1-15) node-list))
|
|
)
|
|
(sparticle-subsampler-method-10
|
|
(-> self subsampler)
|
|
(-> (the-as process-drawable v1-15) node-list data (-> self target-joint) bone transform)
|
|
)
|
|
(set! (-> self root trans quad) (-> self subsampler spawn-mat trans quad))
|
|
)
|
|
(else
|
|
(let ((a0-11 (-> self root trans)))
|
|
(set! (-> self mat trans quad) (-> a0-11 quad))
|
|
)
|
|
(sparticle-subsampler-method-10 (-> self subsampler) (-> self mat))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function part-tracker-init-base
|
|
;; INFO: Used lq/sq
|
|
(defbehavior part-tracker-init-base part-tracker ((arg0 sparticle-launch-group)
|
|
(arg1 time-frame)
|
|
(arg2 (function part-tracker vector))
|
|
(arg3 uint)
|
|
(arg4 process-drawable)
|
|
(arg5 object)
|
|
)
|
|
(stack-size-set! (-> self main-thread) 16)
|
|
(when (= pointer process-tree)
|
|
(+! (-> self clock ref-count) -1)
|
|
(+! (-> *display* part-clock ref-count) 1)
|
|
(set! (-> self clock) (-> *display* part-clock))
|
|
)
|
|
(set! (-> self target) (process->handle arg4))
|
|
(cond
|
|
(arg4
|
|
(set! (-> self target-joint) (the-as int arg5))
|
|
)
|
|
((logtest? (-> arg0 flags) (sp-group-flag sp5))
|
|
(let* ((s1-1 (-> self mat))
|
|
(a2-1 (math-camera-matrix))
|
|
(v1-18 (-> a2-1 rvec quad))
|
|
(a0-10 (-> a2-1 uvec quad))
|
|
(a1-2 (-> a2-1 fvec quad))
|
|
(a2-2 (-> a2-1 trans quad))
|
|
)
|
|
(set! (-> s1-1 rvec quad) v1-18)
|
|
(set! (-> s1-1 uvec quad) a0-10)
|
|
(set! (-> s1-1 fvec quad) a1-2)
|
|
(set! (-> s1-1 trans quad) a2-2)
|
|
)
|
|
(set! (-> self mat trans quad) (-> (the-as matrix arg5) trans quad))
|
|
(set! (-> self offset quad) (-> self mat trans quad))
|
|
)
|
|
(else
|
|
(let* ((v1-21 (-> self mat))
|
|
(a3-1 (the-as matrix arg5))
|
|
(a0-15 (-> a3-1 rvec quad))
|
|
(a1-3 (-> a3-1 uvec quad))
|
|
(a2-3 (-> a3-1 fvec quad))
|
|
(a3-2 (-> a3-1 trans quad))
|
|
)
|
|
(set! (-> v1-21 rvec quad) a0-15)
|
|
(set! (-> v1-21 uvec quad) a1-3)
|
|
(set! (-> v1-21 fvec quad) a2-3)
|
|
(set! (-> v1-21 trans quad) a3-2)
|
|
)
|
|
(set! (-> self offset quad) (-> self mat trans quad))
|
|
)
|
|
)
|
|
(set! (-> self root) (new 'process 'trsqv))
|
|
(set! (-> self root trans quad) (-> self mat trans quad))
|
|
(if (zero? arg0)
|
|
(go process-drawable-art-error "null group")
|
|
)
|
|
(set! (-> self callback) arg2)
|
|
(set! (-> self linger-callback) #f)
|
|
(set! (-> self userdata) arg3)
|
|
(set! arg1 (cond
|
|
((> arg1 0)
|
|
(empty)
|
|
arg1
|
|
)
|
|
((= arg1 -1)
|
|
0
|
|
)
|
|
(else
|
|
(the-as time-frame (-> arg0 duration))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self duration) (the-as time-frame arg1))
|
|
(set! (-> self linger-duration) (the-as time-frame (-> arg0 linger-duration)))
|
|
(if (or (zero? (+ (-> self duration) (seconds 0.007))) (= (-> self duration) (seconds 218.447)))
|
|
(deactivate self)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 57
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x3d :page #x4))
|
|
(:num 1.0)
|
|
(:scale-x (meters 1))
|
|
(:scale-y :copy scale-x)
|
|
(:timer (seconds 0.1))
|
|
)
|
|
)
|
|
|
|
;; definition for function part-tracker-subsampler-init
|
|
(defbehavior part-tracker-subsampler-init part-tracker-subsampler ((arg0 part-tracker-subsampler-init-params))
|
|
(part-tracker-init-base
|
|
(-> arg0 group)
|
|
(-> arg0 duration)
|
|
(-> arg0 callback)
|
|
(-> arg0 userdata)
|
|
(-> arg0 target)
|
|
(-> arg0 mat-joint)
|
|
)
|
|
(dotimes (s5-0 1)
|
|
(let* ((v1-2 (-> arg0 group launcher s5-0))
|
|
(s4-0 (-> *part-id-table* (-> v1-2 launcher)))
|
|
)
|
|
(let ((a2-1 (if (logtest? (-> v1-2 flags) (sp-group-item-flag is-3d))
|
|
*sp-particle-system-3d*
|
|
*sp-particle-system-2d*
|
|
)
|
|
)
|
|
)
|
|
self
|
|
(set! (-> self subsampler)
|
|
(new 'process 'sparticle-subsampler a2-1 (-> *part-id-table* 57) (-> arg0 subsample-num))
|
|
)
|
|
)
|
|
(set! (-> self subsampler sp-launcher) s4-0)
|
|
)
|
|
)
|
|
(go-virtual active)
|
|
)
|
|
|
|
;; definition for function part-tracker-init
|
|
(defbehavior part-tracker-init part-tracker ((arg0 part-tracker-init-params))
|
|
(part-tracker-init-base
|
|
(-> arg0 group)
|
|
(-> arg0 duration)
|
|
(-> arg0 callback)
|
|
(-> arg0 userdata)
|
|
(-> arg0 target)
|
|
(-> arg0 mat-joint)
|
|
)
|
|
(set! (-> self part) (create-launch-control (-> arg0 group) self))
|
|
(when (and (-> arg0 target) (logtest? (-> self part group flags) (sp-group-flag sp12 sp14)))
|
|
(let* ((gp-0 (-> self part))
|
|
(s5-0 (method-of-object gp-0 sparticle-launch-control-method-20))
|
|
(s4-0 (add-connection *part-local-space-engine* self local-space-proc-joint (-> self target-joint) 0 0))
|
|
)
|
|
(let ((v1-10 (process->handle (-> arg0 target))))
|
|
(if (= v1-10 #f)
|
|
(set! v1-10 (process->handle self))
|
|
)
|
|
(set! (-> (the-as particle-local-space-info s4-0) hand) (the-as handle v1-10))
|
|
)
|
|
(matrix-identity! (-> (the-as particle-local-space-info s4-0) mat-new))
|
|
(matrix-identity! (-> (the-as particle-local-space-info s4-0) mat-prev))
|
|
(set! (-> (the-as particle-local-space-info s4-0) flags)
|
|
(if (logtest? (-> self part group flags) (sp-group-flag sp14))
|
|
(part-local-space-flags pls0)
|
|
(part-local-space-flags)
|
|
)
|
|
)
|
|
(s5-0 gp-0 (the-as float s4-0))
|
|
)
|
|
)
|
|
(set! (-> self event-hook) (-> (method-of-object self active) event))
|
|
(go-virtual active)
|
|
)
|
|
|
|
;; definition for function part-tracker-track-root
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun part-tracker-track-root ((arg0 sparticle-system) (arg1 sparticle-cpuinfo) (arg2 vector))
|
|
(let ((v1-3 (-> arg1 key proc root trans)))
|
|
(set! (-> arg2 x) (-> v1-3 x))
|
|
(set! (-> arg2 y) (-> v1-3 y))
|
|
(set! (-> arg2 z) (-> v1-3 z))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function part-tracker-move-to-target
|
|
(defun part-tracker-move-to-target ((arg0 part-tracker))
|
|
(let* ((a0-1 *target*)
|
|
(a2-0 (if (not a0-1)
|
|
(-> arg0 root trans)
|
|
(get-trans a0-1 3)
|
|
)
|
|
)
|
|
)
|
|
(vector-lerp!
|
|
(-> arg0 root trans)
|
|
(-> arg0 offset)
|
|
a2-0
|
|
(* 0.006666667 (the float (- (current-time) (-> arg0 state-time))))
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function part-tracker-track-target
|
|
;; INFO: Used lq/sq
|
|
(defun part-tracker-track-target ((arg0 part-tracker))
|
|
(set! (-> arg0 linger-callback) (-> arg0 callback))
|
|
(let* ((a0-1 *target*)
|
|
(v1-2 (if (not a0-1)
|
|
(-> arg0 root trans)
|
|
(get-trans a0-1 3)
|
|
)
|
|
)
|
|
(v0-1 (-> arg0 root trans))
|
|
)
|
|
(set! (-> v0-1 quad) (-> v1-2 quad))
|
|
v0-1
|
|
)
|
|
)
|
|
|
|
;; definition for method 15 of type lightning-tracker
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod notify-parent-of-death ((this lightning-tracker))
|
|
(with-pp
|
|
(let ((gp-0 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> gp-0 from) (process->ppointer pp))
|
|
(set! (-> gp-0 num-params) 1)
|
|
(set! (-> gp-0 message) 'notify)
|
|
(set! (-> gp-0 param 0) (the-as uint 'die))
|
|
(let ((s5-0 send-event-function)
|
|
(s4-0 (ppointer->process (-> this parent)))
|
|
)
|
|
(s5-0
|
|
(if (type? s4-0 process)
|
|
s4-0
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 16 of type lightning-tracker
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod update ((this lightning-tracker))
|
|
(if (-> this callback)
|
|
((-> this callback) this)
|
|
)
|
|
(let ((a0-6 (cond
|
|
((>= (-> this target-joint0) 0)
|
|
(let ((s5-0 (handle->process (-> this target0))))
|
|
(if (type? s5-0 process-drawable)
|
|
s5-0
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(the-as process #f)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((< (-> this target-joint0) 0)
|
|
(when (and (!= (-> this lightning spec rand-func) 3) (!= (-> this lightning spec rand-func) 2))
|
|
(let ((v1-17 (-> this lightning))
|
|
(a0-9 (-> this offset0))
|
|
)
|
|
(set! (-> v1-17 state meet data 0 quad) (-> a0-9 quad))
|
|
)
|
|
)
|
|
)
|
|
((or (not a0-6) (zero? (-> (the-as process-drawable a0-6) root)))
|
|
(deactivate this)
|
|
)
|
|
((= (-> this target-joint0) 256)
|
|
(let ((s5-1 (-> this lightning))
|
|
(a0-12 (get-trans (the-as process-focusable a0-6) 3))
|
|
)
|
|
(set! (-> s5-1 state meet data 0 quad) (-> a0-12 quad))
|
|
)
|
|
)
|
|
(else
|
|
(let ((s5-2 (-> this lightning))
|
|
(a0-16 (vector<-cspace!
|
|
(new 'stack-no-clear 'vector)
|
|
(-> (the-as process-focusable a0-6) node-list data (-> this target-joint0))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> s5-2 state meet data 0 quad) (-> a0-16 quad))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((a0-22 (cond
|
|
((>= (-> this target-joint1) 0)
|
|
(let ((s5-3 (handle->process (-> this target1))))
|
|
(if (type? s5-3 process-drawable)
|
|
(the-as process-focusable s5-3)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(the-as process-focusable #f)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((< (-> this target-joint1) 0)
|
|
(when (and (!= (-> this lightning spec rand-func) 3) (!= (-> this lightning spec rand-func) 2))
|
|
(let ((a0-26 (-> this lightning))
|
|
(v1-44 (-> this offset1))
|
|
)
|
|
(set! (-> a0-26 state meet data (+ (-> a0-26 state points-to-draw) -1) quad) (-> v1-44 quad))
|
|
)
|
|
)
|
|
)
|
|
((or (not a0-22) (zero? (-> a0-22 root)))
|
|
(deactivate this)
|
|
)
|
|
((= (-> this target-joint1) 256)
|
|
(let ((gp-1 (-> this lightning))
|
|
(v1-51 (get-trans a0-22 3))
|
|
)
|
|
(set! (-> gp-1 state meet data (+ (-> gp-1 state points-to-draw) -1) quad) (-> v1-51 quad))
|
|
)
|
|
)
|
|
(else
|
|
(let ((s5-4 (-> this lightning))
|
|
(v1-54 (vector<-cspace! (new 'stack-no-clear 'vector) (-> a0-22 node-list data (-> this target-joint1))))
|
|
)
|
|
(set! (-> s5-4 state meet data (+ (-> s5-4 state points-to-draw) -1) quad) (-> v1-54 quad))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (lightning-tracker)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('die)
|
|
(deactivate self)
|
|
)
|
|
)
|
|
)
|
|
:exit (behavior ()
|
|
(when (nonzero? (-> self sound))
|
|
(let ((v1-1 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
|
|
(set! (-> v1-1 command) (sound-command set-param))
|
|
(set! (-> v1-1 id) (-> self sound))
|
|
(set! (-> v1-1 params volume) -4)
|
|
(set! (-> v1-1 auto-time) 240)
|
|
(set! (-> v1-1 auto-from) 2)
|
|
(set! (-> v1-1 params mask) (the-as uint 17))
|
|
(-> v1-1 id)
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(set! (-> self sound) (new 'static 'sound-id))
|
|
(when (!= (+ (-> self lightning spec delay) (-> self lightning spec delay-rand)) 0.0)
|
|
(let ((gp-0 (current-time))
|
|
(s5-0 (the int (rand-vu-float-range
|
|
(-> self lightning spec delay)
|
|
(+ (-> self lightning spec delay) (-> self lightning spec delay-rand))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(while (not (time-elapsed? gp-0 s5-0))
|
|
(suspend)
|
|
)
|
|
)
|
|
)
|
|
(let ((gp-1 (-> self lightning spec sound)))
|
|
(when gp-1
|
|
(let ((s5-1 (new 'stack-no-clear 'vector)))
|
|
(set! (-> s5-1 quad) (-> self offset1 quad))
|
|
(when (and (>= (-> self target-joint1) 0) (< (-> self target-joint1) 256))
|
|
(let* ((s4-0 (handle->process (-> self target1)))
|
|
(v1-28 (if (type? s4-0 process-drawable)
|
|
(the-as process-drawable s4-0)
|
|
)
|
|
)
|
|
)
|
|
(if (and v1-28 (nonzero? (-> v1-28 root)))
|
|
(set! (-> s5-1 quad)
|
|
(-> (vector<-cspace! (new 'stack-no-clear 'vector) (-> v1-28 node-list data (-> self target-joint1))) quad)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self sound) (sound-play-by-spec (the-as sound-spec gp-1) (new-sound-id) s5-1))
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-33 (-> self lightning))
|
|
(a0-10 1)
|
|
)
|
|
(let ((a1-10 (!= a0-10 (-> v1-33 state mode))))
|
|
(case a0-10
|
|
((3)
|
|
(if a1-10
|
|
(set! (-> v1-33 state counter) 0.0)
|
|
)
|
|
)
|
|
((1)
|
|
(set! (-> v1-33 state start-color) (-> v1-33 spec start-color))
|
|
(set! (-> v1-33 state end-color) (-> v1-33 spec end-color))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> v1-33 state mode) (the-as uint a0-10))
|
|
)
|
|
(set-time! (-> self start-time))
|
|
(while (or (zero? (-> self duration)) (not (time-elapsed? (-> self start-time) (-> self duration))))
|
|
(update self)
|
|
(suspend)
|
|
)
|
|
(let ((f30-0 (-> self lightning spec fade-time)))
|
|
(when (< 0.0 f30-0)
|
|
(let ((v1-47 (-> self lightning))
|
|
(a0-14 3)
|
|
)
|
|
(let ((a1-20 (!= a0-14 (-> v1-47 state mode))))
|
|
(case a0-14
|
|
((3)
|
|
(if a1-20
|
|
(set! (-> v1-47 state counter) 0.0)
|
|
)
|
|
)
|
|
((1)
|
|
(set! (-> v1-47 state start-color) (-> v1-47 spec start-color))
|
|
(set! (-> v1-47 state end-color) (-> v1-47 spec end-color))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> v1-47 state mode) (the-as uint a0-14))
|
|
)
|
|
(set-time! (-> self start-time))
|
|
(while (not (time-elapsed? (-> self start-time) (the int f30-0)))
|
|
(suspend)
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-54 (-> self lightning))
|
|
(a0-17 0)
|
|
)
|
|
(let ((a1-30 (!= a0-17 (-> v1-54 state mode))))
|
|
(case a0-17
|
|
((3)
|
|
(if a1-30
|
|
(set! (-> v1-54 state counter) 0.0)
|
|
)
|
|
)
|
|
((1)
|
|
(set! (-> v1-54 state start-color) (-> v1-54 spec start-color))
|
|
(set! (-> v1-54 state end-color) (-> v1-54 spec end-color))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> v1-54 state mode) (the-as uint a0-17))
|
|
)
|
|
(notify-parent-of-death self)
|
|
(suspend)
|
|
0
|
|
)
|
|
)
|
|
|
|
;; definition for function lightning-tracker-init
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior lightning-tracker-init lightning-tracker ((arg0 lightning-spec) (arg1 time-frame) (arg2 symbol) (arg3 process-drawable) (arg4 vector) (arg5 vector))
|
|
(stack-size-set! (-> self main-thread) 128)
|
|
(set! (-> self target0) (process->handle arg3))
|
|
(let ((s1-1 (ppointer->process (-> self parent))))
|
|
(set! (-> self target1) (process->handle (the-as process (if (type? s1-1 process-drawable)
|
|
s1-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
((>= 256 (the-as int arg4))
|
|
(set! (-> self target-joint0) (the-as int arg4))
|
|
(vector-identity! (-> self offset0))
|
|
)
|
|
(else
|
|
(set! (-> self target-joint0) -1)
|
|
(set! (-> self offset0 quad) (-> arg4 quad))
|
|
)
|
|
)
|
|
(cond
|
|
((>= 256 (the-as int arg5))
|
|
(set! (-> self target-joint1) (the-as int arg5))
|
|
(vector-identity! (-> self offset1))
|
|
)
|
|
(else
|
|
(set! (-> self target-joint1) -1)
|
|
(set! (-> self offset1 quad) (-> arg5 quad))
|
|
)
|
|
)
|
|
(set! (-> self root) (new 'process 'trsqv))
|
|
(set! (-> self callback) (the-as (function lightning-tracker none) arg2))
|
|
(set! arg1
|
|
(cond
|
|
((> arg1 0)
|
|
(empty)
|
|
arg1
|
|
)
|
|
((= arg1 -1)
|
|
0
|
|
)
|
|
(else
|
|
(the-as
|
|
time-frame
|
|
(the int (rand-vu-float-range (-> arg0 duration) (+ (-> arg0 duration) (-> arg0 duration-rand))))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> self duration) (the-as time-frame arg1))
|
|
(set! (-> self lightning) (new 'process 'lightning-control arg0 self 0.0))
|
|
(let ((v1-21 (-> self lightning))
|
|
(a0-17 0)
|
|
)
|
|
(let ((a1-7 (!= a0-17 (-> v1-21 state mode))))
|
|
(case a0-17
|
|
((3)
|
|
(if a1-7
|
|
(set! (-> v1-21 state counter) 0.0)
|
|
)
|
|
)
|
|
((1)
|
|
(set! (-> v1-21 state start-color) (-> v1-21 spec start-color))
|
|
(set! (-> v1-21 state end-color) (-> v1-21 spec end-color))
|
|
)
|
|
)
|
|
)
|
|
(set! (-> v1-21 state mode) (the-as uint a0-17))
|
|
)
|
|
(go-virtual active)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function process-grab?
|
|
;; WARN: Return type mismatch object vs symbol.
|
|
(defbehavior process-grab? process ((arg0 process) (arg1 symbol))
|
|
(let ((a0-1 (command-get-process arg0 *target*)))
|
|
(the-as symbol (if a0-1
|
|
(send-event a0-1 'change-mode 'grab (cond
|
|
((= arg1 #t)
|
|
#f
|
|
)
|
|
((= arg1 'dead)
|
|
'dead
|
|
)
|
|
(else
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function process-release?
|
|
;; WARN: Return type mismatch object vs symbol.
|
|
(defbehavior process-release? process ((arg0 process))
|
|
(let* ((gp-0 (command-get-process arg0 *target*))
|
|
(a0-2 (if (type? gp-0 process-focusable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(the-as symbol (if (and a0-2 (focus-test? (the-as process-focusable a0-2) grabbed))
|
|
(send-event a0-2 'end-mode 'grab)
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function camera-look-at
|
|
(defun camera-look-at ((arg0 pair) (arg1 uint))
|
|
(let ((gp-0 (command-get-process arg0 *target*)))
|
|
(if gp-0
|
|
(send-event *camera* 'change-target gp-0 arg1)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition for function ja-anim-done?
|
|
;; WARN: Return type mismatch object vs symbol.
|
|
(defun ja-anim-done? ((arg0 process))
|
|
(with-pp
|
|
(let ((gp-0 (command-get-process arg0 *target*)))
|
|
(the-as
|
|
symbol
|
|
(when gp-0
|
|
(cond
|
|
((type? gp-0 manipy)
|
|
(send-event gp-0 'query 'done)
|
|
)
|
|
((type? gp-0 process-drawable)
|
|
(when (not (logtest? (-> (the-as process-drawable gp-0) skel status) (joint-control-status spooling-not-last-block))
|
|
)
|
|
(let ((s5-0 pp))
|
|
(set! pp gp-0)
|
|
(let ((v0-1 (the-as object (ja-done? 0))))
|
|
(set! pp s5-0)
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function camera-pov-from
|
|
(defun camera-pov-from ((arg0 pair) (arg1 uint))
|
|
(let ((gp-0 (command-get-process arg0 *target*)))
|
|
(when gp-0
|
|
(when (= arg1 -10)
|
|
(set! arg1 (the-as uint 0))
|
|
(when (> (-> (the-as process-drawable gp-0) skel active-channels) 0)
|
|
(let ((v1-7 (the-as
|
|
joint
|
|
(get-art-by-name-method (-> (the-as process-drawable gp-0) draw jgeo) "camera" (the-as type #f))
|
|
)
|
|
)
|
|
)
|
|
(if v1-7
|
|
(set! arg1 (the-as uint (+ (-> v1-7 number) 1)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-9 (process->ppointer gp-0)))
|
|
(set-setting! 'pov-handle v1-9 (the float arg1) (-> v1-9 0 pid))
|
|
)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition of type med-res-level
|
|
(deftype med-res-level (process-drawable)
|
|
((level-name symbol)
|
|
(part-mode symbol)
|
|
(index int32)
|
|
)
|
|
(:state-methods
|
|
idle
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type med-res-level
|
|
(defmethod inspect ((this med-res-level))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tlevel-name: ~A~%" (-> this level-name))
|
|
(format #t "~2Tpart-mode: ~A~%" (-> this part-mode))
|
|
(format #t "~2Tindex: ~D~%" (-> this index))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (med-res-level)
|
|
:virtual #t
|
|
:code (behavior ()
|
|
(until #f
|
|
(let ((v1-1 (level-get *level* (-> self level-name))))
|
|
(cond
|
|
((and v1-1 (= (-> v1-1 display?) 'special))
|
|
(logclear! (-> self draw status) (draw-control-status no-draw))
|
|
(if (nonzero? (-> self skel))
|
|
(ja :num! (loop!))
|
|
)
|
|
)
|
|
((and v1-1 (= (-> v1-1 status) 'active))
|
|
(logior! (-> self draw status) (draw-control-status no-draw))
|
|
)
|
|
(else
|
|
(logclear! (-> self draw status) (draw-control-status no-draw))
|
|
(if (nonzero? (-> self skel))
|
|
(ja :num! (loop!))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
#f
|
|
)
|
|
:post ja-post
|
|
)
|
|
|
|
;; definition for method 11 of type med-res-level
|
|
(defmethod init-from-entity! ((this med-res-level) (arg0 entity-actor))
|
|
(stack-size-set! (-> this main-thread) 128)
|
|
(let ((s4-0 (res-lump-struct arg0 'art-name structure))
|
|
(s3-0 (res-lump-struct (-> this entity) 'level structure))
|
|
(v1-5 (res-lump-value (-> this entity) 'index uint128 :time -1000000000.0))
|
|
)
|
|
(when s3-0
|
|
(set! (-> this level-name) (the-as symbol s3-0))
|
|
(set! (-> this index) (the-as int v1-5))
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(process-drawable-from-entity! this arg0)
|
|
(logclear! (-> this mask) (process-mask actor-pause))
|
|
(initialize-skeleton-by-name this (the-as string s4-0))
|
|
(logior! (-> this draw status) (draw-control-status no-closest-distance))
|
|
(if (nonzero? (-> this draw))
|
|
(go (method-of-object this idle))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 10 of type part-spawner
|
|
(defmethod deactivate ((this part-spawner))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(if (nonzero? (-> this part))
|
|
(kill-particles (-> this part))
|
|
)
|
|
(if (nonzero? (-> this sound))
|
|
(stop! (-> this sound))
|
|
)
|
|
(if (nonzero? (-> this sound-extra))
|
|
(stop! (-> this sound-extra))
|
|
)
|
|
((method-of-type process deactivate) this)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 15 of type part-spawner
|
|
(defmethod is-in-view? ((this part-spawner))
|
|
(sphere<-vector+r! (-> this world-sphere) (-> this root trans) (-> this radius))
|
|
(sphere-in-view-frustum? (-> this world-sphere))
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (part-spawner)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('stop)
|
|
(process-entity-status! self (entity-perm-status subtask-complete) #t)
|
|
(set! (-> self enable) #f)
|
|
#t
|
|
)
|
|
(('start)
|
|
(process-entity-status! self (entity-perm-status subtask-complete) #f)
|
|
(set! (-> self enable) #t)
|
|
#t
|
|
)
|
|
(('trans)
|
|
(let ((v0-1 (the-as object (-> (the-as vector (-> block param 0)) quad))))
|
|
(set! (-> self root trans quad) (the-as uint128 v0-1))
|
|
v0-1
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(when (-> self enable)
|
|
(when (nonzero? (-> self path))
|
|
(path-control-method-9 (-> self path))
|
|
(get-point-at-percent-along-path! (-> self path) (-> self root trans) (-> self path-pos) 'interp)
|
|
(displacement-between-points-at-percent-normalized! (-> self path) (-> self last-velocity) (-> self path-pos))
|
|
(let ((f0-3 (+ (-> self path-pos) (* (-> self path-speed) (seconds-per-frame)))))
|
|
(set! (-> self path-pos) f0-3)
|
|
(set! (-> self path-pos) (- f0-3 (* (the float (the int (/ f0-3 1.0))) 1.0)))
|
|
)
|
|
)
|
|
(spawn (-> self part) (-> self root trans))
|
|
(when (nonzero? (-> self sound))
|
|
(update-trans! (-> self sound) (-> self root trans))
|
|
(update! (-> self sound))
|
|
)
|
|
(when (nonzero? (-> self sound-extra))
|
|
(update-trans! (-> self sound-extra) (-> self root trans))
|
|
(update! (-> self sound-extra))
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition for method 11 of type part-spawner
|
|
;; INFO: Used lq/sq
|
|
(defmethod init-from-entity! ((this part-spawner) (arg0 entity-actor))
|
|
(local-vars (sv-16 string))
|
|
(stack-size-set! (-> this main-thread) 16)
|
|
(logior! (-> this mask) (process-mask ambient))
|
|
(+! (-> this clock ref-count) -1)
|
|
(+! (-> *display* part-clock ref-count) 1)
|
|
(set! (-> this clock) (-> *display* part-clock))
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(set! (-> this root trans quad) (-> arg0 extra trans quad))
|
|
(quaternion-copy! (-> this root quat) (-> arg0 quat))
|
|
(vector-identity! (-> this root scale))
|
|
(set! (-> this radius) 12288.0)
|
|
(set! (-> this enable)
|
|
(not (and (-> this entity) (logtest? (-> this entity extra perm status) (entity-perm-status subtask-complete)))
|
|
)
|
|
)
|
|
(set! (-> this sound) (new 'process 'ambient-sound (-> this entity) (-> this root trans) 0.0))
|
|
(set! (-> this sound-extra) (new 'process 'ambient-sound (-> this entity) (-> this root trans) 1.0))
|
|
(when (res-lump-data arg0 'path pointer)
|
|
(set! (-> this path) (new 'process 'curve-control this 'path -1000000000.0))
|
|
(logior! (-> this path flags) (path-control-flag display draw-line draw-point draw-text))
|
|
(set! (-> this path-speed) (res-lump-float arg0 'speed :default 1.0))
|
|
)
|
|
(let ((v1-36 (res-lump-struct arg0 'trans-offset structure)))
|
|
(if v1-36
|
|
(vector+! (-> this root trans) (-> this root trans) (the-as vector v1-36))
|
|
)
|
|
)
|
|
(let ((s4-0 (res-lump-struct arg0 'rot-offset (pointer degrees))))
|
|
(when s4-0
|
|
(if (< 0.0 (-> s4-0 0))
|
|
(quaternion-rotate-local-x! (-> this root quat) (-> this root quat) (-> s4-0 0))
|
|
)
|
|
(if (< 0.0 (-> s4-0 1))
|
|
(quaternion-rotate-local-y! (-> this root quat) (-> this root quat) (-> s4-0 1))
|
|
)
|
|
(if (< 0.0 (-> s4-0 2))
|
|
(quaternion-rotate-local-z! (-> this root quat) (-> this root quat) (-> s4-0 2))
|
|
)
|
|
)
|
|
)
|
|
(set! sv-16 "#f")
|
|
(set! (-> this mode) (entity-lookup-part-group arg0 (& sv-16) 'art-name))
|
|
(when (-> this mode)
|
|
(let ((s5-1 (-> this mode 0)))
|
|
(when (and (nonzero? s5-1) (= (-> s5-1 type) sparticle-launch-group))
|
|
(cond
|
|
((logtest? (-> s5-1 flags) (sp-group-flag sp8))
|
|
(countdown (v1-60 (-> s5-1 length))
|
|
(let* ((a0-34 (-> s5-1 launcher v1-60))
|
|
(a2-12 (-> *part-id-table* (-> a0-34 launcher)))
|
|
)
|
|
(when (nonzero? a2-12)
|
|
(let ((a1-22 (-> this level part-engine)))
|
|
(when (and a1-22 (< (-> a1-22 length) (-> a1-22 allocated-length)))
|
|
(let ((a3-14 (-> a1-22 data (-> a1-22 length))))
|
|
(set! (-> a3-14 next1) (the-as connectable a2-12))
|
|
(set! (-> a3-14 prev1) (the-as connectable (-> a0-34 hour-mask)))
|
|
(set! (-> (the-as vector (&-> a3-14 param0)) quad) (-> this root trans quad))
|
|
(set! (-> a3-14 param3) (the-as int (-> a0-34 fade-after)))
|
|
)
|
|
(+! (-> a1-22 length) 1)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(process-entity-status! this (entity-perm-status dead) #t)
|
|
(deactivate this)
|
|
)
|
|
((logtest? (-> s5-1 flags) (sp-group-flag sp9))
|
|
(process-entity-status! this (entity-perm-status dead) #t)
|
|
(deactivate this)
|
|
)
|
|
(else
|
|
(set! (-> this part) (create-launch-control s5-1 this))
|
|
(when (logtest? (-> s5-1 flags) (sp-group-flag sp10))
|
|
(process-entity-status! this (entity-perm-status subtask-complete) #t)
|
|
(set! (-> this enable) #f)
|
|
)
|
|
(go (method-of-object this active))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(go process-drawable-art-error sv-16)
|
|
)
|
|
|
|
;; definition of type launcher
|
|
(deftype launcher (process-drawable)
|
|
((spring-height meters)
|
|
(camera state)
|
|
(active-distance float)
|
|
(seek-time time-frame)
|
|
(dest vector :inline)
|
|
(sound-id sound-id)
|
|
)
|
|
(:state-methods
|
|
idle
|
|
active
|
|
deactivated
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type launcher
|
|
(defmethod inspect ((this launcher))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tspring-height: (meters ~m)~%" (-> this spring-height))
|
|
(format #t "~2Tcamera: ~A~%" (-> this camera))
|
|
(format #t "~2Tactive-distance: ~f~%" (-> this active-distance))
|
|
(format #t "~2Tseek-time: ~D~%" (-> this seek-time))
|
|
(format #t "~2Tdest: ~`vector`P~%" (-> this dest))
|
|
(format #t "~2Tsound-id: ~D~%" (-> this sound-id))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpartgroup group-beach-launcher
|
|
:id 7
|
|
:bounds (static-bspherem 0 3 0 5)
|
|
:parts ((sp-item 58 :fade-after (meters 100) :falloff-to (meters 100))
|
|
(sp-item 59 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 60 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 61 :fade-after (meters 50) :falloff-to (meters 80))
|
|
(sp-item 62 :fade-after (meters 70) :falloff-to (meters 100))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 58
|
|
:init-specs ((:num 1.5)
|
|
(:x (meters 1.5))
|
|
(:y (meters -0.5))
|
|
(:rot-x 5)
|
|
(:r 4096.0)
|
|
(:g 2867.2)
|
|
(:b 3276.8)
|
|
(:vel-y (meters 0.026666667))
|
|
(:timer (seconds 0.9))
|
|
(:flags (distort))
|
|
(:next-time (seconds 0.6))
|
|
(:next-launcher 63)
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 63
|
|
:init-specs ((:fade-b -4.551111))
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 59
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x18 :page #x4))
|
|
(:num 1.0)
|
|
(:x (meters 0) (meters 1.8))
|
|
(:scale-x (meters 0.2))
|
|
(:rot-x (degrees 90))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y (meters 2.5) (meters 2.5))
|
|
(:r 0.0 1 128.0)
|
|
(:g 64.0 196.0)
|
|
(:b 128.0 128.0)
|
|
(:a 128.0)
|
|
(:scalevel-x (meters -0.0025))
|
|
(:scalevel-y (meters 0.24414062) (meters 0.48828125))
|
|
(:timer (seconds 0.27))
|
|
(:flags (sp-cpuinfo-flag-3))
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 60
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x18 :page #x4))
|
|
(:num 2.0)
|
|
(:x (meters 1.8) (meters 1))
|
|
(:scale-x (meters 0.2))
|
|
(:rot-x (degrees 90))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y (meters 0.5) (meters 1))
|
|
(:r 0.0 1 128.0)
|
|
(:g 64.0 196.0)
|
|
(:b 128.0 128.0)
|
|
(:a 128.0)
|
|
(:scalevel-x (meters -0.0025))
|
|
(:scalevel-y (meters 0.048828125) (meters 0.09765625))
|
|
(:timer (seconds 0.27))
|
|
(:flags (sp-cpuinfo-flag-3))
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 61
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x50 :page #x4))
|
|
(:num 1.5)
|
|
(:x (meters 2.9) (meters 2.5))
|
|
(:y (meters -0.5))
|
|
(:scale-x (meters 0.3) (meters 0.4))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y (meters 0.1) (meters 0.1))
|
|
(:r 10.0 6.0)
|
|
(:g 64.0 128.0)
|
|
(:b 10.0 6.0)
|
|
(:a 80.0)
|
|
(:vel-x (meters -0.011666667) (meters -0.0033333334))
|
|
(:vel-y (meters 0))
|
|
(:rotvel-z (degrees -1.2) 1 (degrees 2.4))
|
|
(:fade-a -0.2)
|
|
(:accel-y (meters 0.0016666667))
|
|
(:friction 0.996)
|
|
(:timer (seconds 0.6) (seconds 0.397))
|
|
(:flags (sp-cpuinfo-flag-2))
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 62
|
|
:init-specs ((:texture (new 'static 'texture-id :page #x4))
|
|
(:num 0.5)
|
|
(:x (meters 2.9) (meters 2.5))
|
|
(:y (meters -0.5))
|
|
(:scale-x (meters 2) (meters 1))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y :copy scale-x)
|
|
(:r 32.0 32.0)
|
|
(:g 32.0 32.0)
|
|
(:b 10.0 5.0)
|
|
(:a 0.0)
|
|
(:vel-x (meters -0.011666667) (meters -0.0033333334))
|
|
(:vel-y (meters 0))
|
|
(:rotvel-z (degrees -1.2) 1 (degrees 2.4))
|
|
(:fade-a 0.6)
|
|
(:accel-y (meters 0.0016666667))
|
|
(:friction 0.996)
|
|
(:timer (seconds 0.9))
|
|
(:flags (sp-cpuinfo-flag-2 sp-cpuinfo-flag-3))
|
|
(:next-time (seconds 0.15))
|
|
(:next-launcher 64)
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 64
|
|
:init-specs ((:fade-a -0.18))
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpartgroup group-jungle-launcher
|
|
:id 8
|
|
:bounds (static-bspherem 0 3 0 5)
|
|
:parts ((sp-item 58 :fade-after (meters 100) :falloff-to (meters 100))
|
|
(sp-item 65 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 66 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 67 :fade-after (meters 70) :falloff-to (meters 100))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 65
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x18 :page #x4))
|
|
(:num 1.0)
|
|
(:x (meters 0) (meters 1.4))
|
|
(:scale-x (meters 0.2))
|
|
(:rot-x (degrees 90))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y (meters 2.5) (meters 2.5))
|
|
(:r 0.0 1 128.0)
|
|
(:g 64.0 196.0)
|
|
(:b 128.0 128.0)
|
|
(:a 128.0)
|
|
(:scalevel-x (meters -0.0025))
|
|
(:scalevel-y (meters 0.24414062) (meters 0.48828125))
|
|
(:timer (seconds 0.27))
|
|
(:flags (sp-cpuinfo-flag-3))
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 66
|
|
:init-specs ((:texture (new 'static 'texture-id :index #x18 :page #x4))
|
|
(:num 2.0)
|
|
(:x (meters 1.4) (meters 0.9))
|
|
(:scale-x (meters 0.2))
|
|
(:rot-x (degrees 90))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y (meters 0.5) (meters 1))
|
|
(:r 0.0 1 128.0)
|
|
(:g 64.0 196.0)
|
|
(:b 128.0 128.0)
|
|
(:a 128.0)
|
|
(:scalevel-x (meters -0.0025))
|
|
(:scalevel-y (meters 0.048828125) (meters 0.09765625))
|
|
(:timer (seconds 0.27))
|
|
(:flags (sp-cpuinfo-flag-3))
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 67
|
|
:init-specs ((:texture (new 'static 'texture-id :page #x4))
|
|
(:num 0.5)
|
|
(:x (meters 2.9) (meters 2.5))
|
|
(:y (meters -0.5))
|
|
(:scale-x (meters 2) (meters 1))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y :copy scale-x)
|
|
(:r 64.0 32.0)
|
|
(:g 32.0 32.0)
|
|
(:b 10.0 5.0)
|
|
(:a 0.0)
|
|
(:vel-x (meters -0.011666667) (meters -0.0033333334))
|
|
(:vel-y (meters 0))
|
|
(:rotvel-z (degrees -1.2) 1 (degrees 2.4))
|
|
(:fade-a 0.6)
|
|
(:accel-y (meters 0.0016666667))
|
|
(:friction 0.996)
|
|
(:timer (seconds 0.9))
|
|
(:flags (sp-cpuinfo-flag-2 sp-cpuinfo-flag-3))
|
|
(:next-time (seconds 0.15))
|
|
(:next-launcher 64)
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpartgroup group-swamp-launcher
|
|
:id 9
|
|
:bounds (static-bspherem 0 3 0 5)
|
|
:parts ((sp-item 58 :fade-after (meters 100) :falloff-to (meters 100))
|
|
(sp-item 59 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 60 :fade-after (meters 70) :falloff-to (meters 100) :flags (is-3d))
|
|
(sp-item 68 :fade-after (meters 70) :falloff-to (meters 100))
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defpart 68
|
|
:init-specs ((:texture (new 'static 'texture-id :page #x4))
|
|
(:num 0.5)
|
|
(:x (meters 2.9) (meters 2.5))
|
|
(:y (meters -0.5))
|
|
(:scale-x (meters 2) (meters 1))
|
|
(:rot-z (degrees 0) (degrees 360))
|
|
(:scale-y :copy scale-x)
|
|
(:r 16.0 16.0)
|
|
(:g 16.0 16.0)
|
|
(:b 5.0 2.5)
|
|
(:a 0.0)
|
|
(:vel-x (meters -0.011666667) (meters -0.0033333334))
|
|
(:vel-y (meters 0))
|
|
(:rotvel-z (degrees -1.2) 1 (degrees 2.4))
|
|
(:fade-a 0.6)
|
|
(:accel-y (meters 0.0016666667))
|
|
(:friction 0.996)
|
|
(:timer (seconds 0.9))
|
|
(:flags (sp-cpuinfo-flag-2))
|
|
(:next-time (seconds 0.15))
|
|
(:next-launcher 64)
|
|
(:rotate-y (degrees 0) (degrees 360))
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-launcher-joystick
|
|
;; INFO: Used lq/sq
|
|
(defbehavior cam-launcher-joystick camera-slave ()
|
|
(when (not (logtest? (-> *camera* settings master-options) (cam-master-options IGNORE_ANALOG)))
|
|
(let ((s5-0 (new 'stack-no-clear 'matrix)))
|
|
(set! (-> s5-0 rvec quad) (the-as uint128 0))
|
|
(set! (-> s5-0 uvec quad) (the-as uint128 0))
|
|
(set! (-> s5-0 fvec quad) (the-as uint128 0))
|
|
(set! (-> s5-0 trans quad) (the-as uint128 0))
|
|
(let ((gp-0 (vector-reset! (new 'stack-no-clear 'vector))))
|
|
(let* ((f0-0 (analog-input (the-as int (+ (-> *cpad-list* cpads 0 rightx) -128)) 0.0 48.0 110.0 -1.0))
|
|
(f0-1 (* -546.13336 f0-0))
|
|
(f0-3 (fmin 546.13336 (fmax -546.13336 f0-1)))
|
|
)
|
|
(matrix-axis-angle! s5-0 (-> *camera* local-down) f0-3)
|
|
)
|
|
(vector-! gp-0 (-> self trans) (-> *camera* tpos-curr))
|
|
(vector-matrix*! gp-0 gp-0 s5-0)
|
|
(vector+! (-> self trans) gp-0 (-> *camera* tpos-curr))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate cam-launcher-shortfall (camera-slave)
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('teleport)
|
|
#f
|
|
)
|
|
(else
|
|
(cam-standard-event-handler proc argc message block)
|
|
)
|
|
)
|
|
)
|
|
:enter (behavior ()
|
|
(when (not (-> self enter-has-run))
|
|
(let ((gp-0 (new 'stack-no-clear 'vector)))
|
|
(vector--float*! (-> self trans) (-> *camera* tpos-curr) (-> *camera* local-down) 28672.0)
|
|
(vector-flatten! gp-0 (-> self tracking inv-mat fvec) (-> *camera* local-down))
|
|
(vector-normalize! gp-0 1.0)
|
|
(set! (-> self pivot-pt quad) (-> gp-0 quad))
|
|
(vector+float*! gp-0 gp-0 (-> *camera* local-down) 1000.0)
|
|
(vector-normalize-copy! (-> self tracking inv-mat fvec) gp-0 1.0)
|
|
)
|
|
(vector-cross!
|
|
(-> self tracking inv-mat uvec)
|
|
(-> self tracking inv-mat fvec)
|
|
(the-as vector (-> self tracking))
|
|
)
|
|
(set! (-> self blend-from-type) (camera-blend-from-type unknown-0))
|
|
(set! (-> self blend-to-type) (camera-blend-to-type unknown-0))
|
|
0
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(if (not (logtest? (-> *camera* master-options) (cam-master-options-u32 HAVE_TARGET)))
|
|
(cam-slave-go cam-free-floating)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(let ((gp-0 (current-time)))
|
|
(until #f
|
|
(when (not (paused?))
|
|
(vector--float*! (-> self trans) (-> *camera* tpos-curr) (-> *camera* local-down) 28672.0)
|
|
(send-event *camera* 'teleport)
|
|
(if (and (-> *camera* on-ground) (time-elapsed? gp-0 (seconds 1)))
|
|
(send-event *camera* 'change-state cam-string (seconds 0.5))
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; definition for function cam-launcher-long-joystick
|
|
;; INFO: Used lq/sq
|
|
(defbehavior cam-launcher-long-joystick camera-slave ()
|
|
(when (not (logtest? (-> *camera* settings master-options) (cam-master-options IGNORE_ANALOG)))
|
|
(let ((gp-0 (new 'stack-no-clear 'matrix)))
|
|
(set! (-> gp-0 rvec quad) (the-as uint128 0))
|
|
(set! (-> gp-0 uvec quad) (the-as uint128 0))
|
|
(set! (-> gp-0 fvec quad) (the-as uint128 0))
|
|
(set! (-> gp-0 trans quad) (the-as uint128 0))
|
|
(let* ((f0-0 (analog-input (the-as int (+ (-> *cpad-list* cpads 0 rightx) -128)) 0.0 48.0 110.0 -1.0))
|
|
(f0-1 (* -546.13336 f0-0))
|
|
(f0-3 (fmin 546.13336 (fmax -546.13336 f0-1)))
|
|
)
|
|
(matrix-axis-angle! gp-0 (-> *camera* local-down) f0-3)
|
|
)
|
|
(vector-matrix*! (-> self view-flat) (-> self view-flat) gp-0)
|
|
)
|
|
(vector-normalize! (-> self view-flat) 4096.0)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate cam-launcher-longfall (camera-slave)
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('teleport)
|
|
#f
|
|
)
|
|
(else
|
|
(cam-standard-event-handler proc argc message block)
|
|
)
|
|
)
|
|
)
|
|
:enter (behavior ()
|
|
(when (not (-> self enter-has-run))
|
|
(new 'stack-no-clear 'vector)
|
|
(vector-negate! (-> self view-flat) (-> self tracking inv-mat fvec))
|
|
(vector-normalize! (-> self view-flat) 4096.0)
|
|
(vector--float*! (-> self trans) (-> *camera* tpos-curr) (-> *camera* local-down) 28672.0)
|
|
(vector+! (-> self trans) (-> self trans) (-> self view-flat))
|
|
(set! (-> self blend-from-type) (camera-blend-from-type unknown-0))
|
|
(set! (-> self blend-to-type) (camera-blend-to-type unknown-0))
|
|
(cam-calc-follow! (-> self tracking) (-> self trans) #f)
|
|
(slave-set-rotation! (-> self tracking) (-> self trans) (-> self options) (-> self fov) #f)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(if (not (logtest? (-> *camera* master-options) (cam-master-options-u32 HAVE_TARGET)))
|
|
(cam-slave-go cam-free-floating)
|
|
)
|
|
(cam-launcher-long-joystick)
|
|
)
|
|
:code (behavior ()
|
|
(let ((gp-0 (current-time)))
|
|
(until #f
|
|
(when (not (paused?))
|
|
(let ((s4-0 (new 'stack-no-clear 'vector))
|
|
(s5-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
0.0
|
|
0.0
|
|
0.0
|
|
(send-event *camera* 'teleport)
|
|
(let* ((f0-4 (vector-dot (-> self velocity) (-> *camera* local-down)))
|
|
(f30-0 (* 0.975 f0-4))
|
|
)
|
|
(vector--float*! s4-0 (-> *camera* tpos-curr) (-> *camera* local-down) 28672.0)
|
|
(vector-! s4-0 s4-0 (-> self trans))
|
|
(let ((f28-0 (vector-dot s4-0 (-> *camera* local-down))))
|
|
(vector--float*! s5-0 s4-0 (-> *camera* local-down) f28-0)
|
|
(cond
|
|
((< f28-0 f30-0)
|
|
(set! f30-0 f28-0)
|
|
)
|
|
((< 20480.0 f28-0)
|
|
(let ((f28-1 (+ -20480.0 f28-0)))
|
|
(let ((f0-8 (lerp f30-0 f28-1 0.005)))
|
|
(if (< f30-0 f0-8)
|
|
(set! f30-0 f0-8)
|
|
)
|
|
)
|
|
(if (< (* 0.09 f28-1) f30-0)
|
|
(set! f30-0 (* 0.09 f28-1))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(vector+float*! (-> self velocity) s5-0 (-> *camera* local-down) f30-0)
|
|
)
|
|
)
|
|
(vector+! (-> self trans) (-> self trans) (-> self velocity))
|
|
(set! (-> self trans x) (-> *camera* tpos-curr x))
|
|
(set! (-> self trans z) (-> *camera* tpos-curr z))
|
|
(vector+! (-> self trans) (-> self trans) (-> self view-flat))
|
|
(if (and (-> *camera* on-ground) (time-elapsed? gp-0 (seconds 1)))
|
|
(send-event *camera* 'change-state cam-string (seconds 0.5))
|
|
)
|
|
)
|
|
(vector-reset! (-> self tracking follow-off))
|
|
(vector+! (-> self tracking follow-pt) (-> *camera* tpos-curr-adj) (-> self tracking follow-off))
|
|
(vector--float*!
|
|
(-> self tracking follow-pt)
|
|
(-> self tracking follow-pt)
|
|
(-> *camera* local-down)
|
|
(-> *camera* settings target-height)
|
|
)
|
|
(slave-set-rotation! (-> self tracking) (-> self trans) (-> self options) (-> self fov) #f)
|
|
(suspend)
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (launcher)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('instant-death)
|
|
(go-virtual deactivated)
|
|
)
|
|
(('trans)
|
|
(move-to-point! (the-as collide-shape (-> self root)) (the-as vector (-> block param 0)))
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(when (and *target*
|
|
(and (>= (-> self active-distance) (vector-vector-distance (-> self root trans) (-> *target* control trans)))
|
|
(not (logtest? (focus-status teleporting) (-> *target* focus-status)))
|
|
)
|
|
)
|
|
(cond
|
|
((send-event *target* 'query 'powerup (pickup-type eco-blue))
|
|
(go-virtual active)
|
|
)
|
|
(else
|
|
(let ((gp-0 'target-launch))
|
|
(if (= (send-event *target* 'query 'mode) gp-0)
|
|
(send-event *target* 'end-mode 'launch)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(if (and (and *target* (and (>= 32768.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
|
|
(not (logtest? (focus-status teleporting) (-> *target* focus-status)))
|
|
)
|
|
)
|
|
(not (send-event *target* 'query 'powerup (pickup-type eco-blue)))
|
|
)
|
|
(talker-spawn-func (-> *talker-speech* 44) *entity-pool* (target-pos 0) (the-as region #f))
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (launcher)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(when (or (= message 'touch) (= message 'attack))
|
|
(set-time! (-> self state-time))
|
|
(send-event proc 'launch (-> self spring-height) (-> self camera) (-> self dest) (-> self seek-time))
|
|
)
|
|
(cond
|
|
((= message 'instant-death)
|
|
(go-virtual deactivated)
|
|
)
|
|
((= message 'trans)
|
|
(move-to-point! (the-as collide-shape (-> self root)) (the-as vector (-> block param 0)))
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
)
|
|
)
|
|
)
|
|
:exit (behavior ()
|
|
(let ((v1-0 (the-as sound-rpc-set-param (get-sound-buffer-entry))))
|
|
(set! (-> v1-0 command) (sound-command set-param))
|
|
(set! (-> v1-0 id) (-> self sound-id))
|
|
(set! (-> v1-0 params volume) -4)
|
|
(set! (-> v1-0 auto-time) 120)
|
|
(set! (-> v1-0 auto-from) 2)
|
|
(set! (-> v1-0 params mask) (the-as uint 17))
|
|
(-> v1-0 id)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(if (or (or (not *target*)
|
|
(or (< (-> self active-distance) (vector-vector-distance (-> self root trans) (-> *target* control trans)))
|
|
(focus-test? *target* teleporting)
|
|
)
|
|
)
|
|
(not (send-event *target* 'query 'powerup (pickup-type eco-blue)))
|
|
)
|
|
(go-virtual idle)
|
|
)
|
|
(spawn (-> self part) (-> self root trans))
|
|
(sound-play "launch-idle" :id (-> self sound-id))
|
|
(if (and (and *target*
|
|
(and (>= (+ 2867.2 (-> (the-as collide-shape (-> self root)) root-prim prim-core world-sphere w))
|
|
(vector-vector-distance (-> self root trans) (-> *target* control trans))
|
|
)
|
|
(not (logtest? (focus-status teleporting) (-> *target* focus-status)))
|
|
)
|
|
)
|
|
(not (time-elapsed? (-> self state-time) (seconds 0.5)))
|
|
)
|
|
(send-event *target* 'launch (-> self spring-height) (-> self camera) (-> self dest) (-> self seek-time))
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(sound-play "launch-start")
|
|
(sleep-code)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate deactivated (launcher)
|
|
:virtual #t
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition for method 11 of type launcher
|
|
(defmethod init-from-entity! ((this launcher) (arg0 entity-actor))
|
|
(stack-size-set! (-> this main-thread) 128)
|
|
(let ((s4-0 (new 'process 'collide-shape this (collide-list-enum hit-by-player))))
|
|
(let ((v1-4 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
|
|
(set! (-> v1-4 prim-core collide-as) (collide-spec enemy))
|
|
(set! (-> v1-4 prim-core collide-with) (collide-spec jak player-list))
|
|
(set-vector! (-> v1-4 local-sphere) 0.0 0.0 0.0 12288.0)
|
|
(set! (-> s4-0 total-prims) (the-as uint 1))
|
|
(set! (-> s4-0 root-prim) v1-4)
|
|
)
|
|
(set! (-> s4-0 nav-radius) 13926.4)
|
|
(let ((v1-6 (-> s4-0 root-prim)))
|
|
(set! (-> s4-0 backup-collide-as) (-> v1-6 prim-core collide-as))
|
|
(set! (-> s4-0 backup-collide-with) (-> v1-6 prim-core collide-with))
|
|
)
|
|
(set! (-> this root) s4-0)
|
|
)
|
|
(process-drawable-from-entity! this arg0)
|
|
(update-transforms (the-as collide-shape (-> this root)))
|
|
(set! (-> this active-distance) 409600.0)
|
|
(set! (-> this spring-height) (res-lump-float arg0 'spring-height :default 163840.0))
|
|
(let ((s4-1 (res-lump-value arg0 'mode uint128 :time -1000000000.0)))
|
|
(let ((v1-14 (-> this level name)))
|
|
(set! (-> this part) (create-launch-control
|
|
(cond
|
|
((= v1-14 'beach)
|
|
(-> *part-group-id-table* 7)
|
|
)
|
|
((= v1-14 'swamp)
|
|
(-> *part-group-id-table* 9)
|
|
)
|
|
(else
|
|
(-> *part-group-id-table* 8)
|
|
)
|
|
)
|
|
this
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-20 (logand (the-as int s4-1) 255)))
|
|
(cond
|
|
((= (the-as uint v1-20) 1)
|
|
(set! (-> this camera) cam-launcher-longfall)
|
|
)
|
|
((= (the-as uint v1-20) 2)
|
|
(set! (-> this camera) #f)
|
|
)
|
|
(else
|
|
(set! (-> this camera) cam-launcher-shortfall)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(let ((v1-25 (res-lump-struct arg0 'alt-vector vector)))
|
|
(when v1-25
|
|
(set-vector! (-> this dest) (-> v1-25 x) (-> v1-25 y) (-> v1-25 z) 1.0)
|
|
(set! (-> this seek-time) (the-as time-frame (the int (* 300.0 (-> v1-25 w)))))
|
|
)
|
|
)
|
|
(set! (-> this sound-id) (new-sound-id))
|
|
(nav-mesh-connect-from-ent this)
|
|
(go (method-of-object this idle))
|
|
)
|
|
|
|
;; definition for function launcher-init-by-other
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior launcher-init-by-other launcher ((arg0 vector) (arg1 float) (arg2 int) (arg3 float))
|
|
(stack-size-set! (-> self main-thread) 128)
|
|
(let ((s2-0 (new 'process 'collide-shape self (collide-list-enum hit-by-player))))
|
|
(let ((v1-4 (new 'process 'collide-shape-prim-sphere s2-0 (the-as uint 0))))
|
|
(set! (-> v1-4 prim-core collide-as) (collide-spec enemy))
|
|
(set! (-> v1-4 prim-core collide-with) (collide-spec jak player-list))
|
|
(set-vector! (-> v1-4 local-sphere) 0.0 0.0 0.0 12288.0)
|
|
(set! (-> s2-0 total-prims) (the-as uint 1))
|
|
(set! (-> s2-0 root-prim) v1-4)
|
|
)
|
|
(set! (-> s2-0 nav-radius) (* 0.75 (-> s2-0 root-prim local-sphere w)))
|
|
(let ((v1-7 (-> s2-0 root-prim)))
|
|
(set! (-> s2-0 backup-collide-as) (-> v1-7 prim-core collide-as))
|
|
(set! (-> s2-0 backup-collide-with) (-> v1-7 prim-core collide-with))
|
|
)
|
|
(set! (-> self root) s2-0)
|
|
)
|
|
(set! (-> self root trans quad) (-> arg0 quad))
|
|
(set-vector! (-> self root scale) 1.0 1.0 1.0 1.0)
|
|
(set-vector! (-> self root quat) 0.0 0.0 0.0 1.0)
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
(set! (-> self spring-height) arg1)
|
|
(set! (-> self active-distance) arg3)
|
|
(let ((v1-18 (-> self level name)))
|
|
(set! (-> self part) (create-launch-control
|
|
(cond
|
|
((= v1-18 'beach)
|
|
(-> *part-group-id-table* 7)
|
|
)
|
|
((= v1-18 'swamp)
|
|
(-> *part-group-id-table* 9)
|
|
)
|
|
(else
|
|
(-> *part-group-id-table* 8)
|
|
)
|
|
)
|
|
self
|
|
)
|
|
)
|
|
)
|
|
(case (logand arg2 255)
|
|
((1)
|
|
(set! (-> self camera) cam-launcher-longfall)
|
|
)
|
|
((2)
|
|
(set! (-> self camera) #f)
|
|
)
|
|
(else
|
|
(set! (-> self camera) cam-launcher-shortfall)
|
|
)
|
|
)
|
|
(let ((v1-29 (res-lump-struct (-> self entity) 'alt-vector vector)))
|
|
(when v1-29
|
|
(set-vector! (-> self dest) (-> v1-29 x) (-> v1-29 y) (-> v1-29 z) 1.0)
|
|
(set! (-> self seek-time) (the-as time-frame (the int (* 300.0 (-> v1-29 w)))))
|
|
)
|
|
)
|
|
(set! (-> self sound-id) (new-sound-id))
|
|
(go-virtual idle)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (touch-tracker)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(local-vars (v0-0 object))
|
|
(case message
|
|
(('touched)
|
|
(let ((v1-1 (ppointer->process (-> self parent))))
|
|
(when (!= v1-1 proc)
|
|
(cond
|
|
((= (-> self event) 'attack)
|
|
(send-event
|
|
proc
|
|
(-> self event)
|
|
:from v1-1
|
|
#f
|
|
(static-attack-info ((mode (-> self event-mode)) (id (new-attack-id))))
|
|
)
|
|
)
|
|
((-> self event)
|
|
(send-event proc (-> self event) :from v1-1)
|
|
)
|
|
(else
|
|
(let ((t0-5 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> t0-5 from) (process->ppointer proc))
|
|
(set! (-> t0-5 num-params) argc)
|
|
(set! (-> t0-5 message) message)
|
|
(set! (-> t0-5 param 0) (-> block param 0))
|
|
(set! (-> t0-5 param 1) (-> block param 1))
|
|
(set! (-> t0-5 param 2) (-> block param 2))
|
|
(set! (-> t0-5 param 3) (-> block param 3))
|
|
(set! (-> t0-5 param 4) (-> block param 4))
|
|
(set! (-> t0-5 param 5) (-> block param 5))
|
|
(send-event-function v1-1 t0-5)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('target)
|
|
(set! v0-0 (process->handle (the-as process (-> block param 0))))
|
|
(set! (-> self target) (the-as handle v0-0))
|
|
v0-0
|
|
)
|
|
(('event)
|
|
(set! (-> self event) (the-as symbol (-> block param 0)))
|
|
(set! v0-0 (-> block param 1))
|
|
(set! (-> self event-mode) (the-as symbol v0-0))
|
|
v0-0
|
|
)
|
|
(('exit)
|
|
(set! v0-0 (-> block param 0))
|
|
(set! (-> self run-function) (the-as (function object) v0-0))
|
|
v0-0
|
|
)
|
|
(('eval)
|
|
((the-as (function touch-tracker object) (-> block param 0)) self)
|
|
)
|
|
(('function)
|
|
(set! v0-0 (-> block param 0))
|
|
(set! (-> self callback) (the-as (function touch-tracker none) v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(set-time! (-> self state-time))
|
|
(while ((-> self run-function))
|
|
(let* ((gp-0 (handle->process (-> self target)))
|
|
(a0-4 (if (type? gp-0 process-drawable)
|
|
gp-0
|
|
)
|
|
)
|
|
)
|
|
(when a0-4
|
|
(let* ((gp-1 (-> (the-as process-drawable a0-4) root))
|
|
(a0-6 (if (type? gp-1 collide-shape)
|
|
gp-1
|
|
)
|
|
)
|
|
)
|
|
(if a0-6
|
|
(set! (-> (the-as collide-shape (-> self root)) trans quad)
|
|
(-> (the-as collide-shape a0-6) root-prim prim-core world-sphere quad)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(if (-> self callback)
|
|
((-> self callback) self)
|
|
)
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
(let ((a1-3 (new 'stack-no-clear 'overlaps-others-params)))
|
|
(set! (-> a1-3 options) (overlaps-others-options oo1))
|
|
(set! (-> a1-3 collide-with-filter) (the-as collide-spec -1))
|
|
(set! (-> a1-3 tlist) *touching-list*)
|
|
(find-overlapping-shapes (the-as collide-shape (-> self root)) a1-3)
|
|
)
|
|
(suspend)
|
|
)
|
|
(let ((v1-21 (-> (the-as collide-shape (-> self root)) root-prim)))
|
|
(set! (-> v1-21 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-21 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(suspend)
|
|
0
|
|
)
|
|
)
|
|
|
|
;; definition for function touch-tracker-init
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior touch-tracker-init touch-tracker ((arg0 vector) (arg1 float) (arg2 time-frame))
|
|
(let ((s4-0 (new 'process 'collide-shape-moving self (collide-list-enum 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 ((v1-6 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
|
|
(set! (-> v1-6 prim-core collide-as) (collide-spec jak enemy))
|
|
(set! (-> v1-6 prim-core collide-with)
|
|
(collide-spec
|
|
crate
|
|
civilian
|
|
enemy
|
|
obstacle
|
|
vehicle-sphere
|
|
hit-by-player-list
|
|
hit-by-others-list
|
|
collectable
|
|
pusher
|
|
)
|
|
)
|
|
(set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 arg1)
|
|
(set! (-> s4-0 total-prims) (the-as uint 1))
|
|
(set! (-> s4-0 root-prim) v1-6)
|
|
)
|
|
(set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
|
|
(let ((v1-9 (-> s4-0 root-prim)))
|
|
(set! (-> s4-0 backup-collide-as) (-> v1-9 prim-core collide-as))
|
|
(set! (-> s4-0 backup-collide-with) (-> v1-9 prim-core collide-with))
|
|
)
|
|
(set! (-> s4-0 event-self) 'touched)
|
|
(set! (-> self root) s4-0)
|
|
)
|
|
(set! (-> self root trans quad) (-> arg0 quad))
|
|
(set! (-> self duration) arg2)
|
|
(set! (-> self target) (the-as handle #f))
|
|
(set! (-> self event) #f)
|
|
(set! (-> self callback) #f)
|
|
(set! (-> self run-function)
|
|
(lambda :behavior touch-tracker () (not (time-elapsed? (-> self state-time) (-> self duration))))
|
|
)
|
|
(set! (-> self event-hook) (-> (method-of-object self active) event))
|
|
(go-virtual active)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 22 of type explosion
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod explosion-method-22 ((this explosion))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function explosion-init-by-other
|
|
;; INFO: Used lq/sq
|
|
(defbehavior explosion-init-by-other explosion ((arg0 explosion-init-params))
|
|
(mem-copy! (the-as pointer (-> self params)) (the-as pointer arg0) 72)
|
|
(logclear! (-> self mask) (process-mask actor-pause movie))
|
|
(let ((s5-0 (new 'process 'collide-shape self (collide-list-enum hit-by-player))))
|
|
(set! (-> s5-0 penetrate-using) (penetrate explode))
|
|
(let ((v1-5 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
|
|
(set! (-> v1-5 prim-core action) (collide-action solid))
|
|
(set-vector! (-> v1-5 local-sphere) 0.0 0.0 0.0 0.0)
|
|
(set! (-> s5-0 total-prims) (the-as uint 1))
|
|
(set! (-> s5-0 root-prim) v1-5)
|
|
)
|
|
(set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
|
|
(let ((v1-8 (-> s5-0 root-prim)))
|
|
(set! (-> s5-0 backup-collide-as) (-> v1-8 prim-core collide-as))
|
|
(set! (-> s5-0 backup-collide-with) (-> v1-8 prim-core collide-with))
|
|
)
|
|
(set! (-> self root) s5-0)
|
|
)
|
|
(set! (-> (the-as collide-shape (-> self root)) event-self) 'touched)
|
|
(set! (-> self root trans quad) (-> arg0 spawn-point quad))
|
|
(quaternion-copy! (-> self root quat) (-> arg0 spawn-quat))
|
|
(vector-identity! (-> self root scale))
|
|
(vector-float*! (-> self root scale) (-> self root scale) (-> arg0 scale))
|
|
(trs-matrix-calc! (-> self root) (-> self mat))
|
|
(let ((v1-19 (-> (the-as collide-shape (-> self root)) root-prim)))
|
|
(set! (-> v1-19 local-sphere w) (-> arg0 radius))
|
|
(set! (-> v1-19 prim-core world-sphere w) (-> arg0 radius))
|
|
(set! (-> v1-19 prim-core collide-with) (-> arg0 collide-with))
|
|
)
|
|
(let* ((v1-20 *game-info*)
|
|
(a0-19 (+ (-> v1-20 attack-id) 1))
|
|
)
|
|
(set! (-> v1-20 attack-id) a0-19)
|
|
(set! (-> self attack-id) a0-19)
|
|
)
|
|
(let ((a0-20 (-> arg0 group)))
|
|
(when a0-20
|
|
(set! (-> self duration) (-> a0-20 duration))
|
|
(set! (-> self linger-duration) (-> a0-20 linger-duration))
|
|
(set! (-> self part) (create-launch-control a0-20 self))
|
|
)
|
|
)
|
|
(let ((v1-26 (new 'stack-no-clear 'traffic-danger-info)))
|
|
(set! (-> v1-26 sphere quad) (-> self root trans quad))
|
|
(vector-reset! (-> v1-26 velocity))
|
|
(set! (-> v1-26 sphere r) (* 2.0 (-> arg0 radius)))
|
|
(set! (-> v1-26 notify-radius) 204800.0)
|
|
(set! (-> v1-26 danger-level) 1.0)
|
|
(set! (-> v1-26 decay-rate) 0.0)
|
|
(set! (-> v1-26 flags) (the-as uint 1))
|
|
(set! (-> v1-26 danger-type) (the-as uint 5))
|
|
(send-event *traffic-manager* 'add-danger-sphere v1-26)
|
|
)
|
|
(explosion-method-22 self)
|
|
(go-virtual explode)
|
|
)
|
|
|
|
;; definition for function explosion-spawn-legacy-version
|
|
(defun explosion-spawn-legacy-version ((arg0 process-drawable) (arg1 type) (arg2 explosion-init-params))
|
|
(let ((s4-0 (get-process *default-dead-pool* arg1 #x4000 1)))
|
|
(when s4-0
|
|
(let ((t9-1 (method-of-type process activate)))
|
|
(t9-1 s4-0 arg0 "explosion" (the-as pointer #x70004000))
|
|
)
|
|
(run-now-in-process s4-0 explosion-init-by-other arg2)
|
|
(-> s4-0 ppointer)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function explosion-spawn
|
|
;; WARN: Return type mismatch process vs none.
|
|
(defun explosion-spawn ((arg0 process-drawable) (arg1 type) (arg2 explosion-init-params))
|
|
(let* ((gp-0 (the-as process #f))
|
|
(s3-0 (get-process *default-dead-pool* explosion #x4000 1))
|
|
(v1-1 (when s3-0
|
|
(let ((t9-1 (method-of-type explosion activate)))
|
|
(t9-1 (the-as explosion s3-0) (the-as process-tree arg1) "explosion" (the-as pointer #x70004000))
|
|
)
|
|
(run-now-in-process s3-0 explosion-init-by-other arg0)
|
|
(-> s3-0 ppointer)
|
|
)
|
|
)
|
|
)
|
|
(if v1-1
|
|
(set! gp-0 (-> v1-1 0))
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function find-closest-solid-sphere-prim
|
|
(defun find-closest-solid-sphere-prim ((arg0 collide-shape) (arg1 vector) (arg2 collide-spec))
|
|
(let ((gp-0 (the-as collide-shape-prim #f)))
|
|
(let ((s3-0 (new 'stack-no-clear 'vector)))
|
|
(set! (-> s3-0 x) (the-as float #x7f800000))
|
|
(let ((s2-0 (-> arg0 root-prim))
|
|
(s1-0 1)
|
|
)
|
|
(when (zero? (-> s2-0 prim-core prim-type))
|
|
(let ((v1-3 s2-0))
|
|
(set! s2-0 (-> (the-as collide-shape-prim-group v1-3) child 0))
|
|
(set! s1-0 (the-as int (-> v1-3 specific 0)))
|
|
)
|
|
)
|
|
(while (nonzero? s1-0)
|
|
(+! s1-0 -1)
|
|
(when (and (= (-> s2-0 prim-core prim-type) -1)
|
|
(logtest? (-> s2-0 prim-core action) (collide-action solid))
|
|
(logtest? (-> s2-0 prim-core collide-as) arg2)
|
|
)
|
|
(set! (-> s3-0 y) (vector-vector-distance arg1 (the-as vector (-> s2-0 prim-core))))
|
|
(set! (-> s3-0 y) (fmax 0.0 (- (-> s3-0 y) (-> s2-0 prim-core world-sphere w))))
|
|
(when (< (-> s3-0 y) (-> s3-0 x))
|
|
(set! (-> s3-0 x) (-> s3-0 y))
|
|
(set! gp-0 s2-0)
|
|
)
|
|
)
|
|
(&+! s2-0 80)
|
|
)
|
|
)
|
|
)
|
|
gp-0
|
|
)
|
|
)
|
|
|
|
;; definition for symbol *explosion-debug-sphere*, type sphere
|
|
(define *explosion-debug-sphere* (new 'static 'sphere))
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate explode (explosion)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(local-vars (a0-13 process))
|
|
(case message
|
|
(('touched)
|
|
(let ((s4-0 (new 'stack-no-clear 'mystery-cquery-type0)))
|
|
(set! (-> s4-0 explosion-trans quad)
|
|
(-> (the-as collide-shape (-> self root)) root-prim prim-core world-sphere quad)
|
|
)
|
|
(let* ((s2-0 proc)
|
|
(s3-0 (if (type? s2-0 process-drawable)
|
|
s2-0
|
|
)
|
|
)
|
|
)
|
|
(when (and s3-0 (!= s3-0 (handle->process (-> self params ignore-proc))))
|
|
(let ((v1-6 (find-closest-solid-sphere-prim
|
|
(the-as collide-shape (-> (the-as process-drawable s3-0) root))
|
|
(-> s4-0 explosion-trans)
|
|
(-> self params collide-with)
|
|
)
|
|
)
|
|
)
|
|
(cond
|
|
(v1-6
|
|
(set! (-> s4-0 proc-trans quad) (-> v1-6 prim-core world-sphere quad))
|
|
)
|
|
((begin
|
|
(let ((s2-2 proc))
|
|
(set! a0-13 (if (type? s2-2 process-focusable)
|
|
s2-2
|
|
)
|
|
)
|
|
)
|
|
a0-13
|
|
)
|
|
(set! (-> s4-0 proc-trans quad) (-> (get-trans (the-as process-focusable a0-13) 3) quad))
|
|
)
|
|
(else
|
|
(let* ((s2-4 (-> (the-as process-focusable s3-0) root))
|
|
(v1-12 (if (type? s2-4 collide-shape)
|
|
s2-4
|
|
)
|
|
)
|
|
)
|
|
(if v1-12
|
|
(set! (-> s4-0 proc-trans quad) (-> v1-12 root-prim prim-core world-sphere quad))
|
|
(set! (-> s4-0 proc-trans quad) (-> (the-as process-focusable s3-0) root trans quad))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> s4-0 dist) (vector-vector-distance (-> s4-0 proc-trans) (-> s4-0 explosion-trans)))
|
|
(set! (-> s4-0 dist) (fmax 0.0 (- (-> s4-0 dist) (-> s4-0 proc-trans w))))
|
|
(set! (-> s4-0 probe) -1.0)
|
|
(when (< 0.0 (-> s4-0 dist))
|
|
(set! (-> s4-0 cquery start-pos quad) (-> s4-0 explosion-trans quad))
|
|
(vector-! (-> s4-0 cquery move-dist) (-> s4-0 proc-trans) (-> s4-0 explosion-trans))
|
|
(let ((v1-23 (-> s4-0 cquery)))
|
|
(set! (-> v1-23 radius) 40.96)
|
|
(set! (-> v1-23 collide-with) (collide-spec backgnd))
|
|
(set! (-> v1-23 ignore-process0) #f)
|
|
(set! (-> v1-23 ignore-process1) #f)
|
|
(set! (-> v1-23 ignore-pat)
|
|
(new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noendlessfall #x1 :board #x1)
|
|
)
|
|
(set! (-> v1-23 action-mask) (collide-action solid))
|
|
)
|
|
(set! (-> s4-0 probe) (fill-and-probe-using-line-sphere *collide-cache* (-> s4-0 cquery)))
|
|
)
|
|
(when (< (-> s4-0 probe) 0.0)
|
|
(let ((s3-1 (new 'stack-no-clear 'inline-array 'vector 2)))
|
|
(vector-! (-> s3-1 0) (-> s4-0 proc-trans) (-> s4-0 explosion-trans))
|
|
(set! (-> s3-1 1 x) (- 1.0 (fmin 1.0 (/ (-> s4-0 dist) (-> self params radius)))))
|
|
(set! (-> s3-1 1 y) (+ 1.0 (* (-> s3-1 1 x) (+ -1.0 (-> self params damage-scale)))))
|
|
(set! (-> s3-1 1 z) (* (-> s3-1 1 y) (-> self params damage)))
|
|
(vector-normalize! (-> s3-1 0) (-> s3-1 1 w))
|
|
(send-event
|
|
proc
|
|
'attack
|
|
(-> block param 0)
|
|
(static-attack-info
|
|
:mask (vehicle-impulse-factor)
|
|
((id (-> self attack-id))
|
|
(damage (-> s3-1 1 z))
|
|
(vehicle-damage-factor (-> self params vehicle-damage-factor))
|
|
(vehicle-impulse-factor (-> self params vehicle-impulse-factor))
|
|
(mode 'explode)
|
|
(attacker-velocity (-> s3-1 0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(set-time! (-> self start-time))
|
|
(when (nonzero? (-> self params collide-with))
|
|
(update-transforms (the-as collide-shape (-> self root)))
|
|
(let ((a1-0 (new 'stack-no-clear 'overlaps-others-params)))
|
|
(set! (-> a1-0 options) (overlaps-others-options))
|
|
(set! (-> a1-0 collide-with-filter) (the-as collide-spec -1))
|
|
(set! (-> a1-0 tlist) *touching-list*)
|
|
(find-overlapping-shapes (the-as collide-shape (-> self root)) a1-0)
|
|
)
|
|
)
|
|
(let ((v1-11 (-> (the-as collide-shape (-> self root)) root-prim)))
|
|
(set! (-> v1-11 prim-core collide-as) (collide-spec))
|
|
(set! (-> v1-11 prim-core collide-with) (collide-spec))
|
|
)
|
|
0
|
|
(while (not (time-elapsed? (-> self start-time) (the-as time-frame (-> self duration))))
|
|
(sparticle-launch-control-method-17 (-> self part) (-> self mat))
|
|
(suspend)
|
|
)
|
|
(set-time! (-> self start-time))
|
|
(while (not (time-elapsed? (-> self start-time) (the-as time-frame (-> self linger-duration))))
|
|
(suspend)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function process-drawable-random-point!
|
|
(defun process-drawable-random-point! ((arg0 process-drawable) (arg1 vector))
|
|
(let ((v1-1 (-> arg0 node-list length))
|
|
(s4-0 (-> arg0 root))
|
|
)
|
|
(cond
|
|
((>= v1-1 7)
|
|
(let ((v1-2 (rand-vu-int-range 3 (+ v1-1 -1))))
|
|
(vector<-cspace! arg1 (-> arg0 node-list data v1-2))
|
|
)
|
|
)
|
|
((and (nonzero? s4-0) (type? s4-0 collide-shape))
|
|
(vector+!
|
|
arg1
|
|
(the-as vector (-> (the-as collide-shape s4-0) root-prim prim-core))
|
|
(rand-vu-sphere-point! arg1 (-> (the-as collide-shape s4-0) root-prim prim-core world-sphere w))
|
|
)
|
|
)
|
|
(else
|
|
(vector+! arg1 (-> arg0 root trans) (rand-vu-sphere-point! arg1 (-> arg0 draw bounds w)))
|
|
)
|
|
)
|
|
)
|
|
arg1
|
|
)
|
|
|
|
;; definition for function process-drawable-pair-random-point!
|
|
;; INFO: Used lq/sq
|
|
(defun process-drawable-pair-random-point! ((arg0 process-drawable) (arg1 process-drawable) (arg2 vector) (arg3 float))
|
|
(let ((s4-0 (new-stack-vector0))
|
|
(s3-0 (new-stack-vector0))
|
|
)
|
|
(process-drawable-random-point! arg0 s4-0)
|
|
(process-drawable-random-point! arg1 s3-0)
|
|
(vector-lerp! arg2 s4-0 s3-0 arg3)
|
|
)
|
|
)
|
|
|
|
;; definition of type simple-prim
|
|
(deftype simple-prim (process-drawable)
|
|
((strip prim-strip)
|
|
)
|
|
(:state-methods
|
|
active
|
|
)
|
|
(:methods
|
|
(init-strip! (_type_) none)
|
|
(strip-setup (_type_) none)
|
|
(get-alpha (_type_) int)
|
|
(allocate-trans-and-strip! (_type_) prim-strip)
|
|
(get-color (_type_) rgba)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type simple-prim
|
|
(defmethod inspect ((this simple-prim))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tstrip: ~A~%" (-> this strip))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 11 of type simple-prim
|
|
(defmethod init-from-entity! ((this simple-prim) (arg0 entity-actor))
|
|
(allocate-trans-and-strip! this)
|
|
(process-entity-set! this arg0)
|
|
(process-drawable-from-entity! this arg0)
|
|
(let ((v1-3 ((method-of-type res-lump get-property-struct)
|
|
(-> this entity)
|
|
'trans-offset
|
|
'interp
|
|
-1000000000.0
|
|
*zero-vector*
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(vector+! (-> this root trans) (-> this root trans) (the-as vector v1-3))
|
|
)
|
|
(let ((f0-0 (res-lump-float (-> this entity) 'scale :default 1.0)))
|
|
(vector-float*! (-> this root scale) (-> this root scale) f0-0)
|
|
)
|
|
(vector-float*! (-> this root scale) (-> this root scale) 4096.0)
|
|
(let ((f0-2 (res-lump-float (-> this entity) 'rotoffset)))
|
|
(quaternion-rotate-y! (-> this root quat) (-> this root quat) f0-2)
|
|
)
|
|
(let ((f0-3 (res-lump-float (-> this entity) 'tiltmin)))
|
|
(quaternion-rotate-local-x! (-> this root quat) (-> this root quat) f0-3)
|
|
)
|
|
(set! (-> this strip tex-id) (new 'static 'texture-id :index #x3 :page #x1))
|
|
(go (method-of-object this active))
|
|
)
|
|
|
|
;; definition for method 24 of type simple-prim
|
|
(defmethod allocate-trans-and-strip! ((this simple-prim))
|
|
"Allocate transform and strip."
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(quaternion-identity! (-> this root quat))
|
|
(let ((v0-2 (new 'process 'prim-strip 4 (new 'static 'texture-id :index #x3 :page #x1) (the-as string #f))))
|
|
(set! (-> this strip) v0-2)
|
|
v0-2
|
|
)
|
|
)
|
|
|
|
;; definition for function simple-prim-init-by-other
|
|
;; INFO: Used lq/sq
|
|
(defbehavior simple-prim-init-by-other simple-prim ((arg0 vector) (arg1 vector) (arg2 texture-id))
|
|
(allocate-trans-and-strip! self)
|
|
(set! (-> self root trans quad) (-> arg0 quad))
|
|
(set! (-> self root scale quad) (-> arg1 quad))
|
|
(set! (-> self strip tex-id) arg2)
|
|
(go-virtual active)
|
|
)
|
|
|
|
;; definition for method 22 of type simple-prim
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod strip-setup ((this simple-prim))
|
|
(set! (-> this strip num-verts) (the-as uint 4))
|
|
(set! (-> this strip alpha) *simple-prim-alpha-blend*)
|
|
(set! (-> this strip adnops 0 cmds) (gs-reg64 test-1))
|
|
(set! (-> this strip data0) (new 'static 'gs-test
|
|
:ate #x1
|
|
:atst (gs-atest greater-equal)
|
|
:aref #x26
|
|
:zte #x1
|
|
:ztst (gs-ztest greater-equal)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (simple-prim)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
'()
|
|
)
|
|
:trans (behavior ()
|
|
(strip-setup self)
|
|
(init-strip! self)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition for method 23 of type simple-prim
|
|
(defmethod get-alpha ((this simple-prim))
|
|
128
|
|
)
|
|
|
|
;; definition for method 25 of type simple-prim
|
|
(defmethod get-color ((this simple-prim))
|
|
*color-gray*
|
|
)
|
|
|
|
;; definition for method 21 of type simple-prim
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch rgba vs none.
|
|
(defmethod init-strip! ((this simple-prim))
|
|
(quaternion-normalize! (-> this root quat))
|
|
(let ((s2-0 (vector-x-quaternion! (new 'stack-no-clear 'vector) (-> this root quat)))
|
|
(s3-0 (vector-y-quaternion! (new 'stack-no-clear 'vector) (-> this root quat)))
|
|
(gp-0 (get-alpha this))
|
|
(s4-0 (new 'stack-no-clear 'vector))
|
|
(s5-0 (get-color this))
|
|
)
|
|
(vector-normalize! s2-0 (-> this root scale x))
|
|
(vector-normalize! s3-0 (-> this root scale y))
|
|
(let ((v1-8 (-> this strip data)))
|
|
(vector+! s4-0 (-> this root trans) s2-0)
|
|
(vector+! s4-0 s4-0 s3-0)
|
|
(set! (-> v1-8 0 pos quad) (-> s4-0 quad))
|
|
(set! (-> v1-8 0 stq z) 0.0)
|
|
(set! (-> v1-8 0 stq x) 0.0)
|
|
(set! (-> v1-8 0 stq y) 0.0)
|
|
(set! (-> v1-8 0 col) s5-0)
|
|
(set! (-> v1-8 0 col a) gp-0)
|
|
(let ((v1-9 (-> v1-8 1)))
|
|
(vector+float*! s4-0 (-> this root trans) s2-0 -1.0)
|
|
(vector+! s4-0 s4-0 s3-0)
|
|
(set! (-> v1-9 pos quad) (-> s4-0 quad))
|
|
(set! (-> v1-9 stq z) 0.0)
|
|
(set! (-> v1-9 stq x) 1.0)
|
|
(set! (-> v1-9 stq y) 0.0)
|
|
(set! (-> v1-9 col) s5-0)
|
|
(set! (-> v1-9 col a) gp-0)
|
|
(let ((v1-10 (&+ v1-9 32)))
|
|
(vector+! s4-0 (-> this root trans) s2-0)
|
|
(vector+float*! s4-0 s4-0 s3-0 -1.0)
|
|
(set! (-> v1-10 pos quad) (-> s4-0 quad))
|
|
(set! (-> v1-10 stq z) 0.0)
|
|
(set! (-> v1-10 stq x) 0.0)
|
|
(set! (-> v1-10 stq y) 1.0)
|
|
(set! (-> v1-10 col) s5-0)
|
|
(set! (-> v1-10 col a) gp-0)
|
|
(let ((v1-11 (&+ v1-10 32)))
|
|
(vector+float*! s4-0 (-> this root trans) s2-0 -1.0)
|
|
(vector+float*! s4-0 s4-0 s3-0 -1.0)
|
|
(set! (-> v1-11 pos quad) (-> s4-0 quad))
|
|
(set! (-> v1-11 stq z) 0.0)
|
|
(set! (-> v1-11 stq x) 1.0)
|
|
(set! (-> v1-11 stq y) 1.0)
|
|
(set! (-> v1-11 col) s5-0)
|
|
(set! (-> v1-11 col a) gp-0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 7 of type simple-prim
|
|
(defmethod relocate ((this simple-prim) (offset int))
|
|
(if (nonzero? (-> this strip))
|
|
(&+! (-> this strip) offset)
|
|
)
|
|
(call-parent-method this offset)
|
|
)
|
|
|
|
;; definition of type simple-prim-zbuf-mask
|
|
(deftype simple-prim-zbuf-mask (simple-prim)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type simple-prim-zbuf-mask
|
|
(defmethod inspect ((this simple-prim-zbuf-mask))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type simple-prim inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 22 of type simple-prim-zbuf-mask
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod strip-setup ((this simple-prim-zbuf-mask))
|
|
(set! (-> this strip num-verts) (the-as uint 4))
|
|
(set! (-> this strip alpha) *simple-prim-additive*)
|
|
(set! (-> this strip adnops 0 cmds) (gs-reg64 test-1))
|
|
(set! (-> this strip data0) (new 'static 'gs-test
|
|
:ate #x1
|
|
:atst (gs-atest greater-equal)
|
|
:aref #x26
|
|
:zte #x1
|
|
:ztst (gs-ztest greater-equal)
|
|
)
|
|
)
|
|
(set! (-> this strip bucket) (bucket-id generic-sprite-1))
|
|
(set! (-> this strip sink) (the-as uint 65))
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 25 of type simple-prim-zbuf-mask
|
|
(defmethod get-color ((this simple-prim-zbuf-mask))
|
|
*color-black*
|
|
)
|
|
|
|
;; definition of type simple-prim-particle-binding
|
|
(deftype simple-prim-particle-binding (simple-prim)
|
|
((color rgba)
|
|
(lifetime time-frame)
|
|
)
|
|
(:state-methods
|
|
die
|
|
)
|
|
(:methods
|
|
(setup! (_type_ int sparticle-cpuinfo sparticle-launchinfo) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type simple-prim-particle-binding
|
|
(defmethod inspect ((this simple-prim-particle-binding))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type simple-prim inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tcolor: ~D~%" (-> this color))
|
|
(format #t "~2Tlifetime: ~D~%" (-> this lifetime))
|
|
(format #t "~2Tstate-time: ~D~%" (-> this state-time))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 25 of type simple-prim-particle-binding
|
|
(defmethod get-color ((this simple-prim-particle-binding))
|
|
(-> this color)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (simple-prim-particle-binding)
|
|
:virtual #t
|
|
:code nothing
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (simple-prim-particle-binding)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
(set-time! (-> self state-time))
|
|
)
|
|
:trans (behavior ()
|
|
(init-strip! self)
|
|
(if (time-elapsed? (-> self state-time) (-> self lifetime))
|
|
(go-virtual die)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition for method 27 of type simple-prim-particle-binding
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod setup! ((this simple-prim-particle-binding) (arg0 int) (arg1 sparticle-cpuinfo) (arg2 sparticle-launchinfo))
|
|
"Set up this prim with the given particle info."
|
|
(set! (-> this lifetime) (seconds 5))
|
|
(set! (-> this root scale x) (-> arg2 launchrot w))
|
|
(set! (-> this root scale y) (-> arg2 conerot w))
|
|
(set! (-> this color r) (the int (* 128.0 (-> arg2 rotate-x))))
|
|
(set! (-> this color g) (the int (* 128.0 (-> arg2 rotate-y))))
|
|
(set! (-> this color b) (the int (* 128.0 (-> arg2 rotate-z))))
|
|
(set! (-> this color a) (the int (* 128.0 (-> arg2 coneradius))))
|
|
(set-vector! (-> this root trans) (-> arg2 launchrot x) (-> arg2 launchrot y) (-> arg2 launchrot z) 1.0)
|
|
(set! (-> this strip adnops 0 cmds) (gs-reg64 test-1))
|
|
(set! (-> this strip data0) (new 'static 'gs-test
|
|
:ate #x1
|
|
:atst (gs-atest greater-equal)
|
|
:aref #x26
|
|
:zte #x1
|
|
:ztst (gs-ztest greater-equal)
|
|
)
|
|
)
|
|
(cond
|
|
((logtest? (-> arg1 flags) (sp-cpuinfo-flag aux-list))
|
|
(set! (-> this strip alpha) *simple-prim-additive*)
|
|
(set! (-> this color) *color-black*)
|
|
)
|
|
((logtest? (-> arg1 flags) (sp-cpuinfo-flag sp-cpuinfo-flag-3))
|
|
(set! (-> this strip alpha) *simple-prim-additive*)
|
|
)
|
|
(else
|
|
(set! (-> this strip alpha) *simple-prim-alpha-blend*)
|
|
)
|
|
)
|
|
(set! (-> this strip num-verts) (the-as uint 4))
|
|
(none)
|
|
)
|
|
|
|
;; definition for function birth-func-simple-prim
|
|
(defun birth-func-simple-prim ((arg0 int) (arg1 sparticle-cpuinfo) (arg2 sparticle-launchinfo))
|
|
(let ((s3-0 (get-process *default-dead-pool* simple-prim-particle-binding #x4000 1)))
|
|
(setup!
|
|
(the-as simple-prim-particle-binding (-> (when s3-0
|
|
(let ((t9-1 (method-of-type process activate)))
|
|
(t9-1 s3-0 *entity-pool* "prim" (the-as pointer #x70004000))
|
|
)
|
|
(run-now-in-process
|
|
s3-0
|
|
simple-prim-init-by-other
|
|
*zero-vector*
|
|
*zero-vector*
|
|
(new 'static 'texture-id :index #x3 :page #x1)
|
|
)
|
|
(-> s3-0 ppointer)
|
|
)
|
|
0
|
|
)
|
|
)
|
|
arg0
|
|
arg1
|
|
arg2
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition of type part-controller
|
|
(deftype part-controller (process)
|
|
((actor-group (pointer actor-group))
|
|
(actor-group-count int32)
|
|
(spawn-delay time-frame)
|
|
(current-part-index uint16)
|
|
(state-time time-frame)
|
|
(next-reset-time time-frame)
|
|
(reset-interval-min time-frame)
|
|
(reset-interval-max time-frame)
|
|
(particle-launchers (array (pointer sparticle-launch-group)))
|
|
(spawn-sound sound-name)
|
|
)
|
|
(:state-methods
|
|
active
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type part-controller
|
|
;; INFO: Used lq/sq
|
|
(defmethod inspect ((this part-controller))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-7)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tactor-group: #x~X~%" (-> this actor-group))
|
|
(dotimes (s5-0 (-> this actor-group-count))
|
|
(format #t "~T [~D]~2Tactor-group: ~`actor-group`P~%" s5-0 (-> this actor-group s5-0))
|
|
)
|
|
(format #t "~2Tactor-group-count: ~D~%" (-> this actor-group-count))
|
|
(format #t "~2Tspawn-delay: ~D~%" (-> this spawn-delay))
|
|
(format #t "~2Tcurrent-part-index: ~D~%" (-> this current-part-index))
|
|
(format #t "~2Tstate-time: ~D~%" (-> this state-time))
|
|
(format #t "~2Tnext-reset-time: ~D~%" (-> this next-reset-time))
|
|
(format #t "~2Treset-interval-min: ~D~%" (-> this reset-interval-min))
|
|
(format #t "~2Treset-interval-max: ~D~%" (-> this reset-interval-max))
|
|
(format #t "~2Tparticle-launchers: ~A~%" (-> this particle-launchers))
|
|
(format #t "~2Tspawn-sound: ~D~%" (-> this spawn-sound))
|
|
(label cfg-7)
|
|
this
|
|
)
|
|
|
|
;; definition for method 7 of type part-controller
|
|
(defmethod relocate ((this part-controller) (offset int))
|
|
(if (nonzero? (-> this particle-launchers))
|
|
(&+! (-> this particle-launchers) offset)
|
|
)
|
|
(call-parent-method this offset)
|
|
)
|
|
|
|
;; definition for method 12 of type part-controller
|
|
(defmethod run-logic? ((this part-controller))
|
|
"Should this process be run? Checked by execute-process-tree."
|
|
#t
|
|
)
|
|
|
|
;; definition for method 11 of type part-controller
|
|
;; INFO: Used lq/sq
|
|
(defmethod init-from-entity! ((this part-controller) (arg0 entity-actor))
|
|
(local-vars (sv-16 res-tag) (sv-32 string))
|
|
(stack-size-set! (-> this main-thread) 32)
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((v1-3 (res-lump-data (-> this entity) 'actor-groups pointer :tag-ptr (& sv-16))))
|
|
(cond
|
|
((and v1-3 (nonzero? (-> sv-16 elt-count)))
|
|
(set! (-> this actor-group) (the-as (pointer actor-group) v1-3))
|
|
(set! (-> this actor-group-count) (the-as int (-> sv-16 elt-count)))
|
|
)
|
|
(else
|
|
(set! (-> this actor-group) (the-as (pointer actor-group) #f))
|
|
(set! (-> this actor-group-count) 0)
|
|
0
|
|
)
|
|
)
|
|
)
|
|
(logclear! (-> this mask) (process-mask actor-pause))
|
|
(when (<= (-> this actor-group-count) 0)
|
|
(process-entity-status! this (entity-perm-status dead) #t)
|
|
(deactivate this)
|
|
(return 0)
|
|
)
|
|
(let ((a0-9 ((method-of-type res-lump get-property-struct)
|
|
arg0
|
|
'sound-name
|
|
'interp
|
|
-1000000000.0
|
|
""
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this spawn-sound) (string->sound-name (the-as string a0-9)))
|
|
)
|
|
(let ((a3-2 (+ 0 (-> this actor-group 0 length))))
|
|
(set! (-> this particle-launchers)
|
|
(the-as (array (pointer sparticle-launch-group)) (new 'process 'boxed-array pointer a3-2))
|
|
)
|
|
)
|
|
(set! (-> this particle-launchers length) 0)
|
|
(dotimes (s4-0 (min 1 (-> this actor-group-count)))
|
|
(dotimes (s3-0 (-> this actor-group s4-0 length))
|
|
(set! sv-32 "#f")
|
|
(set! (-> this particle-launchers (-> this particle-launchers length))
|
|
(entity-lookup-part-group
|
|
(the-as entity-actor (-> this actor-group s4-0 data s3-0 actor))
|
|
(& sv-32)
|
|
'art-name
|
|
)
|
|
)
|
|
(+! (-> this particle-launchers length) 1)
|
|
)
|
|
)
|
|
(set! (-> this spawn-delay) (the-as time-frame (the int (* 300.0 (res-lump-float arg0 'delay :default 1.0)))))
|
|
(let ((s4-1 (the int (* 300.0 (res-lump-float arg0 'base-time :default 4.0))))
|
|
(v1-50 (the int (* 300.0 (res-lump-float arg0 'offset-time :default 2.0))))
|
|
)
|
|
(set! (-> this reset-interval-min) (the-as time-frame (- s4-1 v1-50)))
|
|
(set! (-> this reset-interval-max) (the-as time-frame (+ s4-1 v1-50)))
|
|
)
|
|
(go (method-of-object this active))
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (part-controller)
|
|
:virtual #t
|
|
:enter (behavior ()
|
|
(set-time! (-> self state-time))
|
|
(set! (-> self next-reset-time) (+ (current-time)
|
|
(-> self reset-interval-min)
|
|
(mod
|
|
(the-as int (rand-uint31-gen *random-generator*))
|
|
(+ (- 1 (-> self reset-interval-min)) (-> self reset-interval-max))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(when (< (-> self next-reset-time) (current-time))
|
|
(set! (-> self current-part-index) (the-as uint 0))
|
|
(set! (-> self state-time) 0)
|
|
(set! (-> self next-reset-time) (+ (current-time)
|
|
(-> self reset-interval-min)
|
|
(mod
|
|
(the-as int (rand-uint31-gen *random-generator*))
|
|
(+ (- 1 (-> self reset-interval-min)) (-> self reset-interval-max))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (and (time-elapsed? (-> self state-time) (-> self spawn-delay))
|
|
(< (-> self current-part-index) (the-as uint (-> self particle-launchers length)))
|
|
)
|
|
(when (-> self particle-launchers (-> self current-part-index))
|
|
(let ((gp-1 (-> self actor-group 0 data (-> self current-part-index) actor extra trans)))
|
|
(sound-play-by-name (-> self spawn-sound) (new-sound-id) 1024 0 0 (sound-group) gp-1)
|
|
(cond
|
|
((logtest? (-> self particle-launchers (-> self current-part-index) 0 flags) (sp-group-flag sp13))
|
|
(set! (-> *launch-matrix* trans quad) (-> gp-1 quad))
|
|
(let ((gp-2 (get-process *default-dead-pool* part-tracker-subsampler #x4000 0)))
|
|
(when gp-2
|
|
(let ((t9-4 (method-of-type part-tracker-subsampler activate)))
|
|
(t9-4
|
|
(the-as part-tracker-subsampler gp-2)
|
|
*entity-pool*
|
|
"part-tracker-subsampler"
|
|
(the-as pointer #x70004000)
|
|
)
|
|
)
|
|
(let ((t9-5 run-function-in-process)
|
|
(a0-18 gp-2)
|
|
(a1-3 part-tracker-subsampler-init)
|
|
)
|
|
(set! (-> *part-tracker-subsampler-params-default* group)
|
|
(-> self particle-launchers (-> self current-part-index) 0)
|
|
)
|
|
(set! (-> *part-tracker-subsampler-params-default* duration) 0)
|
|
(set! (-> *part-tracker-subsampler-params-default* callback) #f)
|
|
(set! (-> *part-tracker-subsampler-params-default* userdata) (the-as uint #f))
|
|
(set! (-> *part-tracker-subsampler-params-default* target) #f)
|
|
(set! (-> *part-tracker-subsampler-params-default* mat-joint) *launch-matrix*)
|
|
(set! (-> *part-tracker-subsampler-params-default* subsample-num) 1.0)
|
|
((the-as (function object object object none) t9-5) a0-18 a1-3 *part-tracker-subsampler-params-default*)
|
|
)
|
|
(-> gp-2 ppointer)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> *launch-matrix* trans quad) (-> gp-1 quad))
|
|
(let ((gp-3 (get-process *default-dead-pool* part-tracker #x4000 0)))
|
|
(when gp-3
|
|
(let ((t9-7 (method-of-type part-tracker activate)))
|
|
(t9-7 (the-as part-tracker gp-3) *entity-pool* "part-tracker" (the-as pointer #x70004000))
|
|
)
|
|
(let ((t9-8 run-function-in-process)
|
|
(a0-23 gp-3)
|
|
(a1-6 part-tracker-init)
|
|
)
|
|
(set! (-> *part-tracker-params-default* group) (-> self particle-launchers (-> self current-part-index) 0))
|
|
(set! (-> *part-tracker-params-default* duration) 0)
|
|
(set! (-> *part-tracker-params-default* callback) #f)
|
|
(set! (-> *part-tracker-params-default* userdata) (the-as uint #f))
|
|
(set! (-> *part-tracker-params-default* target) #f)
|
|
(set! (-> *part-tracker-params-default* mat-joint) *launch-matrix*)
|
|
((the-as (function object object object none) t9-8) a0-23 a1-6 *part-tracker-params-default*)
|
|
)
|
|
(-> gp-3 ppointer)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(+! (-> self current-part-index) 1)
|
|
(set-time! (-> self state-time))
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition of type sound-controller
|
|
(deftype sound-controller (process)
|
|
((spawn-sound sound-name)
|
|
(sync sync-linear :inline)
|
|
(prev-val float)
|
|
(pos vector :inline)
|
|
)
|
|
(:state-methods
|
|
active
|
|
die
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type sound-controller
|
|
;; INFO: Used lq/sq
|
|
(defmethod inspect ((this sound-controller))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tspawn-sound: ~D~%" (-> this spawn-sound))
|
|
(format #t "~2Tsync: #<sync-linear @ #x~X>~%" (-> this sync))
|
|
(format #t "~2Tprev-val: ~f~%" (-> this prev-val))
|
|
(format #t "~2Tpos: #<vector @ #x~X>~%" (-> this pos))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 11 of type sound-controller
|
|
;; INFO: Used lq/sq
|
|
(defmethod init-from-entity! ((this sound-controller) (arg0 entity-actor))
|
|
(stack-size-set! (-> this main-thread) 32)
|
|
(let ((a0-3 (the-as string ((method-of-type res-lump get-property-struct)
|
|
arg0
|
|
'sound-name
|
|
'interp
|
|
-1000000000.0
|
|
""
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this spawn-sound) (string->sound-name a0-3))
|
|
)
|
|
(set! (-> this pos quad) (-> arg0 extra trans quad))
|
|
(let ((a1-3 (new 'stack-no-clear 'sync-info-params)))
|
|
(let ((v1-5 0))
|
|
(if #f
|
|
(set! v1-5 (logior v1-5 1))
|
|
)
|
|
(set! (-> a1-3 sync-type) 'sync-linear)
|
|
(set! (-> a1-3 sync-flags) (the-as sync-flags v1-5))
|
|
)
|
|
(set! (-> a1-3 entity) arg0)
|
|
(set! (-> a1-3 period) (the-as uint #x6fc23b000))
|
|
(set! (-> a1-3 percent) 0.0)
|
|
(initialize! (-> this sync) a1-3)
|
|
)
|
|
(set! (-> this prev-val) (get-norm! (-> this sync) 0))
|
|
(go (method-of-object this active))
|
|
)
|
|
|
|
;; definition for method 10 of type sound-controller
|
|
(defmethod deactivate ((this sound-controller))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(call-parent-method this)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (sound-controller)
|
|
:virtual #t
|
|
:code (behavior ()
|
|
'()
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (sound-controller)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('die)
|
|
(go-virtual die)
|
|
)
|
|
(('reset)
|
|
(sync-now! (-> self sync) 0.0)
|
|
)
|
|
(('play)
|
|
(sound-play-by-name (-> self spawn-sound) (new-sound-id) 1024 0 0 (sound-group) (-> self pos))
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(let ((f30-0 (get-norm! (-> self sync) 0)))
|
|
(if (< f30-0 (-> self prev-val))
|
|
(sound-play-by-name (-> self spawn-sound) (new-sound-id) 1024 0 0 (sound-group) (-> self pos))
|
|
)
|
|
(set! (-> self prev-val) f30-0)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; definition of type sound-on-path
|
|
(deftype sound-on-path (process-drawable)
|
|
"An [[ambient-sound]] that is being moved along a path."
|
|
((spawn-sound sound-name)
|
|
(loop-sound uint32 :offset 228)
|
|
(amb-sound ambient-sound)
|
|
(is-spooling? symbol)
|
|
)
|
|
(:state-methods
|
|
active
|
|
die
|
|
no-play
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type sound-on-path
|
|
;; INFO: Used lq/sq
|
|
(defmethod inspect ((this sound-on-path))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tspawn-sound: ~D~%" (-> this spawn-sound))
|
|
(format #t "~2Tpath: ~A~%" (-> this path))
|
|
(format #t "~2Tloop-sound: ~D~%" (-> this loop-sound))
|
|
(format #t "~2Tamb-sound: ~A~%" (-> this amb-sound))
|
|
(format #t "~2Tis-spooling?: ~A~%" (-> this is-spooling?))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 10 of type sound-on-path
|
|
(defmethod deactivate ((this sound-on-path))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(if (nonzero? (-> this amb-sound))
|
|
(stop! (-> this amb-sound))
|
|
)
|
|
(if (nonzero? (-> this loop-sound))
|
|
(sound-stop (the-as sound-id (-> this loop-sound)))
|
|
)
|
|
((method-of-type process-drawable deactivate) this)
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 7 of type sound-on-path
|
|
;; WARN: Return type mismatch process-drawable vs sound-on-path.
|
|
(defmethod relocate ((this sound-on-path) (offset int))
|
|
(if (nonzero? (-> this amb-sound))
|
|
(&+! (-> this amb-sound) offset)
|
|
)
|
|
(the-as sound-on-path ((method-of-type process-drawable relocate) this offset))
|
|
)
|
|
|
|
;; definition for method 11 of type sound-on-path
|
|
(defmethod init-from-entity! ((this sound-on-path) (arg0 entity-actor))
|
|
(stack-size-set! (-> this main-thread) 32)
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(process-drawable-from-entity! this arg0)
|
|
(let ((s4-0 ((method-of-type res-lump get-property-struct)
|
|
arg0
|
|
'sound-name
|
|
'interp
|
|
-1000000000.0
|
|
""
|
|
(the-as (pointer res-tag) #f)
|
|
*res-static-buf*
|
|
)
|
|
)
|
|
)
|
|
(set! (-> this is-spooling?) (nonzero? (res-lump-value arg0 'spooling-val uint128 :time -1000000000.0)))
|
|
(set! (-> this path) (new 'process 'path-control this 'path 0.0 arg0 #f))
|
|
(logior! (-> this path flags) (path-control-flag display draw-line draw-point draw-text))
|
|
(logclear! (-> this mask) (process-mask actor-pause))
|
|
(when (= s4-0 "")
|
|
(go (method-of-object this no-play))
|
|
(return 0)
|
|
)
|
|
(cond
|
|
((-> this is-spooling?)
|
|
(set! (-> this loop-sound)
|
|
(the-as
|
|
uint
|
|
(add-process *gui-control* this (gui-channel background) (gui-action queue) (the-as string s4-0) -99.0 0)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> this amb-sound) (new 'process 'ambient-sound (the-as basic s4-0) (-> this root trans) 0.0))
|
|
(let ((f0-0 (res-lump-float arg0 'sound-falloff-far :default 245760.0)))
|
|
(set-falloff-far! (-> this amb-sound) f0-0)
|
|
)
|
|
(update-vol! (-> this amb-sound) 1.0)
|
|
(update-pitch-mod! (-> this amb-sound) 0.0)
|
|
)
|
|
)
|
|
)
|
|
(go (method-of-object this active))
|
|
)
|
|
|
|
;; definition for method 12 of type sound-on-path
|
|
(defmethod run-logic? ((this sound-on-path))
|
|
"Should this process be run? Checked by execute-process-tree."
|
|
#t
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die (sound-on-path)
|
|
:virtual #t
|
|
:code (behavior ()
|
|
'()
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate no-play (sound-on-path)
|
|
:virtual #t
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (sound-on-path)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('die)
|
|
(go-virtual die)
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(let ((f0-0 (path-control-method-25 (-> self path) (target-pos 0)))
|
|
(gp-1 (new 'stack-no-clear 'vector))
|
|
)
|
|
(get-point-at-percent-along-path! (-> self path) gp-1 f0-0 'interp)
|
|
(set! (-> self root trans quad) (-> gp-1 quad))
|
|
(cond
|
|
((-> self is-spooling?)
|
|
(case (get-status *gui-control* (the-as sound-id (-> self loop-sound)))
|
|
(((gui-status ready))
|
|
(set-action!
|
|
*gui-control*
|
|
(gui-action play)
|
|
(the-as sound-id (-> self loop-sound))
|
|
(gui-channel none)
|
|
(gui-action none)
|
|
(the-as string #f)
|
|
(the-as (function gui-connection symbol) #f)
|
|
(the-as process #f)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(update-trans! (-> self amb-sound) gp-1)
|
|
(update! (-> self amb-sound))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (external-camera-controller)
|
|
:virtual #t
|
|
:trans (behavior ()
|
|
(set-zero! *camera-smush-control*)
|
|
)
|
|
:code (behavior ()
|
|
(process-entity-status! self (entity-perm-status no-kill) #t)
|
|
(set-setting! 'calm #t 0.0 0)
|
|
(while (not (process-grab? *target* #f))
|
|
(suspend)
|
|
)
|
|
(set-setting! 'mode-name 'cam-fixed 0.0 0)
|
|
(set-setting! 'interp-time 'abs 450.0 0)
|
|
(set-setting! 'entity-name (res-lump-struct (-> self entity) 'camera-name structure) 0.0 0)
|
|
(let ((gp-1 (current-time)))
|
|
(until (time-elapsed? gp-1 (-> self pause-time))
|
|
(suspend)
|
|
)
|
|
)
|
|
(if (-> self blur)
|
|
(set-setting! 'blur-a 'abs 0.5 0)
|
|
)
|
|
(remove-setting! 'mode-name)
|
|
(remove-setting! 'entity-name)
|
|
(remove-setting! 'interp-time)
|
|
(let ((gp-2 (current-time)))
|
|
(until (time-elapsed? gp-2 (seconds 0.5))
|
|
(suspend)
|
|
)
|
|
)
|
|
(while (not (process-release? *target*))
|
|
(suspend)
|
|
)
|
|
(remove-setting! 'interp-time)
|
|
(let ((gp-3 (current-time)))
|
|
(until (time-elapsed? gp-3 (seconds 0.5))
|
|
(suspend)
|
|
)
|
|
)
|
|
(remove-setting! 'blur-a)
|
|
(process-entity-status! self (entity-perm-status no-kill) #f)
|
|
)
|
|
)
|
|
|
|
;; definition for function external-camera-controller-init-by-other
|
|
(defbehavior external-camera-controller-init-by-other external-camera-controller ((arg0 entity) (arg1 time-frame) (arg2 symbol))
|
|
(process-entity-set! self arg0)
|
|
(set! (-> self pause-time) arg1)
|
|
(set! (-> self blur) arg2)
|
|
(go-virtual active)
|
|
)
|
|
|
|
;; definition of type level-exit
|
|
(deftype level-exit (process-drawable)
|
|
((minimap connection-minimap)
|
|
(task-counter uint32)
|
|
(ent basic)
|
|
)
|
|
(:state-methods
|
|
active
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type level-exit
|
|
(defmethod inspect ((this level-exit))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tminimap: #<connection-minimap @ #x~X>~%" (-> this minimap))
|
|
(format #t "~2Ttask-counter: ~D~%" (-> this task-counter))
|
|
(format #t "~2Tent: ~A~%" (-> this ent))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 11 of type level-exit
|
|
(defmethod init-from-entity! ((this level-exit) (arg0 entity-actor))
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(process-drawable-from-entity! this arg0)
|
|
(set! (-> this minimap) #f)
|
|
(set! (-> this task-counter) (the-as uint 0))
|
|
(set! (-> this ent) arg0)
|
|
(go (method-of-object this active))
|
|
)
|
|
|
|
;; definition for method 12 of type level-exit
|
|
(defmethod run-logic? ((this level-exit))
|
|
"Should this process be run? Checked by execute-process-tree."
|
|
#t
|
|
)
|
|
|
|
;; definition for method 10 of type level-exit
|
|
(defmethod deactivate ((this level-exit))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(if (-> this minimap)
|
|
(kill-callback (-> *minimap* engine) (-> this minimap))
|
|
)
|
|
(call-parent-method this)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (level-exit)
|
|
:virtual #t
|
|
:trans (behavior ()
|
|
(set! (-> self task-counter) (-> *game-info* task-counter))
|
|
(if *bigmap*
|
|
(bigmap-method-16 *bigmap*)
|
|
)
|
|
(let ((gp-0 (res-lump-struct (-> self entity) 'on-running structure)))
|
|
(cond
|
|
((or (not gp-0) (and gp-0 (script-eval (the-as pair gp-0))))
|
|
(if (not (-> self minimap))
|
|
(set! (-> self minimap) (add-icon! *minimap* self (the-as uint 14) (the-as int #f) (the-as vector #t) 0))
|
|
)
|
|
)
|
|
(else
|
|
(when (-> self minimap)
|
|
(logior! (-> self minimap flags) (minimap-flag fade-out))
|
|
(set! (-> self minimap) #f)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|