mirror of
https://github.com/open-goal/jak-project
synced 2026-06-11 21:19:11 -04:00
Hat Kid
67d4eda169
Manual patches: - `drill-turret`: The static data for `*turret-13-path*`, `*turret-14-path*` and `*turret-15-path*` was decompiled by hand and the integers in the `set-speed-mult` events have been replaced with boxed integer arrays that contain only that integer in order to make the compiler happy. To that effect, the event handler in `target-turret` was changed to access that array instead of just accessing the int. - `hover-nav-control`: In `hover-nav-control::10`, `arg2` is usually a `vector`, but there are some places where it is called with `#t` as `arg2` and, subsequently, crashes the game because it tries to access the `quad` of `arg2` if `arg2` is truthy. To mitigate this, the condition `arg2` has been replaced with `(and (!= arg2 #t) arg2)` (in this case, it would jump to the `else` that just resets the `dest-vel` and `transv` `quad`s) - `drill-baron`: The static data for `*drill-ship-turret-speed-event*` has been decompiled by hand. TODOs: - Jellyfish crash the game - Destroying the metalhead eggs that are on the breakable wall crashes the game (already happened with the Peacemaker before) - Figure out why static data of type `turret-path-event` doesn't decompile The docs for all the hover-nav and nav-network code could use some love in the future, I'm not smart enough to figure out what any of that code actually means, but it seems to work... Also threw in the fix for the ▲ that was accidentally left commented out.
699 lines
31 KiB
Common Lisp
Vendored
Generated
699 lines
31 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type cam-index
|
|
(deftype cam-index (structure)
|
|
((flags cam-index-options :offset-assert 0)
|
|
(vec vector 2 :inline :offset-assert 16)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x30
|
|
:flag-assert #xb00000030
|
|
(:methods
|
|
(cam-index-method-9 (_type_ symbol entity vector curve) symbol 9)
|
|
(cam-index-method-10 (_type_ vector) float 10)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-index
|
|
(defmethod inspect cam-index ((obj cam-index))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-index)
|
|
(format #t "~1Tflags: ~D~%" (-> obj flags))
|
|
(format #t "~1Tvec[2] @ #x~X~%" (-> obj vec))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-point
|
|
(deftype tracking-point (structure)
|
|
((position vector :inline :offset-assert 0)
|
|
(direction vector :inline :offset-assert 16)
|
|
(tp-length float :offset-assert 32)
|
|
(next int32 :offset-assert 36)
|
|
(incarnation int32 :offset-assert 40)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x2c
|
|
:flag-assert #x90000002c
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-point
|
|
(defmethod inspect tracking-point ((obj tracking-point))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-point)
|
|
(format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
|
|
(format #t "~1Tdirection: #<vector @ #x~X>~%" (-> obj direction))
|
|
(format #t "~1Ttp-length: ~f~%" (-> obj tp-length))
|
|
(format #t "~1Tnext: ~D~%" (-> obj next))
|
|
(format #t "~1Tincarnation: ~D~%" (-> obj incarnation))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-spline-sampler
|
|
(deftype tracking-spline-sampler (structure)
|
|
((cur-pt int32 :offset-assert 0)
|
|
(partial-pt float :offset-assert 4)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x8
|
|
:flag-assert #x900000008
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-spline-sampler
|
|
(defmethod inspect tracking-spline-sampler ((obj tracking-spline-sampler))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-spline-sampler)
|
|
(format #t "~1Tcur-pt: ~D~%" (-> obj cur-pt))
|
|
(format #t "~1Tpartial-pt: ~f~%" (-> obj partial-pt))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type tracking-spline
|
|
(deftype tracking-spline (structure)
|
|
((point tracking-point 32 :inline :offset-assert 0)
|
|
(summed-len float :offset-assert 1536)
|
|
(free-point int32 :offset-assert 1540)
|
|
(used-point int32 :offset-assert 1544)
|
|
(partial-point float :offset-assert 1548)
|
|
(end-point int32 :offset-assert 1552)
|
|
(next-to-last-point int32 :offset-assert 1556)
|
|
(max-move float :offset-assert 1560)
|
|
(sample-len float :offset-assert 1564)
|
|
(used-count int32 :offset-assert 1568)
|
|
(old-position vector :inline :offset-assert 1584)
|
|
(debug-old-position vector :inline :offset-assert 1600)
|
|
(debug-out-position vector :inline :offset-assert 1616)
|
|
(debug-last-point int32 :offset-assert 1632)
|
|
)
|
|
:method-count-assert 24
|
|
:size-assert #x664
|
|
:flag-assert #x1800000664
|
|
(:methods
|
|
(tracking-spline-method-9 (_type_) none 9)
|
|
(tracking-spline-method-10 (_type_ vector) none 10)
|
|
(debug-point-info (_type_ int) none 11)
|
|
(debug-all-points (_type_) none 12)
|
|
(tracking-spline-method-13 (_type_ int) none 13)
|
|
(tracking-spline-method-14 (_type_ tracking-spline-sampler) none 14)
|
|
(tracking-spline-method-15 (_type_) none 15)
|
|
(tracking-spline-method-16 (_type_ float) none 16)
|
|
(tracking-spline-method-17 (_type_ vector float float symbol) int 17)
|
|
(tracking-spline-method-18 (_type_ float vector tracking-spline-sampler) vector 18)
|
|
(tracking-spline-method-19 (_type_ float vector tracking-spline-sampler) vector 19)
|
|
(tracking-spline-method-20 (_type_ vector int) none 20)
|
|
(tracking-spline-method-21 (_type_ vector float float float) vector 21)
|
|
(tracking-spline-method-22 (_type_ float) symbol 22)
|
|
(debug-draw-spline (_type_) none 23)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type tracking-spline
|
|
(defmethod inspect tracking-spline ((obj tracking-spline))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'tracking-spline)
|
|
(format #t "~1Tpoint[32] @ #x~X~%" (-> obj point))
|
|
(format #t "~1Tsummed-len: ~f~%" (-> obj summed-len))
|
|
(format #t "~1Tfree-point: ~D~%" (-> obj free-point))
|
|
(format #t "~1Tused-point: ~D~%" (-> obj used-point))
|
|
(format #t "~1Tpartial-point: ~f~%" (-> obj partial-point))
|
|
(format #t "~1Tend-point: ~D~%" (-> obj end-point))
|
|
(format #t "~1Tnext-to-last-point: ~D~%" (-> obj next-to-last-point))
|
|
(format #t "~1Tmax-move: ~f~%" (-> obj max-move))
|
|
(format #t "~1Tsample-len: ~f~%" (-> obj sample-len))
|
|
(format #t "~1Tused-count: ~D~%" (-> obj used-count))
|
|
(format #t "~1Told-position: #<vector @ #x~X>~%" (-> obj old-position))
|
|
(format #t "~1Tdebug-old-position: #<vector @ #x~X>~%" (-> obj debug-old-position))
|
|
(format #t "~1Tdebug-out-position: #<vector @ #x~X>~%" (-> obj debug-out-position))
|
|
(format #t "~1Tdebug-last-point: ~D~%" (-> obj debug-last-point))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type cam-float-seeker
|
|
(deftype cam-float-seeker (structure)
|
|
((target float :offset-assert 0)
|
|
(value float :offset-assert 4)
|
|
(vel float :offset-assert 8)
|
|
(accel float :offset-assert 12)
|
|
(max-vel float :offset-assert 16)
|
|
(max-partial float :offset-assert 20)
|
|
)
|
|
:pack-me
|
|
:method-count-assert 13
|
|
:size-assert #x18
|
|
:flag-assert #xd00000018
|
|
(:methods
|
|
(init (_type_ float float float float) none 9)
|
|
(copy-to (_type_ _type_) none 10)
|
|
(update! (_type_ float) none 11)
|
|
(jump-to-target! (_type_ float) float 12)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-float-seeker
|
|
(defmethod inspect cam-float-seeker ((obj cam-float-seeker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-float-seeker)
|
|
(format #t "~1Ttarget: ~f~%" (-> obj target))
|
|
(format #t "~1Tvalue: ~f~%" (-> obj value))
|
|
(format #t "~1Tvel: ~f~%" (-> obj vel))
|
|
(format #t "~1Taccel: ~f~%" (-> obj accel))
|
|
(format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
|
|
(format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 9 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init cam-float-seeker ((obj cam-float-seeker) (arg0 float) (arg1 float) (arg2 float) (arg3 float))
|
|
(set! (-> obj target) arg0)
|
|
(set! (-> obj value) arg0)
|
|
(set! (-> obj vel) 0.0)
|
|
(set! (-> obj accel) arg1)
|
|
(set! (-> obj max-vel) arg2)
|
|
(set! (-> obj max-partial) arg3)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod copy-to cam-float-seeker ((obj cam-float-seeker) (arg0 cam-float-seeker))
|
|
(set! (-> obj target) (-> arg0 target))
|
|
(set! (-> obj value) (-> arg0 value))
|
|
(set! (-> obj vel) (-> arg0 vel))
|
|
(set! (-> obj accel) (-> arg0 accel))
|
|
(set! (-> obj max-vel) (-> arg0 max-vel))
|
|
(set! (-> obj max-partial) (-> arg0 max-partial))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type cam-float-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod update! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
|
|
(with-pp
|
|
0.0
|
|
0.0
|
|
(let* ((f1-2 (- (+ (-> obj target) arg0) (-> obj value)))
|
|
(f0-5 (* (-> obj max-partial) (fabs f1-2)))
|
|
)
|
|
(let ((f1-3 (* f1-2 (* (-> obj accel) (-> pp clock time-adjust-ratio)))))
|
|
(+! (-> obj vel) f1-3)
|
|
)
|
|
(let ((f1-6 (fabs (-> obj vel)))
|
|
(f0-6 (fmin f0-5 (-> obj max-vel)))
|
|
)
|
|
(if (< f0-6 f1-6)
|
|
(set! (-> obj vel) (* (-> obj vel) (/ f0-6 f1-6)))
|
|
)
|
|
)
|
|
)
|
|
(let ((f0-10 (* (-> obj vel) (-> pp clock time-adjust-ratio))))
|
|
(+! (-> obj value) f0-10)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition for method 12 of type cam-float-seeker
|
|
(defmethod jump-to-target! cam-float-seeker ((obj cam-float-seeker) (arg0 float))
|
|
(set! (-> obj value) (+ (-> obj target) arg0))
|
|
(set! (-> obj vel) 0.0)
|
|
0.0
|
|
)
|
|
|
|
;; definition of type cam-vector-seeker
|
|
(deftype cam-vector-seeker (structure)
|
|
((target vector :inline :offset-assert 0)
|
|
(value vector :inline :offset-assert 16)
|
|
(vel vector :inline :offset-assert 32)
|
|
(accel float :offset-assert 48)
|
|
(max-vel float :offset-assert 52)
|
|
(max-partial float :offset-assert 56)
|
|
)
|
|
:method-count-assert 11
|
|
:size-assert #x3c
|
|
:flag-assert #xb0000003c
|
|
(:methods
|
|
(init (_type_ vector float float float) none 9)
|
|
(update! (_type_ vector) none 10)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type cam-vector-seeker
|
|
(defmethod inspect cam-vector-seeker ((obj cam-vector-seeker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-vector-seeker)
|
|
(format #t "~1Ttarget: #<vector @ #x~X>~%" (-> obj target))
|
|
(format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
|
|
(format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
|
|
(format #t "~1Taccel: ~f~%" (-> obj accel))
|
|
(format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
|
|
(format #t "~1Tmax-partial: ~f~%" (-> obj max-partial))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition for method 9 of type cam-vector-seeker
|
|
;; INFO: Used lq/sq
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod init cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector) (arg1 float) (arg2 float) (arg3 float))
|
|
(cond
|
|
(arg0
|
|
(set! (-> obj target quad) (-> arg0 quad))
|
|
(set! (-> obj value quad) (-> arg0 quad))
|
|
)
|
|
(else
|
|
(vector-reset! (-> obj target))
|
|
(vector-reset! (-> obj value))
|
|
)
|
|
)
|
|
(vector-reset! (-> obj vel))
|
|
(set! (-> obj accel) arg1)
|
|
(set! (-> obj max-vel) arg2)
|
|
(set! (-> obj max-partial) arg3)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 10 of type cam-vector-seeker
|
|
;; WARN: Return type mismatch int vs none.
|
|
(defmethod update! cam-vector-seeker ((obj cam-vector-seeker) (arg0 vector))
|
|
(with-pp
|
|
(let ((v1-0 (new 'stack-no-clear 'vector)))
|
|
0.0
|
|
(cond
|
|
(arg0
|
|
(vector+! v1-0 (-> obj target) arg0)
|
|
(vector-! v1-0 v1-0 (-> obj value))
|
|
)
|
|
(else
|
|
(vector-! v1-0 (-> obj target) (-> obj value))
|
|
)
|
|
)
|
|
(let ((f0-2 (* (-> obj max-partial) (vector-length v1-0))))
|
|
(vector-float*! v1-0 v1-0 (* (-> obj accel) (-> pp clock time-adjust-ratio)))
|
|
(vector+! (-> obj vel) (-> obj vel) v1-0)
|
|
(let ((f1-3 (vector-length (-> obj vel)))
|
|
(f0-3 (fmin f0-2 (-> obj max-vel)))
|
|
)
|
|
(if (< f0-3 f1-3)
|
|
(vector-float*! (-> obj vel) (-> obj vel) (/ f0-3 f1-3))
|
|
)
|
|
)
|
|
)
|
|
(vector-float*! v1-0 (-> obj vel) (-> pp clock time-adjust-ratio))
|
|
(vector+! (-> obj value) (-> obj value) v1-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
)
|
|
|
|
;; definition of type cam-rotation-tracker
|
|
(deftype cam-rotation-tracker (structure)
|
|
((inv-mat matrix :inline :offset-assert 0)
|
|
(no-follow basic :offset-assert 64)
|
|
(follow-pt vector :inline :offset-assert 80)
|
|
(follow-off vector :inline :offset-assert 96)
|
|
(follow-blend float :offset-assert 112)
|
|
(tilt-adjust cam-float-seeker :inline :offset-assert 116)
|
|
(point-of-interest-blend cam-float-seeker :inline :offset-assert 140)
|
|
(underwater-blend cam-float-seeker :inline :offset-assert 164)
|
|
(looking-at vector :inline :offset-assert 192)
|
|
(looking-interesting vector :inline :offset-assert 208)
|
|
(old-cam-trans vector :inline :offset-assert 224)
|
|
(follow-height-extra cam-float-seeker :inline :offset-assert 240)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x108
|
|
:flag-assert #x900000108
|
|
)
|
|
|
|
;; definition for method 3 of type cam-rotation-tracker
|
|
(defmethod inspect cam-rotation-tracker ((obj cam-rotation-tracker))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(format #t "[~8x] ~A~%" obj 'cam-rotation-tracker)
|
|
(format #t "~1Tinv-mat: ~`matrix`P~%" (-> obj inv-mat))
|
|
(format #t "~1Tno-follow: ~A~%" (-> obj no-follow))
|
|
(format #t "~1Tfollow-pt: ~`vector`P~%" (-> obj follow-pt))
|
|
(format #t "~1Tfollow-off: ~`vector`P~%" (-> obj follow-off))
|
|
(format #t "~1Tfollow-blend: ~f~%" (-> obj follow-blend))
|
|
(format #t "~1Ttilt-adjust: #<cam-float-seeker @ #x~X>~%" (-> obj tilt-adjust))
|
|
(format #t "~1Tpoint-of-interest-blend: #<cam-float-seeker @ #x~X>~%" (-> obj point-of-interest-blend))
|
|
(format #t "~1Tunderwater-blend: #<cam-float-seeker @ #x~X>~%" (-> obj underwater-blend))
|
|
(format #t "~1Tlooking-at: ~`vector`P~%" (-> obj looking-at))
|
|
(format #t "~1Tlooking-interesting: ~`vector`P~%" (-> obj looking-interesting))
|
|
(format #t "~1Told-cam-trans: ~`vector`P~%" (-> obj old-cam-trans))
|
|
(format #t "~1Tfollow-height-extra: #<cam-float-seeker @ #x~X>~%" (-> obj follow-height-extra))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-combiner
|
|
(deftype camera-combiner (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(inv-camera-rot matrix :inline :offset-assert 144)
|
|
(fov float :offset-assert 208)
|
|
(interp-val float :offset-assert 212)
|
|
(interp-step float :offset-assert 216)
|
|
(dist-from-src float :offset-assert 220)
|
|
(dist-from-dest float :offset-assert 224)
|
|
(flip-control-axis vector :inline :offset-assert 240)
|
|
(velocity vector :inline :offset-assert 256)
|
|
(tracking-status uint64 :offset-assert 272)
|
|
(tracking-options int32 :offset-assert 280)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 288)
|
|
(fast-rot basic :offset-assert 552)
|
|
)
|
|
:heap-base #x1b0
|
|
:method-count-assert 14
|
|
:size-assert #x22c
|
|
:flag-assert #xe01b0022c
|
|
(:states
|
|
cam-combiner-active
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type camera-combiner
|
|
(defmethod inspect camera-combiner ((obj camera-combiner))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(format #t "~2Tinv-camera-rot: ~`matrix`P~%" (-> obj inv-camera-rot))
|
|
(format #t "~2Tfov: ~f~%" (-> obj fov))
|
|
(format #t "~2Tinterp-val: ~f~%" (-> obj interp-val))
|
|
(format #t "~2Tinterp-step: ~f~%" (-> obj interp-step))
|
|
(format #t "~2Tdist-from-src: ~f~%" (-> obj dist-from-src))
|
|
(format #t "~2Tdist-from-dest: ~f~%" (-> obj dist-from-dest))
|
|
(format #t "~2Tflip-control-axis: #<vector @ #x~X>~%" (-> obj flip-control-axis))
|
|
(format #t "~2Tvelocity: #<vector @ #x~X>~%" (-> obj velocity))
|
|
(format #t "~2Ttracking-status: ~D~%" (-> obj tracking-status))
|
|
(format #t "~2Ttracking-options: ~D~%" (-> obj tracking-options))
|
|
(format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
|
|
(format #t "~2Tfast-rot: ~A~%" (-> obj fast-rot))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-slave
|
|
(deftype camera-slave (process)
|
|
((trans vector :inline :offset-assert 128)
|
|
(fov float :offset-assert 144)
|
|
(fov0 float :offset-assert 148)
|
|
(fov1 float :offset-assert 152)
|
|
(fov-index cam-index :inline :offset-assert 160)
|
|
(tracking cam-rotation-tracker :inline :offset-assert 208)
|
|
(view-off-param float :offset-assert 472)
|
|
(view-off vector :inline :offset-assert 480)
|
|
(joystick-saved-view-off vector :inline :offset-assert 496)
|
|
(min-z-override float :offset-assert 512)
|
|
(view-flat vector :inline :offset-assert 528)
|
|
(string-vel-dir uint32 :offset-assert 544)
|
|
(string-trans vector :inline :offset-assert 560)
|
|
(position-spline tracking-spline :inline :offset-assert 576)
|
|
(pivot-pt vector :inline :offset-assert 2224)
|
|
(pivot-rad float :offset-assert 2240)
|
|
(circular-follow vector :inline :offset-assert 2256)
|
|
(max-angle-offset float :offset-assert 2272)
|
|
(max-angle-curr float :offset-assert 2276)
|
|
(options cam-slave-options-u32 :offset-assert 2280)
|
|
(cam-entity entity :offset-assert 2284)
|
|
(butt-timer uint64 :offset-assert 2288)
|
|
(butt-seek basic :offset-assert 2296)
|
|
(butt-vector vector :inline :offset-assert 2304)
|
|
(velocity vector :inline :offset-assert 2320)
|
|
(desired-pos vector :inline :offset-assert 2336)
|
|
(time-dist-too-far uint32 :offset-assert 2352)
|
|
(los-state slave-los-state :offset-assert 2356)
|
|
(good-point vector :inline :offset-assert 2368)
|
|
(los-tgt-spline-pt int32 :offset-assert 2384)
|
|
(los-tgt-spline-pt-incarnation int32 :offset-assert 2388)
|
|
(los-last-pos vector :inline :offset-assert 2400)
|
|
(intro-curve curve :inline :offset-assert 2416)
|
|
(intro-offset vector :inline :offset-assert 2448)
|
|
(intro-t float :offset-assert 2464)
|
|
(intro-t-step float :offset-assert 2468)
|
|
(outro-exit-value float :offset-assert 2472)
|
|
(spline-exists basic :offset-assert 2476)
|
|
(spline-curve curve :inline :offset-assert 2480)
|
|
(spline-offset vector :inline :offset-assert 2512)
|
|
(index cam-index :inline :offset-assert 2528)
|
|
(saved-pt vector :inline :offset-assert 2576)
|
|
(spline-tt float :offset-assert 2592)
|
|
(spline-follow-dist float :offset-assert 2596)
|
|
(enter-has-run symbol :offset-assert 2600)
|
|
(blend-from-type uint64 :offset-assert 2608)
|
|
(blend-to-type camera-blend-to-type :offset-assert 2616)
|
|
(have-phony-joystick basic :offset-assert 2624)
|
|
(phony-joystick-x float :offset-assert 2628)
|
|
(phony-joystick-y float :offset-assert 2632)
|
|
(string-min-val vector :inline :offset-assert 2640)
|
|
(string-max-val vector :inline :offset-assert 2656)
|
|
(string-val-locked basic :offset-assert 2672)
|
|
(relative-position vector :inline :offset-assert 2688)
|
|
(string-relative basic :offset-assert 2704)
|
|
)
|
|
:heap-base #xa20
|
|
:method-count-assert 14
|
|
:size-assert #xa94
|
|
:flag-assert #xe0a200a94
|
|
(:states
|
|
cam-bike
|
|
cam-circular
|
|
cam-decel
|
|
cam-endlessfall
|
|
cam-eye
|
|
cam-fixed
|
|
cam-fixed-read-entity
|
|
cam-free-floating
|
|
cam-launcher-longfall
|
|
cam-launcher-shortfall
|
|
cam-lookat
|
|
cam-point-watch
|
|
cam-pov
|
|
cam-pov-track
|
|
cam-pov180
|
|
cam-really-fixed
|
|
cam-remote
|
|
cam-robotboss
|
|
cam-spline
|
|
cam-standoff
|
|
cam-standoff-read-entity
|
|
cam-stick
|
|
cam-string
|
|
cam-turret
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type camera-slave
|
|
(defmethod inspect camera-slave ((obj camera-slave))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Ttrans: ~`vector`P~%" (-> obj trans))
|
|
(format #t "~2Tfov: ~f~%" (-> obj fov))
|
|
(format #t "~2Tfov0: ~f~%" (-> obj fov0))
|
|
(format #t "~2Tfov1: ~f~%" (-> obj fov1))
|
|
(format #t "~2Tfov-index: #<cam-index @ #x~X>~%" (-> obj fov-index))
|
|
(format #t "~2Ttracking: #<cam-rotation-tracker @ #x~X>~%" (-> obj tracking))
|
|
(format #t "~2Tview-off-param: ~f~%" (-> obj view-off-param))
|
|
(format #t "~2Tview-off: ~`vector`P~%" (-> obj view-off))
|
|
(format #t "~2Tjoystick-saved-view-off: ~`vector`P~%" (-> obj joystick-saved-view-off))
|
|
(format #t "~2Tmin-z-override: ~f~%" (-> obj min-z-override))
|
|
(format #t "~2Tview-flat: ~`vector`P~%" (-> obj view-flat))
|
|
(format #t "~2Tstring-vel-dir: ~D~%" (-> obj string-vel-dir))
|
|
(format #t "~2Tstring-trans: ~`vector`P~%" (-> obj string-trans))
|
|
(format #t "~2Tposition-spline: #<tracking-spline @ #x~X>~%" (-> obj position-spline))
|
|
(format #t "~2Tpivot-pt: ~`vector`P~%" (-> obj pivot-pt))
|
|
(format #t "~2Tpivot-rad: ~f~%" (-> obj pivot-rad))
|
|
(format #t "~2Tcircular-follow: #<vector @ #x~X>~%" (-> obj circular-follow))
|
|
(format #t "~2Tmax-angle-offset: ~f~%" (-> obj max-angle-offset))
|
|
(format #t "~2Tmax-angle-curr: ~f~%" (-> obj max-angle-curr))
|
|
(format #t "~2Toptions: ~D~%" (-> obj options))
|
|
(format #t "~2Tcam-entity: ~A~%" (-> obj cam-entity))
|
|
(format #t "~2Tbutt-timer: ~D~%" (-> obj butt-timer))
|
|
(format #t "~2Tbutt-seek: ~A~%" (-> obj butt-seek))
|
|
(format #t "~2Tbutt-vector: ~`vector`P~%" (-> obj butt-vector))
|
|
(format #t "~2Tvelocity: ~`vector`P~%" (-> obj velocity))
|
|
(format #t "~2Tdesired-pos: ~`vector`P~%" (-> obj desired-pos))
|
|
(format #t "~2Ttime-dist-too-far: ~D~%" (-> obj time-dist-too-far))
|
|
(format #t "~2Tlos-state: ~D~%" (-> obj los-state))
|
|
(format #t "~2Tgood-point: ~`vector`P~%" (-> obj good-point))
|
|
(format #t "~2Tlos-tgt-spline-pt: ~D~%" (-> obj los-tgt-spline-pt))
|
|
(format #t "~2Tlos-tgt-spline-pt-incarnation: ~D~%" (-> obj los-tgt-spline-pt-incarnation))
|
|
(format #t "~2Tlos-last-pos: ~`vector`P~%" (-> obj los-last-pos))
|
|
(format #t "~2Tintro-curve: #<curve @ #x~X>~%" (-> obj intro-curve))
|
|
(format #t "~2Tintro-offset: #<vector @ #x~X>~%" (-> obj intro-offset))
|
|
(format #t "~2Tintro-t: ~f~%" (-> obj intro-t))
|
|
(format #t "~2Tintro-t-step: ~f~%" (-> obj intro-t-step))
|
|
(format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
|
|
(format #t "~2Tspline-exists: ~A~%" (-> obj spline-exists))
|
|
(format #t "~2Tspline-curve: #<curve @ #x~X>~%" (-> obj spline-curve))
|
|
(format #t "~2Tspline-offset: #<vector @ #x~X>~%" (-> obj spline-offset))
|
|
(format #t "~2Tindex: #<cam-index @ #x~X>~%" (-> obj index))
|
|
(format #t "~2Tsaved-pt: #<vector @ #x~X>~%" (-> obj saved-pt))
|
|
(format #t "~2Tspline-tt: ~f~%" (-> obj spline-tt))
|
|
(format #t "~2Tspline-follow-dist: ~f~%" (-> obj spline-follow-dist))
|
|
(format #t "~2Tenter-has-run: ~A~%" (-> obj enter-has-run))
|
|
(format #t "~2Tblend-from-type: ~D~%" (-> obj blend-from-type))
|
|
(format #t "~2Tblend-to-type: ~D~%" (-> obj blend-to-type))
|
|
(format #t "~2Thave-phony-joystick: ~A~%" (-> obj have-phony-joystick))
|
|
(format #t "~2Tphony-joystick-x: ~f~%" (-> obj phony-joystick-x))
|
|
(format #t "~2Tphony-joystick-y: ~f~%" (-> obj phony-joystick-y))
|
|
(format #t "~2Tstring-min-val: #<vector @ #x~X>~%" (-> obj string-min-val))
|
|
(format #t "~2Tstring-max-val: #<vector @ #x~X>~%" (-> obj string-max-val))
|
|
(format #t "~2Tstring-val-locked: ~A~%" (-> obj string-val-locked))
|
|
(format #t "~2Trelative-position: #<vector @ #x~X>~%" (-> obj relative-position))
|
|
(format #t "~2Tstring-relative: ~A~%" (-> obj string-relative))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; definition of type camera-master
|
|
(deftype camera-master (process)
|
|
((master-options cam-master-options-u32 :offset-assert 128)
|
|
(settings cam-setting-data :offset-assert 132)
|
|
(slave (pointer camera-slave) :offset-assert 136)
|
|
(decel (pointer camera-slave) :offset-assert 140)
|
|
(slave-options uint32 :offset-assert 144)
|
|
(view-off-param-save float :offset-assert 148)
|
|
(changer uint32 :offset-assert 152)
|
|
(string-min cam-vector-seeker :inline :offset-assert 160)
|
|
(string-max cam-vector-seeker :inline :offset-assert 224)
|
|
(string-push-z float :offset-assert 284)
|
|
(local-down vector :inline :offset-assert 288)
|
|
(focus focus :inline :offset-assert 304)
|
|
(being-attacked symbol :offset-assert 316)
|
|
(attack-start time-frame :offset-assert 320)
|
|
(on-ground symbol :offset-assert 328)
|
|
(under-water int32 :offset-assert 332)
|
|
(on-pole symbol :offset-assert 336)
|
|
(tgt-rot-mat matrix :inline :offset-assert 352)
|
|
(tgt-face-mat matrix :inline :offset-assert 416)
|
|
(tpos-old vector :inline :offset-assert 480)
|
|
(tpos-curr vector :inline :offset-assert 496)
|
|
(tpos-old-adj vector :inline :offset-assert 512)
|
|
(tpos-curr-adj vector :inline :offset-assert 528)
|
|
(tpos-tgt vector :inline :offset-assert 544)
|
|
(upspeed float :offset-assert 560)
|
|
(pitch-off vector :inline :offset-assert 576)
|
|
(target-spline tracking-spline :inline :offset-assert 592)
|
|
(ease-from vector :inline :offset-assert 2240)
|
|
(ease-t float :offset-assert 2256)
|
|
(ease-step float :offset-assert 2260)
|
|
(ease-to vector :inline :offset-assert 2272)
|
|
(outro-curve curve :inline :offset-assert 2288)
|
|
(outro-t float :offset-assert 2308)
|
|
(outro-t-step float :offset-assert 2312)
|
|
(outro-exit-value float :offset-assert 2316)
|
|
(water-drip-time time-frame :offset-assert 2320)
|
|
(water-drip sparticle-launch-control :offset-assert 2328)
|
|
(water-drip-mult float :offset-assert 2332)
|
|
(water-drip-speed float :offset-assert 2336)
|
|
)
|
|
:heap-base #x8b0
|
|
:method-count-assert 17
|
|
:size-assert #x924
|
|
:flag-assert #x1108b00924
|
|
(:methods
|
|
(camera-master-method-14 (_type_ vector) vector 14)
|
|
(camera-master-method-15 (_type_ vector) vector 15)
|
|
(camera-master-method-16 (_type_ symbol) int 16)
|
|
)
|
|
(:states
|
|
cam-master-active
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type camera-master
|
|
(defmethod inspect camera-master ((obj camera-master))
|
|
(when (not obj)
|
|
(set! obj obj)
|
|
(goto cfg-4)
|
|
)
|
|
(let ((t9-0 (method-of-type process inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~2Tmaster-options: ~D~%" (-> obj master-options))
|
|
(format #t "~2Tsettings: #<cam-setting-data @ #x~X>~%" (-> obj settings))
|
|
(format #t "~2Tslave: #x~X~%" (-> obj slave))
|
|
(format #t "~2Tdecel: #x~X~%" (-> obj decel))
|
|
(format #t "~2Tslave-options: ~D~%" (-> obj slave-options))
|
|
(format #t "~2Tview-off-param-save: ~f~%" (-> obj view-off-param-save))
|
|
(format #t "~2Tchanger: #x~X~%" (-> obj changer))
|
|
(format #t "~2Tstring-min: #<cam-vector-seeker @ #x~X>~%" (-> obj string-min))
|
|
(format #t "~2Tstring-max: #<cam-vector-seeker @ #x~X>~%" (-> obj string-max))
|
|
(format #t "~2Tstring-push-z: ~f~%" (-> obj string-push-z))
|
|
(format #t "~2Tlocal-down: ~`vector`P~%" (-> obj local-down))
|
|
(format #t "~2Tfocus: #<focus @ #x~X>~%" (-> obj focus))
|
|
(format #t "~2Tbeing-attacked: ~A~%" (-> obj being-attacked))
|
|
(format #t "~2Tattack-start: ~D~%" (-> obj attack-start))
|
|
(format #t "~2Ton-ground: ~A~%" (-> obj on-ground))
|
|
(format #t "~2Tunder-water: ~D~%" (-> obj under-water))
|
|
(format #t "~2Ton-pole: ~A~%" (-> obj on-pole))
|
|
(format #t "~2Ttgt-rot-mat: ~`matrix`P~%" (-> obj tgt-rot-mat))
|
|
(format #t "~2Ttgt-face-mat: ~`matrix`P~%" (-> obj tgt-face-mat))
|
|
(format #t "~2Ttpos-old: ~`vector`P~%" (-> obj tpos-old))
|
|
(format #t "~2Ttpos-curr: ~`vector`P~%" (-> obj tpos-curr))
|
|
(format #t "~2Ttpos-old-adj: ~`vector`P~%" (-> obj tpos-old-adj))
|
|
(format #t "~2Ttpos-curr-adj: ~`vector`P~%" (-> obj tpos-curr-adj))
|
|
(format #t "~2Ttpos-tgt: ~`vector`P~%" (-> obj tpos-tgt))
|
|
(format #t "~2Tupspeed: ~f~%" (-> obj upspeed))
|
|
(format #t "~2Tpitch-off: ~`vector`P~%" (-> obj pitch-off))
|
|
(format #t "~2Ttarget-spline: #<tracking-spline @ #x~X>~%" (-> obj target-spline))
|
|
(format #t "~2Tease-from: #<vector @ #x~X>~%" (-> obj ease-from))
|
|
(format #t "~2Tease-t: ~f~%" (-> obj ease-t))
|
|
(format #t "~2Tease-step: ~f~%" (-> obj ease-step))
|
|
(format #t "~2Tease-to: #<vector @ #x~X>~%" (-> obj ease-to))
|
|
(format #t "~2Toutro-curve: #<curve @ #x~X>~%" (-> obj outro-curve))
|
|
(format #t "~2Toutro-t: ~f~%" (-> obj outro-t))
|
|
(format #t "~2Toutro-t-step: ~f~%" (-> obj outro-t-step))
|
|
(format #t "~2Toutro-exit-value: ~f~%" (-> obj outro-exit-value))
|
|
(format #t "~2Twater-drip-time: ~D~%" (-> obj water-drip-time))
|
|
(format #t "~2Twater-drip: ~A~%" (-> obj water-drip))
|
|
(format #t "~2Twater-drip-mult: ~f~%" (-> obj water-drip-mult))
|
|
(format #t "~2Twater-drip-speed: ~f~%" (-> obj water-drip-speed))
|
|
(label cfg-4)
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
0
|