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

;; definition of type sync-info-params
(deftype sync-info-params (structure)
  "Parameters used to set up a [[sync-info]]."
  ((sync-type   symbol)
   (sync-flags  sync-flags)
   (entity      basic)
   (period      uint32)
   (percent     float)
   (ease-in     float)
   (ease-out    float)
   (pause-in    float)
   (pause-out   float)
   )
  )

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

;; definition of type sync-info
(deftype sync-info (structure)
  ((sync-flags  sync-flags)
   (offset      float)
   (period      uint32)
   )
  (:methods
    (get-current-phase-no-mod (_type_) float)
    (get-phase-offset (_type_) float)
    (get-norm! (_type_ int) float)
    (get-scaled-val! (_type_ float int) float)
    (initialize! (_type_ sync-info-params) none)
    (get-timeframe-offset! (_type_ time-frame) time-frame)
    (sync-now! (_type_ float) none)
    )
  )

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

;; definition of type sync-linear
(deftype sync-linear (sync-info)
  ()
  :pack-me
  )

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

;; definition of type sync-eased
(deftype sync-eased (sync-info)
  ((tlo        float)
   (thi        float)
   (ylo        float)
   (m2         float)
   (yend       float)
   (pause-in   float)
   (pause-out  float)
   )
  :pack-me
  )

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

;; definition of type sync-paused
(deftype sync-paused (sync-info)
  ((pause-in   float)
   (pause-out  float)
   )
  )

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

;; definition of type delayed-rand-float
(deftype delayed-rand-float (structure)
  ((min-time    int32)
   (max-time    int32)
   (max-val     float)
   (timer       int32)
   (start-time  time-frame)
   (value       float)
   )
  :pack-me
  (:methods
    (set-params! (_type_ int int float) float)
    (reset! (_type_) float)
    (update! (_type_) float)
    (update-and-clear! (_type_) none)
    )
  )

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

;; definition of type oscillating-float
(deftype oscillating-float (structure)
  ((value    float)
   (target   float)
   (vel      float)
   (max-vel  float)
   (damping  float)
   (accel    float)
   )
  :allow-misaligned
  (:methods
    (set-params! (_type_ float float float float) float)
    (update! (_type_ float) float)
    )
  )

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

;; definition of type bouncing-float
(deftype bouncing-float (structure)
  ((osc         oscillating-float  :inline)
   (max-value   float)
   (min-value   float)
   (elasticity  float)
   (state       int32)
   )
  :allow-misaligned
  (:methods
    (set-params! (_type_ float float float float float float float) float)
    (update! (_type_ float) float)
    (at-min? (_type_) symbol)
    (at-max? (_type_) symbol)
    )
  )

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

;; definition of type delayed-rand-vector
(deftype delayed-rand-vector (structure)
  ((min-time    int32)
   (max-time    int32)
   (xz-max      float)
   (y-max       float)
   (timer       int32)
   (start-time  time-frame)
   (value       vector  :inline)
   )
  (:methods
    (set-params! (_type_ int int float float) vector)
    (update-now! (_type_) vector)
    (update-with-delay! (_type_) vector)
    (update-with-delay-or-reset! (_type_) vector)
    )
  )

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

;; definition of type oscillating-vector
(deftype oscillating-vector (structure)
  ((value    vector  :inline)
   (target   vector  :inline)
   (vel      vector  :inline)
   (max-vel  float)
   (damping  float)
   (accel    float)
   )
  (:methods
    (set-params! (_type_ vector float float float) vector)
    (update! (_type_ vector) vector)
    )
  )

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

;; failed to figure out what this is:
0