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

;; definition of type manipy
(deftype manipy (process-drawable)
  ((new-trans-hook       (function none)         :offset-assert 176)
   (cur-trans-hook       (function none)         :offset-assert 180)
   (cur-event-hook       (function none)         :offset-assert 184)
   (new-joint-anim       art-joint-anim          :offset-assert 188)
   (new-joint-anim-blend uint64                  :offset-assert 192)
   (anim-mode            symbol                  :offset-assert 200)
   (cur-grab-handle      handle                  :offset-assert 208)
   (cur-target-handle    handle                  :offset-assert 216)
   (old-grab-pos         vector          :inline :offset-assert 224)
   (joint                joint-mod       4       :offset-assert 240)
   (new-post-hook        (function none)         :offset-assert 256)
   (cur-post-hook        (function none)         :offset-assert 260)
   (clone-copy-trans     basic                   :offset-assert 264)
   (shadow-backup        basic                   :offset-assert 268)
   (draw?                symbol                  :offset-assert 272)
   )
  :heap-base #xb0
  :method-count-assert 20
  :size-assert         #x114
  :flag-assert         #x1400b00114
  (:states
    manipy-idle
    )
  )

;; definition for method 3 of type manipy
(defmethod inspect manipy ((obj manipy))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tnew-trans-hook: ~A~%" (-> obj new-trans-hook))
  (format #t "~T~Tcur-trans-hook: ~A~%" (-> obj cur-trans-hook))
  (format #t "~T~Tcur-event-hook: ~A~%" (-> obj cur-event-hook))
  (format #t "~T~Tnew-joint-anim: ~A~%" (-> obj new-joint-anim))
  (format #t "~T~Tnew-joint-anim-blend: ~D~%" (-> obj new-joint-anim-blend))
  (format #t "~T~Tanim-mode: ~A~%" (-> obj anim-mode))
  (format #t "~T~Tcur-grab-handle: ~D~%" (-> obj cur-grab-handle))
  (format #t "~T~Tcur-target-handle: ~D~%" (-> obj cur-target-handle))
  (format #t "~T~Told-grab-pos: ~`vector`P~%" (-> obj old-grab-pos))
  (format #t "~T~Tjoint[4] @ #x~X~%" (-> obj joint))
  (format #t "~T~Tnew-post-hook: ~A~%" (-> obj new-post-hook))
  (format #t "~T~Tcur-post-hook: ~A~%" (-> obj cur-post-hook))
  (format #t "~T~Tclone-copy-trans: ~A~%" (-> obj clone-copy-trans))
  (format #t "~T~Tshadow-backup: ~A~%" (-> obj shadow-backup))
  (format #t "~T~Tdraw?: ~A~%" (-> obj draw?))
  obj
  )

;; definition of type part-spawner
(deftype part-spawner (process-drawable)
  ((mode         (pointer sparticle-launch-group)         :offset-assert 176)
   (enable       symbol                                   :offset-assert 180)
   (radius       meters                                   :offset-assert 184)
   (world-sphere sphere                           :inline :offset-assert 192)
   )
  :heap-base #x60
  :method-count-assert 21
  :size-assert         #xd0
  :flag-assert         #x15006000d0
  (:methods
    (is-visible? (_type_) symbol 20)
    )
  (:states
    part-spawner-active
    )
  )

;; definition for method 3 of type part-spawner
(defmethod inspect part-spawner ((obj part-spawner))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tmode: #x~X~%" (-> obj mode))
  (format #t "~T~Tenable: ~A~%" (-> obj enable))
  (format #t "~T~Tradius: (meters ~m)~%" (-> obj radius))
  (format #t "~T~Tworld-sphere: #<sphere @ #x~X>~%" (-> obj world-sphere))
  obj
  )

;; definition of type part-tracker
(deftype part-tracker (process)
  ((root            trsqv                                    :offset-assert 112)
   (part            sparticle-launch-control                 :offset-assert 116)
   (target          handle                                   :offset-assert 120)
   (callback        (function part-tracker vector)           :offset-assert 128)
   (linger-callback (function part-tracker vector)           :offset-assert 132)
   (duration        time-frame                               :offset-assert 136)
   (linger-duration time-frame                               :offset-assert 144)
   (start-time      time-frame                               :offset-assert 152)
   (offset          vector                         :inline   :offset-assert 160)
   (userdata        uint64                                   :offset-assert 176)
   (user-time       time-frame                     2         :offset-assert 184)
   (user-vector     vector                         2 :inline :offset-assert 208)
   (user-handle     uint32                         2         :offset-assert 240)
   )
  :heap-base #x90
  :method-count-assert 14
  :size-assert         #xf8
  :flag-assert         #xe009000f8
  (:states
    part-tracker-process
    )
  )

;; definition for method 3 of type part-tracker
(defmethod inspect part-tracker ((obj part-tracker))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Troot: ~A~%" (-> obj root))
  (format #t "~T~Tpart: ~A~%" (-> obj part))
  (format #t "~T~Ttarget: ~D~%" (-> obj target))
  (format #t "~T~Tcallback: ~A~%" (-> obj callback))
  (format #t "~T~Tlinger-callback: ~A~%" (-> obj linger-callback))
  (format #t "~T~Tduration: ~D~%" (-> obj duration))
  (format #t "~T~Tlinger-duration: ~D~%" (-> obj linger-duration))
  (format #t "~T~Tstart-time: ~D~%" (-> obj start-time))
  (format #t "~T~Toffset: ~`vector`P~%" (-> obj offset))
  (format #t "~T~Tuserdata: ~A~%" (-> obj userdata))
  (format #t "~T~Tuser-time[2] @ #x~X~%" (-> obj user-time))
  (format #t "~T~Tuser-vector[2] @ #x~X~%" (-> obj user-vector))
  (format #t "~T~Tuser-handle[2] @ #x~X~%" (-> obj user-handle))
  obj
  )

;; definition of type camera-tracker
(deftype camera-tracker (process)
  ((entity-override entity-actor     :offset         52)
   (grab-target     handle           :offset        120)
   (grab-event      symbol           :offset-assert 128)
   (release-event   symbol           :offset-assert 132)
   (old-global-mask process-mask     :offset-assert 136)
   (old-self-mask   process-mask     :offset-assert 140)
   (old-parent-mask process-mask     :offset-assert 144)
   (look-at-target  handle           :offset-assert 152)
   (pov-target      handle           :offset-assert 160)
   (work-process    handle           :offset-assert 168)
   (anim-process    handle           :offset-assert 176)
   (start-time      time-frame       :offset-assert 184)
   (callback        basic            :offset-assert 192)
   (userdata        basic            :offset-assert 196)
   (message         basic            :offset-assert 200)
   (border-value    basic            :offset-assert 204)
   (mask-to-clear   process-mask     :offset-assert 208)
   (script          pair             :offset-assert 212)
   (script-line     pair             :offset-assert 216)
   (script-func     (function none)  :offset-assert 220)
   )
  :heap-base #x70
  :method-count-assert 15
  :size-assert         #xe0
  :flag-assert         #xf007000e0
  (:methods
    (eval (_type_ pair) process 14)
    )
  (:states
    camera-tracker-process
    )
  )

;; definition for method 3 of type camera-tracker
(defmethod inspect camera-tracker ((obj camera-tracker))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tname: ~A~%" (-> obj name))
  (format #t "~T~Tgrab-target: ~D~%" (-> obj grab-target))
  (format #t "~T~Tgrab-event: ~A~%" (-> obj grab-event))
  (format #t "~T~Trelease-event: ~A~%" (-> obj release-event))
  (format #t "~T~Told-global-mask: ~D~%" (-> obj old-global-mask))
  (format #t "~T~Told-self-mask: ~D~%" (-> obj old-self-mask))
  (format #t "~T~Told-parent-mask: ~D~%" (-> obj old-parent-mask))
  (format #t "~T~Tlook-at-target: ~D~%" (-> obj look-at-target))
  (format #t "~T~Tpov-target: ~D~%" (-> obj pov-target))
  (format #t "~T~Twork-process: ~D~%" (-> obj work-process))
  (format #t "~T~Tanim-process: ~D~%" (-> obj anim-process))
  (format #t "~T~Tstart-time: ~D~%" (-> obj start-time))
  (format #t "~T~Tcallback: ~A~%" (-> obj callback))
  (format #t "~T~Tuserdata: ~A~%" (-> obj userdata))
  (format #t "~T~Tmessage: ~A~%" (-> obj message))
  (format #t "~T~Tborder-value: ~A~%" (-> obj border-value))
  (format #t "~T~Tmask-to-clear: ~D~%" (-> obj mask-to-clear))
  (format #t "~T~Tscript: ~A~%" (-> obj script))
  (format #t "~T~Tscript-line: ~A~%" (-> obj script-line))
  (format #t "~T~Tscript-func: ~A~%" (-> obj script-func))
  obj
  )

;; definition of type touch-tracker
(deftype touch-tracker (process-drawable)
  ((root-override collide-shape-moving           :offset        112)
   (duration      time-frame                     :offset-assert 176)
   (target        handle                         :offset-assert 184)
   (event         symbol                         :offset-assert 192)
   (run-function  (function object)              :offset-assert 196)
   (callback      (function touch-tracker none)  :offset-assert 200)
   (event-mode    basic                          :offset-assert 204)
   )
  :heap-base #x60
  :method-count-assert 20
  :size-assert         #xd0
  :flag-assert         #x14006000d0
  (:states
    touch-tracker-idle
    )
  )

;; definition for method 3 of type touch-tracker
(defmethod inspect touch-tracker ((obj touch-tracker))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tduration: ~D~%" (-> obj duration))
  (format #t "~T~Ttarget: ~D~%" (-> obj target))
  (format #t "~T~Tevent: ~A~%" (-> obj event))
  (format #t "~T~Trun-function: ~A~%" (-> obj run-function))
  (format #t "~T~Tcallback: ~A~%" (-> obj callback))
  (format #t "~T~Tevent-mode: ~A~%" (-> obj event-mode))
  obj
  )

;; definition of type swingpole
(deftype swingpole (process)
  ((root        trsq           :offset-assert 112)
   (dir         vector :inline :offset-assert 128)
   (range       meters         :offset-assert 144)
   (edge-length meters         :offset-assert 148)
   )
  :heap-base #x30
  :method-count-assert 14
  :size-assert         #x98
  :flag-assert         #xe00300098
  (:states
    swingpole-active
    swingpole-stance
    )
  )

;; definition for method 3 of type swingpole
(defmethod inspect swingpole ((obj swingpole))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Troot: ~A~%" (-> obj root))
  (format #t "~T~Tdir: ~`vector`P~%" (-> obj dir))
  (format #t "~T~Trange: (meters ~m)~%" (-> obj range))
  (format #t "~T~Tedge-length: (meters ~m)~%" (-> obj edge-length))
  obj
  )

;; definition of type gui-query
(deftype gui-query (structure)
  ((x-position        int32   :offset-assert   0)
   (y-position        int32   :offset-assert   4)
   (message           string  :offset-assert   8)
   (decision          symbol  :offset-assert  12)
   (only-allow-cancel symbol  :offset-assert  16)
   (no-msg            string  :offset-assert  20)
   (message-space     int32   :offset-assert  24)
   )
  :pack-me
  :method-count-assert 11
  :size-assert         #x1c
  :flag-assert         #xb0000001c
  (:methods
    (init! (_type_ string int int int symbol string) none 9)
    (get-response (_type_) symbol 10)
    )
  )

;; definition for method 3 of type gui-query
(defmethod inspect gui-query ((obj gui-query))
  (format #t "[~8x] ~A~%" obj 'gui-query)
  (format #t "~Tx-position: ~D~%" (-> obj x-position))
  (format #t "~Ty-position: ~D~%" (-> obj y-position))
  (format #t "~Tmessage: ~A~%" (-> obj message))
  (format #t "~Tdecision: ~A~%" (-> obj decision))
  (format #t "~Tonly-allow-cancel: ~A~%" (-> obj only-allow-cancel))
  (format #t "~Tno-msg: ~A~%" (-> obj no-msg))
  (format #t "~Tmessage-space: ~D~%" (-> obj message-space))
  obj
  )

;; definition of type othercam
(deftype othercam (process)
  ((hand              handle               :offset-assert 112)
   (old-global-mask   process-mask         :offset-assert 120)
   (mask-to-clear     process-mask         :offset-assert 124)
   (cam-joint-index   int32                :offset-assert 128)
   (old-pos           vector       :inline :offset-assert 144)
   (old-mat-z         vector       :inline :offset-assert 160)
   (had-valid-frame   basic                :offset-assert 176)
   (border-value      basic                :offset-assert 180)
   (die?              symbol               :offset-assert 184)
   (survive-anim-end? symbol               :offset-assert 188)
   (spooling?         symbol               :offset-assert 192)
   )
  :heap-base #x60
  :method-count-assert 14
  :size-assert         #xc4
  :flag-assert         #xe006000c4
  (:states
    othercam-running
    )
  )

;; definition for method 3 of type othercam
(defmethod inspect othercam ((obj othercam))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Thand: ~D~%" (-> obj hand))
  (format #t "~T~Told-global-mask: ~D~%" (-> obj old-global-mask))
  (format #t "~T~Tmask-to-clear: ~D~%" (-> obj mask-to-clear))
  (format #t "~T~Tcam-joint-index: ~D~%" (-> obj cam-joint-index))
  (format #t "~T~Told-pos: #<vector @ #x~X>~%" (-> obj old-pos))
  (format #t "~T~Told-mat-z: #<vector @ #x~X>~%" (-> obj old-mat-z))
  (format #t "~T~Thad-valid-frame: ~A~%" (-> obj had-valid-frame))
  (format #t "~T~Tborder-value: ~A~%" (-> obj border-value))
  (format #t "~T~Tdie?: ~A~%" (-> obj die?))
  (format #t "~T~Tsurvive-anim-end?: ~A~%" (-> obj survive-anim-end?))
  (format #t "~T~Tspooling?: ~A~%" (-> obj spooling?))
  obj
  )

;; definition of type process-hidden
(deftype process-hidden (process)
  ()
  :method-count-assert 15
  :size-assert         #x70
  :flag-assert         #xf00000070
  (:methods
    (die () _type_ :state 14)
    )
  )

;; definition for method 3 of type process-hidden
(defmethod inspect process-hidden ((obj process-hidden))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tname: ~A~%" (-> obj name))
  (format #t "~Tmask: ~D~%" (-> obj mask))
  (format #t "~Tparent: #x~X~%" (-> obj parent))
  (format #t "~Tbrother: #x~X~%" (-> obj brother))
  (format #t "~Tchild: #x~X~%" (-> obj child))
  (format #t "~Tppointer: #x~X~%" (-> obj ppointer))
  (format #t "~Tself: ~A~%" (-> obj self))
  (format #t "~Tpool: ~A~%" (-> obj pool))
  (format #t "~Tstatus: ~A~%" (-> obj status))
  (format #t "~Tpid: ~D~%" (-> obj pid))
  (format #t "~Tmain-thread: ~A~%" (-> obj main-thread))
  (format #t "~Ttop-thread: ~A~%" (-> obj top-thread))
  (format #t "~Tentity: ~A~%" (-> obj entity))
  (format #t "~Tstate: ~A~%" (-> obj state))
  (format #t "~Ttrans-hook: ~A~%" (-> obj trans-hook))
  (format #t "~Tpost-hook: ~A~%" (-> obj post-hook))
  (format #t "~Tevent-hook: ~A~%" (-> obj event-hook))
  (format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~Tnext-state: ~A~%" (-> obj next-state))
  (format #t "~Theap-base: #x~X~%" (-> obj heap-base))
  (format #t "~Theap-top: #x~X~%" (-> obj heap-top))
  (format #t "~Theap-cur: #x~X~%" (-> obj heap-cur))
  (format #t "~Tstack-frame-top: ~A~%" (-> obj stack-frame-top))
  (format #t "~Theap: #<kheap @ #x~X>~%" (&-> obj heap-base))
  (format #t "~Tconnection-list: ~`'connectable`P~%" (-> obj connection-list))
  (format #t "~Tstack[0] @ #x~X~%" (-> obj stack))
  obj
  )

;; failed to figure out what this is:
0