mirror of
https://github.com/open-goal/jak-project
synced 2026-06-07 12:07:48 -04:00
Tyler Wilding
1211 lines
38 KiB
Common Lisp
Vendored
Generated
1211 lines
38 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type under-warp
|
|
(deftype under-warp (process-drawable)
|
|
((interp float)
|
|
)
|
|
(:state-methods
|
|
idle
|
|
die-fast
|
|
)
|
|
(:methods
|
|
(under-warp-method-22 (_type_) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type under-warp
|
|
(defmethod inspect ((this under-warp))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tinterp: ~f~%" (-> this interp))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defskelgroup skel-under-warp under-warp under-warp-lod0-jg under-warp-idle-ja
|
|
((under-warp-lod0-mg (meters 999999)))
|
|
:bounds (static-spherem 0 0 0 8)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (under-warp)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('die-fast)
|
|
(set-under-fog-interp! 0.0)
|
|
(go-virtual die-fast)
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(until #f
|
|
(let ((v1-2 (-> self skel root-channel 1))
|
|
(f0-0 (-> self interp))
|
|
)
|
|
(set! (-> v1-2 frame-interp 1) f0-0)
|
|
(set! (-> v1-2 frame-interp 0) f0-0)
|
|
)
|
|
(ja :num! (loop!))
|
|
(ja :chan 1 :num! (chan 0))
|
|
(ja-no-eval :group! under-warp-idle-ja :num! (seek!) :frame-num 0.0)
|
|
(until (ja-done? 0)
|
|
(suspend)
|
|
(ja :num! (seek!))
|
|
)
|
|
)
|
|
#f
|
|
)
|
|
:post (behavior ()
|
|
(under-warp-method-22 self)
|
|
(ja-post)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate die-fast (under-warp)
|
|
:virtual #t
|
|
:code nothing
|
|
)
|
|
|
|
;; definition for method 22 of type under-warp
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod under-warp-method-22 ((this under-warp))
|
|
(rlet ((acc :class vf)
|
|
(vf0 :class vf)
|
|
(vf4 :class vf)
|
|
(vf5 :class vf)
|
|
(vf6 :class vf)
|
|
(vf7 :class vf)
|
|
)
|
|
(init-vf0-vector)
|
|
(let ((s3-0 (camera-matrix))
|
|
(s5-0 (new 'stack-no-clear 'vector))
|
|
(gp-0 (new 'stack-no-clear 'vector))
|
|
(f30-0 4096.0)
|
|
)
|
|
(let ((f0-4 (* 0.00013563369 (tan (* 0.5 (-> *math-camera* fov))) f30-0)))
|
|
(set-vector! (-> this root scale) f0-4 f0-4 f0-4 1.0)
|
|
)
|
|
(set! (-> gp-0 quad) (-> (camera-pos) quad))
|
|
(vector-normalize-copy! s5-0 (-> s3-0 vector 2) 1.0)
|
|
(matrix->quaternion (-> this root quat) s3-0)
|
|
(let ((v1-10 (-> this root trans)))
|
|
(let ((a0-5 f30-0))
|
|
(.mov vf7 a0-5)
|
|
)
|
|
(.lvf vf5 (&-> s5-0 quad))
|
|
(.lvf vf4 (&-> gp-0 quad))
|
|
(.add.x.vf vf6 vf0 vf0 :mask #b1000)
|
|
(.mul.x.vf acc vf5 vf7 :mask #b111)
|
|
(.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111)
|
|
(.svf (&-> v1-10 quad) vf6)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for function under-warp-init-by-other
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior under-warp-init-by-other under-warp ((arg0 vector) (arg1 quaternion) (arg2 entity-actor))
|
|
(set! (-> self level) (the-as level arg2))
|
|
(set! (-> self root) (new 'process 'trsqv))
|
|
(set! (-> self root trans quad) (-> arg0 quad))
|
|
(quaternion-copy! (-> self root quat) arg1)
|
|
(initialize-skeleton
|
|
self
|
|
(the-as skeleton-group (art-group-get-by-name *level* "skel-under-warp" (the-as (pointer uint32) #f)))
|
|
(the-as pair 0)
|
|
)
|
|
(set! (-> self interp) 0.5)
|
|
(ja-channel-push! 2 (seconds 0.3))
|
|
(ja-no-eval :group! under-warp-idle-ja :num! (loop!))
|
|
(let ((gp-2 (-> self skel root-channel 1)))
|
|
(let ((f0-2 (-> self interp)))
|
|
(set! (-> gp-2 frame-interp 1) f0-2)
|
|
(set! (-> gp-2 frame-interp 0) f0-2)
|
|
)
|
|
(joint-control-channel-group! gp-2 (the-as art-joint-anim under-warp-none-ja) num-func-identity)
|
|
(set! (-> gp-2 frame-num) 0.0)
|
|
)
|
|
(logior! (-> self skel status) (joint-control-status blend-shape))
|
|
(go-virtual idle)
|
|
(none)
|
|
)
|
|
|
|
;; definition of type underb-master
|
|
(deftype underb-master (process)
|
|
((warp-handle handle)
|
|
(tank-handle handle)
|
|
(underwater-time time-frame)
|
|
(last-air-beep-time time-frame)
|
|
(ambient-sound-id sound-id)
|
|
(air-supply float)
|
|
(air-charge-up? symbol)
|
|
(under-water-pitch-mod float)
|
|
(big-room-entered symbol)
|
|
(big-room-timer time-frame)
|
|
(under-plat-player-on symbol)
|
|
(under-plat-is-up symbol)
|
|
)
|
|
(:state-methods
|
|
idle
|
|
big-room-player-under
|
|
big-room-player-plat
|
|
underb-master-state-17
|
|
big-room-player-above
|
|
big-room-player-falling
|
|
big-room-player-exiting
|
|
big-room-player-done
|
|
)
|
|
(:methods
|
|
(under-warp-check (_type_) symbol)
|
|
(spawn-air-tank-hud (_type_ symbol) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type underb-master
|
|
(defmethod inspect ((this underb-master))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Twarp-handle: ~D~%" (-> this warp-handle))
|
|
(format #t "~2Ttank-handle: ~D~%" (-> this tank-handle))
|
|
(format #t "~2Tunderwater-time: ~D~%" (-> this underwater-time))
|
|
(format #t "~2Tlast-air-beep-time: ~D~%" (-> this last-air-beep-time))
|
|
(format #t "~2Tambient-sound-id: ~D~%" (-> this ambient-sound-id))
|
|
(format #t "~2Tair-supply: ~f~%" (-> this air-supply))
|
|
(format #t "~2Tair-charge-up?: ~A~%" (-> this air-charge-up?))
|
|
(format #t "~2Tunder-water-pitch-mod: ~f~%" (-> this under-water-pitch-mod))
|
|
(format #t "~2Tbig-room-entered: ~A~%" (-> this big-room-entered))
|
|
(format #t "~2Tbig-room-timer: ~D~%" (-> this big-room-timer))
|
|
(format #t "~2Tunder-plat-player-on: ~A~%" (-> this under-plat-player-on))
|
|
(format #t "~2Tunder-plat-is-up: ~A~%" (-> this under-plat-is-up))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for symbol *underb-master*, type (pointer underb-master)
|
|
(define *underb-master* (the-as (pointer underb-master) #f))
|
|
|
|
;; definition for method 10 of type underb-master
|
|
(defmethod deactivate ((this underb-master))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(sound-stop (-> this ambient-sound-id))
|
|
(send-event (handle->process (-> this warp-handle)) 'die-fast)
|
|
(set! *underb-master* (the-as (pointer underb-master) #f))
|
|
((method-of-type process deactivate) this)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function underb-master-event-handler
|
|
;; INFO: Used lq/sq
|
|
;; WARN: disable def twice: 121. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare.
|
|
(defbehavior underb-master-event-handler underb-master ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(local-vars (v0-0 object))
|
|
(case arg2
|
|
(('query)
|
|
(case (-> arg3 param 0)
|
|
(('mech)
|
|
(not (-> *setting-control* user-current pilot-exit))
|
|
)
|
|
(('bubbler)
|
|
(and (handle->process (-> self warp-handle))
|
|
(or (and (-> self next-state) (= (-> self next-state name) 'idle)) (not (under-warp-check self)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('request)
|
|
(case (-> arg3 param 0)
|
|
(('mech)
|
|
(cond
|
|
((-> arg3 param 1)
|
|
(cond
|
|
((-> *setting-control* user-current pilot-exit)
|
|
(let ((a1-2 *target*))
|
|
(when (and a1-2 (focus-test? a1-2 mech))
|
|
(set-setting! 'pilot-exit #f 0.0 0)
|
|
(apply-settings *setting-control*)
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
#t
|
|
)
|
|
)
|
|
)
|
|
((-> *setting-control* user-current pilot-exit)
|
|
#t
|
|
)
|
|
(else
|
|
(remove-setting! 'pilot-exit)
|
|
(apply-settings *setting-control*)
|
|
(not (-> *setting-control* user-current pilot-exit))
|
|
)
|
|
)
|
|
)
|
|
(('under-warp)
|
|
(cond
|
|
((-> arg3 param 1)
|
|
(set-under-fog-interp! 1.0)
|
|
(when (not (handle->process (-> self warp-handle)))
|
|
(let ((s2-0 (camera-matrix))
|
|
(s3-0 (new 'stack-no-clear 'vector))
|
|
(gp-0 (new 'stack-no-clear 'vector))
|
|
(s5-0 (new 'stack-no-clear 'quaternion))
|
|
)
|
|
(set! (-> gp-0 quad) (-> (camera-pos) quad))
|
|
(vector-normalize-copy! s3-0 (-> s2-0 vector 2) 1.0)
|
|
(matrix->quaternion s5-0 s2-0)
|
|
(set! (-> self warp-handle)
|
|
(ppointer->handle (process-spawn under-warp gp-0 s5-0 (-> self level) :to *display-pool*))
|
|
)
|
|
)
|
|
(set! v0-0 (sound-play "mech-under-amb"))
|
|
(set! (-> self ambient-sound-id) (the-as sound-id v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
(else
|
|
(set-under-fog-interp! 0.0)
|
|
(let ((a0-41 (handle->process (-> self warp-handle))))
|
|
(when a0-41
|
|
(send-event a0-41 'die-fast)
|
|
(set! (-> self warp-handle) (the-as handle #f))
|
|
(sound-stop (-> self ambient-sound-id))
|
|
(set! (-> self ambient-sound-id) (new 'static 'sound-id))
|
|
0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('big-room)
|
|
(case (-> arg3 param 1)
|
|
(('status)
|
|
(cond
|
|
((-> arg3 param 2)
|
|
(set! v0-0 #t)
|
|
(set! (-> self big-room-entered) (the-as symbol v0-0))
|
|
v0-0
|
|
)
|
|
(else
|
|
(set! (-> self big-room-entered) #f)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
(('under-plat)
|
|
(case (-> arg3 param 2)
|
|
(('player)
|
|
(cond
|
|
((-> arg3 param 3)
|
|
(set! v0-0 #t)
|
|
(set! (-> self under-plat-player-on) (the-as symbol v0-0))
|
|
v0-0
|
|
)
|
|
(else
|
|
(set! (-> self under-plat-player-on) #f)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
(('up)
|
|
(cond
|
|
((-> arg3 param 3)
|
|
(set! v0-0 #t)
|
|
(set! (-> self under-plat-is-up) (the-as symbol v0-0))
|
|
v0-0
|
|
)
|
|
(else
|
|
(set! (-> self under-plat-is-up) #f)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('bubbler)
|
|
(set! v0-0 #t)
|
|
(set! (-> self air-charge-up?) (the-as symbol v0-0))
|
|
v0-0
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 22 of type underb-master
|
|
(defmethod under-warp-check ((this underb-master))
|
|
"Used to check whether the underwater warp effect should be drawn."
|
|
(let ((target-pos (target-pos 0))
|
|
(tpos-offset (new 'stack-no-clear 'vector))
|
|
(a1-0 (new 'stack-no-clear 'vector))
|
|
(v1-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(set! (-> tpos-offset x) (+ -827392.0 (-> target-pos x)))
|
|
(set! (-> tpos-offset y) 0.0)
|
|
(set! (-> tpos-offset z) (+ -7671808.0 (-> target-pos z)))
|
|
(set! (-> a1-0 x) -94208.0)
|
|
(set! (-> a1-0 y) 0.0)
|
|
(set! (-> a1-0 z) -143360.0)
|
|
(vector-cross! v1-0 tpos-offset a1-0)
|
|
(< (-> v1-0 y) 0.0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 23 of type underb-master
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod spawn-air-tank-hud ((this underb-master) (arg0 symbol))
|
|
"Spawns or hides the air tank HUD bar."
|
|
(cond
|
|
(arg0
|
|
(if (not (handle->process (-> this tank-handle)))
|
|
(set! (-> this tank-handle)
|
|
(ppointer->handle (process-spawn hud-mech-air-tank :init hud-init-by-other :to this))
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(send-event (handle->process (-> this tank-handle)) 'hide-and-die)
|
|
(set! (-> this tank-handle) (the-as handle #f))
|
|
)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function underb-master-post
|
|
(defbehavior underb-master-post underb-master ()
|
|
#t
|
|
(let ((gp-0 *target*))
|
|
(let ((f30-0 0.0))
|
|
(when (and gp-0 (not (-> *setting-control* user-current pilot-exit)))
|
|
(let ((s5-0 (new 'stack-no-clear 'water-info)))
|
|
(water-info-init! (-> gp-0 control) s5-0 (collide-action solid semi-solid))
|
|
(let ((v1-7 (-> s5-0 flags)))
|
|
(if (logtest? (water-flags touch-water) v1-7)
|
|
(set! f30-0 (lerp-scale 0.0 1.0 (- (-> gp-0 control trans y) (-> s5-0 trans y)) -4096.0 -20480.0))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(when (!= f30-0 (-> self under-water-pitch-mod))
|
|
(set! (-> self under-water-pitch-mod) f30-0)
|
|
(if (= f30-0 0.0)
|
|
(remove-setting! 'under-water-pitch-mod)
|
|
(set-setting! 'under-water-pitch-mod 'abs f30-0 0)
|
|
)
|
|
)
|
|
)
|
|
(if (or (not gp-0) (not (logtest? (-> gp-0 water flags) (water-flags under-water))))
|
|
(set! (-> self air-charge-up?) #t)
|
|
(set-time! (-> self underwater-time))
|
|
)
|
|
)
|
|
(cond
|
|
((-> self air-charge-up?)
|
|
(set! (-> self air-supply) (seek-with-smooth (-> self air-supply) 1.0 (* 2.0 (seconds-per-frame)) 0.125 0.01))
|
|
(when (= (-> self air-supply) 1.0)
|
|
(set! (-> self air-charge-up?) #f)
|
|
(set! (-> self air-supply) 1.01)
|
|
(set! (-> self last-air-beep-time) 0)
|
|
0
|
|
)
|
|
)
|
|
(else
|
|
(seek! (-> self air-supply) 0.0 (* 0.04 (seconds-per-frame)))
|
|
(cond
|
|
((= (-> self air-supply) 0.0)
|
|
(send-event *target* 'attack #f (static-attack-info ((id (new-attack-id)) (mode 'air))))
|
|
)
|
|
(else
|
|
(when (>= 0.4 (-> self air-supply))
|
|
(let ((v1-39 (the int (lerp-scale 90.0 300.0 (-> self air-supply) 0.0 0.4))))
|
|
(when (time-elapsed? (-> self last-air-beep-time) v1-39)
|
|
(set-time! (-> self last-air-beep-time))
|
|
(sound-play "oxygen-warning")
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> *game-info* air-supply) (fmin 1.0 (-> self air-supply)))
|
|
(if (or (and *target* (not (logtest? (focus-status mech) (-> *target* focus-status))))
|
|
(and (>= (-> self air-supply) 1.0) (time-elapsed? (-> self underwater-time) (seconds 3)))
|
|
)
|
|
(spawn-air-tank-hud self #f)
|
|
(spawn-air-tank-hud self #t)
|
|
)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate idle (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
0
|
|
)
|
|
:trans (behavior ()
|
|
(if (-> self big-room-entered)
|
|
(go-virtual big-room-player-under)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-under (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
0
|
|
)
|
|
:trans (behavior ()
|
|
(if (-> self under-plat-player-on)
|
|
(go-virtual big-room-player-plat)
|
|
)
|
|
(if (not (-> self big-room-entered))
|
|
(go-virtual idle)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-plat (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
(set-setting! 'entity-name "camera-239" 0.0 0)
|
|
(send-event (ppointer->process *underb-master*) 'request 'under-warp #f)
|
|
)
|
|
:exit (behavior ()
|
|
(remove-setting! 'entity-name)
|
|
)
|
|
:trans (behavior ()
|
|
(let ((gp-0 (target-pos 0)))
|
|
(if (or (and (-> self under-plat-is-up) (-> self under-plat-player-on)) (< -245760.0 (-> gp-0 y)))
|
|
(go-virtual big-room-player-above)
|
|
)
|
|
(if (and (not (-> self under-plat-player-on)) (< (-> gp-0 y) -245760.0))
|
|
(go-virtual big-room-player-falling)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-above (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
(persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 600.0 0)
|
|
(remove-setting! 'mode-name)
|
|
)
|
|
:trans (behavior ()
|
|
(if (< (-> (target-pos 0) y) -245760.0)
|
|
(go-virtual big-room-player-falling)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-falling (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
(set-setting! 'mode-name 'cam-endlessfall 0.0 0)
|
|
)
|
|
:exit (behavior ()
|
|
(send-event (ppointer->process *underb-master*) 'request 'under-warp #t)
|
|
(persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 0.0 0)
|
|
(remove-setting! 'mode-name)
|
|
)
|
|
:trans (behavior ()
|
|
(cond
|
|
((not *target*)
|
|
(go-virtual idle)
|
|
)
|
|
((under-warp-check self)
|
|
(if (< (-> (target-pos 0) y) -258048.0)
|
|
(go-virtual big-room-player-exiting)
|
|
)
|
|
)
|
|
(else
|
|
(if (< (-> (target-pos 0) y) -278528.0)
|
|
(go-virtual big-room-player-under)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-exiting (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
(persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 0.0 0)
|
|
(set-setting! 'entity-name "camera-244" 0.0 0)
|
|
(set-time! (-> self big-room-timer))
|
|
(send-event (ppointer->process *underb-master*) 'request 'under-warp #t)
|
|
)
|
|
:exit (behavior ()
|
|
(persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 600.0 0)
|
|
(remove-setting! 'entity-name)
|
|
)
|
|
:trans (behavior ()
|
|
(if (time-elapsed? (-> self big-room-timer) (seconds 1))
|
|
(go-virtual idle)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate big-room-player-done (underb-master)
|
|
:virtual #t
|
|
:event underb-master-event-handler
|
|
:enter (behavior ()
|
|
(go-virtual idle)
|
|
)
|
|
:code sleep-code
|
|
:post underb-master-post
|
|
)
|
|
|
|
;; definition for function underb-master-init-by-other
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defbehavior underb-master-init-by-other underb-master ((arg0 level))
|
|
(set! *underb-master* (the-as (pointer underb-master) (process->ppointer self)))
|
|
(set! (-> self warp-handle) (the-as handle #f))
|
|
(set! (-> self tank-handle) (the-as handle #f))
|
|
(set! (-> self level) arg0)
|
|
(set! (-> self air-supply) 1.0)
|
|
(set! (-> self air-charge-up?) #f)
|
|
(set! (-> self ambient-sound-id) (new 'static 'sound-id))
|
|
(set! (-> self big-room-entered) #f)
|
|
(set! (-> self under-plat-player-on) #f)
|
|
(set! (-> self under-plat-is-up) #f)
|
|
(go-virtual idle)
|
|
(none)
|
|
)
|
|
|
|
;; definition for function underb-login
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun underb-login ((arg0 level))
|
|
(set! *nav-network* (new 'loading-level 'nav-network))
|
|
(nav-network-method-9 *nav-network*)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function underb-deactivate
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun underb-deactivate ((arg0 level))
|
|
(set! *nav-network* (the-as nav-network 0))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function underb-activate
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defun underb-activate ((arg0 level))
|
|
(nav-network-method-10 *nav-network* arg0 *under-adjacency*)
|
|
(let ((v1-3 (process-spawn underb-master arg0 :to *entity-pool*)))
|
|
(if v1-3
|
|
(set! (-> v1-3 0 level) arg0)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition of type under-locking
|
|
(deftype under-locking (process-drawable)
|
|
((id int8)
|
|
(up-y float)
|
|
(down-y float)
|
|
(mode under-locking-mode)
|
|
(which-reminder? symbol)
|
|
(spooled-sound-id sound-id)
|
|
(draining-part sparticle-launch-control)
|
|
(actor-group (pointer actor-group))
|
|
(spooled-sound-delay int32)
|
|
(last-reminder-time time-frame :offset 256)
|
|
)
|
|
(:state-methods
|
|
startup
|
|
active
|
|
filling
|
|
draining
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type under-locking
|
|
(defmethod inspect ((this under-locking))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(format #t "~2Tid: ~D~%" (-> this id))
|
|
(format #t "~2Tup-y: ~f~%" (-> this up-y))
|
|
(format #t "~2Tdown-y: ~f~%" (-> this down-y))
|
|
(format #t "~2Tmode: ~D~%" (-> this mode))
|
|
(format #t "~2Twhich-reminder?: ~A~%" (-> this which-reminder?))
|
|
(format #t "~2Tspooled-sound-id: ~D~%" (-> this spooled-sound-id))
|
|
(format #t "~2Tdraining-part: ~A~%" (-> this draining-part))
|
|
(format #t "~2Tactor-group: #x~X~%" (-> this actor-group))
|
|
(format #t "~2Tspooled-sound-delay: ~D~%" (-> this spooled-sound-delay))
|
|
(format #t "~2Tstate-time: ~D~%" (-> this state-time))
|
|
(format #t "~2Tlast-reminder-time: ~D~%" (-> this last-reminder-time))
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for method 7 of type under-locking
|
|
;; WARN: Return type mismatch process-drawable vs under-locking.
|
|
(defmethod relocate ((this under-locking) (offset int))
|
|
(if (nonzero? (-> this draining-part))
|
|
(&+! (-> this draining-part) offset)
|
|
)
|
|
(the-as under-locking ((method-of-type process-drawable relocate) this offset))
|
|
)
|
|
|
|
;; definition for method 10 of type under-locking
|
|
(defmethod deactivate ((this under-locking))
|
|
"Make a process dead, clean it up, remove it from the active pool, and return to dead pool."
|
|
(if (nonzero? (-> this draining-part))
|
|
(kill-and-free-particles (-> this draining-part))
|
|
)
|
|
((method-of-type process-drawable deactivate) this)
|
|
(none)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate startup (under-locking)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('test)
|
|
#f
|
|
)
|
|
)
|
|
)
|
|
:enter (behavior ()
|
|
(set-time! (-> self state-time))
|
|
)
|
|
:trans (behavior ()
|
|
(let ((v1-0 (-> self actor-group)))
|
|
(cond
|
|
((and v1-0
|
|
(let ((a0-2 (-> v1-0 0 data 0 actor)))
|
|
(if a0-2
|
|
(-> a0-2 extra process)
|
|
)
|
|
)
|
|
(let ((a0-5 (-> v1-0 0 data 1 actor)))
|
|
(if a0-5
|
|
(-> a0-5 extra process)
|
|
)
|
|
)
|
|
(let ((a1-2 (-> v1-0 0 data 2 actor)))
|
|
(if a1-2
|
|
(-> a1-2 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when (time-elapsed? (-> self state-time) (seconds 0.1))
|
|
(let ((a0-13 (-> v1-0 0 data 0 actor)))
|
|
(if a0-13
|
|
(-> a0-13 extra process)
|
|
)
|
|
)
|
|
(let ((v1-2 (-> v1-0 0 data 1 actor)))
|
|
(if v1-2
|
|
(-> v1-2 extra process)
|
|
)
|
|
)
|
|
(let ((a1-6 *target*))
|
|
(cond
|
|
((and a1-6 (focus-test? a1-6 mech))
|
|
(set! (-> self mode) (under-locking-mode want-drain))
|
|
(let ((a1-8 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-8 from) (process->ppointer self))
|
|
(set! (-> a1-8 num-params) 1)
|
|
(set! (-> a1-8 message) 'move-to-y)
|
|
(set! (-> a1-8 param 0) (the-as uint (-> self up-y)))
|
|
(let ((t9-0 send-event-function)
|
|
(v1-13 (-> self actor-group 0 data 2 actor))
|
|
)
|
|
(t9-0
|
|
(if v1-13
|
|
(-> v1-13 extra process)
|
|
)
|
|
a1-8
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(set! (-> self mode) (under-locking-mode want-mech))
|
|
(let ((a1-9 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-9 from) (process->ppointer self))
|
|
(set! (-> a1-9 num-params) 1)
|
|
(set! (-> a1-9 message) 'move-to-y)
|
|
(set! (-> a1-9 param 0) (the-as uint (-> self down-y)))
|
|
(let ((t9-1 send-event-function)
|
|
(v1-22 (-> self actor-group 0 data 2 actor))
|
|
)
|
|
(t9-1
|
|
(if v1-22
|
|
(-> v1-22 extra process)
|
|
)
|
|
a1-9
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(go-virtual active)
|
|
)
|
|
)
|
|
(else
|
|
(set-time! (-> self state-time))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate active (under-locking)
|
|
:virtual #t
|
|
:event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
|
|
(case message
|
|
(('test)
|
|
(let ((v1-1 (-> self mode)))
|
|
(cond
|
|
((-> block param 0)
|
|
(when (or (= v1-1 (under-locking-mode want-mech)) (= v1-1 (under-locking-mode want-exit-mech)))
|
|
(let ((a0-4 *target*))
|
|
(and a0-4 (not (logtest? (focus-status mech) (-> a0-4 focus-status))))
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(or (= v1-1 (under-locking-mode airlock-wait)) (= v1-1 (under-locking-mode want-drain)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(case (-> self mode)
|
|
(((under-locking-mode want-mech))
|
|
(let ((v1-1 *target*)
|
|
(a0-1 (-> self actor-group))
|
|
)
|
|
(when (and v1-1 a0-1)
|
|
(if (and (-> a0-1 0 data 0 actor)
|
|
(focus-test? v1-1 mech)
|
|
(send-event (ppointer->process *underb-master*) 'request 'mech #t)
|
|
)
|
|
(set! (-> self mode) (under-locking-mode want-fill))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(((under-locking-mode want-fill))
|
|
(if (not (logtest? (-> self actor-group 0 data 0 actor extra perm status) (entity-perm-status subtask-complete)))
|
|
(go-virtual filling)
|
|
)
|
|
)
|
|
(((under-locking-mode airlock-wait))
|
|
(let ((a1-2 (new 'stack-no-clear 'event-message-block)))
|
|
(set! (-> a1-2 from) (process->ppointer self))
|
|
(set! (-> a1-2 num-params) 0)
|
|
(set! (-> a1-2 message) 'front)
|
|
(let ((t9-2 send-event-function)
|
|
(v1-24 (-> self actor-group 0 data 1 actor))
|
|
)
|
|
(if (not (t9-2
|
|
(if v1-24
|
|
(-> v1-24 extra process)
|
|
)
|
|
a1-2
|
|
)
|
|
)
|
|
(set! (-> self mode) (under-locking-mode want-drain))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(((under-locking-mode want-drain))
|
|
(if (>= 20480.0 (vector-vector-xz-distance (target-pos 0) (-> self root trans)))
|
|
(set! (-> self mode) (under-locking-mode drain))
|
|
)
|
|
)
|
|
(((under-locking-mode drain))
|
|
(go-virtual draining)
|
|
)
|
|
(((under-locking-mode want-exit-mech))
|
|
(let ((a1-4 *target*))
|
|
(when (or (not a1-4) (not (logtest? (focus-status mech) (-> a1-4 focus-status))))
|
|
(set! (-> self mode) (under-locking-mode want-mech))
|
|
0
|
|
)
|
|
)
|
|
(when (time-elapsed? (-> self last-reminder-time) (seconds 9))
|
|
(set-time! (-> self last-reminder-time))
|
|
(add-process
|
|
*gui-control*
|
|
self
|
|
(gui-channel ashelin)
|
|
(gui-action play)
|
|
(if (-> self which-reminder?)
|
|
"cityv193"
|
|
"cityv192"
|
|
)
|
|
-99.0
|
|
0
|
|
)
|
|
(set! (-> self which-reminder?) (not (-> self which-reminder?)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code sleep-code
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate filling (under-locking)
|
|
:virtual #t
|
|
:event (-> (method-of-type under-locking active) event)
|
|
:enter (behavior ()
|
|
(set! (-> self spooled-sound-id)
|
|
(add-process *gui-control* self (gui-channel ashelin) (gui-action queue) "wtrfill" -99.0 0)
|
|
)
|
|
(set! (-> self state-time) 0)
|
|
(set! (-> self spooled-sound-delay) (if (= (-> self id) 1)
|
|
120
|
|
0
|
|
)
|
|
)
|
|
)
|
|
:trans (behavior ()
|
|
(when (and (zero? (-> self state-time))
|
|
(= (get-status *gui-control* (-> self spooled-sound-id)) (gui-status ready))
|
|
)
|
|
(set-time! (-> self state-time))
|
|
(set-time! (-> self last-reminder-time))
|
|
)
|
|
(when (nonzero? (-> self state-time))
|
|
(when (and (>= (-> self spooled-sound-delay) 0) (time-elapsed? (-> self state-time) (-> self spooled-sound-delay)))
|
|
(set-action!
|
|
*gui-control*
|
|
(gui-action play)
|
|
(-> self spooled-sound-id)
|
|
(gui-channel none)
|
|
(gui-action none)
|
|
(the-as string #f)
|
|
(the-as (function gui-connection symbol) #f)
|
|
(the-as process #f)
|
|
)
|
|
(set! (-> self spooled-sound-delay) -1)
|
|
)
|
|
(let* ((v1-21 (-> self actor-group 0 data 2 actor))
|
|
(gp-0 (if v1-21
|
|
(-> v1-21 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when gp-0
|
|
(let ((f0-0 (-> (the-as water-anim gp-0) root trans y)))
|
|
(when (!= f0-0 (-> self up-y))
|
|
(let ((f0-4 (seek f0-0 (-> self up-y) (* 12288.0 (seconds-per-frame)))))
|
|
(send-event gp-0 'move-to-y f0-4)
|
|
)
|
|
)
|
|
)
|
|
(if (time-elapsed? (-> self state-time) (seconds 2))
|
|
(spawn (-> self part) (-> self root trans))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(while (zero? (-> self state-time))
|
|
(suspend)
|
|
)
|
|
(until #f
|
|
(let* ((v1-4 (-> self actor-group 0 data 2 actor))
|
|
(gp-0 (if v1-4
|
|
(-> v1-4 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when gp-0
|
|
(if (< (- (-> (camera-pos) y) (-> (the-as water-anim gp-0) root trans y)) 22528.0)
|
|
(goto cfg-11)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
#f
|
|
(label cfg-11)
|
|
(let ((a3-1 (res-lump-struct (-> self entity) 'camera-name structure)))
|
|
(if a3-1
|
|
(set-setting! 'entity-name a3-1 0.0 0)
|
|
)
|
|
)
|
|
(until #f
|
|
(let* ((a0-2 (-> self actor-group 0 data 2 actor))
|
|
(v1-19 (if a0-2
|
|
(-> a0-2 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when v1-19
|
|
(when (= (-> (the-as water-anim v1-19) root trans y) (-> self up-y))
|
|
(persist-with-delay *setting-control* 'interp-time (seconds 0.05) 'interp-time 'abs 0.0 0)
|
|
(remove-setting! 'entity-name)
|
|
(send-event (ppointer->process *underb-master*) 'request 'under-warp #t)
|
|
(set! (-> self mode) (under-locking-mode airlock-wait))
|
|
(go-virtual active)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate draining (under-locking)
|
|
:virtual #t
|
|
:event (-> (method-of-type under-locking active) event)
|
|
:enter (behavior ()
|
|
(set! (-> self spooled-sound-id)
|
|
(add-process *gui-control* self (gui-channel ashelin) (gui-action queue) "wtrdrain" -99.0 0)
|
|
)
|
|
(set! (-> self state-time) 0)
|
|
0
|
|
)
|
|
:trans (behavior ()
|
|
(when (and (zero? (-> self state-time))
|
|
(= (get-status *gui-control* (-> self spooled-sound-id)) (gui-status ready))
|
|
)
|
|
(set-time! (-> self state-time))
|
|
(set-time! (-> self last-reminder-time))
|
|
(set-action!
|
|
*gui-control*
|
|
(gui-action play)
|
|
(-> self spooled-sound-id)
|
|
(gui-channel none)
|
|
(gui-action none)
|
|
(the-as string #f)
|
|
(the-as (function gui-connection symbol) #f)
|
|
(the-as process #f)
|
|
)
|
|
)
|
|
(when (nonzero? (-> self state-time))
|
|
(let* ((v1-14 (-> self actor-group 0 data 2 actor))
|
|
(gp-0 (if v1-14
|
|
(-> v1-14 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when gp-0
|
|
(let ((f0-0 (-> (the-as water-anim gp-0) root trans y)))
|
|
(when (!= f0-0 (-> self down-y))
|
|
(let ((f0-4 (seek f0-0 (-> self down-y) (* 12288.0 (seconds-per-frame)))))
|
|
(send-event gp-0 'move-to-y f0-4)
|
|
)
|
|
)
|
|
)
|
|
(if (not (time-elapsed? (-> self state-time) (seconds 1)))
|
|
(spawn (-> self draining-part) (-> self root trans))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
:code (behavior ()
|
|
(while (zero? (-> self state-time))
|
|
(suspend)
|
|
)
|
|
(let ((a3-1 (res-lump-struct (-> self entity) 'camera-name structure)))
|
|
(if a3-1
|
|
(set-setting! 'entity-name a3-1 0.0 0)
|
|
)
|
|
)
|
|
(send-event (ppointer->process *underb-master*) 'request 'under-warp #f)
|
|
(until #f
|
|
(let* ((a0-3 (-> self actor-group 0 data 2 actor))
|
|
(v1-15 (if a0-3
|
|
(-> a0-3 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when v1-15
|
|
(if (< (-> (the-as water-anim v1-15) root trans y) (+ 10240.0 (-> (target-pos 0) y)))
|
|
(goto cfg-17)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
#f
|
|
(label cfg-17)
|
|
(remove-setting! 'entity-name)
|
|
(until #f
|
|
(let* ((a0-8 (-> self actor-group 0 data 2 actor))
|
|
(v1-26 (if a0-8
|
|
(-> a0-8 extra process)
|
|
)
|
|
)
|
|
)
|
|
(when v1-26
|
|
(when (= (-> (the-as water-anim v1-26) root trans y) (-> self down-y))
|
|
(set! (-> self mode) (under-locking-mode want-exit-mech))
|
|
(send-event (ppointer->process *underb-master*) 'request 'mech #f)
|
|
(set! (-> self which-reminder?) #f)
|
|
(go-virtual active)
|
|
)
|
|
)
|
|
)
|
|
(suspend)
|
|
)
|
|
#f
|
|
)
|
|
)
|
|
|
|
;; definition for method 11 of type under-locking
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch object vs none.
|
|
(defmethod init-from-entity! ((this under-locking) (arg0 entity-actor))
|
|
"Typically the method that does the initial setup on the process, potentially using the [[entity-actor]] provided as part of that.
|
|
This commonly includes things such as:
|
|
- stack size
|
|
- collision information
|
|
- loading the skeleton group / bones
|
|
- sounds"
|
|
(local-vars (sv-16 res-tag))
|
|
(set! (-> this which-reminder?) #f)
|
|
(set! (-> this spooled-sound-id) (new 'static 'sound-id))
|
|
(set! (-> this root) (new 'process 'trsqv))
|
|
(process-drawable-from-entity! this arg0)
|
|
(set! (-> this id) (res-lump-value arg0 'extra-id int :time -1000000000.0))
|
|
(let ((f0-0 (-> this root trans y)))
|
|
(set! (-> this up-y) (+ 49152.0 f0-0))
|
|
(set! (-> this down-y) (+ f0-0 (if (= (-> this id) 2)
|
|
-16384.0
|
|
-20480.0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! sv-16 (new 'static 'res-tag))
|
|
(let ((a0-6 (res-lump-data (-> this entity) 'actor-groups pointer :tag-ptr (& sv-16))))
|
|
(if (and a0-6 (nonzero? (-> sv-16 elt-count)))
|
|
(set! (-> this actor-group) (the-as (pointer actor-group) a0-6))
|
|
(set! (-> this actor-group) (the-as (pointer actor-group) #f))
|
|
)
|
|
)
|
|
(set! (-> this part) (create-launch-control (-> *part-group-id-table* 498) this))
|
|
(set! (-> this draining-part) (create-launch-control (-> *part-group-id-table* 499) this))
|
|
(go (method-of-object this startup))
|
|
(none)
|
|
)
|
|
|
|
;; definition of type water-anim-under
|
|
(deftype water-anim-under (water-anim)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type water-anim-under
|
|
(defmethod inspect ((this water-anim-under))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type water-anim inspect)))
|
|
(t9-0 this)
|
|
)
|
|
(label cfg-4)
|
|
this
|
|
)
|
|
|
|
;; definition for symbol ripple-for-water-anim-under, type ripple-wave-set
|
|
(define ripple-for-water-anim-under (new 'static 'ripple-wave-set
|
|
:count 3
|
|
:converted #f
|
|
:normal-scale 1.0
|
|
:wave (new 'static 'inline-array ripple-wave 4
|
|
(new 'static 'ripple-wave :scale 40.0 :xdiv 1 :speed 1.5)
|
|
(new 'static 'ripple-wave :scale 40.0 :xdiv -1 :zdiv 1 :speed 1.5)
|
|
(new 'static 'ripple-wave :scale 20.0 :xdiv 5 :zdiv 3 :speed 0.75)
|
|
(new 'static 'ripple-wave)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 24 of type water-anim-under
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init-water! ((this water-anim-under))
|
|
"Initialize a [[water-anim]]'s default settings, this may include applying a [[riple-control]]"
|
|
(let ((t9-0 (method-of-type water-anim init-water!)))
|
|
(t9-0 this)
|
|
)
|
|
(let ((v1-2 (new 'process 'ripple-control)))
|
|
(set! (-> this draw ripple) v1-2)
|
|
(set-vector! (-> this draw color-mult) 0.01 0.45 0.5 0.75)
|
|
(set! (-> v1-2 global-scale) 3072.0)
|
|
(set! (-> v1-2 close-fade-dist) 163840.0)
|
|
(set! (-> v1-2 far-fade-dist) 245760.0)
|
|
(set! (-> v1-2 waveform) ripple-for-water-anim-under)
|
|
)
|
|
0
|
|
(none)
|
|
)
|