mirror of
https://github.com/open-goal/jak-project
synced 2026-08-07 10:16:45 -04:00
Hat Kid
99866cec88
- `fma-sphere` - `prim-beam-h` - `cam-start` - `ragdoll` - `light-trails-h` - `light-trails` - `menu` - `water` - `water-flow` - `hud` - `hud-classes` - `progress` - `progress-draw` --- The `get-texture` macro replaces calls to `lookup-texture-by-id` and `lookup-texture-by-id-fast`. The `defpart` macro detection was modified to print a pair like `(texture-name tpage-name)` for the texture field that gets turned into a `texture-id` constant. Only used in Jak 3 at the moment, I'll probably go through the other games at a later point.
396 lines
15 KiB
Common Lisp
Vendored
Generated
396 lines
15 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type water-control
|
|
(deftype water-control (basic)
|
|
((flags water-flag)
|
|
(process target)
|
|
(joint-index int32)
|
|
(top-y-offset float)
|
|
(attack-id uint32)
|
|
(enter-water-time time-frame)
|
|
(wade-time time-frame)
|
|
(on-water-time time-frame)
|
|
(enter-swim-time time-frame)
|
|
(swim-time time-frame)
|
|
(base-height meters)
|
|
(wade-height meters)
|
|
(swim-height meters)
|
|
(surface-height meters)
|
|
(bottom-height meters)
|
|
(collide-height meters)
|
|
(height meters)
|
|
(height-offset float 4)
|
|
(base-ocean-offset meters :overlay-at (-> height-offset 0))
|
|
(real-ocean-offset meters :overlay-at (-> height-offset 0))
|
|
(ocean-offset meters :overlay-at (-> height-offset 1))
|
|
(bob-offset meters :overlay-at (-> height-offset 2))
|
|
(align-offset meters :overlay-at (-> height-offset 3))
|
|
(swim-depth meters :offset 108)
|
|
(bob smush-control :inline)
|
|
(ripple handle)
|
|
(ripple-size meters)
|
|
(wake-size meters)
|
|
(bottom vector 2 :inline)
|
|
(top vector 2 :inline)
|
|
(enter-water-pos vector :inline)
|
|
(drip-old-pos vector :inline)
|
|
(drip-joint-index int32)
|
|
(drip-wetness float)
|
|
(drip-time time-frame)
|
|
(drip-speed float)
|
|
(drip-height meters)
|
|
(drip-mult float)
|
|
(distort-time time-frame)
|
|
(enter-water-sound sound-name)
|
|
(normal vector :inline)
|
|
)
|
|
(:methods
|
|
(new (symbol type process int float float float) _type_)
|
|
(water-control-method-9 (_type_) none)
|
|
(water-control-method-10 (_type_) none)
|
|
(start-bobbing! (_type_ float int int) none)
|
|
(distance-from-surface (_type_) float)
|
|
(spawn-ripples (_type_ float vector int vector symbol) none)
|
|
(display-water-marks? (_type_) symbol)
|
|
(enter-water (_type_) none)
|
|
(water-control-method-16 (_type_) none)
|
|
(water-control-method-17 (_type_) none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type water-control
|
|
;; INFO: Used lq/sq
|
|
(defmethod inspect ((this water-control))
|
|
(when (not this)
|
|
(set! this this)
|
|
(goto cfg-68)
|
|
)
|
|
(format #t "[~8x] ~A~%" this (-> this type))
|
|
(format #t "~1Tflags: #x~X : (water-flag " (-> this flags))
|
|
(let ((s5-0 (-> this flags)))
|
|
(if (= (logand s5-0 (water-flag active)) (water-flag active))
|
|
(format #t "active ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag deadly)) (water-flag deadly))
|
|
(format #t "deadly ")
|
|
)
|
|
(if (= (logand (water-flag touch-water-good) s5-0) (shl #x8000 16))
|
|
(format #t "touch-water-good ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag lava)) (water-flag lava))
|
|
(format #t "lava ")
|
|
)
|
|
(if (= (logand (water-flag jump-out) s5-0) (water-flag jump-out))
|
|
(format #t "jump-out ")
|
|
)
|
|
(if (= (logand (water-flag head-under-water) s5-0) (water-flag head-under-water))
|
|
(format #t "head-under-water ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag under-water)) (water-flag under-water))
|
|
(format #t "under-water ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag swamp)) (water-flag swamp))
|
|
(format #t "swamp ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag dark-eco)) (water-flag dark-eco))
|
|
(format #t "dark-eco ")
|
|
)
|
|
(if (= (logand (water-flag part-water) s5-0) (water-flag part-water))
|
|
(format #t "part-water ")
|
|
)
|
|
(if (= (logand (water-flag break-surface) s5-0) (water-flag break-surface))
|
|
(format #t "break-surface ")
|
|
)
|
|
(if (= (logand (water-flag over-water) s5-0) (water-flag over-water))
|
|
(format #t "over-water ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag use-ocean)) (water-flag use-ocean))
|
|
(format #t "use-ocean ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag flow)) (water-flag flow))
|
|
(format #t "flow ")
|
|
)
|
|
(if (= (logand (water-flag wading) s5-0) (water-flag wading))
|
|
(format #t "wading ")
|
|
)
|
|
(if (= (logand (water-flag part-rings) s5-0) (water-flag part-rings))
|
|
(format #t "part-rings ")
|
|
)
|
|
(if (= (logand (water-flag part-drip) s5-0) (water-flag part-drip))
|
|
(format #t "part-drip ")
|
|
)
|
|
(if (= (logand (water-flag part-splash) s5-0) (water-flag part-splash))
|
|
(format #t "part-splash ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag swim-ground)) (water-flag swim-ground))
|
|
(format #t "swim-ground ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag tar)) (water-flag tar))
|
|
(format #t "tar ")
|
|
)
|
|
(if (= (logand (water-flag swimming) s5-0) (water-flag swimming))
|
|
(format #t "swimming ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag mud)) (water-flag mud))
|
|
(format #t "mud ")
|
|
)
|
|
(if (= (logand (water-flag event) s5-0) (water-flag event))
|
|
(format #t "event ")
|
|
)
|
|
(if (= (logand (water-flag bouncing) s5-0) (water-flag bouncing))
|
|
(format #t "bouncing ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag use-water-anim)) (water-flag use-water-anim))
|
|
(format #t "use-water-anim ")
|
|
)
|
|
(if (= (logand (water-flag spawn-drip) s5-0) (water-flag spawn-drip))
|
|
(format #t "spawn-drip ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag can-swim)) (water-flag can-swim))
|
|
(format #t "can-swim ")
|
|
)
|
|
(if (= (logand (water-flag touch-water) s5-0) (water-flag touch-water))
|
|
(format #t "touch-water ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag no-grab-sound)) (water-flag no-grab-sound))
|
|
(format #t "no-grab-ground ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag can-wade)) (water-flag can-wade))
|
|
(format #t "can-wade ")
|
|
)
|
|
(if (= (logand (water-flag find-water) s5-0) (water-flag find-water))
|
|
(format #t "find-water ")
|
|
)
|
|
(if (= (logand s5-0 (water-flag can-ground)) (water-flag can-ground))
|
|
(format #t "can-ground ")
|
|
)
|
|
)
|
|
(format #t ")~%")
|
|
(format #t "~1Tprocess: ~A~%" (-> this process))
|
|
(format #t "~1Tjoint-index: ~D~%" (-> this joint-index))
|
|
(format #t "~1Ttop-y-offset: ~f~%" (-> this top-y-offset))
|
|
(format #t "~1Tattack-id: ~D~%" (-> this attack-id))
|
|
(format #t "~1Tenter-water-time: ~D~%" (-> this enter-water-time))
|
|
(format #t "~1Twade-time: ~D~%" (-> this wade-time))
|
|
(format #t "~1Ton-water-time: ~D~%" (-> this on-water-time))
|
|
(format #t "~1Tenter-swim-time: ~D~%" (-> this enter-swim-time))
|
|
(format #t "~1Tswim-time: ~D~%" (-> this swim-time))
|
|
(format #t "~1Tbase-height: (meters ~m)~%" (-> this base-height))
|
|
(format #t "~1Twade-height: (meters ~m)~%" (-> this wade-height))
|
|
(format #t "~1Tswim-height: (meters ~m)~%" (-> this swim-height))
|
|
(format #t "~1Tsurface-height: (meters ~m)~%" (-> this surface-height))
|
|
(format #t "~1Tbottom-height: (meters ~m)~%" (-> this bottom-height))
|
|
(format #t "~1Tcollide-height: (meters ~m)~%" (-> this collide-height))
|
|
(format #t "~1Theight: (meters ~m)~%" (-> this height))
|
|
(format #t "~1Theight-offset[4] @ #x~X~%" (-> this height-offset))
|
|
(format #t "~1Tbase-ocean-offset: (meters ~m)~%" (-> this base-ocean-offset))
|
|
(format #t "~1Treal-ocean-offset: (meters ~m)~%" (-> this base-ocean-offset))
|
|
(format #t "~1Tocean-offset: (meters ~m)~%" (-> this ocean-offset))
|
|
(format #t "~1Tbob-offset: (meters ~m)~%" (-> this bob-offset))
|
|
(format #t "~1Talign-offset: (meters ~m)~%" (-> this align-offset))
|
|
(format #t "~1Tswim-depth: (meters ~m)~%" (-> this swim-depth))
|
|
(format #t "~1Tbob: #<smush-control @ #x~X>~%" (-> this bob))
|
|
(format #t "~1Tripple: ~D~%" (-> this ripple))
|
|
(format #t "~1Tripple-size: (meters ~m)~%" (-> this ripple-size))
|
|
(format #t "~1Twake-size: (meters ~m)~%" (-> this wake-size))
|
|
(format #t "~1Tbottom[2] @ #x~X~%" (-> this bottom))
|
|
(format #t "~1Ttop[2] @ #x~X~%" (-> this top))
|
|
(format #t "~1Tenter-water-pos: ~`vector`P~%" (-> this enter-water-pos))
|
|
(format #t "~1Tdrip-old-pos: ~`vector`P~%" (-> this drip-old-pos))
|
|
(format #t "~1Tdrip-joint-index: ~D~%" (-> this drip-joint-index))
|
|
(format #t "~1Tdrip-wetness: ~f~%" (-> this drip-wetness))
|
|
(format #t "~1Tdrip-time: ~D~%" (-> this drip-time))
|
|
(format #t "~1Tdrip-speed: ~f~%" (-> this drip-speed))
|
|
(format #t "~1Tdrip-height: (meters ~m)~%" (-> this drip-height))
|
|
(format #t "~1Tdrip-mult: ~f~%" (-> this drip-mult))
|
|
(format #t "~1Tdistort-time: ~D~%" (-> this distort-time))
|
|
(format #t "~1Tenter-water-sound: ~D~%" (-> this enter-water-sound))
|
|
(format #t "~1Tnormal: #<vector @ #x~X>~%" (-> this normal))
|
|
(label cfg-68)
|
|
this
|
|
)
|
|
|
|
;; definition for method 14 of type water-control
|
|
(defmethod display-water-marks? ((this water-control))
|
|
*display-water-marks*
|
|
)
|
|
|
|
;; definition for method 0 of type water-control
|
|
;; INFO: Used lq/sq
|
|
(defmethod new water-control ((allocation symbol) (type-to-make type) (arg0 process) (arg1 int) (arg2 float) (arg3 float) (arg4 float))
|
|
(let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(set! (-> v0-0 process) (the-as target arg0))
|
|
(set! (-> v0-0 joint-index) arg1)
|
|
(set! (-> v0-0 wade-height) arg4)
|
|
(set! (-> v0-0 swim-height) arg3)
|
|
(set! (-> v0-0 bottom-height) 32768.0)
|
|
(set! (-> v0-0 ripple-size) 1638.4)
|
|
(set! (-> v0-0 wake-size) 3072.0)
|
|
(set! (-> v0-0 ripple) (the-as handle #f))
|
|
(set! (-> v0-0 drip-mult) 1.0)
|
|
(set! (-> v0-0 top-y-offset) arg2)
|
|
(let* ((v1-6 *game-info*)
|
|
(a0-2 (+ (-> v1-6 attack-id) 1))
|
|
)
|
|
(set! (-> v1-6 attack-id) a0-2)
|
|
(set! (-> v0-0 attack-id) a0-2)
|
|
)
|
|
(set! (-> v0-0 enter-water-sound) (static-sound-name "swim-enter"))
|
|
v0-0
|
|
)
|
|
)
|
|
|
|
;; definition for method 12 of type water-control
|
|
(defmethod distance-from-surface ((this water-control))
|
|
(- (-> this top 0 y) (-> this height))
|
|
)
|
|
|
|
;; definition of type water-vol
|
|
(deftype water-vol (process-hidden)
|
|
()
|
|
)
|
|
|
|
;; definition for method 3 of type water-vol
|
|
(defmethod inspect ((this water-vol))
|
|
(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
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
0
|