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

;; definition of type rolling-part
(deftype rolling-part (part-spawner)
  ()
  )

;; definition for method 3 of type rolling-part
(defmethod inspect ((this rolling-part))
  (let ((t9-0 (method-of-type part-spawner inspect)))
    (t9-0 this)
    )
  this
  )

;; definition of type rollingcam
(deftype rollingcam (process-hidden)
  ()
  )

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

;; failed to figure out what this is:
(defskelgroup *rollingcam-sg* rollingcam rollingcam-lod0-jg rollingcam-anim-ja
              ((rollingcam-lod0-mg (meters 999999)))
              :bounds (static-spherem 0 0 0 30)
              )

;; definition of type pusher-base
(deftype pusher-base (process-drawable)
  ((root       collide-shape-moving :override)
   (max-frame  float)
   )
  )

;; definition for method 3 of type pusher-base
(defmethod inspect ((this pusher-base))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~T~Tmax-frame: ~f~%" (-> this max-frame))
  this
  )

;; definition of type pusher
(deftype pusher (pusher-base)
  ((sync  sync-info-paused  :inline)
   (cyl   cylinder          :inline)
   )
  (:states
    pusher-idle
    )
  )

;; definition for method 3 of type pusher
(defmethod inspect ((this pusher))
  (let ((t9-0 (method-of-type pusher-base inspect)))
    (t9-0 this)
    )
  (format #t "~T~Tsync: #<sync-info-paused @ #x~X>~%" (-> this sync))
  (format #t "~T~Tcyl: #<cylinder @ #x~X>~%" (-> this cyl))
  this
  )

;; definition of type gorge-pusher
(deftype gorge-pusher (pusher-base)
  ((min-frame  float)
   )
  (:states
    gorge-pusher-idle
    )
  )

;; definition for method 3 of type gorge-pusher
(defmethod inspect ((this gorge-pusher))
  (let ((t9-0 (method-of-type pusher-base inspect)))
    (t9-0 this)
    )
  (format #t "~T~Tmin-frame: ~f~%" (-> this min-frame))
  this
  )

;; failed to figure out what this is:
(defskelgroup *pusher-sg* pusher pusher-lod0-jg pusher-idle-ja
              ((pusher-lod0-mg (meters 999999)))
              :bounds (static-spherem 0 0 0 10)
              )

;; definition for function pusher-base-init
(defbehavior pusher-base-init pusher-base ()
  (logior! (-> self mask) (process-mask enemy platform))
  (let ((gp-0 (new 'process 'collide-shape-moving self (collide-list-enum hit-by-others))))
    (set! (-> gp-0 dynam) (copy *standard-dynamics* 'process))
    (set! (-> gp-0 reaction) default-collision-reaction)
    (set! (-> gp-0 no-reaction)
          (the-as (function collide-shape-moving collide-shape-intersect vector vector none) nothing)
          )
    (let ((s5-0 (new 'process 'collide-shape-prim-group gp-0 (the-as uint 1) 0)))
      (set! (-> s5-0 prim-core collide-as) (collide-kind ground-object))
      (set! (-> s5-0 collide-with) (collide-kind target))
      (set! (-> s5-0 prim-core action) (collide-action solid rider-plat-sticky))
      (set! (-> s5-0 transform-index) 0)
      (set-vector! (-> s5-0 local-sphere) -8192.0 0.0 0.0 40960.0)
      (set-root-prim! gp-0 s5-0)
      (let ((s4-0 (new 'process 'collide-shape-prim-mesh gp-0 (the-as uint 0) (the-as uint 0))))
        (set! (-> s4-0 prim-core collide-as) (collide-kind ground-object))
        (set! (-> s4-0 collide-with) (collide-kind target))
        (set! (-> s4-0 prim-core action) (collide-action solid rider-plat-sticky))
        (set! (-> s4-0 prim-core offense) (collide-offense indestructible))
        (set! (-> s4-0 transform-index) 4)
        (set-vector! (-> s4-0 local-sphere) 8192.0 0.0 0.0 28672.0)
        (append-prim s5-0 s4-0)
        )
      )
    (set! (-> gp-0 nav-radius) (* 0.75 (-> gp-0 root-prim local-sphere w)))
    (backup-collide-with-as gp-0)
    (set! (-> self root) gp-0)
    gp-0
    )
  )

;; failed to figure out what this is:
(defstate pusher-idle (pusher)
  :trans rider-trans
  :code (behavior ()
    (loop
      (let ((f0-0 -1.0))
        (when (and *target* *camera*)
          (let ((gp-0 (new 'stack-no-clear 'vector)))
            (vector-! gp-0 (target-pos 0) (camera-pos))
            (set! f0-0 (ray-capsule-intersect (-> self cyl) (camera-pos) gp-0))
            )
          )
        (if (< f0-0 0.0)
            (ja :num! (seek! (get-current-value-with-mirror (-> self sync) (-> self max-frame))))
            (ja :num! (seek! 0.0))
            )
        )
      (suspend)
      )
    )
  :post rider-post
  )

;; definition for method 11 of type pusher
;; INFO: Used lq/sq
;; INFO: Return type mismatch object vs none.
(defmethod init-from-entity! ((this pusher) (arg0 entity-actor))
  (pusher-base-init)
  (process-drawable-from-entity! this arg0)
  (initialize-skeleton this *pusher-sg* '())
  (load-params! (-> this sync) this (the-as uint 1500) 0.0 0.15 0.15)
  (set! (-> this max-frame) (res-lump-float arg0 'max-frame :default (the float (ja-num-frames 0))))
  (set! (-> this cyl origin quad) (-> this root trans quad))
  (vector-x-quaternion! (-> this cyl axis) (-> this root quat))
  (vector-negate! (-> this cyl axis) (-> this cyl axis))
  (set! (-> this cyl length) 36864.0)
  (set! (-> this cyl radius) 20480.0)
  (go pusher-idle)
  (none)
  )

;; failed to figure out what this is:
(defstate gorge-pusher-idle (gorge-pusher)
  :trans rider-trans
  :code (behavior ()
    (loop
      (if (task-closed? (game-task rolling-race) (task-status need-introduction))
          (ja :num! (seek! (-> self min-frame)))
          (ja :num! (seek! (-> self max-frame)))
          )
      (suspend)
      )
    )
  :post rider-post
  )

;; definition for method 11 of type gorge-pusher
;; INFO: Return type mismatch object vs none.
(defmethod init-from-entity! ((this gorge-pusher) (arg0 entity-actor))
  (pusher-base-init)
  (process-drawable-from-entity! this arg0)
  (initialize-skeleton this *pusher-sg* '())
  (set! (-> this max-frame) (res-lump-float arg0 'max-frame :default 1.0))
  (set! (-> this max-frame) (* (-> this max-frame) (the float (ja-num-frames 0))))
  (set! (-> this min-frame) (res-lump-float arg0 'min-frame))
  (set! (-> this min-frame) (* (-> this min-frame) (the float (ja-num-frames 0))))
  (cond
    ((task-closed? (game-task rolling-race) (task-status need-introduction))
     (let ((v1-6 (-> this skel root-channel 0)))
       (set! (-> v1-6 num-func) num-func-identity)
       (set! (-> v1-6 frame-num) (-> this min-frame))
       )
     )
    (else
      (let ((v1-10 (-> this skel root-channel 0)))
        (set! (-> v1-10 num-func) num-func-identity)
        (set! (-> v1-10 frame-num) (-> this max-frame))
        )
      )
    )
  (go gorge-pusher-idle)
  (none)
  )

;; definition of type dark-plant
(deftype dark-plant (process-drawable)
  ((num-alts  int32)
   (alts      entity-actor  4)
   )
  (:states
    dark-plant-death
    dark-plant-gone
    dark-plant-idle
    dark-plant-sprout
    dark-plant-startup
    )
  )

;; definition for method 3 of type dark-plant
(defmethod inspect ((this dark-plant))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~T~Tnum-alts: ~D~%" (-> this num-alts))
  (format #t "~T~Talts[4] @ #x~X~%" (-> this alts))
  this
  )

;; failed to figure out what this is:
(defskelgroup *dark-plant-sg* dark-plant dark-plant-lod0-jg dark-plant-idle-ja
              ((dark-plant-lod0-mg (meters 999999)))
              :bounds (static-spherem 0 2.25 0 6)
              )

;; definition for function dark-plant-check-target
;; INFO: Return type mismatch object vs symbol.
(defun dark-plant-check-target ((arg0 dark-plant))
  (the-as symbol (and *target* (and (< (vector-vector-distance (-> arg0 root trans) (target-pos 0)) 16384.0)
                                    (send-event *target* 'query 'powerup (pickup-type eco-green))
                                    )
                      )
          )
  )

;; definition for function dark-plant-randomize
(defun dark-plant-randomize ((arg0 dark-plant))
  (quaternion-axis-angle! (-> arg0 root quat) 0.0 1.0 0.0 (rand-vu-float-range 0.0 65536.0))
  (let ((s5-1 (new 'stack-no-clear 'vector)))
    (set-vector! s5-1 (rand-vu-float-range -1024.0 1024.0) 0.0 (rand-vu-float-range -1024.0 1024.0) 1.0)
    (vector+! (-> arg0 root trans) (-> arg0 entity extra trans) s5-1)
    )
  )

;; definition for function dark-plants-all-done
(defun dark-plants-all-done ((arg0 dark-plant))
  (loop
    (if (!= (-> arg0 state) dark-plant-gone)
        (return #f)
        )
    (if (zero? (-> arg0 num-alts))
        (return #t)
        )
    (let ((v1-9 (-> arg0 alts 0 extra process)))
      (if (not v1-9)
          (return #t)
          )
      (if (= v1-9 arg0)
          (return #t)
          )
      (set! arg0 (the-as dark-plant v1-9))
      )
    )
  (the-as symbol #f)
  )

;; definition for function dark-plant-has-bad-neighbor
(defun dark-plant-has-bad-neighbor ((arg0 dark-plant))
  (dotimes (v1-0 (-> arg0 num-alts))
    (let ((a1-4 (-> arg0 alts v1-0 extra process)))
      (if (and a1-4 (!= (-> a1-4 state) dark-plant-gone))
          (return #t)
          )
      )
    )
  #f
  )

;; definition for function dark-plant-trans
;; INFO: Return type mismatch object vs none.
(defbehavior dark-plant-trans dark-plant ()
  (if (dark-plant-check-target self)
      (go dark-plant-death)
      )
  (none)
  )

;; failed to figure out what this is:
(defstate dark-plant-sprout (dark-plant)
  :trans dark-plant-trans
  :code (behavior ()
    (dark-plant-randomize self)
    (logclear! (-> self draw status) (draw-status hidden))
    (sound-play "darkvine-grow")
    (ja-no-eval :group! dark-plant-sprout-ja :num! (seek!) :frame-num 0.0)
    (until (ja-done? 0)
      (suspend)
      (ja :num! (seek!))
      )
    (go dark-plant-idle)
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate dark-plant-gone (dark-plant)
  :code (behavior ()
    (logior! (-> self draw status) (draw-status hidden))
    (let* ((f30-0 1500.0)
           (v1-4 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
           (v1-5 (the-as number (logior #x3f800000 v1-4)))
           (gp-0 (+ (the int (* f30-0 (+ -1.0 (the-as float v1-5)))) 3000))
           )
      (set-time! (-> self state-time))
      (loop
        (when (and (!= (get-task-status (game-task rolling-plants)) (task-status invalid))
                   (!= (get-task-status (game-task rolling-plants)) 7)
                   )
          (cond
            ((time-elapsed? (-> self state-time) gp-0)
             (go dark-plant-sprout)
             )
            ((dark-plant-check-target self)
             (set-time! (-> self state-time))
             )
            ((not (dark-plant-has-bad-neighbor self))
             (set-time! (-> self state-time))
             )
            (else
              )
            )
          )
        (suspend)
        )
      )
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate dark-plant-death (dark-plant)
  :code (behavior ()
    (spawn (-> self part) (-> self root trans))
    (ja-channel-push! 1 (seconds 0.2))
    (sound-play "darkvine-kill")
    (ja-no-eval :group! dark-plant-death-ja :num! (seek!) :frame-num 0.0)
    (until (ja-done? 0)
      (suspend)
      (ja :num! (seek!))
      )
    (go dark-plant-gone)
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate dark-plant-idle (dark-plant)
  :trans dark-plant-trans
  :code (behavior ()
    (loop
      (when (and (logtest? (-> self draw status) (draw-status was-drawn))
                 *target*
                 (>= 81920.0 (vector-vector-distance (-> self root trans) (-> *target* control trans)))
                 )
        (if (rand-vu-percent? 0.3)
            (sound-play "darkvine-move")
            )
        (when (task-closed? (game-task rolling-plants) (task-status need-hint))
          (level-hint-spawn (text-id rolling-plants-hint) "sksp0113" (the-as entity #f) *entity-pool* (game-task none))
          (if (not (send-event *target* 'query 'powerup (pickup-type eco-green)))
              (level-hint-spawn
                (text-id rolling-plants-hint-eco-green)
                "sksp0114"
                (the-as entity #f)
                *entity-pool*
                (game-task none)
                )
              )
          )
        )
      (let ((gp-1 (-> self skel root-channel 0)))
        (set! (-> gp-1 frame-group) (the-as art-joint-anim dark-plant-idle-ja))
        (set! (-> gp-1 param 0) (the float (+ (-> (the-as art-joint-anim dark-plant-idle-ja) data 0 length) -1)))
        (let ((f30-1 0.9)
              (f28-0 0.25)
              )
          (set! (-> gp-1 param 1) (+ f30-1 (* f28-0 (rand-float-gen))))
          )
        (set! (-> gp-1 frame-num) 0.0)
        (joint-control-channel-group! gp-1 (the-as art-joint-anim dark-plant-idle-ja) num-func-seek!)
        )
      (until (ja-done? 0)
        (suspend)
        (let ((gp-2 (-> self skel root-channel 0)))
          (set! (-> gp-2 param 0) (the float (+ (-> gp-2 frame-group data 0 length) -1)))
          (let ((f30-2 0.9)
                (f28-1 0.25)
                )
            (set! (-> gp-2 param 1) (+ f30-2 (* f28-1 (rand-float-gen))))
            )
          (joint-control-channel-group-eval! gp-2 (the-as art-joint-anim #f) num-func-seek!)
          )
        )
      )
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate dark-plant-startup (dark-plant)
  :trans dark-plant-trans
  :code (behavior ()
    (let ((gp-0 (-> self skel root-channel 0)))
      (set! (-> gp-0 frame-group) (the-as art-joint-anim dark-plant-idle-ja))
      (set! (-> gp-0 param 0) (the float (+ (-> (the-as art-joint-anim dark-plant-idle-ja) data 0 length) -1)))
      (set! (-> gp-0 param 1) 1.0)
      (set! (-> gp-0 frame-num) (* (rand-float-gen) (the float (ja-num-frames 0))))
      (joint-control-channel-group! gp-0 (the-as art-joint-anim dark-plant-idle-ja) num-func-seek!)
      )
    (until (ja-done? 0)
      (suspend)
      (ja :num! (seek!))
      )
    (go dark-plant-idle)
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defpartgroup group-dark-plant
  :id 455
  :duration (seconds 0.14)
  :flags (use-local-clock)
  :bounds (static-bspherem 0 0 0 15)
  :parts ((sp-item 1764) (sp-item 2356))
  )

;; failed to figure out what this is:
(defpart 2356
  :init-specs ((:texture (new 'static 'texture-id :index #x12 :page #x2))
    (:num 1.0)
    (:y (meters 2))
    (:scale-x (meters 12))
    (:rot-z (degrees 0) (degrees 360))
    (:scale-y :copy scale-x)
    (:r 0.0 64.0)
    (:g 192.0 64.0)
    (:b 0.0 32.0)
    (:a 96.0)
    (:fade-g -3.0)
    (:fade-a -2.4)
    (:timer (seconds 0.14))
    (:flags (bit2 bit3 bit14))
    )
  )

;; failed to figure out what this is:
(defpart 1764
  :init-specs ((:texture (new 'static 'texture-id :index #xf :page #x2))
    (:num 128.0)
    (:scale-x (meters 0.2) (meters 0.4))
    (:scale-y :copy scale-x)
    (:r 0.0 128.0)
    (:g 192.0 64.0)
    (:b 0.0)
    (:a 32.0 96.0)
    (:vel-y (meters 0) (meters 0.02))
    (:scalevel-x (meters -0.00066666666))
    (:scalevel-y :copy scalevel-x)
    (:fade-a -0.42666668)
    (:accel-y (meters 0) (meters 0.0013333333))
    (:friction 0.95)
    (:timer (seconds 1))
    (:flags (bit2 bit3))
    (:conerot-x (degrees 45))
    (:conerot-y (degrees 0) (degrees 360))
    (:conerot-radius (meters 0) (meters 4.5))
    (:rotate-y (degrees -15) (degrees 30))
    )
  )

;; definition for method 11 of type dark-plant
;; INFO: Return type mismatch object vs none.
(defmethod init-from-entity! ((this dark-plant) (arg0 entity-actor))
  (set! (-> this root) (new 'process 'trsqv))
  (process-drawable-from-entity! this arg0)
  (initialize-skeleton this *dark-plant-sg* '())
  (set! (-> this part) (create-launch-control (-> *part-group-id-table* 455) this))
  (set! (-> this num-alts) (min 4 (entity-actor-count (-> this entity) 'alt-actor)))
  (dotimes (s5-3 (-> this num-alts))
    (set! (-> this alts s5-3) (entity-actor-lookup (-> this entity) 'alt-actor s5-3))
    )
  (if (zero? (-> this num-alts))
      (format 0 "ERROR<GMJ>: ~S has no alternates~%" (-> this name))
      )
  (dark-plant-randomize this)
  (case (get-task-status (game-task rolling-plants))
    (((task-status invalid) (task-status need-resolution))
     (go dark-plant-gone)
     )
    (else
      (go dark-plant-startup)
      )
    )
  (none)
  )

;; definition of type happy-plant
(deftype happy-plant (process-drawable)
  ((root       collide-shape :override)
   (alt-actor  entity-actor)
   )
  (:states
    happy-plant-init
    happy-plant-opened
    happy-plant-opening
    )
  )

;; definition for method 3 of type happy-plant
(defmethod inspect ((this happy-plant))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~T~Talt-actor: ~A~%" (-> this alt-actor))
  this
  )

;; failed to figure out what this is:
(defskelgroup *happy-plant-sg* happy-plant happy-plant-lod0-jg happy-plant-init-ja
              ((happy-plant-lod0-mg (meters 20)) (happy-plant-lod1-mg (meters 999999)))
              :bounds (static-spherem 0 2.25 0 6)
              )

;; failed to figure out what this is:
(defstate happy-plant-opened (happy-plant)
  :code (behavior ()
    (loop
      (ja-no-eval :group! happy-plant-idle-ja :num! (seek!) :frame-num 0.0)
      (until (ja-done? 0)
        (suspend)
        (ja :num! (seek!))
        )
      )
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate happy-plant-opening (happy-plant)
  :exit (behavior ()
    (when *target*
      (logclear! (-> *target* mask) (process-mask sleep))
      (process-entity-status! self (entity-perm-status bit-3) #f)
      (logior! (-> self mask) (process-mask actor-pause))
      )
    )
  :code (behavior ()
    (close-specific-task! (game-task rolling-plants) (task-status need-reminder))
    (process-entity-status! self (entity-perm-status bit-3) #t)
    (logclear! (-> self mask) (process-mask actor-pause))
    (while (and *target* (< (vector-vector-distance (-> self root trans) (target-pos 0)) 24576.0))
      (suspend)
      )
    (let ((gp-2
            (ppointer->handle (manipy-spawn (-> self entity extra trans) (-> self entity) *rollingcam-sg* #f :to self))
            )
          )
      (let ((s5-1 (get-process *default-dead-pool* othercam #x4000)))
        (ppointer->handle (when s5-1
                            (let ((t9-8 (method-of-type othercam activate)))
                              (t9-8 (the-as othercam s5-1) (-> gp-2 process 0) 'othercam (the-as pointer #x70004000))
                              )
                            (run-now-in-process s5-1 othercam-init-by-other (-> gp-2 process 0) 4 #f #t)
                            (-> s5-1 ppointer)
                            )
                          )
        )
      (let ((s5-3
              (ppointer->handle (process-spawn fuel-cell :init fuel-cell-init-as-clone (process->handle self) 55 :to self))
              )
            )
        (if *target*
            (logior! (-> *target* mask) (process-mask sleep))
            )
        (send-event (-> gp-2 process 0) 'anim-mode 'clone-anim)
        (ja-play-spooled-anim
          (new 'static 'spool-anim
            :name "happy-plant-open"
            :index 5
            :parts 2
            :command-list '((0 send-event target draw #f) (10000 send-event target draw #t))
            )
          (the-as art-joint-anim #f)
          (the-as art-joint-anim happy-plant-idle-ja)
          (the-as (function process-drawable symbol) false-func)
          )
        (ja-channel-set! 1)
        (ja :group! happy-plant-idle-ja)
        (if (handle->process (the-as int gp-2))
            (deactivate (-> gp-2 process 0))
            )
        (let ((gp-3 (handle->process s5-3)))
          (when gp-3
            (send-event gp-3 'stop-cloning)
            (let ((s5-4 (new-stack-vector0)))
              (vector<-cspace! s5-4 (joint-node happy-plant-lod0-jg fuelcell))
              (send-event gp-3 'trans s5-4)
              )
            )
          )
        )
      )
    (restore-collide-with-as (-> self root))
    (go happy-plant-opened)
    )
  :post transform-post
  )

;; failed to figure out what this is:
(defstate happy-plant-init (happy-plant)
  :trans (behavior ()
    (when (-> self alt-actor)
      (spool-push *art-control* "happy-plant-open" 0 self -99.0)
      (let* ((gp-0 (-> self alt-actor extra process))
             (a0-2 (if (and (nonzero? gp-0) (type-type? (-> gp-0 type) dark-plant))
                       gp-0
                       )
                   )
             )
        (when a0-2
          (if (dark-plants-all-done (the-as dark-plant a0-2))
              (go happy-plant-opening)
              )
          )
        )
      )
    )
  :code (behavior ()
    (clear-collide-with-as (-> self root))
    (loop
      (ja-no-eval :group! (ja-group) :num! (seek!) :frame-num 0.0)
      (until (ja-done? 0)
        (suspend)
        (ja :num! (seek!))
        )
      )
    )
  :post ja-post
  )

;; definition for method 11 of type happy-plant
;; INFO: Return type mismatch object vs none.
(defmethod init-from-entity! ((this happy-plant) (arg0 entity-actor))
  (stack-size-set! (-> this main-thread) 512)
  (let ((s4-0 (new 'process 'collide-shape this (collide-list-enum hit-by-player))))
    (let ((s3-0 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
      (set! (-> s3-0 prim-core collide-as) (collide-kind enemy))
      (set! (-> s3-0 collide-with) (collide-kind target))
      (set! (-> s3-0 prim-core action) (collide-action solid))
      (set! (-> s3-0 prim-core offense) (collide-offense indestructible))
      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 8192.0)
      (set-root-prim! s4-0 s3-0)
      )
    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
    (backup-collide-with-as s4-0)
    (set! (-> this root) s4-0)
    )
  (process-drawable-from-entity! this arg0)
  (initialize-skeleton this *happy-plant-sg* '())
  (set! (-> this alt-actor) (entity-actor-lookup (-> this entity) 'alt-actor 0))
  (case (get-task-status (game-task rolling-plants))
    (((task-status invalid))
     (let ((v1-19 (-> this skel root-channel 0)))
       (set! (-> v1-19 frame-group) (the-as art-joint-anim (-> this draw art-group data 4)))
       )
     (go happy-plant-opened)
     )
    (((task-status need-resolution))
     (let ((s5-1 (new 'stack-no-clear 'vector)))
       (let ((v1-23 (-> this skel root-channel 0)))
         (set! (-> v1-23 frame-group) (the-as art-joint-anim (-> this draw art-group data 4)))
         )
       (logior! (-> this skel status) (janim-status inited))
       (ja-post)
       (logclear! (-> this skel status) (janim-status inited))
       (vector<-cspace! s5-1 (-> this node-list data 25))
       (birth-pickup-at-point s5-1 (pickup-type fuel-cell) 55.0 #f this (the-as fact-info #f))
       )
     (go happy-plant-opened)
     )
    (else
      (go happy-plant-init)
      )
    )
  (none)
  )

;; definition of type race-time
(deftype race-time (structure)
  ((digit  int8  5)
   )
  :pack-me
  )

;; definition for method 3 of type race-time
(defmethod inspect ((this race-time))
  (format #t "[~8x] ~A~%" this 'race-time)
  (format #t "~Tdigit[5] @ #x~X~%" (-> this digit))
  this
  )

;; definition for function race-time-copy!
(defun race-time-copy! ((arg0 race-time) (arg1 race-time))
  (dotimes (v1-0 5)
    (set! (-> arg0 digit v1-0) (-> arg1 digit v1-0))
    )
  #f
  )

;; definition for function seconds->race-time
;; INFO: Return type mismatch int vs none.
(defun seconds->race-time ((arg0 race-time) (arg1 time-frame))
  (let* ((v1-1 (max 0 (min #x2bf1d arg1)))
         (f0-1 (* 0.0033333334 (the float v1-1)))
         )
    (set! (-> arg0 digit 0) (the int (* 0.016666668 f0-1)))
    (let ((f0-2 (- f0-1 (* 60.0 (the float (-> arg0 digit 0))))))
      (set! (-> arg0 digit 1) (the int (* 0.1 f0-2)))
      (let ((f0-3 (- f0-2 (* 10.0 (the float (-> arg0 digit 1))))))
        (set! (-> arg0 digit 2) (the int f0-3))
        (let ((f0-4 (- f0-3 (the float (-> arg0 digit 2)))))
          (set! (-> arg0 digit 3) (the int (* 10.0 f0-4)))
          (let ((f0-5 (- f0-4 (* 0.1 (the float (-> arg0 digit 3))))))
            (set! (-> arg0 digit 4) (the int (* 100.0 f0-5)))
            )
          )
        )
      )
    )
  (none)
  )

;; definition for function race-time->seconds
(defun race-time->seconds ((arg0 race-time))
  (let ((f0-5 (+ (the float (* 60 (-> arg0 digit 0)))
                 (the float (* 10 (-> arg0 digit 1)))
                 (the float (-> arg0 digit 2))
                 (* 0.1 (the float (-> arg0 digit 3)))
                 (* 0.01 (the float (-> arg0 digit 4)))
                 )
              )
        )
    (the int (* 300.0 f0-5))
    )
  )

;; definition for function race-time-less-than
(defun race-time-less-than ((arg0 race-time) (arg1 race-time))
  (dotimes (v1-0 5)
    (cond
      ((< (-> arg0 digit v1-0) (-> arg1 digit v1-0))
       (return #t)
       )
      ((< (-> arg1 digit v1-0) (-> arg0 digit v1-0))
       (return #f)
       )
      )
    )
  #f
  )

;; definition for function race-time-save
;; ERROR: Type Propagation failed: Failed type prop at op 6 ((set! v1 (l.wu (+ a0 -4)))): Could not get type of load: (set! v1 (l.wu (+ a0 -4))). 
;; ERROR: Type analysis failed
;; ERROR: Function may read a register that is not set: a2
(defun race-time-save ((a0-0 race-time) (a1-0 task-control))
  (local-vars
    (v0-0 none)
    (v0-1 symbol)
    (v1-0 none)
    (v1-1 none)
    (a0-1 none)
    (a1-1 none)
    (a2-0 none)
    (a2-1 none)
    (s3-0 int)
    (t9-0 none)
    )
  (set! s3-0 0)
  (while (<.si s3-0 5)
    (set! a0-1 a2-0)
    (set! v1-0 (the-as none (l.wu (+ a0-1 -4))))
    (set! t9-0 (the-as none (l.wu (+ v1-0 84))))
    (set! v1-1 (the-as none (+ s3-0 a0-0)))
    (set! a1-1 (the-as none (l.b v1-1)))
    (set! a2-1 (the-as none (+ a1-0 s3-0)))
    (call!)
    (set! v1-2 (the-as none v0-0))
    (set! s3-0 (the-as int (+ s3-0 1)))
    )
  (set! v0-1 #f)
  (ret-value v0-1)
  )

;; definition for function race-time-read
;; ERROR: function was not converted to expressions. Cannot decompile.

;; failed to figure out what this is:
(defskelgroup *rolling-start-whole-sg* rolling-start rolling-start-whole-lod0-jg rolling-start-idle-ja
              ((rolling-start-whole-lod0-mg (meters 999999)))
              :bounds (static-spherem 0 0 0 30)
              )

;; failed to figure out what this is:
(defskelgroup *rolling-start-broken-sg* rolling-start rolling-start-broken-lod0-jg rolling-start-idle-ja
              ((rolling-start-broken-lod0-mg (meters 999999)))
              :bounds (static-spherem 0 0 0 30)
              )

;; definition of type rolling-start
(deftype rolling-start (process-drawable)
  ((whole-look   lod-set  :inline)
   (broken-look  lod-set  :inline)
   )
  (:states
    (rolling-start-break symbol)
    rolling-start-whole
    )
  )

;; definition for method 3 of type rolling-start
(defmethod inspect ((this rolling-start))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~T~Twhole-look: #<lod-set @ #x~X>~%" (-> this whole-look))
  (format #t "~T~Tbroken-look: #<lod-set @ #x~X>~%" (-> this broken-look))
  this
  )

;; failed to figure out what this is:
(defstate rolling-start-break (rolling-start)
  :event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
    (case message
      (('unbreak)
       (go rolling-start-whole)
       )
      )
    )
  :code (behavior ((arg0 symbol))
    (ja-no-eval :group! rolling-start-break-whole-ja :num! (seek!) :frame-num 0.0)
    (until (ja-done? 0)
      (suspend)
      (ja :num! (seek!))
      )
    (lods-assign! (-> self draw) (-> self broken-look))
    (ja-no-eval :group! rolling-start-break-broken-ja :num! (seek!) :frame-num 0.0)
    (until (ja-done? 0)
      (suspend)
      (ja :num! (seek!))
      )
    (loop
      (ja-no-eval :group! rolling-start-broken-ja :num! (seek!) :frame-num 0.0)
      (until (ja-done? 0)
        (suspend)
        (ja :num! (seek!))
        )
      (if arg0
          (deactivate self)
          )
      )
    )
  :post ja-post
  )

;; failed to figure out what this is:
(defstate rolling-start-whole (rolling-start)
  :event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
    (case message
      (('break)
       (sound-play "cool-rolling-st")
       (go rolling-start-break #f)
       )
      (('break-and-die)
       (go rolling-start-break #t)
       )
      )
    )
  :code (behavior ()
    (lods-assign! (-> self draw) (-> self whole-look))
    (loop
      (ja-no-eval :group! rolling-start-idle-ja :num! (seek!) :frame-num 0.0)
      (until (ja-done? 0)
        (suspend)
        (ja :num! (seek!))
        )
      )
    )
  :post ja-post
  )

;; definition for function rolling-start-init-by-other
;; INFO: Used lq/sq
;; INFO: Return type mismatch object vs none.
(defbehavior rolling-start-init-by-other rolling-start ((arg0 vector) (arg1 float))
  (set! (-> self root) (new 'process 'trsqv))
  (set! (-> self root trans quad) (-> arg0 quad))
  (initialize-skeleton self *rolling-start-whole-sg* '())
  (setup-lods! (-> self whole-look) *rolling-start-whole-sg* (-> self draw art-group) (-> self entity))
  (setup-lods! (-> self broken-look) *rolling-start-broken-sg* (-> self draw art-group) (-> self entity))
  (let ((s5-1 (new 'stack-no-clear 'matrix)))
    (matrix-rotate-y! s5-1 arg1)
    (matrix->quaternion (-> self root quat) s5-1)
    )
  (go rolling-start-whole)
  (none)
  )

;; definition of type gorge
(deftype gorge (process-drawable)
  ((root       collide-shape-moving :override)
   (coord      matrix                :inline)
   (radius     float)
   (thickness  float)
   )
  )

;; definition for method 3 of type gorge
(defmethod inspect ((this gorge))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 this)
    )
  (format #t "~T~Tcoord: #<matrix @ #x~X>~%" (-> this coord))
  (format #t "~T~Tradius: ~f~%" (-> this radius))
  (format #t "~T~Tthickness: ~f~%" (-> this thickness))
  this
  )

;; definition for function gorge-init
(defbehavior gorge-init gorge ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float))
  (forward-down->inv-matrix (-> self coord) arg1 (new 'static 'vector :y -1.0))
  (matrix-transpose! (-> self coord) (-> self coord))
  (let ((s3-0 (new 'stack-no-clear 'vector)))
    (vector-matrix*! s3-0 arg0 (-> self coord))
    (vector-negate! (-> self coord vector 3) s3-0)
    )
  (set! (-> self coord vector 3 w) 1.0)
  (set! (-> self radius) arg2)
  (set! (-> self thickness) arg3)
  )

;; definition of type gorge-start
(deftype gorge-start (gorge)
  ((tasks             task-control)
   (record-time       race-time  :inline)
   (this-time         race-time  :inline)
   (start-banner      handle)
   (end-banner        handle)
   (timer-pos-offset  int32)
   (ticker            ticky      :inline)
   )
  (:states
    gorge-start-idle
    gorge-start-race-aborted
    gorge-start-race-finished
    gorge-start-racing
    gorge-start-ready
    )
  )

;; definition for method 3 of type gorge-start
(defmethod inspect ((this gorge-start))
  (let ((t9-0 (method-of-type gorge inspect)))
    (t9-0 this)
    )
  (format #t "~T~Ttasks: ~A~%" (-> this tasks))
  (format #t "~T~Trecord-time: #<race-time @ #x~X>~%" (-> this record-time))
  (format #t "~T~Tthis-time: #<race-time @ #x~X>~%" (-> this this-time))
  (format #t "~T~Tstart-banner: ~D~%" (-> this start-banner))
  (format #t "~T~Tend-banner: ~D~%" (-> this end-banner))
  (format #t "~T~Ttimer-pos-offset: ~D~%" (-> this timer-pos-offset))
  (format #t "~T~Tticker: #<ticky @ #x~X>~%" (-> this ticker))
  this
  )

;; definition of type gorge-finish
(deftype gorge-finish (gorge)
  ((alt-actor  entity-actor)
   )
  (:states
    gorge-finish-idle
    )
  )

;; definition for method 3 of type gorge-finish
(defmethod inspect ((this gorge-finish))
  (let ((t9-0 (method-of-type gorge inspect)))
    (t9-0 this)
    )
  (format #t "~T~Talt-actor: ~A~%" (-> this alt-actor))
  this
  )

;; definition of type gorge-abort
(deftype gorge-abort (gorge)
  ()
  (:states
    gorge-abort-idle
    )
  )

;; definition for method 3 of type gorge-abort
(defmethod inspect ((this gorge-abort))
  (let ((t9-0 (method-of-type gorge inspect)))
    (t9-0 this)
    )
  this
  )

;; definition for function gorge-behind
;; INFO: Used lq/sq
(defun gorge-behind ((arg0 gorge))
  (if (not *target*)
      (return #f)
      )
  (let ((gp-0 (new-stack-vector0)))
    (vector-matrix*! gp-0 (target-pos 0) (-> arg0 coord))
    (and (< (fabs (-> gp-0 x)) (-> arg0 radius))
         (< (-> gp-0 y) (-> arg0 radius))
         (< 0.0 (-> gp-0 y))
         (< (-> gp-0 z) 0.0)
         )
    )
  )

;; definition for function gorge-in-front
;; INFO: Used lq/sq
(defun gorge-in-front ((arg0 gorge))
  (if (not *target*)
      (return #f)
      )
  (let ((s5-0 (new-stack-vector0)))
    (vector-matrix*! s5-0 (target-pos 0) (-> arg0 coord))
    (and (< (fabs (-> s5-0 x)) (-> arg0 radius))
         (< (-> s5-0 y) (-> arg0 radius))
         (< 0.0 (-> s5-0 y))
         (< 0.0 (-> s5-0 z))
         (< (-> s5-0 z) (-> arg0 thickness))
         )
    )
  )

;; definition for function gorge-trans
;; INFO: Return type mismatch symbol vs none.
(defun gorge-trans ()
  (none)
  )

;; failed to figure out what this is:
(defstate gorge-abort-idle (gorge-abort)
  :trans gorge-trans
  :code (behavior ()
    (loop
      (suspend)
      (if (gorge-behind self)
          (send-event (ppointer->process (-> self parent)) 'aborted)
          )
      )
    )
  )

;; definition for function gorge-abort-init-by-other
;; INFO: Used lq/sq
;; INFO: Return type mismatch object vs none.
(defbehavior gorge-abort-init-by-other gorge-abort ((arg0 vector) (arg1 vector) (arg2 float))
  (set! (-> self root) (the-as collide-shape-moving (new 'process 'trsqv)))
  (set! (-> self root trans quad) (-> arg0 quad))
  (gorge-init arg0 arg1 arg2 8192.0)
  (go gorge-abort-idle)
  (none)
  )

;; failed to figure out what this is:
(defstate gorge-finish-idle (gorge-finish)
  :trans gorge-trans
  :code (behavior ()
    (loop
      (suspend)
      (if (gorge-in-front self)
          (send-event (ppointer->process (-> self parent)) 'finished)
          )
      )
    )
  )

;; definition for function gorge-finish-init-by-other
;; INFO: Used lq/sq
;; INFO: Return type mismatch object vs none.
(defbehavior gorge-finish-init-by-other gorge-finish ((arg0 vector) (arg1 vector) (arg2 float))
  (set! (-> self root) (the-as collide-shape-moving (new 'process 'trsqv)))
  (set! (-> self root trans quad) (-> arg0 quad))
  (gorge-init arg0 arg1 arg2 20480.0)
  (go gorge-finish-idle)
  (none)
  )

;; definition for function race-time->string
(defun race-time->string ((arg0 race-time))
  (cond
    ((zero? (-> arg0 digit 0))
     (format
       (clear *temp-string*)
       "~D~D.~D~D"
       (-> arg0 digit 1)
       (-> arg0 digit 2)
       (-> arg0 digit 3)
       (-> arg0 digit 4)
       )
     *temp-string*
     )
    (else
      (format
        (clear *temp-string*)
        "~D:~D~D.~D~D"
        (-> arg0 digit 0)
        (-> arg0 digit 1)
        (-> arg0 digit 2)
        (-> arg0 digit 3)
        (-> arg0 digit 4)
        )
      *temp-string*
      )
    )
  )

;; definition for function gorge-start-draw-time
;; INFO: Return type mismatch object vs none.
(defbehavior gorge-start-draw-time gorge-start ((arg0 symbol) (arg1 symbol))
  (let ((gp-0 (new
                'stack
                'font-context
                *font-default-matrix*
                0
                0
                0.0
                (font-color progress-yellow)
                (font-flags shadow kerning)
                )
              )
        )
    (let ((v1-1 gp-0))
      (set! (-> v1-1 width) (the float 200))
      )
    (let ((v1-2 gp-0))
      (set! (-> v1-2 height) (the float 50))
      )
    (let ((v1-3 gp-0))
      (set! (-> v1-3 scale) 0.7)
      )
    (set! (-> gp-0 origin x) (the float (+ (-> self timer-pos-offset) 392)))
    (set! (-> gp-0 origin y) (the float (- 10 (-> self timer-pos-offset))))
    (set! (-> gp-0 flags) (font-flags shadow kerning right large))
    (print-game-text (lookup-text! *common-text* (text-id time) #f) gp-0 #f 128 22)
    (+! (-> gp-0 origin x) 10.0)
    (set! (-> gp-0 flags) (font-flags shadow kerning large))
    (print-game-text (race-time->string (-> self this-time)) gp-0 #f 128 22)
    (+! (-> gp-0 origin x) -10.0)
    (+! (-> gp-0 origin y) 15.0)
    (set! (-> gp-0 flags) (font-flags shadow kerning right large))
    (print-game-text (lookup-text! *common-text* (text-id record) #f) gp-0 #f 128 22)
    (+! (-> gp-0 origin x) 10.0)
    (set! (-> gp-0 flags) (font-flags shadow kerning large))
    (print-game-text (race-time->string (-> self record-time)) gp-0 #f 128 22)
    (cond
      ((not arg0)
       )
      ((race-time-less-than (-> self this-time) (-> self record-time))
       (when (< (mod (-> *display* real-frame-counter) 90) 60)
         (let ((v1-18 gp-0))
           (set! (-> v1-18 scale) 1.0)
           )
         (set! (-> gp-0 origin x) 156.0)
         (set! (-> gp-0 origin y) 80.0)
         (set! (-> gp-0 flags) (font-flags shadow kerning middle middle-vert large))
         (let ((a0-15 gp-0))
           (set! (-> a0-15 color) (font-color red))
           )
         (print-game-text (lookup-text! *common-text* (text-id new-record) #f) gp-0 #f 128 22)
         )
       (when arg1
         (close-specific-task! (-> self entity extra perm task) (task-status need-reminder))
         (level-hint-spawn
           (text-id rolling-race-beat-record)
           "sksp0109"
           (the-as entity #f)
           *entity-pool*
           (game-task none)
           )
         (let ((t9-14 race-time-save)
               (a0-20 (-> self this-time))
               (a1-13 1)
               )
           (-> self tasks)
           (t9-14 a0-20 (the-as task-control a1-13))
           )
         )
       )
      (else
        (if arg1
            (ambient-hint-spawn "st-lose" (the-as vector #f) *entity-pool* 'stinger)
            )
        (when (< (mod (-> *display* real-frame-counter) 90) 60)
          (let ((v1-30 gp-0))
            (set! (-> v1-30 scale) 1.0)
            )
          (set! (-> gp-0 origin x) 156.0)
          (set! (-> gp-0 origin y) 80.0)
          (set! (-> gp-0 flags) (font-flags shadow kerning middle middle-vert large))
          (let ((a0-23 gp-0))
            (set! (-> a0-23 color) (font-color red))
            )
          (print-game-text (lookup-text! *common-text* (text-id try-again) #f) gp-0 #f 128 22)
          )
        )
      )
    )
  (none)
  )

;; definition for function gorge-start-launch-start-banner
;; INFO: Used lq/sq
;; INFO: Return type mismatch int vs handle.
(defbehavior gorge-start-launch-start-banner gorge-start ()
  (the-as handle (when (task-closed? (game-task rolling-race) (task-status need-introduction))
                   (when (not (handle->process (-> self start-banner)))
                     (let ((gp-0 (new 'stack-no-clear 'vector)))
                       (set! (-> gp-0 quad) (-> self root trans quad))
                       (let ((v0-1 (ppointer->handle (process-spawn rolling-start gp-0 0.0 :to self))))
                         (set! (-> self start-banner) (the-as handle v0-1))
                         v0-1
                         )
                       )
                     )
                   )
          )
  )

;; failed to figure out what this is:
(defstate gorge-start-race-finished (gorge-start)
  :trans (behavior ()
    (gorge-trans)
    )
  :code (behavior ()
    (gorge-start-draw-time #t #t)
    (suspend)
    (set-time! (-> self state-time))
    (until (time-elapsed? (-> self state-time) (seconds 3))
      (seekl! (-> self timer-pos-offset) 100 (the int (* 3.0 (-> *display* time-adjust-ratio))))
      (when (= (-> self timer-pos-offset) 100)
        (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'enable)
        (send-event (ppointer->process (-> *hud-parts* money)) 'enable)
        )
      (gorge-start-draw-time #t #f)
      (suspend)
      (if (gorge-in-front self)
          (go gorge-start-ready)
          )
      )
    (go gorge-start-idle)
    )
  )

;; failed to figure out what this is:
(defstate gorge-start-race-aborted (gorge-start)
  :trans (behavior ()
    (gorge-trans)
    )
  :code (behavior ()
    (set-time! (-> self state-time))
    (until (time-elapsed? (-> self state-time) (seconds 3))
      (seekl! (-> self timer-pos-offset) 100 (the int (* 5.0 (-> *display* time-adjust-ratio))))
      (when (= (-> self timer-pos-offset) 100)
        (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'enable)
        (send-event (ppointer->process (-> *hud-parts* money)) 'enable)
        )
      (when (< (mod (-> *display* real-frame-counter) 90) 60)
        (let ((gp-0
                (new 'stack 'font-context *font-default-matrix* 156 80 0.0 (font-color red) (font-flags shadow kerning))
                )
              )
          (let ((v1-20 gp-0))
            (set! (-> v1-20 width) (the float 200))
            )
          (let ((v1-21 gp-0))
            (set! (-> v1-21 height) (the float 50))
            )
          (set! (-> gp-0 flags) (font-flags shadow kerning middle middle-vert large))
          (print-game-text (lookup-text! *common-text* (text-id race-aborted) #f) gp-0 #f 128 22)
          )
        )
      (suspend)
      (if (gorge-in-front self)
          (go gorge-start-ready)
          )
      )
    (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'enable)
    (send-event (ppointer->process (-> *hud-parts* money)) 'enable)
    (go gorge-start-idle)
    )
  )

;; failed to figure out what this is:
(defstate gorge-start-racing (gorge-start)
  :event (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
    (case message
      (('finished)
       (go gorge-start-race-finished)
       )
      (('aborted)
       (go gorge-start-race-aborted)
       )
      )
    )
  :enter (behavior ()
    (send-event (handle->process (-> self start-banner)) 'break)
    (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'disable)
    (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'hide)
    (send-event (ppointer->process (-> *hud-parts* money)) 'disable)
    (send-event (ppointer->process (-> *hud-parts* money)) 'hide)
    (let ((t9-5 race-time-read)
          (a0-8 (-> self record-time))
          (a1-5 1)
          (a2-1 (-> self tasks))
          )
      #x34bc
      (t9-5 a0-8 (the-as task-control a1-5) (the-as time-frame a2-1))
      )
    (set! (-> self end-banner)
          (ppointer->handle
            (process-spawn rolling-start (new 'static 'vector :x -86016.0 :y 112640.0 :z -6309888.0) 16384.0 :to self)
            )
          )
    (process-spawn
      gorge-finish
      (new 'static 'vector :x -86016.0 :y 114688.0 :z -6303744.0)
      (new 'static 'vector :x -1.0)
      57344.0
      :to self
      )
    (process-spawn
      gorge-abort
      (new 'static 'vector :x -696320.0 :y 122880.0 :z -6828032.0)
      (new 'static 'vector :x -0.707 :y 0.707)
      163840.0
      :to self
      )
    (process-spawn
      gorge-abort
      (new 'static 'vector :x -847872.0 :y 143360.0 :z -6828032.0)
      (new 'static 'vector :x 0.707 :y 0.707)
      163840.0
      :to self
      )
    (process-spawn
      gorge-abort
      (new 'static 'vector :x -417792.0 :y 143360.0 :z -6004736.0)
      (new 'static 'vector :x -0.5 :y 0.707 :z 0.3)
      266240.0
      :to self
      )
    (process-spawn
      gorge-abort
      (new 'static 'vector :x -647168.0 :y 143360.0 :z -6025216.0)
      (new 'static 'vector :x 0.5 :y 0.707 :z -0.3)
      163840.0
      :to self
      )
    (sleep (-> self ticker) (seconds 6000))
    (set-setting! 'sound-flava #f 40.0 (music-flava rolling-gorge))
    )
  :exit (behavior ()
    (let* ((v1-0 (-> self child))
           (gp-0 (-> v1-0 0 brother))
           )
      (while v1-0
        (if (not (or (= v1-0 (-> self start-banner process)) (= v1-0 (-> self end-banner process))))
            (deactivate (-> v1-0 0))
            )
        (set! v1-0 gp-0)
        (set! gp-0 (-> v1-0 0 brother))
        )
      )
    (send-event (handle->process (-> self end-banner)) 'break-and-die)
    (send-event (handle->process (-> self start-banner)) 'unbreak)
    (remove-setting! 'sound-flava)
    )
  :trans gorge-trans
  :code (behavior ()
    (set! (-> self state-time) (-> *display* game-frame-counter))
    (loop
      (seconds->race-time (-> self this-time) (- (-> *display* game-frame-counter) (-> self state-time)))
      (seekl! (-> self timer-pos-offset) 0 (the int (* 5.0 (-> *display* time-adjust-ratio))))
      (completed? (-> self ticker))
      (gorge-start-draw-time #f #f)
      (suspend)
      (if (or (not *target*) (gorge-in-front self))
          (go gorge-start-ready)
          )
      )
    )
  )

;; failed to figure out what this is:
(defstate gorge-start-ready (gorge-start)
  :trans gorge-trans
  :code (behavior ()
    (loop
      (suspend)
      (seekl! (-> self timer-pos-offset) 100 (the int (* 5.0 (-> *display* time-adjust-ratio))))
      (when (= (-> self timer-pos-offset) 100)
        (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'enable)
        (send-event (ppointer->process (-> *hud-parts* money)) 'enable)
        )
      (gorge-start-draw-time #f #f)
      (cond
        ((gorge-in-front self)
         )
        ((gorge-behind self)
         (go gorge-start-racing)
         )
        (else
          (go gorge-start-idle)
          )
        )
      )
    )
  )

;; failed to figure out what this is:
(defstate gorge-start-idle (gorge-start)
  :enter (behavior ()
    (logior! (-> self mask) (process-mask actor-pause))
    (process-entity-status! self (entity-perm-status bit-3) #f)
    )
  :exit (behavior ()
    (logclear! (-> self mask) (process-mask actor-pause))
    (process-entity-status! self (entity-perm-status bit-3) #t)
    )
  :trans (behavior ()
    (gorge-start-launch-start-banner)
    (gorge-trans)
    )
  :code (behavior ()
    (loop
      (suspend)
      (seekl! (-> self timer-pos-offset) 100 (the int (* 5.0 (-> *display* time-adjust-ratio))))
      (when (= (-> self timer-pos-offset) 100)
        (send-event (ppointer->process (-> *hud-parts* fuel-cell)) 'enable)
        (send-event (ppointer->process (-> *hud-parts* money)) 'enable)
        )
      (if (gorge-in-front self)
          (go gorge-start-ready)
          )
      )
    )
  )

;; definition for method 11 of type gorge-start
;; INFO: Used lq/sq
;; INFO: Return type mismatch object vs none.
(defmethod init-from-entity! ((this gorge-start) (arg0 entity-actor))
  (set! (-> this root) (the-as collide-shape-moving (new 'process 'trsqv)))
  (process-drawable-from-entity! this arg0)
  (let ((a0-3 (new 'stack-no-clear 'vector)))
    (set! (-> a0-3 quad) (-> this root trans quad))
    (+! (-> a0-3 y) -8192.0)
    (gorge-init a0-3 (new 'static 'vector :z 1.0) 102400.0 40960.0)
    )
  (set! (-> this tasks) (get-task-control (-> this entity extra perm task)))
  (set! (-> this start-banner) (the-as handle #f))
  (set! (-> this end-banner) (the-as handle #f))
  (set! (-> this timer-pos-offset) 100)
  (go gorge-start-idle)
  (none)
  )

;; definition of type rolling-water
(deftype rolling-water (water-anim)
  ()
  )

;; definition for method 3 of type rolling-water
(defmethod inspect ((this rolling-water))
  (let ((t9-0 (method-of-type water-anim inspect)))
    (t9-0 this)
    )
  this
  )

;; definition for symbol ripple-for-rolling-water, type object
(define ripple-for-rolling-water
  (the-as object (new 'static 'ripple-wave-set
                   :count 3
                   :converted #f
                   :normal-scale 1.0
                   :wave (new 'static 'inline-array ripple-wave 4
                     (new 'static 'ripple-wave :scale 40.0 :xdiv 1 :speed 1.5)
                     (new 'static 'ripple-wave :scale 40.0 :xdiv -1 :zdiv 1 :speed 1.5)
                     (new 'static 'ripple-wave :scale 20.0 :xdiv 5 :zdiv 3 :speed 0.75)
                     (new 'static 'ripple-wave)
                     )
                   )
                 )
  )

;; definition for method 22 of type rolling-water
;; INFO: Return type mismatch water-flags vs none.
(defmethod water-vol-method-22 ((this rolling-water))
  (let ((t9-0 (method-of-type water-anim water-vol-method-22)))
    (t9-0 this)
    )
  (let ((v1-2 (new 'process 'ripple-control)))
    (set! (-> this draw ripple) v1-2)
    (set-vector! (-> this draw color-mult) 0.01 0.45 0.5 0.75)
    (set! (-> v1-2 global-scale) 3072.0)
    (set! (-> v1-2 close-fade-dist) 163840.0)
    (set! (-> v1-2 far-fade-dist) 245760.0)
    (set! (-> v1-2 waveform) (the-as ripple-wave-set ripple-for-rolling-water))
    )
  (logclear! (-> this flags) (water-flags wt23))
  (none)
  )