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

;; definition of type process-drawable
(deftype process-drawable (process)
  ((root        trsqv                     :offset-assert 112)
   (node-list   cspace-array              :offset-assert 116)
   (draw        draw-control              :offset-assert 120)
   (skel        joint-control             :offset-assert 124)
   (nav         nav-control               :offset-assert 128)
   (align       align-control             :offset-assert 132)
   (path        path-control              :offset-assert 136)
   (vol         vol-control               :offset-assert 140)
   (fact        fact-info                 :offset-assert 144)
   (link        actor-link-info           :offset-assert 148)
   (part        sparticle-launch-control  :offset-assert 152)
   (water       water-control             :offset-assert 156)
   (sound       ambient-sound             :offset-assert 160)
   (state-flags state-flags               :offset-assert 164)
   (state-time  time-frame                :offset-assert 168)
   )
  :heap-base #x40
  :method-count-assert 20
  :size-assert         #xb0
  :flag-assert         #x14004000b0
  (:methods
    (initialize-skeleton (_type_ skeleton-group pair) none 14)
    (initialize-skeleton-by-name (_type_ string object) _type_ 15)
    (apply-alignment (_type_ align-opts transformq vector) collide-shape 16)
    (do-joint-math! (_type_) none 17)
    (cleanup-for-death (_type_) none 18)
    (evaluate-joint-control (_type_) none 19)
    )
  (:states
    (process-drawable-art-error string)
    process-drawable-idle
    )
  )

