;;-*-Lisp-*-
(in-package goal)

;; definition of type ragdoll-edit-info
(deftype ragdoll-edit-info (structure)
  ((editing          symbol)
   (current-func     uint64)
   (analog-func      uint64)
   (affect           uint64)
   (single-step      uint64)
   (collision        symbol)
   (gravity          symbol)
   (skel-visible     uint64)
   (current-joint    int8)
   (auto-setup-now   basic)
   (child-stack      ragdoll-joint  60)
   (child-stack-num  int8)
   (last-frame       time-frame)
   (last-frame-dur   time-frame)
   )
  (:methods
    (has-joint? (_type_ ragdoll-joint) symbol)
    (ragdoll-edit-info-method-10 (_type_ object ragdoll-joint) symbol)
    (fill-child-stack! (_type_ ragdoll) none)
    (ragdoll-edit-info-method-12 (_type_) none)
    (cycle-joints! (_type_ ragdoll) none)
    (ragdoll-edit-info-method-14 (_type_ matrix vector (inline-array ragdoll-joint) ragdoll process-drawable) vector)
    (ragdoll-edit-info-method-15 (_type_) none)
    (ragdoll-edit-info-method-16 (_type_ ragdoll process-drawable) none)
    (ragdoll-edit-info-method-17 (_type_ ragdoll process-drawable) none)
    )
  )

