mirror of
https://github.com/open-goal/jak-project
synced 2026-05-31 17:32:51 -04:00
water111
637990314b
Closes #736 --------- Co-authored-by: Hat Kid <6624576+Hat-Kid@users.noreply.github.com>
476 lines
20 KiB
Common Lisp
476 lines
20 KiB
Common Lisp
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; name: fish.gc
|
|
;; name in dgo: fish
|
|
;; dgos: FOR
|
|
|
|
;; +++fish-type
|
|
(defenum fish-type
|
|
:type int32
|
|
:bitfield #f
|
|
(red 0)
|
|
(blue 1)
|
|
(green 2)
|
|
(yellow 3))
|
|
;; ---fish-type
|
|
|
|
|
|
;; DECOMP BEGINS
|
|
|
|
(defskelgroup skel-minnow minnow minnow-lod0-jg minnow-idle-ja
|
|
((minnow-lod0-mg (meters 999999)))
|
|
:bounds (static-spherem 0 0 0 1)
|
|
)
|
|
|
|
(deftype minnow (process-drawable)
|
|
()
|
|
(:state-methods
|
|
idle
|
|
)
|
|
)
|
|
|
|
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior minnow-init-by-other minnow ((arg0 object) (arg1 fish-type))
|
|
"TODO - fish type"
|
|
(set! (-> self root) (new 'process 'trsqv))
|
|
(set! (-> self root trans quad) (the-as uint128 0))
|
|
(quaternion-identity! (-> self root quat))
|
|
(vector-identity! (-> self root scale))
|
|
(initialize-skeleton
|
|
self
|
|
(the-as skeleton-group (art-group-get-by-name *level* "skel-minnow" (the-as (pointer uint32) #f)))
|
|
(the-as pair 0)
|
|
)
|
|
(setup-masks (-> self draw) 0 -1)
|
|
(cond
|
|
((= arg1 (fish-type red))
|
|
(setup-masks (-> self draw) 4 0)
|
|
)
|
|
((= arg1 (fish-type blue))
|
|
(setup-masks (-> self draw) 1 0)
|
|
)
|
|
((= arg1 (fish-type green))
|
|
(setup-masks (-> self draw) 2 0)
|
|
)
|
|
(else
|
|
(setup-masks (-> self draw) 8 0)
|
|
)
|
|
)
|
|
(go-virtual idle)
|
|
(none)
|
|
)
|
|
|
|
(defstate idle (minnow)
|
|
:virtual #t
|
|
:code (behavior ()
|
|
(until #f
|
|
(ja-no-eval :group! minnow-idle-ja :num! (seek! max 5.0) :frame-num 0.0)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek! max 5.0))
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
:post ja-post
|
|
)
|
|
|
|
(deftype fish (structure)
|
|
((pos vector :inline)
|
|
(vel vector :inline)
|
|
(border-f vector :inline)
|
|
(avoid-d vector :inline)
|
|
(wander float)
|
|
(max-speed float)
|
|
(speed float)
|
|
(handle handle)
|
|
)
|
|
)
|
|
|
|
|
|
(deftype fish-manager (process-drawable)
|
|
((fishes fish 12 :inline)
|
|
)
|
|
(:state-methods
|
|
idle
|
|
)
|
|
)
|
|
|
|
|
|
(defstate idle (fish-manager)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(format #t "training-manager received event ~s~%" message)
|
|
(format #t "event-from ~s~%" proc)
|
|
)
|
|
:code sleep-code
|
|
:post (behavior ()
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((gp-0 (-> self nav))
|
|
(s5-0 (new 'stack 'clamp-travel-vector-to-mesh-return-info))
|
|
)
|
|
(dotimes (s4-0 12)
|
|
(let* ((s1-0 (-> self fishes s4-0))
|
|
(s2-0 (-> s1-0 pos))
|
|
(s3-0 (-> s1-0 vel))
|
|
)
|
|
(new 'stack-no-clear 'vector)
|
|
(new 'stack-no-clear 'vector)
|
|
(let ((sv-544 (new 'stack-no-clear 'vector)))
|
|
(new 'stack-no-clear 'vector)
|
|
(let ((s0-0 (new-stack-vector0)))
|
|
(set! (-> sv-544 quad) (-> s3-0 quad))
|
|
(vector-rotate-around-y! sv-544 sv-544 (rand-vu-float-range 0.0 65536.0))
|
|
(vector-float*! sv-544 sv-544 0.5)
|
|
(cond
|
|
((and *target* (< (-> (target-pos 0) y) 0.0))
|
|
(let ((sv-512 (new 'stack-no-clear 'vector)))
|
|
(let ((sv-496 s2-0)
|
|
(v0-4 (target-pos 0))
|
|
)
|
|
(.lvf vf4 (&-> sv-496 quad))
|
|
(.lvf vf5 (&-> v0-4 quad))
|
|
)
|
|
(.mov.vf.w vf6 vf0)
|
|
(.sub.vf.xyz vf6 vf4 vf5)
|
|
(.svf (&-> sv-512 quad) vf6)
|
|
(let* ((v1-21 sv-512)
|
|
(f0-5 (+ (* (-> v1-21 x) (-> v1-21 x)) (* (-> v1-21 z) (-> v1-21 z))))
|
|
)
|
|
(cond
|
|
((< f0-5 (square 16384.0))
|
|
(set! (-> s1-0 max-speed) 40960.0)
|
|
(vector-normalize! sv-512 (* 4096.0 (/ 4096.0 f0-5)))
|
|
(let ((a0-9 (-> s1-0 avoid-d)))
|
|
(let ((v1-28 (-> s1-0 avoid-d)))
|
|
(let ((a1-6 100000.0))
|
|
(.mov vf7 a1-6)
|
|
)
|
|
(.lvf vf5 (&-> sv-512 quad))
|
|
(.lvf vf4 (&-> v1-28 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-9 quad) vf6)
|
|
)
|
|
#t
|
|
)
|
|
((< f0-5 (square 81920.0))
|
|
(set! (-> s1-0 max-speed) 16384.0)
|
|
)
|
|
(else
|
|
(set! (-> s1-0 max-speed) 4096.0)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> s1-0 max-speed) 4096.0)
|
|
)
|
|
)
|
|
(let ((sv-528 (new 'stack-no-clear 'vector)))
|
|
(let ((v1-39 s2-0))
|
|
(let ((a0-10 sv-544))
|
|
(let ((a1-9 -0.1))
|
|
(.mov vf7 a1-9)
|
|
)
|
|
(.lvf vf5 (&-> a0-10 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-39 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> sv-528 quad) vf6)
|
|
(let ((v1-41 gp-0)
|
|
(a0-11 sv-528)
|
|
(a1-10 (new 'stack-no-clear 'nav-find-poly-parms))
|
|
)
|
|
(vector-! (-> a1-10 point) a0-11 (-> v1-41 state mesh bounds))
|
|
(set! (-> a1-10 y-threshold) (-> v1-41 nearest-y-threshold))
|
|
(set! (-> a1-10 ignore) (the-as uint 2))
|
|
(let ((sv-720 (find-poly-containing-point-local (-> v1-41 state mesh) a1-10)))
|
|
(new 'stack-no-clear 'vector)
|
|
(when sv-720
|
|
(clamp-vector-to-mesh-no-gaps gp-0 sv-528 sv-720 sv-544 s5-0)
|
|
(cond
|
|
((-> s5-0 found-boundary)
|
|
(let ((a1-12 (-> s1-0 border-f)))
|
|
(let ((v1-48 (-> s1-0 border-f)))
|
|
(let ((a0-15 (-> s5-0 boundary-normal)))
|
|
(let ((a2-5 -10000.0))
|
|
(.mov vf7 a2-5)
|
|
)
|
|
(.lvf vf5 (&-> a0-15 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-48 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a1-12 quad) vf6)
|
|
)
|
|
)
|
|
(else
|
|
(let ((sv-608 (vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 1.0)))
|
|
(let ((a1-14 sv-608))
|
|
(let ((v1-49 s2-0))
|
|
(let ((a0-17 sv-608))
|
|
(let ((a2-8 4096.0))
|
|
(.mov vf7 a2-8)
|
|
)
|
|
(.lvf vf5 (&-> a0-17 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-49 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a1-14 quad) vf6)
|
|
)
|
|
(let ((sv-592 sv-608))
|
|
(let ((sv-560 sv-608))
|
|
(let ((sv-576 (new 'stack-no-clear 'vector)))
|
|
(set! (-> sv-576 x) (cos (-> s1-0 wander)))
|
|
(set! (-> sv-576 y) 0.0)
|
|
(set! (-> sv-576 z) (sin (-> s1-0 wander)))
|
|
(set! (-> sv-576 w) 1.0)
|
|
(let ((v1-59 3276.8))
|
|
(.mov vf7 v1-59)
|
|
)
|
|
(.lvf vf5 (&-> sv-576 quad))
|
|
)
|
|
(.lvf vf4 (&-> sv-560 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> sv-592 quad) vf6)
|
|
)
|
|
(vector-! sv-608 sv-608 s2-0)
|
|
(let ((a0-21 s0-0))
|
|
(let ((v1-64 s0-0))
|
|
(let ((a1-18 10.0))
|
|
(.mov vf7 a1-18)
|
|
)
|
|
(.lvf vf5 (&-> sv-608 quad))
|
|
(.lvf vf4 (&-> v1-64 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-21 quad) vf6)
|
|
)
|
|
)
|
|
(+! (-> s1-0 wander) (rand-vu-float-range -1820.4445 1820.4445))
|
|
)
|
|
)
|
|
)
|
|
(let ((sv-624 0)
|
|
(sv-688 (new 'stack-no-clear 'vector))
|
|
)
|
|
(set! (-> sv-688 quad) (the-as uint128 0))
|
|
(let ((sv-704 (new 'stack-no-clear 'vector)))
|
|
(set! (-> sv-704 quad) (the-as uint128 0))
|
|
(let ((sv-640 0))
|
|
(while (< sv-640 12)
|
|
(when (!= sv-640 s4-0)
|
|
(let ((sv-656 (-> self fishes sv-640))
|
|
(sv-672 (new 'stack-no-clear 'vector))
|
|
)
|
|
(let ((v1-78 s2-0)
|
|
(a0-25 (-> sv-656 pos))
|
|
)
|
|
(.lvf vf4 (&-> v1-78 quad))
|
|
(.lvf vf5 (&-> a0-25 quad))
|
|
)
|
|
(.mov.vf.w vf6 vf0)
|
|
(.sub.vf.xyz vf6 vf4 vf5)
|
|
(.svf (&-> sv-672 quad) vf6)
|
|
(let* ((v1-80 sv-672)
|
|
(f0-29 (+ (* (-> v1-80 x) (-> v1-80 x)) (* (-> v1-80 z) (-> v1-80 z))))
|
|
)
|
|
(when (< f0-29 (square 4096.0))
|
|
(vector-normalize! sv-672 (* 4096.0 (/ 4096.0 f0-29)))
|
|
(let ((a0-27 s0-0))
|
|
(let ((v1-87 s0-0))
|
|
(let ((a1-24 100.0))
|
|
(.mov vf7 a1-24)
|
|
)
|
|
(.lvf vf5 (&-> sv-672 quad))
|
|
(.lvf vf4 (&-> v1-87 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-27 quad) vf6)
|
|
)
|
|
(vector+! sv-688 sv-688 (-> sv-656 pos))
|
|
(vector+! sv-704 sv-704 (-> sv-656 vel))
|
|
(+! sv-624 1)
|
|
sv-624
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(+! sv-640 1)
|
|
)
|
|
)
|
|
(when (nonzero? sv-624)
|
|
(vector-float*! sv-688 sv-688 (/ 1.0 (the float sv-624)))
|
|
(vector-! sv-688 sv-688 s2-0)
|
|
(let ((v1-104 sv-688))
|
|
(vector-normalize!
|
|
sv-688
|
|
(* 4096.0 (/ 4096.0 (+ (* (-> v1-104 x) (-> v1-104 x)) (* (-> v1-104 z) (-> v1-104 z)))))
|
|
)
|
|
)
|
|
(let ((a0-36 s0-0))
|
|
(let ((v1-106 s0-0))
|
|
(let ((a1-36 100.0))
|
|
(.mov vf7 a1-36)
|
|
)
|
|
(.lvf vf5 (&-> sv-688 quad))
|
|
(.lvf vf4 (&-> v1-106 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-36 quad) vf6)
|
|
)
|
|
(vector-float*! sv-704 sv-704 (/ 1.0 (the float sv-624)))
|
|
(vector-! sv-704 sv-704 s3-0)
|
|
(let ((a0-39 s0-0))
|
|
(let ((v1-110 s0-0))
|
|
(let ((a1-43 5.0))
|
|
(.mov vf7 a1-43)
|
|
)
|
|
(.lvf vf5 (&-> sv-704 quad))
|
|
(.lvf vf4 (&-> v1-110 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-39 quad) vf6)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(vector-float*! (-> s1-0 avoid-d) (-> s1-0 avoid-d) 0.95)
|
|
(vector-float*! (-> s1-0 border-f) (-> s1-0 border-f) 0.99)
|
|
(vector+! s0-0 s0-0 (-> s1-0 border-f))
|
|
(vector+! s0-0 s0-0 (-> s1-0 avoid-d))
|
|
(set! (-> s0-0 y) 0.0)
|
|
(let ((a0-44 s3-0))
|
|
(let ((v1-117 s3-0))
|
|
(let ((a1-52 (seconds-per-frame)))
|
|
(.mov vf7 a1-52)
|
|
)
|
|
(.lvf vf5 (&-> s0-0 quad))
|
|
(.lvf vf4 (&-> v1-117 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a0-44 quad) vf6)
|
|
)
|
|
(vector-float*! s3-0 s3-0 0.8)
|
|
(let ((a1-54 s2-0))
|
|
(let ((v1-120 s2-0))
|
|
(let ((a0-46 s3-0))
|
|
(let ((a2-10 (seconds-per-frame)))
|
|
(.mov vf7 a2-10)
|
|
)
|
|
(.lvf vf5 (&-> a0-46 quad))
|
|
)
|
|
(.lvf vf4 (&-> v1-120 quad))
|
|
)
|
|
(.add.x.vf.w vf6 vf0 vf0)
|
|
(.mul.x.vf.xyz acc vf5 vf7)
|
|
(.add.mul.w.vf.xyz vf6 vf4 vf0 acc)
|
|
(.svf (&-> a1-54 quad) vf6)
|
|
)
|
|
(cloest-point-on-mesh (-> self nav) s2-0 s2-0 sv-720)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> s2-0 y) -1638.4)
|
|
(let ((v1-124 (handle->process (-> s1-0 handle))))
|
|
(when v1-124
|
|
(set! (-> (the-as process-drawable v1-124) root trans quad) (-> s2-0 quad))
|
|
(forward-up->quaternion
|
|
(-> (the-as process-drawable v1-124) root quat)
|
|
(vector-normalize-copy! (new 'stack-no-clear 'vector) s3-0 1.0)
|
|
*up-vector*
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod init-from-entity! ((this fish-manager) (arg0 entity-actor))
|
|
"Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
|
|
This commonly includes things such as:
|
|
- stack size
|
|
- collision information
|
|
- loading the skeleton group / bones
|
|
- sounds"
|
|
(let ((s4-0 (new 'process 'collide-shape-moving this (collide-list-enum usually-hit-by-player))))
|
|
(set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
|
|
(set! (-> s4-0 reaction) cshape-reaction-default)
|
|
(set! (-> s4-0 no-reaction)
|
|
(the-as (function collide-shape-moving collide-query vector vector object) nothing)
|
|
)
|
|
(let ((v1-6 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
|
|
(set-vector! (-> v1-6 local-sphere) 0.0 0.0 0.0 9216.0)
|
|
(set! (-> s4-0 total-prims) (the-as uint 1))
|
|
(set! (-> s4-0 root-prim) v1-6)
|
|
)
|
|
(set! (-> s4-0 nav-radius) 4096.0)
|
|
(let ((v1-8 (-> s4-0 root-prim)))
|
|
(set! (-> s4-0 backup-collide-as) (-> v1-8 prim-core collide-as))
|
|
(set! (-> s4-0 backup-collide-with) (-> v1-8 prim-core collide-with))
|
|
)
|
|
(set! (-> this root) s4-0)
|
|
)
|
|
(process-drawable-from-entity! this arg0)
|
|
(get-nav-control this (the-as nav-mesh #f))
|
|
(let ((s5-1 (rand-vu-int-count 4)))
|
|
(dotimes (s4-1 12)
|
|
(let ((s3-0 (-> this fishes s4-1)))
|
|
(let ((f30-1 (* 182.04445 (the float (rand-vu-int-count 360)))))
|
|
(set! (-> s3-0 pos quad) (-> this root trans quad))
|
|
(+! (-> s3-0 pos x) (rand-vu-float-range 409.6 4096.0))
|
|
(+! (-> s3-0 pos z) (rand-vu-float-range 409.6 4096.0))
|
|
(set! (-> s3-0 wander) (rand-vu-float-range 0.0 65536.0))
|
|
(set-vector! (-> s3-0 vel) (cos f30-1) 0.0 (sin f30-1) 1.0)
|
|
)
|
|
(set! (-> s3-0 border-f quad) (the-as uint128 0))
|
|
(set! (-> s3-0 avoid-d quad) (the-as uint128 0))
|
|
(set! (-> s3-0 max-speed) 16384.0)
|
|
(set! (-> s3-0 handle) (ppointer->handle (process-spawn minnow this s5-1 :to this)))
|
|
)
|
|
)
|
|
)
|
|
(go (method-of-object this idle))
|
|
(none)
|
|
)
|