;; definition for method 3 of type process-drawable
(defmethod inspect process-drawable ((obj process-drawable))
  (let ((t9-0 (method-of-type process inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Troot: ~A~%" (-> obj root))
  (format #t "~T~Tnode-list: ~A~%" (-> obj node-list))
  (format #t "~T~Tdraw: ~A~%" (-> obj draw))
  (format #t "~T~Tskel: ~A~%" (-> obj skel))
  (format #t "~T~Tnav: ~A~%" (-> obj nav))
  (format #t "~T~Talign: ~A~%" (-> obj align))
  (format #t "~T~Tpath: ~A~%" (-> obj path))
  (format #t "~T~Tvol: ~A~%" (-> obj vol))
  (format #t "~T~Tfact: ~A~%" (-> obj fact))
  (format #t "~T~Tlink: ~A~%" (-> obj link))
  (format #t "~T~Tpart: ~A~%" (-> obj part))
  (format #t "~T~Twater: ~A~%" (-> obj water))
  (format #t "~T~Tsound: ~A~%" (-> obj sound))
  (format #t "~T~Tstate-flags: ~D~%" (-> obj state-flags))
  (format #t "~T~Tstate-time: ~D~%" (-> obj state-time))
  obj
  )

;; definition of type process-drawable-reserved
(deftype process-drawable-reserved (process-drawable)
  ()
  :heap-base #x40
  :method-count-assert 63
  :size-assert         #xb0
  :flag-assert         #x3f004000b0
  (:methods
    (dummy-20 () none 20)
    (dummy-21 () none 21)
    (dummy-22 () none 22)
    (dummy-23 () none 23)
    (dummy-24 () none 24)
    (dummy-25 () none 25)
    (dummy-26 () none 26)
    (dummy-27 () none 27)
    (dummy-28 () none 28)
    (dummy-29 () none 29)
    (dummy-30 () none 30)
    (dummy-31 () none 31)
    (dummy-32 () none 32)
    (dummy-33 () none 33)
    (dummy-34 () none 34)
    (dummy-35 () none 35)
    (dummy-36 () none 36)
    (dummy-37 () none 37)
    (dummy-38 () none 38)
    (dummy-39 () none 39)
    (dummy-40 () none 40)
    (dummy-41 () none 41)
    (dummy-42 () none 42)
    (dummy-43 () none 43)
    (dummy-44 () none 44)
    (dummy-45 () none 45)
    (dummy-46 () none 46)
    (dummy-47 () none 47)
    (dummy-48 () none 48)
    (dummy-49 () none 49)
    (dummy-50 () none 50)
    (dummy-51 () none 51)
    (dummy-52 () none 52)
    (dummy-53 () none 53)
    (dummy-54 () none 54)
    (dummy-55 () none 55)
    (dummy-56 () none 56)
    (dummy-57 () none 57)
    (dummy-58 () none 58)
    (dummy-59 () none 59)
    (dummy-60 () none 60)
    (dummy-61 () none 61)
    (dummy-62 () none 62)
    )
  )

;; definition for method 3 of type process-drawable-reserved
(defmethod inspect process-drawable-reserved ((obj process-drawable-reserved))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 obj)
    )
  obj
  )

;; definition of type attack-info
(deftype attack-info (structure)
  ((trans        vector      :inline :offset-assert   0)
   (vector       vector      :inline :offset-assert  16)
   (intersection vector      :inline :offset-assert  32)
   (attacker     handle              :offset-assert  48)
   (invinc-time  time-frame          :offset-assert  56)
   (mask         attack-mask         :offset-assert  64)
   (mode         symbol              :offset-assert  68)
   (shove-back   meters              :offset-assert  72)
   (shove-up     meters              :offset-assert  76)
   (speed        meters              :offset-assert  80)
   (dist         meters              :offset-assert  84)
   (control      float               :offset-assert  88)
   (angle        symbol              :offset-assert  92)
   (rotate-to    degrees             :offset-assert  96)
   (prev-state   state               :offset-assert 100)
   )
  :method-count-assert 10
  :size-assert         #x68
  :flag-assert         #xa00000068
  (:methods
    (combine! (_type_ attack-info) none 9)
    )
  )

;; definition for method 3 of type attack-info
(defmethod inspect attack-info ((obj attack-info))
  (format #t "[~8x] ~A~%" obj 'attack-info)
  (format #t "~Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~Tvector: ~`vector`P~%" (-> obj vector))
  (format #t "~Tintersection: ~`vector`P~%" (-> obj intersection))
  (format #t "~Tattacker: ~`handle`P~%" (-> obj attacker))
  (format #t "~Tinvinc-time: ~D~%" (-> obj invinc-time))
  (format #t "~Tmask: ~D~%" (-> obj mask))
  (format #t "~Tmode: ~A~%" (-> obj mode))
  (format #t "~Tshove-back: (meters ~m)~%" (-> obj shove-back))
  (format #t "~Tshove-up: (meters ~m)~%" (-> obj shove-up))
  (format #t "~Tspeed: (meters ~m)~%" (-> obj speed))
  (format #t "~Tdist: (meters ~m)~%" (-> obj dist))
  (format #t "~Tcontrol: ~f~%" (-> obj control))
  (format #t "~Tangle: ~A~%" (-> obj angle))
  (format #t "~Trotate-to: (deg ~r)~%" (-> obj rotate-to))
  (format #t "~Tprev-state: ~A~%" (-> obj prev-state))
  obj
  )

;; definition for symbol *global-attack-id*, type int
(define *global-attack-id* 0)

;; definition of type ground-tween-info
(deftype ground-tween-info (structure)
  ((chan  uint8  3 :offset-assert   0)
   (blend float  3 :offset-assert   4)
   (group uint32 5 :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x24
  :flag-assert         #x900000024
  )

;; definition for method 3 of type ground-tween-info
(defmethod inspect ground-tween-info ((obj ground-tween-info))
  (format #t "[~8x] ~A~%" obj 'ground-tween-info)
  (format #t "~Tchan[3] @ #x~X~%" (-> obj chan))
  (format #t "~Tblend[3] @ #x~X~%" (-> obj blend))
  (format #t "~Tgroup[5] @ #x~X~%" (-> obj group))
  obj
  )

;; failed to figure out what this is:
0
