;;-*-Lisp-*-
(in-package goal)
(bundles "FIC.DGO" "LAV.DGO" "MIS.DGO" "OGR.DGO" "ROL.DGO")
(require "levels/common/blocking-plane.gc")
(require "engine/common-obs/generic-obs.gc")
(require "engine/entity/ambient.gc")
(require "engine/game/task/task-control.gc")
(define-extern blocking-plane-destroy (function none))

(define-extern blocking-plane-spawn (function curve-control none :behavior process))

;; DECOMP BEGINS

(if (not (nmember "racerp" *kernel-packages*)) (set! *kernel-packages* (cons "racerp" *kernel-packages*)))

(deftype racer (process-drawable)
  ((root            collide-shape-moving :override)
   (parent-override (pointer target) :overlay-at parent)
   (extra-trans     vector :inline)
   (condition       int32)
   (cell            handle)
   (path-data       path-control 2)
   (path-target     curve-control :overlay-at (-> path-data 0))
   (path-racer      path-control :overlay-at (-> path-data 1))
   (auto-get-off    symbol)
   (shadow-backup   shadow-geo))
  (:state-methods
   wait-for-start
   idle
   (pickup (state collectable))
   wait-for-return))


(defmethod relocate ((this racer) (offset int))
  (countdown (v1-0 2)
    (if (-> this path-data v1-0) (&+! (-> this path-data v1-0) offset)))
  (the-as racer ((method-of-type process-drawable relocate) this offset)))

(defskelgroup *racer-sg*
  racer
  racer-geo-jg
  racer-racer-idle-ja
  ((racer-geo-mg (meters 999999)))
  :bounds (static-spherem 0 0 0 3.5)
  :shadow racer-shadow-mg
  :sort 1)

(defskelgroup *racer-explode-sg*
  racer
  racer-explode-lod0-jg
  racer-explode-idle-ja
  ((racer-explode-lod0-mg (meters 999999)))
  :bounds (static-spherem 0 0 0 3.5))

(define *racer-shadow-control*
  (new 'static
       'shadow-control
       :settings
       (new 'static
            'shadow-settings
            :flags (shadow-flags disable-fade shdf03)
            :shadow-dir
            (new 'static 'vector :y -1.0 :w 614400.0)
            :bot-plane
            (new 'static 'plane :y 1.0 :w 81920.0)
            :top-plane
            (new 'static 'plane :y 1.0 :w 2048.0))))

(defbehavior racer-effect racer ()
  (when (!= (-> self condition) 4)
    (spawn (-> self part) (-> self root trans))
    (update! (-> self sound)))
  0
  (none))

