mirror of
https://github.com/open-goal/jak-project
synced 2026-06-09 04:40:19 -04:00
ManDude
899 lines
35 KiB
Common Lisp
Vendored
Generated
899 lines
35 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition for method 11 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod clear-force-torque! rigid-body ((obj rigid-body))
|
|
(set! (-> obj force quad) (-> *null-vector* quad))
|
|
(set! (-> obj torque quad) (-> *null-vector* quad))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 12 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod clear-momentum! rigid-body ((obj rigid-body))
|
|
(set! (-> obj lin-momentum quad) (-> *null-vector* quad))
|
|
(set! (-> obj ang-momentum quad) (-> *null-vector* quad))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 21 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-21 rigid-body ((obj rigid-body))
|
|
(quaternion->matrix (-> obj matrix) (-> obj rotation))
|
|
(TODO-RENAME-18 obj (-> obj matrix vector 3))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 22 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod TODO-RENAME-22 rigid-body ((obj rigid-body) (arg0 vector) (arg1 quaternion) (arg2 float) (arg3 float))
|
|
(clear-force-torque! obj)
|
|
(clear-momentum! obj)
|
|
(vector+! (-> obj position) arg0 (-> obj cm-offset-joint))
|
|
(quaternion-copy! (-> obj rotation) arg1)
|
|
(quaternion-normalize! (-> obj rotation))
|
|
(set! (-> obj lin-momentum-damping-factor) arg2)
|
|
(set! (-> obj ang-momentum-damping-factor) arg3)
|
|
(TODO-RENAME-21 obj)
|
|
(set! (-> obj lin-velocity quad) (-> *null-vector* quad))
|
|
(set! (-> obj ang-velocity quad) (-> *null-vector* quad))
|
|
(set! (-> obj inv-i-world vector 0 quad) (the-as uint128 0))
|
|
(set! (-> obj inv-i-world vector 1 quad) (the-as uint128 0))
|
|
(set! (-> obj inv-i-world vector 2 quad) (the-as uint128 0))
|
|
(set! (-> obj inv-i-world vector 3 quad) (the-as uint128 0))
|
|
(set! (-> obj max-ang-velocity) 0.0)
|
|
(set! (-> obj max-ang-momentum) 0.0)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 9 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-9 rigid-body ((obj rigid-body) (arg0 float) (arg1 float) (arg2 float) (arg3 float))
|
|
(set! (-> obj mass) arg0)
|
|
(let ((f0-1 arg0))
|
|
(set! (-> obj inv-mass) (/ 1.0 f0-1))
|
|
)
|
|
(matrix-identity! (-> obj inertial-tensor))
|
|
(matrix-identity! (-> obj inv-inertial-tensor))
|
|
(let* ((f0-4 arg0)
|
|
(f1-1 12.0)
|
|
(f0-5 (* f0-4 (/ 1.0 f1-1)))
|
|
)
|
|
(let* ((f1-4 arg2)
|
|
(f1-6 (* f1-4 f1-4))
|
|
(f2-1 arg3)
|
|
)
|
|
(set! (-> obj inertial-tensor vector 0 x) (* f0-5 (+ f1-6 (* f2-1 f2-1))))
|
|
)
|
|
(let* ((f1-9 arg1)
|
|
(f1-11 (* f1-9 f1-9))
|
|
(f2-4 arg3)
|
|
)
|
|
(set! (-> obj inertial-tensor vector 1 y) (* f0-5 (+ f1-11 (* f2-4 f2-4))))
|
|
)
|
|
(let* ((f1-14 arg1)
|
|
(f1-16 (* f1-14 f1-14))
|
|
(f2-7 arg2)
|
|
)
|
|
(set! (-> obj inertial-tensor vector 2 z) (* f0-5 (+ f1-16 (* f2-7 f2-7))))
|
|
)
|
|
)
|
|
(let ((f0-7 (-> obj inertial-tensor vector 0 x)))
|
|
(set! (-> obj inv-inertial-tensor vector 0 x) (/ 1.0 f0-7))
|
|
)
|
|
(let ((f0-10 (-> obj inertial-tensor vector 1 y)))
|
|
(set! (-> obj inv-inertial-tensor vector 1 y) (/ 1.0 f0-10))
|
|
)
|
|
(let ((f0-13 (-> obj inertial-tensor vector 2 z)))
|
|
(set! (-> obj inv-inertial-tensor vector 2 z) (/ 1.0 f0-13))
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 17 of type rigid-body
|
|
(defmethod TODO-RENAME-17 rigid-body ((obj rigid-body) (arg0 vector) (arg1 vector))
|
|
(let ((v1-1 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj position))))
|
|
(vector-cross! arg1 (-> obj ang-velocity) v1-1)
|
|
)
|
|
(vector+! arg1 arg1 (-> obj lin-velocity))
|
|
arg1
|
|
)
|
|
|
|
;; definition for function matrix-3x3-triple-transpose-product
|
|
(defun matrix-3x3-triple-transpose-product ((arg0 matrix) (arg1 matrix) (arg2 matrix))
|
|
(let ((s2-0 (new 'stack-no-clear 'matrix))
|
|
(s3-0 (new 'stack-no-clear 'matrix))
|
|
)
|
|
(matrix-transpose! s2-0 arg1)
|
|
(cond
|
|
(#t
|
|
(matrix*! s3-0 arg1 arg2)
|
|
(matrix*! arg0 s3-0 s2-0)
|
|
)
|
|
(else
|
|
(matrix*! s3-0 s2-0 arg2)
|
|
(matrix*! arg0 s3-0 arg1)
|
|
)
|
|
)
|
|
)
|
|
arg0
|
|
)
|
|
|
|
;; definition for method 10 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod dummy-10 rigid-body ((obj rigid-body) (arg0 float))
|
|
(vector+*! (-> obj lin-momentum) (-> obj lin-momentum) (-> obj force) arg0)
|
|
(vector+*! (-> obj ang-momentum) (-> obj ang-momentum) (-> obj torque) arg0)
|
|
(vector-float*! (-> obj lin-momentum) (-> obj lin-momentum) (-> obj lin-momentum-damping-factor))
|
|
(vector-float*! (-> obj ang-momentum) (-> obj ang-momentum) (-> obj ang-momentum-damping-factor))
|
|
(vector-float*! (-> obj lin-velocity) (-> obj lin-momentum) (-> obj inv-mass))
|
|
(set! (-> obj matrix vector 3 quad) (-> *null-vector* quad))
|
|
(matrix-3x3-triple-transpose-product (-> obj inv-i-world) (-> obj matrix) (-> obj inv-inertial-tensor))
|
|
(vector-rotate*! (-> obj ang-velocity) (-> obj ang-momentum) (-> obj inv-i-world))
|
|
(vector+*! (-> obj position) (-> obj position) (-> obj lin-velocity) arg0)
|
|
(let ((s4-0 (new 'stack-no-clear 'quaternion)))
|
|
(set! (-> (the-as vector (&-> s4-0 x)) quad) (-> obj ang-velocity quad))
|
|
(set! (-> s4-0 w) 0.0)
|
|
(quaternion*! s4-0 s4-0 (-> obj rotation))
|
|
(quaternion-float*! s4-0 s4-0 0.5)
|
|
(+! (-> obj rotation x) (* (-> s4-0 x) arg0))
|
|
(+! (-> obj rotation y) (* (-> s4-0 y) arg0))
|
|
(+! (-> obj rotation z) (* (-> s4-0 z) arg0))
|
|
(+! (-> obj rotation w) (* (-> s4-0 w) arg0))
|
|
)
|
|
(quaternion-normalize! (-> obj rotation))
|
|
(quaternion->matrix (-> obj matrix) (-> obj rotation))
|
|
(TODO-RENAME-18 obj (-> obj matrix vector 3))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 13 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-13 rigid-body ((obj rigid-body) (arg0 vector) (arg1 vector))
|
|
(vector+! (-> obj force) (-> obj force) arg1)
|
|
(let* ((v1-2 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj position)))
|
|
(a1-2 (vector-cross! (new 'stack-no-clear 'vector) v1-2 arg1))
|
|
)
|
|
(vector+! (-> obj torque) (-> obj torque) a1-2)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 16 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-16 rigid-body ((obj rigid-body) (arg0 vector) (arg1 vector) (arg2 float))
|
|
(vector+! (-> obj force) (-> obj force) arg1)
|
|
(let* ((a0-3 (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj position)))
|
|
(s4-1 (vector-cross! (new 'stack-no-clear 'vector) a0-3 arg1))
|
|
)
|
|
(let ((f0-0 (vector-length a0-3)))
|
|
(if (< arg2 f0-0)
|
|
(vector-float*! s4-1 s4-1 (/ arg2 f0-0))
|
|
)
|
|
)
|
|
(vector+! (-> obj torque) (-> obj torque) s4-1)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 14 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-14 rigid-body ((obj rigid-body) (arg0 vector) (arg1 vector))
|
|
(let ((s5-0 (new 'stack-no-clear 'vector))
|
|
(s4-0 (new 'stack-no-clear 'vector))
|
|
)
|
|
(vector-rotate*! s4-0 arg1 (-> obj matrix))
|
|
(vector-rotate*! s5-0 arg0 (-> obj matrix))
|
|
(vector+! s5-0 s5-0 (-> obj position))
|
|
(TODO-RENAME-13 obj s5-0 s4-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 15 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-15 rigid-body ((obj rigid-body) (arg0 vector))
|
|
(vector+! (-> obj force) (-> obj force) arg0)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 18 of type rigid-body
|
|
(defmethod TODO-RENAME-18 rigid-body ((obj rigid-body) (arg0 vector))
|
|
(let ((gp-0 (new 'stack-no-clear 'vector)))
|
|
(vector-rotate*! gp-0 (-> obj cm-offset-joint) (-> obj matrix))
|
|
(vector-! arg0 (-> obj position) gp-0)
|
|
)
|
|
arg0
|
|
)
|
|
|
|
;; definition for method 19 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod dummy-19 rigid-body ((obj rigid-body))
|
|
(format #t " force ~M ~M ~M" (-> obj force x) (-> obj force y) (-> obj force z))
|
|
(format #t " torque ~f ~f ~f~%" (-> obj torque x) (-> obj torque y) (-> obj torque z))
|
|
(format #t " position ~M ~M ~M" (-> obj position x) (-> obj position y) (-> obj position z))
|
|
(format
|
|
#t
|
|
" rotation ~f ~f ~f ~f~%"
|
|
(-> obj rotation x)
|
|
(-> obj rotation y)
|
|
(-> obj rotation z)
|
|
(-> obj rotation w)
|
|
)
|
|
(format #t " lin-mom ~M ~M ~M" (-> obj lin-momentum x) (-> obj lin-momentum y) (-> obj lin-momentum z))
|
|
(format #t " ang-mom ~f ~f ~f~%" (-> obj ang-momentum x) (-> obj ang-momentum y) (-> obj ang-momentum z))
|
|
(format #t " lin-vel ~M ~M ~M" (-> obj lin-velocity x) (-> obj lin-velocity y) (-> obj lin-velocity z))
|
|
(format #t " ang-vel ~f ~f ~f~%" (-> obj ang-velocity x) (-> obj ang-velocity y) (-> obj ang-velocity z))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 20 of type rigid-body
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod dummy-20 rigid-body ((obj rigid-body))
|
|
(format #t " force ~M ~M ~M" (-> obj force x) (-> obj force y) (-> obj force z))
|
|
(format #t " torque ~f ~f ~f~%" (-> obj torque x) (-> obj torque y) (-> obj torque z))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition of type rigid-body-platform-constants
|
|
(deftype rigid-body-platform-constants (structure)
|
|
((drag-factor float :offset-assert 0)
|
|
(buoyancy-factor float :offset-assert 4)
|
|
(max-buoyancy-depth meters :offset-assert 8)
|
|
(gravity-factor float :offset-assert 12)
|
|
(gravity meters :offset-assert 16)
|
|
(player-weight meters :offset-assert 20)
|
|
(player-bonk-factor float :offset-assert 24)
|
|
(player-dive-factor float :offset-assert 28)
|
|
(player-force-distance meters :offset-assert 32)
|
|
(player-force-clamp meters :offset-assert 36)
|
|
(player-force-timeout time-frame :offset-assert 40)
|
|
(explosion-force meters :offset-assert 48)
|
|
(linear-damping float :offset-assert 52)
|
|
(angular-damping float :offset-assert 56)
|
|
(control-point-count int32 :offset-assert 60)
|
|
(mass float :offset-assert 64)
|
|
(inertial-tensor-x meters :offset-assert 68)
|
|
(inertial-tensor-y meters :offset-assert 72)
|
|
(inertial-tensor-z meters :offset-assert 76)
|
|
(cm-joint-x meters :offset-assert 80)
|
|
(cm-joint-y meters :offset-assert 84)
|
|
(cm-joint-z meters :offset-assert 88)
|
|
(idle-distance meters :offset-assert 92)
|
|
(platform symbol :offset-assert 96)
|
|
(sound-name string :offset-assert 100)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x68
|
|
:flag-assert #x900000068
|
|
)
|
|
|
|
;; definition for method 3 of type rigid-body-platform-constants
|
|
(defmethod inspect rigid-body-platform-constants ((obj rigid-body-platform-constants))
|
|
(format #t "[~8x] ~A~%" obj 'rigid-body-platform-constants)
|
|
(format #t "~Tdrag-factor: ~f~%" (-> obj drag-factor))
|
|
(format #t "~Tbuoyancy-factor: ~f~%" (-> obj buoyancy-factor))
|
|
(format #t "~Tmax-buoyancy-depth: (meters ~m)~%" (-> obj max-buoyancy-depth))
|
|
(format #t "~Tgravity-factor: ~f~%" (-> obj gravity-factor))
|
|
(format #t "~Tgravity: (meters ~m)~%" (-> obj gravity))
|
|
(format #t "~Tplayer-weight: (meters ~m)~%" (-> obj player-weight))
|
|
(format #t "~Tplayer-bonk-factor: ~f~%" (-> obj player-bonk-factor))
|
|
(format #t "~Tplayer-dive-factor: ~f~%" (-> obj player-dive-factor))
|
|
(format #t "~Tplayer-force-distance: (meters ~m)~%" (-> obj player-force-distance))
|
|
(format #t "~Tplayer-force-clamp: (meters ~m)~%" (-> obj player-force-clamp))
|
|
(format #t "~Tplayer-force-timeout: ~D~%" (-> obj player-force-timeout))
|
|
(format #t "~Texplosion-force: (meters ~m)~%" (-> obj explosion-force))
|
|
(format #t "~Tlinear-damping: ~f~%" (-> obj linear-damping))
|
|
(format #t "~Tangular-damping: ~f~%" (-> obj angular-damping))
|
|
(format #t "~Tcontrol-point-count: ~D~%" (-> obj control-point-count))
|
|
(format #t "~Tmass: ~f~%" (-> obj mass))
|
|
(format #t "~Tinertial-tensor-x: (meters ~m)~%" (-> obj inertial-tensor-x))
|
|
(format #t "~Tinertial-tensor-y: (meters ~m)~%" (-> obj inertial-tensor-y))
|
|
(format #t "~Tinertial-tensor-z: (meters ~m)~%" (-> obj inertial-tensor-z))
|
|
(format #t "~Tcm-joint-x: (meters ~m)~%" (-> obj cm-joint-x))
|
|
(format #t "~Tcm-joint-y: (meters ~m)~%" (-> obj cm-joint-y))
|
|
(format #t "~Tcm-joint-z: (meters ~m)~%" (-> obj cm-joint-z))
|
|
(format #t "~Tidle-distance: (meters ~m)~%" (-> obj idle-distance))
|
|
(format #t "~Tplatform: ~A~%" (-> obj platform))
|
|
(format #t "~Tsound-name: ~A~%" (-> obj sound-name))
|
|
obj
|
|
)
|
|
|
|
;; definition of type rigid-body-control-point-inline-array
|
|
(deftype rigid-body-control-point-inline-array (inline-array-class)
|
|
((data rigid-body-control-point :inline :dynamic :offset 16)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x10
|
|
:flag-assert #x900000010
|
|
)
|
|
|
|
;; definition for method 3 of type rigid-body-control-point-inline-array
|
|
(defmethod inspect rigid-body-control-point-inline-array ((obj rigid-body-control-point-inline-array))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tlength: ~D~%" (-> obj length))
|
|
(format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
|
|
(format #t "~Tdata[0] @ #x~X~%" (-> obj data))
|
|
obj
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(set! (-> rigid-body-control-point-inline-array heap-base) (the-as uint 48))
|
|
|
|
;; definition of type rigid-body-platform
|
|
(deftype rigid-body-platform (process-drawable)
|
|
((root-overlay collide-shape-moving :offset 112)
|
|
(info rigid-body-platform-constants :offset-assert 176)
|
|
(rbody rigid-body :inline :offset-assert 192)
|
|
(control-point-array rigid-body-control-point-inline-array :offset-assert 616)
|
|
(player-velocity vector :inline :offset-assert 624)
|
|
(player-velocity-prev vector :inline :offset-assert 640)
|
|
(player-force-position vector :inline :offset-assert 656)
|
|
(player-force vector :inline :offset-assert 672)
|
|
(sim-time-remaining float :offset-assert 688)
|
|
(float-height-offset float :offset-assert 692)
|
|
(player-attack-id int32 :offset-assert 696)
|
|
(player-bonk-timeout time-frame :offset-assert 704)
|
|
(water-anim water-anim :offset-assert 712)
|
|
(player-contact basic :offset-assert 716)
|
|
(player-impulse collide-shape-prim-mesh :offset-assert 720)
|
|
)
|
|
:heap-base #x270
|
|
:method-count-assert 35
|
|
:size-assert #x2d4
|
|
:flag-assert #x23027002d4
|
|
(:methods
|
|
(rigid-body-platform-idle () _type_ :state 20)
|
|
(rigid-body-platform-float () _type_ :state 21)
|
|
(TODO-RENAME-22 (_type_ vector float) float 22)
|
|
(TODO-RENAME-23 (_type_ float) none 23)
|
|
(TODO-RENAME-24 (_type_ rigid-body-control-point float) none 24)
|
|
(TODO-RENAME-25 (_type_) none 25)
|
|
(TODO-RENAME-26 (_type_) none 26)
|
|
(TODO-RENAME-27 (_type_ vector) none 27)
|
|
(TODO-RENAME-28 (_type_) none 28)
|
|
(TODO-RENAME-29 (_type_ rigid-body-platform-constants) none 29)
|
|
(TODO-RENAME-30 (_type_) none 30)
|
|
(TODO-RENAME-31 (_type_) none 31)
|
|
(dummy-32 (_type_) sound-id 32)
|
|
(dummy-33 (_type_) object 33)
|
|
(TODO-RENAME-34 (_type_) none 34)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type rigid-body-platform
|
|
(defmethod inspect rigid-body-platform ((obj rigid-body-platform))
|
|
(let ((t9-0 (method-of-type process-drawable inspect)))
|
|
(t9-0 obj)
|
|
)
|
|
(format #t "~T~Tinfo: #<rigid-body-platform-constants @ #x~X>~%" (-> obj info))
|
|
(format #t "~T~Trbody: #<rigid-body @ #x~X>~%" (-> obj rbody))
|
|
(format #t "~T~Tcontrol-point-array: ~A~%" (-> obj control-point-array))
|
|
(format #t "~T~Tplayer-velocity: #<vector @ #x~X>~%" (-> obj player-velocity))
|
|
(format #t "~T~Tplayer-velocity-prev: #<vector @ #x~X>~%" (-> obj player-velocity-prev))
|
|
(format #t "~T~Tplayer-force-position: #<vector @ #x~X>~%" (-> obj player-force-position))
|
|
(format #t "~T~Tplayer-force: #<vector @ #x~X>~%" (-> obj player-force))
|
|
(format #t "~T~Tsim-time-remaining: ~f~%" (-> obj sim-time-remaining))
|
|
(format #t "~T~Tfloat-height-offset: ~f~%" (-> obj float-height-offset))
|
|
(format #t "~T~Tplayer-attack-id: ~D~%" (-> obj player-attack-id))
|
|
(format #t "~T~Tplayer-bonk-timeout: ~D~%" (-> obj player-bonk-timeout))
|
|
(format #t "~T~Twater-anim: ~A~%" (-> obj water-anim))
|
|
(format #t "~T~Tplayer-contact: ~A~%" (-> obj player-contact))
|
|
(format #t "~T~Tplayer-impulse: ~A~%" (-> obj player-impulse))
|
|
obj
|
|
)
|
|
|
|
;; definition for method 7 of type rigid-body-platform
|
|
;; INFO: Return type mismatch process-drawable vs rigid-body-platform.
|
|
(defmethod relocate rigid-body-platform ((obj rigid-body-platform) (arg0 int))
|
|
(if (nonzero? (-> obj control-point-array))
|
|
(set! (-> obj control-point-array)
|
|
(the-as rigid-body-control-point-inline-array (+ (the-as int (-> obj control-point-array)) arg0))
|
|
)
|
|
)
|
|
(the-as
|
|
rigid-body-platform
|
|
((the-as (function process-drawable int process-drawable) (find-parent-method rigid-body-platform 7))
|
|
obj
|
|
arg0
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 22 of type rigid-body-platform
|
|
(defmethod TODO-RENAME-22 rigid-body-platform ((obj rigid-body-platform) (arg0 vector) (arg1 float))
|
|
(let ((v1-0 (-> obj water-anim)))
|
|
0.0
|
|
(+ (the-as float (cond
|
|
(v1-0
|
|
(let* ((a2-1 v1-0)
|
|
(a0-1 (if a2-1
|
|
(-> a2-1 ppointer-water-anim 3)
|
|
)
|
|
)
|
|
)
|
|
(if a0-1
|
|
(get-ripple-height a0-1 arg0)
|
|
(-> v1-0 ppointer-water-anim 9)
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(ocean-get-height arg0)
|
|
)
|
|
)
|
|
)
|
|
(-> obj float-height-offset)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for method 24 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-24 rigid-body-platform ((obj rigid-body-platform) (arg0 rigid-body-control-point) (arg1 float))
|
|
(set! (-> arg0 world-pos w) (TODO-RENAME-22 obj (-> arg0 world-pos) arg1))
|
|
(let* ((s4-0 (new 'stack-no-clear 'vector))
|
|
(f0-2 (- (-> arg0 world-pos w) (-> arg0 world-pos y)))
|
|
(f30-0 (/ f0-2 (-> obj info max-buoyancy-depth)))
|
|
)
|
|
(when (< 0.0 f0-2)
|
|
(vector-float*! s4-0 *y-vector* (* (-> obj rbody mass)
|
|
(fmin 1.0 f30-0)
|
|
(/ (-> obj info gravity) (the float (-> obj info control-point-count)))
|
|
(-> obj info gravity-factor)
|
|
(-> obj info buoyancy-factor)
|
|
)
|
|
)
|
|
(TODO-RENAME-13 (-> obj rbody) (-> arg0 world-pos) s4-0)
|
|
(vector-float*! s4-0 (-> arg0 velocity) (* -1.0 (-> obj info drag-factor) (fmin 1.0 f30-0)))
|
|
(TODO-RENAME-13 (-> obj rbody) (-> arg0 world-pos) s4-0)
|
|
)
|
|
)
|
|
0
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 25 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-25 rigid-body-platform ((obj rigid-body-platform))
|
|
(when (or (-> obj player-impulse) (-> obj player-contact))
|
|
(set! (-> obj player-impulse) #f)
|
|
(TODO-RENAME-16
|
|
(-> obj rbody)
|
|
(-> obj player-force-position)
|
|
(-> obj player-force)
|
|
(-> obj info player-force-distance)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 26 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-26 rigid-body-platform ((obj rigid-body-platform))
|
|
(let ((a1-0 (new 'stack-no-clear 'vector)))
|
|
(vector-float*!
|
|
a1-0
|
|
*y-vector*
|
|
(* -1.0 (-> obj info gravity-factor) (-> obj info gravity) (-> obj rbody mass))
|
|
)
|
|
(TODO-RENAME-15 (-> obj rbody) a1-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 27 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-27 rigid-body-platform ((obj rigid-body-platform) (arg0 vector))
|
|
(let ((gp-0 (new 'stack-no-clear 'vector)))
|
|
(vector-! gp-0 arg0 (-> obj rbody position))
|
|
(set! (-> gp-0 y) 0.0)
|
|
(let* ((f0-1 (vector-length gp-0))
|
|
(f1-1 (* 10.0 (fmax 0.0 (fmin 4096.0 (+ -4096.0 f0-1)))))
|
|
)
|
|
(when (< 0.0 f1-1)
|
|
(vector-float*! gp-0 gp-0 (/ f1-1 f0-1))
|
|
(TODO-RENAME-15 (-> obj rbody) gp-0)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 23 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-23 rigid-body-platform ((obj rigid-body-platform) (arg0 float))
|
|
(let ((s4-0 (-> obj rbody matrix)))
|
|
(dotimes (s3-0 (-> obj info control-point-count))
|
|
(let ((s2-0 (-> obj control-point-array data s3-0)))
|
|
(vector-matrix*! (-> s2-0 world-pos) (-> s2-0 local-pos) s4-0)
|
|
(TODO-RENAME-17 (-> obj rbody) (-> s2-0 world-pos) (-> s2-0 velocity))
|
|
(TODO-RENAME-24 obj s2-0 arg0)
|
|
)
|
|
)
|
|
)
|
|
(TODO-RENAME-26 obj)
|
|
(TODO-RENAME-25 obj)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 28 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod TODO-RENAME-28 rigid-body-platform ((obj rigid-body-platform))
|
|
(if (-> obj info platform)
|
|
(detect-riders! (-> obj root-overlay))
|
|
)
|
|
(set! (-> obj player-velocity-prev quad) (-> obj player-velocity quad))
|
|
(if *target*
|
|
(set! (-> obj player-velocity quad) (-> *target* control transv quad))
|
|
(set! (-> obj player-velocity quad) (-> *null-vector* quad))
|
|
)
|
|
(+! (-> obj sim-time-remaining)
|
|
(* 0.0033333334 (the float (- (-> *display* base-frame-counter) (-> *display* old-base-frame-counter))))
|
|
)
|
|
(let ((f30-0 0.016666668)
|
|
(f28-0 (* 0.0033333334 (the float (logand #xffffff (-> *display* base-frame-counter)))))
|
|
)
|
|
(while (>= (-> obj sim-time-remaining) (* 0.5 f30-0))
|
|
(clear-force-torque! (-> obj rbody))
|
|
(TODO-RENAME-23 obj f28-0)
|
|
(dummy-10 (-> obj rbody) f30-0)
|
|
(set! (-> obj sim-time-remaining) (- (-> obj sim-time-remaining) f30-0))
|
|
)
|
|
)
|
|
(set! (-> obj player-contact) #f)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for function rigid-body-platform-event-handler
|
|
;; Used lq/sq
|
|
(defbehavior rigid-body-platform-event-handler rigid-body-platform ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
|
|
(case arg2
|
|
(('bonk)
|
|
(when (>= (- (-> *display* base-frame-counter) (-> self player-bonk-timeout)) (-> self info player-force-timeout))
|
|
(set! (-> self player-bonk-timeout) (-> *display* base-frame-counter))
|
|
(let* ((s5-0 arg0)
|
|
(v1-7 (if (and (nonzero? s5-0) (type-type? (-> s5-0 type) process-drawable))
|
|
s5-0
|
|
)
|
|
)
|
|
)
|
|
(when v1-7
|
|
(set! (-> self player-impulse) (the-as collide-shape-prim-mesh #t))
|
|
(set! (-> self player-force-position quad) (-> (the-as process-drawable v1-7) root trans quad))
|
|
(let ((f0-4 (fmin
|
|
(* 0.00012207031
|
|
(the-as float (-> arg3 param 1))
|
|
(-> self info player-bonk-factor)
|
|
(-> self info player-weight)
|
|
)
|
|
(-> self info player-force-clamp)
|
|
)
|
|
)
|
|
)
|
|
(vector-float*! (-> self player-force) *y-vector* (- f0-4))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('attack)
|
|
(let ((v1-16 (-> arg3 param 2)))
|
|
(when (!= v1-16 (-> self player-attack-id))
|
|
(set! (-> self player-attack-id) (the-as int v1-16))
|
|
(cond
|
|
((= (-> arg3 param 1) 'flop)
|
|
(when (>= (- (-> *display* base-frame-counter) (-> self player-bonk-timeout)) (-> self info player-force-timeout))
|
|
(set! (-> self player-bonk-timeout) (-> *display* base-frame-counter))
|
|
(let* ((gp-1 arg0)
|
|
(v1-24 (if (and (nonzero? gp-1) (type-type? (-> gp-1 type) process-drawable))
|
|
gp-1
|
|
)
|
|
)
|
|
)
|
|
(when v1-24
|
|
(set! (-> self player-impulse) (the-as collide-shape-prim-mesh #t))
|
|
(set! (-> self player-force-position quad) (-> (the-as process-drawable v1-24) root trans quad))
|
|
(let ((f0-9 (fmin
|
|
(* 16.0 (-> self info player-weight) (-> self info player-dive-factor))
|
|
(-> self info player-force-clamp)
|
|
)
|
|
)
|
|
)
|
|
(vector-float*! (-> self player-force) *y-vector* (- f0-9))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
((= (-> arg3 param 1) 'explode)
|
|
(let* ((gp-2 arg0)
|
|
(v1-34 (if (and (nonzero? gp-2) (type-type? (-> gp-2 type) process-drawable))
|
|
gp-2
|
|
)
|
|
)
|
|
)
|
|
(when v1-34
|
|
(set! (-> self player-impulse) (the-as collide-shape-prim-mesh #t))
|
|
(set! (-> self player-force-position quad) (-> (the-as process-drawable v1-34) root trans quad))
|
|
(vector-! (-> self player-force) (-> self rbody position) (-> (the-as process-drawable v1-34) root trans))
|
|
(vector-normalize! (-> self player-force) (-> self info explosion-force))
|
|
)
|
|
)
|
|
)
|
|
(else
|
|
(the-as vector #f)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('impulse)
|
|
(let ((s5-1 arg0))
|
|
(when (if (and (nonzero? s5-1) (type-type? (-> s5-1 type) process-drawable))
|
|
s5-1
|
|
)
|
|
(set! (-> self player-impulse) (the-as collide-shape-prim-mesh #t))
|
|
(set! (-> self player-force-position quad) (-> self rbody position quad))
|
|
(let ((v0-0 (-> self player-force)))
|
|
(set! (-> v0-0 quad) (-> (the-as vector (-> arg3 param 0)) quad))
|
|
v0-0
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(('edge-grabbed)
|
|
(let ((v1-44 (-> arg3 param 0)))
|
|
(when (not (-> self player-impulse))
|
|
(set! (-> self player-contact) #t)
|
|
(set! (-> self player-force-position quad) (-> (the-as vector (+ v1-44 32)) quad))
|
|
(vector-float*! (-> self player-force) *y-vector* (* -1.0 (-> self info player-weight)))
|
|
)
|
|
)
|
|
)
|
|
(('ridden)
|
|
(let ((v1-48 (the-as object (-> arg3 param 0))))
|
|
(when (the-as uint v1-48)
|
|
(let ((v1-50 (handle->process (-> (the-as (pointer handle) v1-48) 0))))
|
|
(when (and v1-50 (= v1-50 *target*) (!= (-> *target* control unknown-surface00 mode) 'swim))
|
|
(when (not (-> self player-impulse))
|
|
(set! (-> self player-contact) #t)
|
|
(set! (-> self player-force-position quad) (-> (the-as process-drawable v1-50) root trans quad))
|
|
(set! (-> self player-force quad) (-> *null-vector* quad))
|
|
(vector+*! (-> self player-force) (-> self player-force) *y-vector* (* -1.0 (-> self info player-weight)))
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition for function rigid-body-platform-post
|
|
(defbehavior rigid-body-platform-post rigid-body-platform ()
|
|
(set! (-> self rbody lin-momentum-damping-factor) (-> self info linear-damping))
|
|
(set! (-> self rbody ang-momentum-damping-factor) (-> self info angular-damping))
|
|
(if (-> self player-impulse)
|
|
(sound-play-by-name (string->sound-name (-> self info sound-name)) (new-sound-id) 1024 0 0 1 #t)
|
|
)
|
|
(TODO-RENAME-28 self)
|
|
(quaternion-copy! (-> self root-overlay quat) (-> self rbody rotation))
|
|
(TODO-RENAME-18 (-> self rbody) (-> self root-overlay trans))
|
|
(if (-> self info platform)
|
|
(rider-post)
|
|
(transform-post)
|
|
)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate rigid-body-platform-idle (rigid-body-platform)
|
|
:virtual #t
|
|
:trans
|
|
(behavior ()
|
|
(if (and *target* (>= (-> self info idle-distance)
|
|
(vector-vector-distance (-> self root-overlay trans) (-> *target* control trans))
|
|
)
|
|
)
|
|
(go-virtual rigid-body-platform-float)
|
|
)
|
|
(none)
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(while #t
|
|
(suspend)
|
|
)
|
|
(none)
|
|
)
|
|
:post
|
|
(the-as (function none :behavior rigid-body-platform) ja-post)
|
|
)
|
|
|
|
;; failed to figure out what this is:
|
|
(defstate rigid-body-platform-float (rigid-body-platform)
|
|
:virtual #t
|
|
:event
|
|
rigid-body-platform-event-handler
|
|
:trans
|
|
(behavior ()
|
|
(if (or (not *target*) (< (-> self info idle-distance)
|
|
(vector-vector-distance (-> self root-overlay trans) (-> *target* control trans))
|
|
)
|
|
)
|
|
(go-virtual rigid-body-platform-idle)
|
|
)
|
|
(none)
|
|
)
|
|
:code
|
|
(behavior ()
|
|
(while #t
|
|
(suspend)
|
|
)
|
|
(none)
|
|
)
|
|
:post
|
|
(the-as (function none :behavior rigid-body-platform) rigid-body-platform-post)
|
|
)
|
|
|
|
;; definition for method 29 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
;; Used lq/sq
|
|
(defmethod TODO-RENAME-29 rigid-body-platform ((obj rigid-body-platform) (arg0 rigid-body-platform-constants))
|
|
(set! (-> obj info) arg0)
|
|
(set! (-> obj control-point-array)
|
|
(new 'process 'rigid-body-control-point-inline-array (-> obj info control-point-count))
|
|
)
|
|
(logior! (-> obj skel status) (janim-status inited))
|
|
(update-transforms! (-> obj root-overlay))
|
|
(set-vector!
|
|
(-> obj rbody cm-offset-joint)
|
|
(-> obj info cm-joint-x)
|
|
(-> obj info cm-joint-y)
|
|
(-> obj info cm-joint-z)
|
|
1.0
|
|
)
|
|
(TODO-RENAME-22
|
|
(-> obj rbody)
|
|
(-> obj root-overlay trans)
|
|
(-> obj root-overlay quat)
|
|
(-> obj info linear-damping)
|
|
(-> obj info angular-damping)
|
|
)
|
|
(TODO-RENAME-9
|
|
(-> obj rbody)
|
|
(-> obj info mass)
|
|
(-> obj info inertial-tensor-x)
|
|
(-> obj info inertial-tensor-y)
|
|
(-> obj info inertial-tensor-z)
|
|
)
|
|
(set! (-> obj player-impulse) #f)
|
|
(set! (-> obj player-contact) #f)
|
|
(set! (-> obj player-bonk-timeout) (-> *display* base-frame-counter))
|
|
(set! (-> obj player-force quad) (-> *null-vector* quad))
|
|
(set! (-> obj player-velocity quad) (-> *null-vector* quad))
|
|
(set! (-> obj player-velocity-prev quad) (-> *null-vector* quad))
|
|
(set! (-> obj water-anim) (the-as water-anim (entity-actor-lookup (-> obj entity) 'water-actor 0)))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 30 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-30 rigid-body-platform ((obj rigid-body-platform))
|
|
(let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
|
|
(set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
|
|
(set! (-> s5-0 reaction) default-collision-reaction)
|
|
(set! (-> s5-0 no-reaction)
|
|
(the-as (function collide-shape-moving collide-shape-intersect vector vector none) nothing)
|
|
)
|
|
(alloc-riders s5-0 1)
|
|
(let ((s4-0 (new 'process 'collide-shape-prim-mesh s5-0 (the-as uint 0) (the-as uint 0))))
|
|
(set! (-> s4-0 prim-core collide-as) (collide-kind ground-object))
|
|
(set! (-> s4-0 collide-with) (collide-kind target))
|
|
(set! (-> s4-0 prim-core action) (collide-action solid ca-1))
|
|
(set! (-> s4-0 prim-core offense) (collide-offense indestructible))
|
|
(set! (-> s4-0 transform-index) 0)
|
|
(set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 20480.0)
|
|
(set-root-prim! s5-0 s4-0)
|
|
)
|
|
(set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
|
|
(backup-collide-with-as s5-0)
|
|
(set! (-> obj root-overlay) s5-0)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for symbol *rigid-body-platform-constants*, type rigid-body-platform-constants
|
|
(define *rigid-body-platform-constants* (new 'static 'rigid-body-platform-constants
|
|
:drag-factor 0.8
|
|
:buoyancy-factor 1.5
|
|
:max-buoyancy-depth (meters 1.5)
|
|
:gravity-factor 1.0
|
|
:gravity (meters 10)
|
|
:player-weight (meters 6.6)
|
|
:player-bonk-factor 1.0
|
|
:player-dive-factor 1.0
|
|
:player-force-distance (meters 1000)
|
|
:player-force-clamp (meters 1000000)
|
|
:player-force-timeout (seconds 0.1)
|
|
:explosion-force (meters 1000)
|
|
:linear-damping 1.0
|
|
:angular-damping 1.0
|
|
:control-point-count 1
|
|
:mass 2.0
|
|
:inertial-tensor-x (meters 3)
|
|
:inertial-tensor-y (meters 2)
|
|
:inertial-tensor-z (meters 3)
|
|
:idle-distance (meters 50)
|
|
:platform #t
|
|
:sound-name #f
|
|
)
|
|
)
|
|
|
|
;; definition for method 34 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-34 rigid-body-platform ((obj rigid-body-platform))
|
|
(go (method-of-object obj rigid-body-platform-idle))
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 31 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod TODO-RENAME-31 rigid-body-platform ((obj rigid-body-platform))
|
|
(set! (-> obj float-height-offset) 0.0)
|
|
(TODO-RENAME-29 obj *rigid-body-platform-constants*)
|
|
(let ((s5-0 (-> obj info control-point-count)))
|
|
(dotimes (s4-0 s5-0)
|
|
(let ((s3-0 (-> obj control-point-array data s4-0)))
|
|
(let ((f30-0 (* 65536.0 (/ (the float s4-0) (the float s5-0)))))
|
|
(set! (-> s3-0 local-pos x) (* 12288.0 (sin f30-0)))
|
|
(set! (-> s3-0 local-pos y) -10240.0)
|
|
(set! (-> s3-0 local-pos z) (* 12288.0 (cos f30-0)))
|
|
)
|
|
(set! (-> s3-0 local-pos w) 1.0)
|
|
)
|
|
)
|
|
)
|
|
0
|
|
(none)
|
|
)
|
|
|
|
;; definition for method 11 of type rigid-body-platform
|
|
;; INFO: Return type mismatch int vs none.
|
|
(defmethod init-from-entity! rigid-body-platform ((obj rigid-body-platform) (arg0 entity-actor))
|
|
(set! (-> obj mask) (logior (process-mask platform) (-> obj mask)))
|
|
(TODO-RENAME-30 obj)
|
|
(process-drawable-from-entity! obj arg0)
|
|
(TODO-RENAME-31 obj)
|
|
(TODO-RENAME-34 obj)
|
|
0
|
|
(none)
|
|
)
|