;; definition for method 3 of type ragdoll-edit-info
(defmethod inspect ((this ragdoll-edit-info))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'ragdoll-edit-info)
  (format #t "~1Tediting: ~A~%" (-> this editing))
  (format #t "~1Tcurrent-func: ~D~%" (-> this current-func))
  (format #t "~1Tanalog-func: ~D~%" (-> this analog-func))
  (format #t "~1Taffect: ~D~%" (-> this affect))
  (format #t "~1Tsingle-step: ~D~%" (-> this single-step))
  (format #t "~1Tcollision: ~A~%" (-> this collision))
  (format #t "~1Tgravity: ~A~%" (-> this gravity))
  (format #t "~1Tskel-visible: ~D~%" (-> this skel-visible))
  (format #t "~1Tcurrent-joint: ~D~%" (-> this current-joint))
  (format #t "~1Tauto-setup-now: ~A~%" (-> this auto-setup-now))
  (format #t "~1Tchild-stack[60] @ #x~X~%" (-> this child-stack))
  (format #t "~1Tchild-stack-num: ~D~%" (-> this child-stack-num))
  (format #t "~1Tlast-frame: ~D~%" (-> this last-frame))
  (format #t "~1Tlast-frame-dur: ~D~%" (-> this last-frame-dur))
  (label cfg-4)
  this
  )

;; definition for symbol *ragdoll-edit-info*, type ragdoll-edit-info
(define *ragdoll-edit-info* (the-as ragdoll-edit-info 0))

;; definition for symbol *ragdoll-edit-info*, type ragdoll-edit-info
(define *ragdoll-edit-info* (new 'static 'ragdoll-edit-info
                              :editing #t
                              :current-func #x9
                              :single-step #x2
                              :collision #t
                              :gravity #t
                              :skel-visible #x1
                              )
        )

;; definition of type ragdoll-joint-setup
(deftype ragdoll-joint-setup (structure)
  ((joint-index   int32)
   (parent-joint  int32)
   (joint-type    uint64)
   (pre-tform     vector  :inline)
   (geo-tform     vector  :inline)
   (axial-slop    float)
   (max-angle     float)
   (coll-rad      float)
   (hit-sound     uint16)
   )
  )

;; definition for method 3 of type ragdoll-joint-setup
(defmethod inspect ((this ragdoll-joint-setup))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'ragdoll-joint-setup)
  (format #t "~1Tjoint-index: ~D~%" (-> this joint-index))
  (format #t "~1Tparent-joint: ~D~%" (-> this parent-joint))
  (format #t "~1Tjoint-type: ~D~%" (-> this joint-type))
  (format #t "~1Tpre-tform: #<vector @ #x~X>~%" (-> this pre-tform))
  (format #t "~1Tgeo-tform: #<vector @ #x~X>~%" (-> this geo-tform))
  (format #t "~1Taxial-slop: ~f~%" (-> this axial-slop))
  (format #t "~1Tmax-angle: ~f~%" (-> this max-angle))
  (format #t "~1Tcoll-rad: ~f~%" (-> this coll-rad))
  (format #t "~1Thit-sound: ~D~%" (-> this hit-sound))
  (label cfg-4)
  this
  )

;; definition of type ragdoll-setup
(deftype ragdoll-setup (structure)
  ((orient-tform     vector  :inline)
   (scale            vector  :inline)
   (bg-collide-with  collide-spec)
   (joint-setup      (array ragdoll-joint-setup))
   )
  )

;; definition for method 3 of type ragdoll-setup
(defmethod inspect ((this ragdoll-setup))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'ragdoll-setup)
  (format #t "~1Torient-tform: #<vector @ #x~X>~%" (-> this orient-tform))
  (format #t "~1Tscale: #<vector @ #x~X>~%" (-> this scale))
  (format #t "~1Tbg-collide-with: ~D~%" (-> this bg-collide-with))
  (format #t "~1Tjoint-setup: ~A~%" (-> this joint-setup))
  (label cfg-4)
  this
  )

;; definition of type ragdoll-joint
(deftype ragdoll-joint (structure)
  ((quat                 quaternion  :inline)
   (position             vector      :inline)
   (velocity             vector      :inline)
   (bounce               vector      :inline)
   (old-x                vector      :inline)
   (pre-tform            vector      :inline)
   (geo-tform            vector      :inline)
   (axial-slop           float)
   (max-angle            degrees)
   (joint-length         float)
   (coll-rad             float)
   (ragdoll-joint-flags  ragdoll-joint-flag)
   (joint-type           uint64)
   (joint-index          int8)
   (parent-joint         int8)
   (parent-index         int8)
   (num-children         int8)
   (old-param0           basic)
   (hit-sound            sound-name)
   (ground-pat           pat-surface)
   (user0                int32)
   (original-speed       float)
   )
  )

;; definition for method 3 of type ragdoll-joint
;; INFO: Used lq/sq
(defmethod inspect ((this ragdoll-joint))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this 'ragdoll-joint)
  (format #t "~1Tquat: #<quaternion @ #x~X>~%" (-> this quat))
  (format #t "~1Tposition: #<vector @ #x~X>~%" (-> this position))
  (format #t "~1Tvelocity: #<vector @ #x~X>~%" (-> this velocity))
  (format #t "~1Tbounce: #<vector @ #x~X>~%" (-> this bounce))
  (format #t "~1Told-x: #<vector @ #x~X>~%" (-> this old-x))
  (format #t "~1Tpre-tform: #<vector @ #x~X>~%" (-> this pre-tform))
  (format #t "~1Tgeo-tform: #<vector @ #x~X>~%" (-> this geo-tform))
  (format #t "~1Taxial-slop: ~f~%" (-> this axial-slop))
  (format #t "~1Tmax-angle: ~f~%" (-> this max-angle))
  (format #t "~1Tjoint-length: ~f~%" (-> this joint-length))
  (format #t "~1Tcoll-rad: ~f~%" (-> this coll-rad))
  (format #t "~1Tragdoll-joint-flags: ~D~%" (-> this ragdoll-joint-flags))
  (format #t "~1Tjoint-type: ~D~%" (-> this joint-type))
  (format #t "~1Tjoint-index: ~D~%" (-> this joint-index))
  (format #t "~1Tparent-joint: ~D~%" (-> this parent-joint))
  (format #t "~1Tparent-index: ~D~%" (-> this parent-index))
  (format #t "~1Tnum-children: ~D~%" (-> this num-children))
  (format #t "~1Told-param0: ~A~%" (-> this old-param0))
  (format #t "~1Thit-sound: ~D~%" (-> this hit-sound))
  (format #t "~1Tground-pat: #x~X~%" (-> this ground-pat))
  (format #t "~1Tuser0: ~D~%" (-> this user0))
  (format #t "~1Toriginal-speed: ~f~%" (-> this original-speed))
  (label cfg-4)
  this
  )

;; definition of type ragdoll
(deftype ragdoll (basic)
  ((ragdoll-joints         ragdoll-joint  60 :inline)
   (num-joints             uint8)
   (mirror                 matrix         :inline)
   (gravity                vector         :inline)
   (gravity-target         vector         :inline)
   (orient-tform           vector         :inline)
   (scale                  vector         :inline)
   (stretch-vel            float)
   (stretch-vel-parallel   float)
   (compress-vel           float)
   (compress-vel-parallel  float)
   (momentum               float)
   (maximum-stretch        float)
   (turn-off-start         time-frame)
   (turn-off-duration      time-frame)
   (copy-velocity-start    time-frame)
   (root-offset            vector         :inline)
   (rotate-vel             quaternion     :inline)
   (rotate-adj             quaternion     :inline)
   (rotate-adj-count       int8)
   (ragdoll-flags          ragdoll-flag)
   (flex-blend             float)
   (stable-joints          int8)
   (ragdoll-joint-remap    uint8          100)
   (allow-destabilize      uint64)
   (bg-collide-with        uint32)
   (water-info             water-info     :inline)
   )
  (:methods
    (ragdoll-method-9 (_type_ matrix process-drawable) none)
    (ragdoll-method-10 (_type_ process-drawable symbol vector symbol) none)
    (turn-off-for-duration! (_type_ time-frame) none)
    (get-parent-joint (_type_ (inline-array ragdoll-joint)) ragdoll-joint)
    (ragdoll-method-13 (_type_ ragdoll-edit-info ragdoll-joint matrix matrix) none)
    (ragdoll-method-14 (_type_ process-drawable ragdoll-joint object matrix) none)
    (ragdoll-method-15 (_type_ process-drawable ragdoll-edit-info) none)
    (ragdoll-setup! (_type_ process-drawable ragdoll-setup) none)
    (ragdoll-method-17 (_type_ process-drawable) none)
    (ragdoll-method-18 (_type_) none)
    (ragdoll-method-19 (_type_ vector int object matrix) none)
    (reset-vec! (_type_ vector) none)
    (ragdoll-method-21 (_type_ vector vector float) vector)
    (get-max-angle-for-joint-idx (_type_ int) degrees)
    (ragdoll-method-23 (_type_ vector vector float symbol) none)
    (ragdoll-method-24 (_type_ vector int) none)
    (enable-ragdoll! (_type_ process-drawable) none)
    )
  )

;; definition for method 3 of type ragdoll
(defmethod inspect ((this ragdoll))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" this (-> this type))
  (format #t "~1Tragdoll-joints[60] @ #x~X~%" (-> this ragdoll-joints))
  (format #t "~1Tnum-joints: ~D~%" (-> this num-joints))
  (format #t "~1Tmirror: #<matrix @ #x~X>~%" (-> this mirror))
  (format #t "~1Tgravity: #<vector @ #x~X>~%" (-> this gravity))
  (format #t "~1Tgravity-target: #<vector @ #x~X>~%" (-> this gravity-target))
  (format #t "~1Torient-tform: #<vector @ #x~X>~%" (-> this orient-tform))
  (format #t "~1Tscale: #<vector @ #x~X>~%" (-> this scale))
  (format #t "~1Tstretch-vel: ~f~%" (-> this stretch-vel))
  (format #t "~1Tstretch-vel-parallel: ~f~%" (-> this stretch-vel-parallel))
  (format #t "~1Tcompress-vel: ~f~%" (-> this compress-vel))
  (format #t "~1Tcompress-vel-parallel: ~f~%" (-> this compress-vel-parallel))
  (format #t "~1Tmomentum: ~f~%" (-> this momentum))
  (format #t "~1Tmaximum-stretch: ~f~%" (-> this maximum-stretch))
  (format #t "~1Tturn-off-start: ~D~%" (-> this turn-off-start))
  (format #t "~1Tturn-off-duration: ~D~%" (-> this turn-off-duration))
  (format #t "~1Tcopy-velocity-start: ~D~%" (-> this copy-velocity-start))
  (format #t "~1Troot-offset: #<vector @ #x~X>~%" (-> this root-offset))
  (format #t "~1Trotate-vel: #<quaternion @ #x~X>~%" (-> this rotate-vel))
  (format #t "~1Trotate-adj: #<quaternion @ #x~X>~%" (-> this rotate-adj))
  (format #t "~1Trotate-adj-count: ~D~%" (-> this rotate-adj-count))
  (format #t "~1Tragdoll-flags: ~D~%" (-> this ragdoll-flags))
  (format #t "~1Tflex-blend: ~f~%" (-> this flex-blend))
  (format #t "~1Tstable-joints: ~D~%" (-> this stable-joints))
  (format #t "~1Tragdoll-joint-remap[100] @ #x~X~%" (-> this ragdoll-joint-remap))
  (format #t "~1Tallow-destabilize: ~D~%" (-> this allow-destabilize))
  (format #t "~1Tbg-collide-with: ~D~%" (-> this bg-collide-with))
  (format #t "~1Twater-info: #<water-info @ #x~X>~%" (-> this water-info))
  (label cfg-4)
  this
  )

;; definition of type ragdoll-proc
(deftype ragdoll-proc (process)
  ((ragdoll         ragdoll)
   (last-attack-id  uint32)
   )
  (:methods
    (ragdoll-proc-method-15 () none)
    (ragdoll-proc-method-16 () none)
    (ragdoll-proc-method-17 () none)
    (ragdoll-proc-method-18 () none)
    (ragdoll-proc-method-19 () none)
    (ragdoll-proc-method-20 () none)
    )
  )

;; definition for method 3 of type ragdoll-proc
(defmethod inspect ((this ragdoll-proc))
  (when (not this)
    (set! this this)
    (goto cfg-4)
    )
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 this)
    )
  (format #t "~2Tragdoll: ~A~%" (-> this ragdoll))
  (format #t "~2Tlast-attack-id: ~D~%" (-> this last-attack-id))
  (label cfg-4)
  this
  )

;; failed to figure out what this is:
0