(defstate wait-for-start (racer)
  :virtual #t
  :event
    (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
      (local-vars (v0-1 structure))
      (case message
        (('trans) (vector+! (the-as vector (-> block param 0)) (-> self root trans) (-> self extra-trans)))
        (('notify) (set! v0-1 #t) (set! (-> self auto-get-off) (the-as symbol v0-1)) v0-1)
        (('shadow)
         (cond
           ((-> block param 0) (set! v0-1 (-> self shadow-backup)) (set! (-> self draw shadow) (the-as shadow-geo v0-1)) v0-1)
           (else (set! (-> self draw shadow) #f) #f)))))
  :exit
    (behavior ()
      (set! (-> self root root-prim prim-core action) (collide-action))
      (set! (-> self root root-prim prim-core offense) (collide-offense no-offense))
      0)
  :code
    (behavior ()
      (label cfg-0)
      (case (-> self condition)
        ((2)
         (let ((gp-0 (get-task-control (-> self entity extra perm task))))
           (if (and *cheat-mode* (cpad-hold? 0 l3)) (goto cfg-77))
           (first-any gp-0 #t)
           (case (current-status gp-0)
             (((task-status need-reward-speech))
              (ja-channel-set! 1)
              (ja :group! racer-racer-idle-ja)
              (set! (-> self root root-prim prim-core action) (collide-action solid attackable-unused))
              (set! (-> self root root-prim prim-core offense) (collide-offense indestructible))
              (ja-post))
             (((task-status invalid)) (goto cfg-77)))))
        ((6)
         (if (or (task-closed? (game-task village2-levitator) (task-status need-hint))
                 (and *cheat-mode* (cpad-hold? 0 l3))
                 (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer))))
           (goto cfg-77)))
        ((5)
         (cond
           ((and *cheat-mode* (cpad-hold? 0 l3)) (goto cfg-77))
           ((>= (-> *game-info* fuel) 72.0) (goto cfg-77))))
        ((3)
         (cond
           ((and (task-complete? *game-info* (-> self entity extra perm task)) (not (handle->process (-> self cell))))
            (when (and (-> self auto-get-off) (send-event *target* 'end-mode))
              (set! (-> self auto-get-off) #f)
              (go-virtual pickup (the-as (state collectable) (method-of-object self idle))))
            (set! (-> self auto-get-off) #f)
            (goto cfg-77))
           ((not (handle->process (-> self cell)))
            (set! (-> self cell)
                  (ppointer->handle (birth-pickup-at-point (vector+! (new 'stack-no-clear 'vector) (-> self root trans) (new 'static 'vector :y 8192.0 :w 1.0))
                                                           (pickup-type fuel-cell)
                                                           (the float (-> self entity extra perm task))
                                                           #f
                                                           self
                                                           (-> self fact)))))))
        ((4)
         (if (and *target* (not (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))) (goto cfg-77)))
        (else (goto cfg-77)))
      (racer-effect)
      (suspend)
      (b! #t cfg-0 :delay (nop!))
      (label cfg-77)
      (if (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))
        (go-virtual wait-for-return)
        (go-virtual idle))))

(defstate idle (racer)
  :virtual #t
  :event
    (-> (method-of-type racer wait-for-start)
        event)
  :enter
    (behavior ()
      (blocking-plane-destroy)
      (blocking-plane-spawn (-> self path-target)))
  :exit
    (-> (method-of-type racer wait-for-start)
        exit)
  :code
    (behavior ()
      (ja-channel-set! 1)
      (ja :group! racer-racer-idle-ja)
      (set! (-> self root root-prim prim-core action) (collide-action solid attackable-unused))
      (set! (-> self root root-prim prim-core offense) (collide-offense indestructible))
      0.0
      (let ((f30-0 (if (= (-> self condition) 4) 61440.0 20480.0)))
        (loop
          (if (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))
            (go-virtual wait-for-return))
          (when (and (and *target* (>= f30-0 (vector-vector-distance (-> self root trans) (-> *target* control trans))))
                     (and (not (movie?)) (not (level-hint-displayed?))))
            (hide-hud)
            (level-hint-surpress!)
            (kill-current-level-hint '() '(sidekick voicebox) 'exit)
            (when (and (hud-hidden?) (can-grab-display? self))
              (let ((gp-0 (new 'stack 'font-context *font-default-matrix* 32 160 0.0 (font-color default) (font-flags shadow kerning))))
                (set-width! gp-0 440)
                (set-height! gp-0 80)
                (set! (-> gp-0 flags) (font-flags shadow kerning large))
                (print-game-text (lookup-text! *common-text* (text-id press-to-use) #f) gp-0 #f 128 22))
              (if (and (or (cpad-pressed? 0 circle) (= (-> self condition) 4)) (send-event *target* 'change-mode 'racing self))
                (go-virtual pickup (the-as (state collectable) (method-of-object self wait-for-return))))))
          (racer-effect)
          (suspend))))
  :post ja-post)

(defstate pickup (racer)
  :virtual #t
  :event
    (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
      (case message
        (('draw)
         (ja-channel-set! 1)
         (ja :group! racer-racer-idle-ja)
         (set! (-> self root root-prim prim-core action) (collide-action solid attackable-unused))
         (set! (-> self root root-prim prim-core offense) (collide-offense indestructible))
         (transform-post))
        (('trans) (vector+! (the-as vector (-> block param 0)) (-> self root trans) (-> self extra-trans)))
        (('touch 'attack) #f)
        (('shadow)
         (cond
           ((-> block param 0)
            (let ((v0-1 (the-as object (-> self shadow-backup)))) (set! (-> self draw shadow) (the-as shadow-geo v0-1)) v0-1))
           (else (set! (-> self draw shadow) #f) #f)))))
  :enter
    (behavior ((arg0 (state collectable)))
      ((the-as (function none :behavior racer) (-> arg0 enter))))
  :code
    (behavior ((arg0 (state collectable)))
      (ja-channel-set! 0)
      (ja-post)
      (while (zero? (ja-group-size))
        (when (or (not *target*) (< 24576.0 (vector-vector-distance (-> self root trans) (-> *target* control trans))))
          (when (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))
            (case (-> (level-get-target-inside *level*) name)
              (('misty)
               (close-specific-task! (game-task misty-bike) (task-status need-reminder-a))
               (level-hint-spawn (text-id misty-bike-hint) "sksp0062" (the-as entity #f) *entity-pool* (game-task none)))))
          (go arg0))
        (racer-effect)
        (suspend))
      (while (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))
        (racer-effect)
        (suspend))
      (suspend-for (seconds 1)
        (racer-effect))
      (go arg0)))

(defstate wait-for-return (racer)
  :virtual #t
  :event
    (behavior ((proc process) (argc int) (message symbol) (block event-message-block))
      (if (and (or (= message 'touch) (= message 'attack)) (and (!= (-> self condition) 4) (send-event *target* 'end-mode)))
        (go-virtual pickup (the-as (state collectable) (method-of-object self idle))))
      (cond
        ((= message 'trans) (vector+! (the-as vector (-> block param 0)) (-> self root trans) (-> self extra-trans)))
        ((= message 'shadow)
         (cond
           ((-> block param 0)
            (let ((v0-3 (the-as structure (-> self shadow-backup)))) (set! (-> self draw shadow) (the-as shadow-geo v0-3)) v0-3))
           (else (set! (-> self draw shadow) #f) #f)))))
  :enter
    (behavior ()
      (blocking-plane-destroy)
      (blocking-plane-spawn (the-as curve-control (-> self path-racer))))
  :code
    (behavior ()
      (ja-channel-set! 0)
      (ja-post)
      (loop
        (if (not (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer))))
          (go-virtual idle))
        (racer-effect)
        (suspend))))

(defmethod init-from-entity! ((this racer) (arg0 entity-actor))
  (let ((s4-0 (new 'process 'collide-shape-moving this (collide-list-enum hit-by-player))))
    (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
    (set! (-> s4-0 reaction) default-collision-reaction)
    (set! (-> s4-0 no-reaction) (the-as (function collide-shape-moving collide-shape-intersect vector vector none) nothing))
    (let ((s3-0 (new 'process 'collide-shape-prim-sphere s4-0 (the-as uint 0))))
      (set! (-> s3-0 prim-core collide-as) (collide-kind wall-object))
      (set! (-> s3-0 collide-with) (collide-kind target))
      (set-vector! (-> s3-0 local-sphere) 0.0 0.0 0.0 6144.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)
  (set-yaw-angle-clear-roll-pitch! (-> this root) (res-lump-float arg0 'rotoffset))
  (initialize-skeleton this *racer-sg* '())
  (set! (-> this shadow-backup) (-> this draw shadow))
  (set! (-> this draw shadow-ctrl) *racer-shadow-control*)
  (let ((v1-23 (-> this node-list data)))
    (set! (-> v1-23 0 param0) cspace<-transformq+trans!)
    (set! (-> v1-23 0 param1) (the-as basic (-> this root trans)))
    (set! (-> v1-23 0 param2) (the-as basic (-> this extra-trans))))
  (set! (-> this condition) (res-lump-value arg0 'index int))
  (set! (-> this fact) (new 'process 'fact-info this (pickup-type eco-pill-random) (-> *FACT-bank* default-pill-inc)))
  (set! (-> this part) (create-launch-control group-racer-trans-pad this))
  (dotimes (s5-1 2)
    (let ((v1-32 (new 'process 'curve-control this 'path (the float (+ s5-1 1)))))
      (set! (-> this path-data s5-1) v1-32)
      (if v1-32 (logior! (-> v1-32 flags) (path-control-flag display draw-line draw-point draw-text)))))
  (set! (-> this path) (-> this path-target))
  (set-vector! (-> this extra-trans) 0.0 6144.0 0.0 1.0)
  (set! (-> this auto-get-off) #f)
  (move-to-ground (-> this root) 40960.0 40960.0 #t (collide-kind background))
  (set! (-> this cell) (the-as handle #f))
  (blocking-plane-spawn (the-as curve-control
                                (if (or (and *target* (logtest? (-> *target* control root-prim prim-core action) (collide-action racer)))
                                        (= (-> this condition) 3))
                                  (-> this path-racer)
                                  (-> this path-target))))
  (set! (-> this sound) (new 'process 'ambient-sound (static-sound-spec "zoom-teleport" :fo-max 30) (-> this root trans)))
  (go (method-of-object this wait-for-start))
  (none))
