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

;; definition of type sync-info-params
(deftype sync-info-params (structure)
  ((sync-type  basic       :offset-assert   0)
   (sync-flags sync-flags  :offset-assert   8)
   (entity     basic       :offset-assert  16)
   (period     uint32      :offset-assert  20)
   (percent    float       :offset-assert  24)
   (ease-in    float       :offset-assert  28)
   (ease-out   float       :offset-assert  32)
   (pause-in   float       :offset-assert  36)
   (pause-out  float       :offset-assert  40)
   )
  :method-count-assert 9
  :size-assert         #x2c
  :flag-assert         #x90000002c
  )

;; definition for method 3 of type sync-info-params
(defmethod inspect sync-info-params ((obj sync-info-params))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'sync-info-params)
  (format #t "~1Tsync-type: ~A~%" (-> obj sync-type))
  (format #t "~1Tsync-flags: ~D~%" (-> obj sync-flags))
  (format #t "~1Tentity: ~A~%" (-> obj entity))
  (format #t "~1Tperiod: ~D~%" (-> obj period))
  (format #t "~1Tpercent: ~f~%" (-> obj percent))
  (format #t "~1Tease-in: ~f~%" (-> obj ease-in))
  (format #t "~1Tease-out: ~f~%" (-> obj ease-out))
  (format #t "~1Tpause-in: ~f~%" (-> obj pause-in))
  (format #t "~1Tpause-out: ~f~%" (-> obj pause-out))
  (label cfg-4)
  obj
  )

;; definition of type sync-info
(deftype sync-info (structure)
  ((sync-flags sync-flags  :offset-assert   0)
   (offset     float       :offset-assert   8)
   (period     uint32      :offset-assert  12)
   )
  :method-count-assert 16
  :size-assert         #x10
  :flag-assert         #x1000000010
  (:methods
    (get-current-phase-no-mod (_type_) float 9)
    (get-phase-offset (_type_) float 10)
    (get-norm! (_type_ int) float 11)
    (get-scaled-val! (_type_ float int) float 12)
    (initialize! (_type_ sync-info-params) none 13)
    (get-timeframe-offset! (_type_ time-frame) time-frame 14)
    (sync-now! (_type_ float) none 15)
    )
  )

;; definition for method 3 of type sync-info
(defmethod inspect sync-info ((obj sync-info))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'sync-info)
  (format #t "~1Tsync-flags: ~D~%" (-> obj sync-flags))
  (format #t "~1Toffset: ~f~%" (-> obj offset))
  (format #t "~1Tperiod: ~D~%" (-> obj period))
  (label cfg-4)
  obj
  )

;; definition of type sync-linear
(deftype sync-linear (sync-info)
  ()
  :method-count-assert 16
  :size-assert         #x10
  :flag-assert         #x1000000010
  )

;; definition for method 3 of type sync-linear
(defmethod inspect sync-linear ((obj sync-linear))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'sync-linear)
  (format #t "~1Tsync-flags: ~D~%" (-> obj sync-flags))
  (format #t "~1Toffset: ~f~%" (-> obj offset))
  (format #t "~1Tperiod: ~D~%" (-> obj period))
  (label cfg-4)
  obj
  )

;; definition of type sync-eased
(deftype sync-eased (sync-info)
  ((tlo       float  :offset-assert  16)
   (thi       float  :offset-assert  20)
   (ylo       float  :offset-assert  24)
   (m2        float  :offset-assert  28)
   (yend      float  :offset-assert  32)
   (pause-in  float  :offset-assert  36)
   (pause-out float  :offset-assert  40)
   )
  :pack-me
  :method-count-assert 16
  :size-assert         #x2c
  :flag-assert         #x100000002c
  )

;; definition for method 3 of type sync-eased
(defmethod inspect sync-eased ((obj sync-eased))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'sync-eased)
  (format #t "~1Tsync-flags: ~D~%" (-> obj sync-flags))
  (format #t "~1Toffset: ~f~%" (-> obj offset))
  (format #t "~1Tperiod: ~D~%" (-> obj period))
  (format #t "~1Ttlo: ~f~%" (-> obj tlo))
  (format #t "~1Tthi: ~f~%" (-> obj thi))
  (format #t "~1Tylo: ~f~%" (-> obj ylo))
  (format #t "~1Tm2: ~f~%" (-> obj m2))
  (format #t "~1Tyend: ~f~%" (-> obj yend))
  (format #t "~1Tpause-in: ~f~%" (-> obj pause-in))
  (format #t "~1Tpause-out: ~f~%" (-> obj pause-out))
  (label cfg-4)
  obj
  )

;; definition of type sync-paused
(deftype sync-paused (sync-info)
  ((pause-in  float  :offset-assert  16)
   (pause-out float  :offset-assert  20)
   )
  :method-count-assert 16
  :size-assert         #x18
  :flag-assert         #x1000000018
  )

;; definition for method 3 of type sync-paused
(defmethod inspect sync-paused ((obj sync-paused))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'sync-paused)
  (format #t "~1Tsync-flags: ~D~%" (-> obj sync-flags))
  (format #t "~1Toffset: ~f~%" (-> obj offset))
  (format #t "~1Tperiod: ~D~%" (-> obj period))
  (format #t "~1Tpause-in: ~f~%" (-> obj pause-in))
  (format #t "~1Tpause-out: ~f~%" (-> obj pause-out))
  (label cfg-4)
  obj
  )

;; definition of type delayed-rand-float
(deftype delayed-rand-float (structure)
  ((min-time   int32       :offset-assert   0)
   (max-time   int32       :offset-assert   4)
   (max-val    float       :offset-assert   8)
   (timer      int32       :offset-assert  12)
   (start-time time-frame  :offset-assert  16)
   (value      float       :offset-assert  24)
   )
  :method-count-assert 13
  :size-assert         #x1c
  :flag-assert         #xd0000001c
  (:methods
    (set-params! (_type_ int int float) float 9)
    (reset! (_type_) float 10)
    (update! (_type_) float 11)
    (update-and-clear! (_type_) none 12)
    )
  )

;; definition for method 3 of type delayed-rand-float
(defmethod inspect delayed-rand-float ((obj delayed-rand-float))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'delayed-rand-float)
  (format #t "~1Tmin-time: ~D~%" (-> obj min-time))
  (format #t "~1Tmax-time: ~D~%" (-> obj max-time))
  (format #t "~1Tmax-val: ~f~%" (-> obj max-val))
  (format #t "~1Ttimer: ~D~%" (-> obj timer))
  (format #t "~1Tstart-time: ~D~%" (-> obj start-time))
  (format #t "~1Tvalue: ~f~%" (-> obj value))
  (label cfg-4)
  obj
  )

;; definition of type oscillating-float
(deftype oscillating-float (structure)
  ((value   float  :offset-assert   0)
   (target  float  :offset-assert   4)
   (vel     float  :offset-assert   8)
   (max-vel float  :offset-assert  12)
   (damping float  :offset-assert  16)
   (accel   float  :offset-assert  20)
   )
  :method-count-assert 11
  :size-assert         #x18
  :flag-assert         #xb00000018
  (:methods
    (set-params! (_type_ float float float float) float 9)
    (update! (_type_ float) float 10)
    )
  )

;; definition for method 3 of type oscillating-float
(defmethod inspect oscillating-float ((obj oscillating-float))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'oscillating-float)
  (format #t "~1Tvalue: ~f~%" (-> obj value))
  (format #t "~1Ttarget: ~f~%" (-> obj target))
  (format #t "~1Tvel: ~f~%" (-> obj vel))
  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~1Tdamping: ~f~%" (-> obj damping))
  (format #t "~1Taccel: ~f~%" (-> obj accel))
  (label cfg-4)
  obj
  )

;; definition of type bouncing-float
(deftype bouncing-float (structure)
  ((osc        oscillating-float :inline :offset-assert   0)
   (max-value  float                     :offset-assert  24)
   (min-value  float                     :offset-assert  28)
   (elasticity float                     :offset-assert  32)
   (state      int32                     :offset-assert  36)
   )
  :method-count-assert 13
  :size-assert         #x28
  :flag-assert         #xd00000028
  (:methods
    (set-params! (_type_ float float float float float float float) float 9)
    (update! (_type_ float) float 10)
    (at-min? (_type_) symbol 11)
    (at-max? (_type_) symbol 12)
    )
  )

;; definition for method 3 of type bouncing-float
(defmethod inspect bouncing-float ((obj bouncing-float))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'bouncing-float)
  (format #t "~1Tosc: #<oscillating-float @ #x~X>~%" (-> obj osc))
  (format #t "~1Tmax-value: ~f~%" (-> obj max-value))
  (format #t "~1Tmin-value: ~f~%" (-> obj min-value))
  (format #t "~1Telasticity: ~f~%" (-> obj elasticity))
  (format #t "~1Tstate: ~D~%" (-> obj state))
  (label cfg-4)
  obj
  )

;; definition of type delayed-rand-vector
(deftype delayed-rand-vector (structure)
  ((min-time   int32              :offset-assert   0)
   (max-time   int32              :offset-assert   4)
   (xz-max     float              :offset-assert   8)
   (y-max      float              :offset-assert  12)
   (timer      int32              :offset-assert  16)
   (start-time time-frame         :offset-assert  24)
   (value      vector     :inline :offset-assert  32)
   )
  :method-count-assert 13
  :size-assert         #x30
  :flag-assert         #xd00000030
  (:methods
    (set-params! (_type_ int int float float) vector 9)
    (update-now! (_type_) vector 10)
    (update-with-delay! (_type_) vector 11)
    (update-with-delay-or-reset! (_type_) vector 12)
    )
  )

;; definition for method 3 of type delayed-rand-vector
(defmethod inspect delayed-rand-vector ((obj delayed-rand-vector))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'delayed-rand-vector)
  (format #t "~1Tmin-time: ~D~%" (-> obj min-time))
  (format #t "~1Tmax-time: ~D~%" (-> obj max-time))
  (format #t "~1Txz-max: ~f~%" (-> obj xz-max))
  (format #t "~1Ty-max: ~f~%" (-> obj y-max))
  (format #t "~1Ttimer: ~D~%" (-> obj timer))
  (format #t "~1Tstart-time: ~D~%" (-> obj start-time))
  (format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
  (label cfg-4)
  obj
  )

;; definition of type oscillating-vector
(deftype oscillating-vector (structure)
  ((value   vector :inline :offset-assert   0)
   (target  vector :inline :offset-assert  16)
   (vel     vector :inline :offset-assert  32)
   (max-vel float          :offset-assert  48)
   (damping float          :offset-assert  52)
   (accel   float          :offset-assert  56)
   )
  :method-count-assert 11
  :size-assert         #x3c
  :flag-assert         #xb0000003c
  (:methods
    (set-params! (_type_ vector float float float) vector 9)
    (update! (_type_ vector) vector 10)
    )
  )

;; definition for method 3 of type oscillating-vector
(defmethod inspect oscillating-vector ((obj oscillating-vector))
  (when (not obj)
    (set! obj obj)
    (goto cfg-4)
    )
  (format #t "[~8x] ~A~%" obj 'oscillating-vector)
  (format #t "~1Tvalue: #<vector @ #x~X>~%" (-> obj value))
  (format #t "~1Ttarget: #<vector @ #x~X>~%" (-> obj target))
  (format #t "~1Tvel: #<vector @ #x~X>~%" (-> obj vel))
  (format #t "~1Tmax-vel: ~f~%" (-> obj max-vel))
  (format #t "~1Tdamping: ~f~%" (-> obj damping))
  (format #t "~1Taccel: ~f~%" (-> obj accel))
  (label cfg-4)
  obj
  )

;; failed to figure out what this is:
0