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

;; definition of type sound-id
(deftype sound-id (uint32)
  ()
  :method-count-assert 10
  :size-assert         #x4
  :flag-assert         #xa00000004
  (:methods
    (unused-9 () none 9)
    )
  )

;; definition of type sound-bank-id
(deftype sound-bank-id (uint32)
  ()
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition of type sound-name
(deftype sound-name (uint128)
  ((lo uint64 :offset   0 :size  64)
   (hi uint64 :offset  64 :size  64)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition of type sound-rpc-cmd
(deftype sound-rpc-cmd (structure)
  ((rsvd1   uint16         :offset-assert   0)
   (command sound-command  :offset-assert   2)
   )
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition for method 3 of type sound-rpc-cmd
(defmethod inspect sound-rpc-cmd ((obj sound-rpc-cmd))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-cmd)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  obj
  )

;; definition of type sound-play-parms
(deftype sound-play-parms (structure)
  ((mask      sound-mask          :offset-assert   0)
   (pitch-mod int16               :offset-assert   2)
   (bend      int16               :offset-assert   4)
   (fo-min    int16               :offset-assert   6)
   (fo-max    int16               :offset-assert   8)
   (fo-curve  int8                :offset-assert  10)
   (priority  int8                :offset-assert  11)
   (volume    int32               :offset-assert  12)
   (trans     vector3w    :inline :offset-assert  16)
   (group     sound-group         :offset-assert  28)
   )
  :pack-me
  :method-count-assert 9
  :size-assert         #x1d
  :flag-assert         #x90000001d
  )

;; definition for method 3 of type sound-play-parms
(defmethod inspect sound-play-parms ((obj sound-play-parms))
  (format #t "[~8x] ~A~%" obj 'sound-play-parms)
  (format #t "~Tmask: ~D~%" (-> obj mask))
  (format #t "~Tpitch-mod: ~D~%" (-> obj pitch-mod))
  (format #t "~Tbend: ~D~%" (-> obj bend))
  (format #t "~Tfo-min: ~D~%" (-> obj fo-min))
  (format #t "~Tfo-max: ~D~%" (-> obj fo-max))
  (format #t "~Tfo-curve: ~D~%" (-> obj fo-curve))
  (format #t "~Tpriority: ~D~%" (-> obj priority))
  (format #t "~Tvolume: ~D~%" (-> obj volume))
  (format #t "~Ttrans[3] @ #x~X~%" (-> obj trans))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  obj
  )

;; definition of type sound-rpc-bank-cmd
(deftype sound-rpc-bank-cmd (sound-rpc-cmd)
  ((bank-name sound-name  :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sound-rpc-bank-cmd
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-bank-cmd ((obj sound-rpc-bank-cmd))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-bank-cmd)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tbank-name: ~D~%" (-> obj bank-name))
  obj
  )

;; definition of type sound-rpc-sound-cmd
(deftype sound-rpc-sound-cmd (sound-rpc-cmd)
  ((id sound-id  :offset-assert   4)
   )
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type sound-rpc-sound-cmd
(defmethod inspect sound-rpc-sound-cmd ((obj sound-rpc-sound-cmd))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-sound-cmd)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  obj
  )

;; definition of type sound-rpc-group-cmd
(deftype sound-rpc-group-cmd (sound-rpc-cmd)
  ((group sound-group  :offset-assert   4)
   )
  :method-count-assert 9
  :size-assert         #x5
  :flag-assert         #x900000005
  )

;; definition for method 3 of type sound-rpc-group-cmd
(defmethod inspect sound-rpc-group-cmd ((obj sound-rpc-group-cmd))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-group-cmd)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  obj
  )

;; definition of type sound-rpc-load-bank
(deftype sound-rpc-load-bank (sound-rpc-bank-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sound-rpc-load-bank
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-load-bank ((obj sound-rpc-load-bank))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-load-bank)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tbank-name: ~D~%" (-> obj bank-name))
  obj
  )

;; definition of type sound-rpc-load-music
(deftype sound-rpc-load-music (sound-rpc-bank-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sound-rpc-load-music
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-load-music ((obj sound-rpc-load-music))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-load-music)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tbank-name: ~D~%" (-> obj bank-name))
  obj
  )

;; definition of type sound-rpc-unload-bank
(deftype sound-rpc-unload-bank (sound-rpc-bank-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sound-rpc-unload-bank
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-unload-bank ((obj sound-rpc-unload-bank))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-unload-bank)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tbank-name: ~D~%" (-> obj bank-name))
  obj
  )

;; definition of type sound-rpc-play
(deftype sound-rpc-play (sound-rpc-sound-cmd)
  ((name  sound-name               :offset-assert  16)
   (parms sound-play-parms :inline :offset-assert  32)
   )
  :method-count-assert 9
  :size-assert         #x3d
  :flag-assert         #x90000003d
  )

;; definition for method 3 of type sound-rpc-play
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-play ((obj sound-rpc-play))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-play)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  (format #t "~Tname: ~D~%" (-> obj name))
  (format #t "~Tparms: #<sound-play-parms @ #x~X>~%" (-> obj parms))
  obj
  )

;; definition of type sound-rpc-pause-sound
(deftype sound-rpc-pause-sound (sound-rpc-sound-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type sound-rpc-pause-sound
(defmethod inspect sound-rpc-pause-sound ((obj sound-rpc-pause-sound))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-pause-sound)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  obj
  )

;; definition of type sound-rpc-stop-sound
(deftype sound-rpc-stop-sound (sound-rpc-sound-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type sound-rpc-stop-sound
(defmethod inspect sound-rpc-stop-sound ((obj sound-rpc-stop-sound))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-stop-sound)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  obj
  )

;; definition of type sound-rpc-continue-sound
(deftype sound-rpc-continue-sound (sound-rpc-sound-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type sound-rpc-continue-sound
(defmethod inspect sound-rpc-continue-sound ((obj sound-rpc-continue-sound))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-continue-sound)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  obj
  )

;; definition of type sound-rpc-set-param
(deftype sound-rpc-set-param (sound-rpc-sound-cmd)
  ((parms     sound-play-parms :inline :offset-assert   8)
   (auto-time int32                    :offset-assert  40)
   (auto-from int32                    :offset-assert  44)
   )
  :method-count-assert 9
  :size-assert         #x30
  :flag-assert         #x900000030
  )

;; definition for method 3 of type sound-rpc-set-param
(defmethod inspect sound-rpc-set-param ((obj sound-rpc-set-param))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-param)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tid: ~D~%" (-> obj id))
  (format #t "~Tparms: #<sound-play-parms @ #x~X>~%" (-> obj parms))
  (format #t "~Tauto-time: ~D~%" (-> obj auto-time))
  (format #t "~Tauto-from: ~D~%" (-> obj auto-from))
  obj
  )

;; definition of type sound-rpc-set-master-volume
(deftype sound-rpc-set-master-volume (sound-rpc-group-cmd)
  ((volume int32  :offset-assert   8)
   )
  :method-count-assert 9
  :size-assert         #xc
  :flag-assert         #x90000000c
  )

;; definition for method 3 of type sound-rpc-set-master-volume
(defmethod inspect sound-rpc-set-master-volume ((obj sound-rpc-set-master-volume))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-master-volume)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  (format #t "~Tvolume: ~D~%" (-> obj volume))
  obj
  )

;; definition of type sound-rpc-pause-group
(deftype sound-rpc-pause-group (sound-rpc-group-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x5
  :flag-assert         #x900000005
  )

;; definition for method 3 of type sound-rpc-pause-group
(defmethod inspect sound-rpc-pause-group ((obj sound-rpc-pause-group))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-pause-group)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  obj
  )

;; definition of type sound-rpc-stop-group
(deftype sound-rpc-stop-group (sound-rpc-group-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x5
  :flag-assert         #x900000005
  )

;; definition for method 3 of type sound-rpc-stop-group
(defmethod inspect sound-rpc-stop-group ((obj sound-rpc-stop-group))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-stop-group)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  obj
  )

;; definition of type sound-rpc-continue-group
(deftype sound-rpc-continue-group (sound-rpc-group-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x5
  :flag-assert         #x900000005
  )

;; definition for method 3 of type sound-rpc-continue-group
(defmethod inspect sound-rpc-continue-group ((obj sound-rpc-continue-group))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-continue-group)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  obj
  )

;; definition of type sound-rpc-get-irx-version
(deftype sound-rpc-get-irx-version (sound-rpc-cmd)
  ((major   uint32   :offset-assert   4)
   (minor   uint32   :offset-assert   8)
   (ee-addr pointer  :offset-assert  12)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition for method 3 of type sound-rpc-get-irx-version
(defmethod inspect sound-rpc-get-irx-version ((obj sound-rpc-get-irx-version))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-get-irx-version)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tmajor: ~D~%" (-> obj major))
  (format #t "~Tminor: ~D~%" (-> obj minor))
  (format #t "~Tee-addr: ~D~%" (-> obj ee-addr))
  obj
  )

;; definition of type sound-rpc-set-language
(deftype sound-rpc-set-language (sound-rpc-cmd)
  ((lang uint32  :offset-assert   4)
   )
  :method-count-assert 9
  :size-assert         #x8
  :flag-assert         #x900000008
  )

;; definition for method 3 of type sound-rpc-set-language
(defmethod inspect sound-rpc-set-language ((obj sound-rpc-set-language))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-language)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tlang: ~D~%" (-> obj lang))
  obj
  )

;; definition of type sound-rpc-set-falloff-curve
(deftype sound-rpc-set-falloff-curve (sound-rpc-cmd)
  ((curve   int32  :offset-assert   4)
   (falloff int32  :offset-assert   8)
   (ease    int32  :offset-assert  12)
   )
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

;; definition for method 3 of type sound-rpc-set-falloff-curve
(defmethod inspect sound-rpc-set-falloff-curve ((obj sound-rpc-set-falloff-curve))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-falloff-curve)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tcurve: ~D~%" (-> obj curve))
  (format #t "~Tfalloff: ~D~%" (-> obj falloff))
  (format #t "~Tease: ~D~%" (-> obj ease))
  obj
  )

;; definition of type sound-rpc-set-sound-falloff
(deftype sound-rpc-set-sound-falloff (sound-rpc-cmd)
  ((name  sound-name  :offset-assert  16)
   (curve int32       :offset-assert  32)
   (min   int32       :offset-assert  36)
   (max   int32       :offset-assert  40)
   )
  :method-count-assert 9
  :size-assert         #x2c
  :flag-assert         #x90000002c
  )

;; definition for method 3 of type sound-rpc-set-sound-falloff
;; INFO: Used lq/sq
(defmethod inspect sound-rpc-set-sound-falloff ((obj sound-rpc-set-sound-falloff))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-sound-falloff)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tname: ~D~%" (-> obj name))
  (format #t "~Tcurve: ~D~%" (-> obj curve))
  (format #t "~Tmin: ~D~%" (-> obj min))
  (format #t "~Tmax: ~D~%" (-> obj max))
  obj
  )

;; definition of type sound-rpc-reload-info
(deftype sound-rpc-reload-info (sound-rpc-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition for method 3 of type sound-rpc-reload-info
(defmethod inspect sound-rpc-reload-info ((obj sound-rpc-reload-info))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-reload-info)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  obj
  )

;; definition of type sound-rpc-set-reverb
(deftype sound-rpc-set-reverb (sound-rpc-cmd)
  ((core   uint8   :offset-assert   4)
   (reverb int32   :offset-assert   8)
   (left   uint32  :offset-assert  12)
   (right  uint32  :offset-assert  16)
   )
  :method-count-assert 9
  :size-assert         #x14
  :flag-assert         #x900000014
  )

;; definition for method 3 of type sound-rpc-set-reverb
(defmethod inspect sound-rpc-set-reverb ((obj sound-rpc-set-reverb))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-reverb)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tcore: ~D~%" (-> obj core))
  (format #t "~Treverb: ~D~%" (-> obj reverb))
  (format #t "~Tleft: ~D~%" (-> obj left))
  (format #t "~Tright: ~D~%" (-> obj right))
  obj
  )

;; definition of type sound-rpc-set-ear-trans
(deftype sound-rpc-set-ear-trans (sound-rpc-cmd)
  ((ear-trans vector3w :inline :offset-assert   4)
   (cam-trans vector3w :inline :offset-assert  16)
   (cam-angle int32            :offset-assert  28)
   )
  :method-count-assert 9
  :size-assert         #x20
  :flag-assert         #x900000020
  )

;; definition for method 3 of type sound-rpc-set-ear-trans
(defmethod inspect sound-rpc-set-ear-trans ((obj sound-rpc-set-ear-trans))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-ear-trans)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tear-trans[3] @ #x~X~%" (-> obj ear-trans))
  (format #t "~Tcam-trans[3] @ #x~X~%" (-> obj cam-trans))
  (format #t "~Tcam-angle: ~D~%" (-> obj cam-angle))
  obj
  )

;; definition of type sound-rpc-set-flava
(deftype sound-rpc-set-flava (sound-rpc-cmd)
  ((flava uint8  :offset-assert   4)
   )
  :method-count-assert 9
  :size-assert         #x5
  :flag-assert         #x900000005
  )

;; definition for method 3 of type sound-rpc-set-flava
(defmethod inspect sound-rpc-set-flava ((obj sound-rpc-set-flava))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-set-flava)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  (format #t "~Tflava: ~D~%" (-> obj flava))
  obj
  )

;; definition of type sound-rpc-shutdown
(deftype sound-rpc-shutdown (sound-rpc-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition for method 3 of type sound-rpc-shutdown
(defmethod inspect sound-rpc-shutdown ((obj sound-rpc-shutdown))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-shutdown)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  obj
  )

;; definition of type sound-rpc-list-sounds
(deftype sound-rpc-list-sounds (sound-rpc-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition for method 3 of type sound-rpc-list-sounds
(defmethod inspect sound-rpc-list-sounds ((obj sound-rpc-list-sounds))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-list-sounds)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  obj
  )

;; definition of type sound-rpc-unload-music
(deftype sound-rpc-unload-music (sound-rpc-cmd)
  ()
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )

;; definition for method 3 of type sound-rpc-unload-music
(defmethod inspect sound-rpc-unload-music ((obj sound-rpc-unload-music))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-unload-music)
  (format #t "~Trsvd1: ~D~%" (-> obj rsvd1))
  (format #t "~Tcommand: ~D~%" (-> obj command))
  obj
  )

;; definition of type sound-rpc-union
(deftype sound-rpc-union (structure)
  ((data              uint32                      20 :offset-assert   0)
   (load-bank         sound-rpc-load-bank            :offset          0)
   (unload-bank       sound-rpc-unload-bank          :offset          0)
   (play              sound-rpc-play                 :offset          0)
   (pause-sound       sound-rpc-pause-sound          :offset          0)
   (stop-sound        sound-rpc-stop-sound           :offset          0)
   (continue-sound    sound-rpc-continue-sound       :offset          0)
   (set-param         sound-rpc-set-param            :offset          0)
   (set-master-volume sound-rpc-set-master-volume    :offset          0)
   (pause-group       sound-rpc-pause-group          :offset          0)
   (stop-group        sound-rpc-stop-group           :offset          0)
   (continue-group    sound-rpc-continue-group       :offset          0)
   (get-irx-version   sound-rpc-get-irx-version      :offset          0)
   (set-falloff-curve sound-rpc-set-falloff-curve    :offset          0)
   (set-sound-falloff sound-rpc-set-sound-falloff    :offset          0)
   (reload-info       sound-rpc-reload-info          :offset          0)
   (set-language      sound-rpc-set-language         :offset          0)
   (set-reverb        sound-rpc-set-reverb           :offset          0)
   (set-ear-trans     sound-rpc-set-ear-trans        :offset          0)
   (set-flava         sound-rpc-set-flava            :offset          0)
   (set-fps           sound-rpc-set-fps              :offset          0)
   (shutdown          sound-rpc-shutdown             :offset          0)
   (list-sounds       sound-rpc-list-sounds          :offset          0)
   (unload-music      sound-rpc-unload-music         :offset          0)
   )
  :method-count-assert 9
  :size-assert         #x50
  :flag-assert         #x900000050
  )

;; definition for method 3 of type sound-rpc-union
(defmethod inspect sound-rpc-union ((obj sound-rpc-union))
  (format #t "[~8x] ~A~%" obj 'sound-rpc-union)
  (format #t "~Tdata[20] @ #x~X~%" (-> obj data))
  (format #t "~Tload-bank: #<sound-rpc-load-bank @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tunload-bank: #<sound-rpc-unload-bank @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tplay: #<sound-rpc-play @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tpause-sound: #<sound-rpc-pause-sound @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tstop-sound: #<sound-rpc-stop-sound @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tcontinue-sound: #<sound-rpc-continue-sound @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-param: #<sound-rpc-set-param @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-master-volume: #<sound-rpc-set-master-volume @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tpause-group: #<sound-rpc-pause-group @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tstop-group: #<sound-rpc-stop-group @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tcontinue-group: #<sound-rpc-continue-group @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tget-irx-version: #<sound-rpc-get-irx-version @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-falloff-curve: #<sound-rpc-set-falloff-curve @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-sound-falloff: #<sound-rpc-set-sound-falloff @ #x~X>~%" (-> obj load-bank))
  (format #t "~Treload-info: #<sound-rpc-reload-info @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-language: #<sound-rpc-set-language @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-reverb: #<sound-rpc-set-reverb @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-ear-trans: #<sound-rpc-set-ear-trans @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tset-flava: #<sound-rpc-set-flava @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tshutdown: #<sound-rpc-shutdown @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tlist-sounds: #<sound-rpc-list-sounds @ #x~X>~%" (-> obj load-bank))
  (format #t "~Tunload-music: #<sound-rpc-unload-music @ #x~X>~%" (-> obj load-bank))
  obj
  )

;; definition of type sound-spec
(deftype sound-spec (basic)
  ((mask            sound-mask     :offset-assert   4)
   (num             float          :offset-assert   8)
   (group           sound-group    :offset-assert  12)
   (sound-name-char uint8       16 :offset         16)
   (sound-name      sound-name     :offset         16)
   (trans           float       4  :offset-assert  32)
   (volume          int32          :offset-assert  48)
   (pitch-mod       int32          :offset-assert  52)
   (bend            int32          :offset-assert  56)
   (fo-min          int16          :offset-assert  60)
   (fo-max          int16          :offset-assert  62)
   (fo-curve        int8           :offset-assert  64)
   (priority        int8           :offset-assert  65)
   (auto-time       int32          :offset-assert  68)
   (auto-from       int32          :offset-assert  72)
   )
  :method-count-assert 9
  :size-assert         #x4c
  :flag-assert         #x90000004c
  )

;; definition for method 3 of type sound-spec
;; INFO: Used lq/sq
(defmethod inspect sound-spec ((obj sound-spec))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tmask: ~D~%" (-> obj mask))
  (format #t "~Tnum: ~f~%" (-> obj num))
  (format #t "~Tgroup: ~D~%" (-> obj group))
  (format #t "~Tsound-name-char[16] @ #x~X~%" (&-> obj sound-name))
  (format #t "~Tsound-name: ~D~%" (-> obj sound-name))
  (format #t "~Ttrans[4] @ #x~X~%" (-> obj trans))
  (format #t "~Tvolume: ~D~%" (-> obj volume))
  (format #t "~Tpitch-mod: ~D~%" (-> obj pitch-mod))
  (format #t "~Tbend: ~D~%" (-> obj bend))
  (format #t "~Tfo-min: ~D~%" (-> obj fo-min))
  (format #t "~Tfo-max: ~D~%" (-> obj fo-max))
  (format #t "~Tfo-curve: ~D~%" (-> obj fo-curve))
  (format #t "~Tpriority: ~D~%" (-> obj priority))
  (format #t "~Tauto-time: ~D~%" (-> obj auto-time))
  (format #t "~Tauto-from: ~D~%" (-> obj auto-from))
  obj
  )

;; definition for symbol *current-sound-id*, type sound-id
(define *current-sound-id* (the-as sound-id #x10000))

;; definition of type ambient-sound
(deftype ambient-sound (basic)
  ((spec         sound-spec              :offset-assert   4)
   (playing-id   sound-id                :offset-assert   8)
   (trans        vector          :inline :offset-assert  16)
   (name         sound-name              :offset-assert  32)
   (play-time    time-frame              :offset-assert  48)
   (time-base    time-frame              :offset-assert  56)
   (time-random  time-frame              :offset-assert  64)
   (volume       int32                   :offset-assert  72)
   (pitch        int32                   :offset-assert  76)
   (falloff-near int32                   :offset-assert  80)
   (falloff-far  int32                   :offset-assert  84)
   (falloff-mode int32                   :offset-assert  88)
   (params       (pointer float)         :offset-assert  92)
   (param-count  int32                   :offset-assert  96)
   (entity       entity                  :offset-assert 100)
   (sound-count  int32                   :offset-assert 104)
   )
  :method-count-assert 14
  :size-assert         #x6c
  :flag-assert         #xe0000006c
  (:methods
    (new (symbol type basic vector) _type_ 0)
    (update! (_type_) int 9)
    (change-sound! (_type_ sound-name) int 10)
    (update-trans! (_type_ vector) int 11)
    (update-vol! (_type_ int) int 12)
    (stop! (_type_) int 13)
    )
  )

;; definition for method 3 of type ambient-sound
;; INFO: Used lq/sq
(defmethod inspect ambient-sound ((obj ambient-sound))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tspec: ~A~%" (-> obj spec))
  (format #t "~Tplaying-id: ~D~%" (-> obj playing-id))
  (format #t "~Ttrans: ~`vector`P~%" (-> obj trans))
  (format #t "~Tname: ~D~%" (-> obj name))
  (format #t "~Tplay-time: ~D~%" (-> obj play-time))
  (format #t "~Ttime-base: ~D~%" (-> obj time-base))
  (format #t "~Ttime-random: ~D~%" (-> obj time-random))
  (format #t "~Tvolume: ~D~%" (-> obj volume))
  (format #t "~Tpitch: ~D~%" (-> obj pitch))
  (format #t "~Tfalloff-near: ~D~%" (-> obj falloff-near))
  (format #t "~Tfalloff-far: ~D~%" (-> obj falloff-far))
  (format #t "~Tfalloff-mode: ~D~%" (-> obj falloff-mode))
  (format #t "~Tparams: #x~X~%" (-> obj params))
  (format #t "~Tparam-count: ~D~%" (-> obj param-count))
  (format #t "~Tentity: ~A~%" (-> obj entity))
  (format #t "~Tsound-count: ~D~%" (-> obj sound-count))
  obj
  )

;; definition for symbol *sound-bank-1*, type symbol
(define *sound-bank-1* #f)

;; definition for symbol *sound-bank-2*, type symbol
(define *sound-bank-2* #f)

;; failed to figure out what this is:
0
