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

;; name: projectile.gc
;; name in dgo: projectile
;; dgos: ENGINE, GAME

;; DECOMP BEGINS

(defun cshape-reaction-projectile ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
  "A projectile's collision reaction -- if the projectile hits a material with [[pat-material::stopproj]] set, kill the projectile"
  (let ((s5-0 (cshape-reaction-default arg0 arg1 arg2 arg3)))
    (case (-> arg1 best-other-tri pat material)
      (((pat-material stopproj))
       (send-event (-> arg0 process) 'die)
       )
      )
    s5-0
    )
  )

;; WARN: Return type mismatch int vs sound-id.
(defmethod play-impact-sound! projectile ((obj projectile))
  "Plays impact sound
       :virtual"
  (the-as sound-id 0)
  )

(defmethod event-handler! projectile ((obj projectile) (arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
  "Multiplex the projectile's event processing, called by [[projectile-event-handler]]"
  (case arg2
    (('track)
     (let ((v0-0 (the-as object (process->handle (the-as process (-> arg3 param 0))))))
       (set! (-> obj last-target) (the-as handle v0-0))
       v0-0
       )
     )
    (('touched 'touch)
     (handle-proj-hit! obj arg0 arg3)
     )
    (('die)
     (kill-projectile! obj)
     )
    )
  )

;; WARN: Return type mismatch object vs projectile.
(defbehavior projectile-event-handler projectile ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
  (the-as projectile (event-handler! self arg0 arg1 arg2 arg3))
  )

;; WARN: Return type mismatch object vs symbol.
(defmethod deal-damage! projectile ((obj projectile) (arg0 process) (arg1 event-message-block))
  "Constructs an [[attack-info]] according to the projectile's `options`"
  (let ((v1-1 (new 'stack 'attack-info)))
    (let ((a0-2 v1-1))
      (set! (-> a0-2 mode) (-> obj attack-mode))
      (set! (-> a0-2 id) (-> obj attack-id))
      (set! (-> a0-2 mask) (attack-info-mask mode id))
      )
    (when (!= (-> obj owner-handle) #f)
      (set! (-> v1-1 attacker) (-> obj owner-handle))
      (logior! (-> v1-1 mask) (attack-info-mask attacker))
      )
    (when (logtest? (-> obj options) (projectile-options account-for-target-velocity))
      (set! (-> v1-1 attacker-velocity quad) (-> obj pre-move-transv quad))
      (set! (-> v1-1 mask) (logior (attack-info-mask attacker-velocity) (-> v1-1 mask)))
      )
    (when (logtest? (-> obj options) (projectile-options deal-damage))
      (set! (-> v1-1 damage) (-> obj damage))
      (set! (-> v1-1 mask) (logior (attack-info-mask damage) (-> v1-1 mask)))
      )
    (when (logtest? (projectile-options respect-invinc-time) (-> obj options))
      (set! (-> v1-1 invinc-time) (-> obj invinc-time))
      (logior! (-> v1-1 mask) (attack-info-mask invinc-time))
      )
    (the-as symbol (send-event
                     arg0
                     (if (logtest? (projectile-options ignore-impact) (-> obj options))
                         'attack-invinc
                         'attack
                         )
                     arg1
                     v1-1
                     )
            )
    )
  )

(defmethod handle-proj-hit! projectile ((obj projectile) (arg0 process) (arg1 event-message-block))
  "When a projectile hits something, first deal damage via [[projectile::37]]
       and increment the projectiles hit count.

       If we've met or exceeded the projectiles maximum allowed hits, switch to the [[projectile::impact]] state"
  (when (-> obj attack-mode)
    (let ((a2-1 (-> arg1 param 0)))
      (when (deal-damage! obj arg0 (the-as event-message-block a2-1))
        (let ((v1-3 (-> obj notify-handle)))
          (send-event (handle->process v1-3) 'notify 'attack arg0)
          )
        (+! (-> obj hits) 1)
        (if (and (>= (-> obj hits) (-> obj max-hits))
                 (not (and (-> obj next-state) (= (-> obj next-state name) 'impact)))
                 )
            (go (method-of-object obj impact))
            )
        )
      )
    )
  )

(defmethod kill-projectile! projectile ((obj projectile))
  "Transition to the [[projectile::impact]] state, always return [[#t]]"
  (if (not (and (-> obj next-state) (= (-> obj next-state name) 'impact)))
      (go (method-of-object obj impact))
      )
  #t
  )

(defmethod draw-laser-sight projectile ((obj projectile))
  "TODO - confirm If applicable, draw the laser sight particles
       :virtual"
  0
  (none)
  )

(defmethod spawn-impact-particles projectile ((obj projectile))
  "Spawns associated particles with the projectile if applicable"
  (if (nonzero? (-> obj part))
      (spawn (-> obj part) (-> obj root-override trans))
      )
  0
  (none)
  )

(defmethod spawn-shell-particles projectile ((obj projectile))
  "TODO - confirm"
  0
  (none)
  )

(defmethod unknown-particles projectile ((obj projectile))
  "TODO - confirm"
  0
  (none)
  )

;; WARN: Return type mismatch int vs sound-id.
(defmethod play-impact-sound projectile ((obj projectile) (arg0 projectile-options))
  (the-as sound-id 0)
  )

(defmethod stop-sound! projectile ((obj projectile))
  "Stops the current `sound-id` if set, re-init the `sound-id` after being stopped"
  (when (nonzero? (-> obj sound-id))
    (sound-stop (-> obj sound-id))
    (set! (-> obj sound-id) (new 'static 'sound-id))
    0
    )
  0
  (none)
  )

(defmethod made-impact? projectile ((obj projectile))
  "TODO - queries the collision cache, return true/false"
  (let ((v1-0 (-> obj root-override))
        (t1-0 (new 'stack-no-clear 'collide-query))
        )
    (let ((a1-0 t1-0))
      (set! (-> a1-0 radius) (-> v1-0 root-prim prim-core world-sphere w))
      (set! (-> a1-0 collide-with) (-> v1-0 root-prim prim-core collide-with))
      (set! (-> a1-0 ignore-process0) obj)
      (set! (-> a1-0 ignore-process1) (handle->process (-> obj ignore-handle)))
      (set! (-> a1-0 ignore-pat) (-> v1-0 pat-ignore-mask))
      (set! (-> a1-0 action-mask) (collide-action solid))
      )
    (fill-and-try-snap-to-surface v1-0 (-> v1-0 transv) -6144.0 0.0 -2048.0 t1-0)
    )
  )

(defun projectile-move-fill-all-dirs ((arg0 projectile))
  (let ((v1-0 (-> arg0 root-override))
        (a2-0 (new 'stack-no-clear 'collide-query))
        )
    (set! (-> a2-0 collide-with) (-> v1-0 root-prim prim-core collide-with))
    (set! (-> a2-0 ignore-process0) arg0)
    (set! (-> a2-0 ignore-process1) (handle->process (-> arg0 ignore-handle)))
    (set! (-> a2-0 ignore-pat) (-> v1-0 pat-ignore-mask))
    (set! (-> a2-0 action-mask) (collide-action solid))
    (fill-cache-integrate-and-collide v1-0 (-> v1-0 transv) a2-0 (meters 0))
    )
  0
  (none)
  )

(defun projectile-move-fill-line-sphere ((arg0 projectile))
  (local-vars (at-0 int))
  (with-pp
    (rlet ((vf0 :class vf)
           (vf1 :class vf)
           (vf2 :class vf)
           )
      (init-vf0-vector)
      (let ((gp-0 (-> arg0 root-override)))
        (let ((a1-0 (new 'stack-no-clear 'collide-query)))
          (let ((a2-0 (-> gp-0 root-prim)))
            (set! (-> a1-0 start-pos quad) (-> gp-0 trans quad))
            (let ((v1-1 (-> a1-0 move-dist)))
              (.lvf vf1 (&-> (-> gp-0 transv) quad))
              (let ((f0-0 (-> pp clock seconds-per-frame)))
                (.mov at-0 f0-0)
                )
              (.mov vf2 at-0)
              (.mov.vf vf1 vf0 :mask #b1000)
              (.mul.x.vf vf1 vf1 vf2 :mask #b111)
              (.svf (&-> v1-1 quad) vf1)
              )
            (let ((v1-2 a1-0))
              (set! (-> v1-2 radius) (-> a2-0 prim-core world-sphere w))
              (set! (-> v1-2 collide-with) (-> a2-0 prim-core collide-with))
              (set! (-> v1-2 ignore-process0) arg0)
              (set! (-> v1-2 ignore-process1) (handle->process (-> arg0 ignore-handle)))
              (set! (-> v1-2 ignore-pat) (-> gp-0 pat-ignore-mask))
              (set! (-> v1-2 action-mask) (collide-action solid))
              )
            )
          (fill-using-line-sphere *collide-cache* a1-0)
          )
        (integrate-and-collide! gp-0 (-> gp-0 transv))
        )
      0
      (none)
      )
    )
  )

(defun projectile-update-velocity-add-gravity ((arg0 projectile))
  (vector-v++!
    (-> arg0 root-override transv)
    (compute-acc-due-to-gravity (-> arg0 root-override) (new-stack-vector0) 1.0)
    )
  0
  (none)
  )

(defun projectile-update-velocity-space-wars ((arg0 projectile))
  (let ((s5-1 (vector-! (new 'stack-no-clear 'vector) (-> arg0 target-pos) (-> arg0 root-override trans))))
    (let ((s4-0 (new 'stack-no-clear 'vector))
          (s3-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) (-> arg0 root-override transv) 1.0))
          (f30-0 (vector-length (-> arg0 root-override transv)))
          )
      (if (logtest? (-> arg0 root-override status) (collide-status touch-surface))
          (vector-flatten! s5-1 s5-1 (-> arg0 root-override local-normal))
          )
      (vector-normalize-copy! s4-0 s5-1 1.0)
      (if (and (or (not (handle->process (-> arg0 last-target)))
                   (zero? (-> (the-as collide-shape (-> (the-as process-drawable (handle->process (-> arg0 last-target))) root))
                              root-prim
                              prim-core
                              collide-as
                              )
                          )
                   )
               (< (vector-dot s4-0 s3-0) 0.0)
               )
          (go (method-of-object arg0 dissipate))
          )
      (vector-deg-slerp (-> arg0 root-override transv) s3-0 s4-0 (-> arg0 tween))
      (vector-normalize! (-> arg0 root-override transv) f30-0)
      )
    (vector+! (-> arg0 root-override transv) (-> arg0 root-override transv) s5-1)
    )
  (vector-v++!
    (-> arg0 root-override transv)
    (compute-acc-due-to-gravity (-> arg0 root-override) (new-stack-vector0) 0.0)
    )
  (if (< (-> arg0 max-speed) (vector-length (-> arg0 root-override transv)))
      (vector-normalize! (-> arg0 root-override transv) (-> arg0 max-speed))
      )
  (if (logtest? (-> arg0 options) (projectile-options lose-altitude))
      (set! (-> arg0 root-override transv y) -40960.0)
      )
  0
  (none)
  )

(defstate moving (projectile)
  :virtual #t
  :event projectile-event-handler
  :exit (behavior ()
    (stop-sound! self)
    (none)
    )
  :trans (behavior ()
    (if (>= (- (-> self clock frame-counter) (-> self spawn-time)) (-> self timeout))
        (go-virtual dissipate)
        )
    (let ((t9-1 (-> self pick-target)))
      (if t9-1
          (t9-1 self)
          )
      )
    (let ((t9-2 (-> self update-velocity)))
      (if t9-2
          (t9-2 self)
          )
      )
    (when (logtest? (-> self options) (projectile-options proj-options-2))
      (seek! (-> self tween) 1.0 (* 0.5 (-> self clock seconds-per-frame)))
      (let ((f0-4 (vector-vector-distance (-> self root-override trans) (-> self target-pos))))
        (cond
          ((< f0-4 20480.0)
           (seek! (-> self tween) 1.0 (* 3.0 (-> self clock seconds-per-frame)))
           )
          ((< f0-4 40960.0)
           (seek! (-> self tween) 1.0 (-> self clock seconds-per-frame))
           )
          )
        )
      )
    (let ((gp-0 (-> self root-override)))
      (set! (-> self pre-move-transv quad) (-> gp-0 transv quad))
      (let ((s5-0 (new 'stack-no-clear 'vector)))
        (set! (-> s5-0 quad) (-> gp-0 trans quad))
        ((-> self move) self)
        (play-impact-sound! self)
        (set! (-> self old-dist (-> self old-dist-count)) (* 0.0625 (vector-vector-distance s5-0 (-> gp-0 trans))))
        )
      )
    (set! (-> self old-dist-count) (logand (+ (-> self old-dist-count) 1) 15))
    (let ((f0-14 0.0))
      (countdown (v1-38 16)
        (+! f0-14 (-> self old-dist v1-38))
        )
      (if (or (and (logtest? (-> self options) (projectile-options proj-options-4))
                   (and (logtest? (-> self root-override status) (collide-status touch-wall)) (< f0-14 2048.0))
                   )
              (< f0-14 (-> self stop-speed))
              )
          (go-sitting! self)
          )
      )
    (none)
    )
  :code (behavior ()
    (until #f
      (spawn-impact-particles self)
      (play-impact-sound self (projectile-options lose-altitude proj-options-2))
      (suspend)
      )
    #f
    (none)
    )
  )

(defstate impact (projectile)
  :virtual #t
  :event projectile-event-handler
  :enter (behavior ()
    (spawn-shell-particles self)
    (play-impact-sound self (projectile-options lose-altitude))
    (none)
    )
  :code (behavior ()
    (suspend)
    (go-virtual die)
    (none)
    )
  )

(defstate dissipate (projectile)
  :virtual #t
  :event projectile-event-handler
  :enter (behavior ()
    (unknown-particles self)
    (play-impact-sound self (projectile-options proj-options-2))
    (none)
    )
  :code (behavior ()
    (suspend)
    (go-virtual die)
    (none)
    )
  )

(defstate die (projectile)
  :virtual #t
  :code (behavior ()
    (let ((v1-0 (-> self notify-handle)))
      (send-event (handle->process v1-0) 'notify 'die)
      )
    (cleanup-for-death self)
    (none)
    )
  )

(defmethod init-proj-settings! projectile ((obj projectile))
  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
       :virtual"
  0
  (none)
  )

(defmethod init-collision! projectile ((obj projectile))
  "Init the [[projectile]]'s [[collide-shape]]"
  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
    (set! (-> s5-0 reaction) cshape-reaction-projectile)
    (set! (-> s5-0 no-reaction)
          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
          )
    (let ((v1-6 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
      (set! (-> v1-6 prim-core collide-as) (collide-spec projectile))
      (set! (-> v1-6 prim-core collide-with)
            (collide-spec backgnd crate civilian enemy obstacle vehicle-sphere hit-by-others-list pusher)
            )
      (set! (-> v1-6 prim-core action) (collide-action solid))
      (set-vector! (-> v1-6 local-sphere) 0.0 5324.8 0.0 5324.8)
      (set! (-> s5-0 total-prims) (the-as uint 1))
      (set! (-> s5-0 root-prim) v1-6)
      )
    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
    (let ((v1-9 (-> s5-0 root-prim)))
      (set! (-> s5-0 backup-collide-as) (-> v1-9 prim-core collide-as))
      (set! (-> s5-0 backup-collide-with) (-> v1-9 prim-core collide-with))
      )
    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
    (set! (-> s5-0 event-self) 'touched)
    (set! (-> obj root-override) s5-0)
    )
  (set! (-> obj root-override pat-ignore-mask)
        (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
        )
  0
  (none)
  )

(defmethod go-moving! projectile ((obj projectile))
  (go (method-of-object obj moving))
  0
  (none)
  )

;; WARN: Return type mismatch object vs none.
(defmethod go-sitting! projectile ((obj projectile))
  (if (not (and (-> obj next-state) (= (-> obj next-state name) 'impact)))
      (go (method-of-object obj impact))
      )
  (none)
  )

(defmethod deactivate projectile ((obj projectile))
  (stop-sound! obj)
  ((method-of-type process-drawable deactivate) obj)
  (none)
  )

;; WARN: Return type mismatch int vs projectile.
(defbehavior projectile-init-by-other projectile ((arg0 projectile-init-by-other-params))
  (stack-size-set! (-> self main-thread) 512)
  (logclear! (-> self mask) (process-mask actor-pause))
  (process-entity-set! self (the-as entity-actor (-> arg0 ent)))
  (set! (-> self charge-level) (-> arg0 charge))
  (set! (-> self options) (-> arg0 options))
  (set! (-> self notify-handle) (-> arg0 notify-handle))
  (set! (-> self owner-handle) (-> arg0 owner-handle))
  (set! (-> self ignore-handle) (-> arg0 ignore-handle))
  (set! (-> self attack-id) (-> arg0 attack-id))
  (set! (-> self attack-mode) #f)
  (set! (-> self max-speed) 40960.0)
  (set! (-> self tween) 1.0)
  (set! (-> self last-target) (the-as handle #f))
  (set! (-> self timeout) (the-as time-frame (-> arg0 timeout)))
  (set! (-> self max-hits) 1)
  (set! (-> self spawn-time) (-> self clock frame-counter))
  (set! (-> self update-velocity) #f)
  (set! (-> self move) projectile-move-fill-line-sphere)
  (set! (-> self pick-target) #f)
  (set! (-> self stop-speed) 204.8)
  (set! (-> self damage) 1.0)
  (countdown (v1-18 16)
    (set! (-> self old-dist v1-18) 4095996000.0)
    )
  (logior! (-> self options) (projectile-options proj-options-4))
  (init-collision! self)
  (let ((s5-0 (-> self root-override)))
    (when (type? s5-0 collide-shape-moving)
      (set! (-> self root-override dynam gravity y) 1228800.0)
      (set! (-> self root-override dynam gravity-length) 1228800.0)
      (set! (-> self root-override dynam gravity-max) 1228800.0)
      )
    (set! (-> self mask) (logior (process-mask projectile) (-> self mask)))
    (logclear! (-> self mask) (process-mask enemy))
    (set! (-> s5-0 trans quad) (-> arg0 pos quad))
    (set! (-> self starting-pos quad) (-> arg0 pos quad))
    (quaternion-copy! (-> s5-0 quat) (-> (the-as process-drawable (-> self parent 0)) root quat))
    (vector-identity! (-> s5-0 scale))
    (set! (-> s5-0 transv quad) (-> arg0 vel quad))
    (set! (-> self pre-move-transv quad) (-> arg0 vel quad))
    (vector-normalize-copy! (-> self starting-dir) (-> arg0 vel) 1.0)
    (vector+float*! (-> self base-target-pos) (-> s5-0 trans) (-> self starting-dir) 2048000.0)
    )
  (set! (-> self target-pos quad) (-> self base-target-pos quad))
  (set! (-> self event-hook) projectile-event-handler)
  (init-proj-settings! self)
  (update-transforms (-> self root-override))
  (draw-laser-sight self)
  (play-impact-sound self (projectile-options))
  (when (logtest? (-> self options) (projectile-options proj-options-8000))
    (if (made-impact? self)
        (go-virtual impact)
        )
    )
  (go-moving! self)
  (the-as projectile 0)
  )

(defbehavior projectile-bounce-update-velocity projectile ((arg0 projectile-bounce))
  (set! (-> arg0 root-override transv y)
        (- (-> arg0 root-override transv y) (* 184320.0 (-> self clock seconds-per-frame)))
        )
  0
  (none)
  )

(defbehavior projectile-bounce-falling-post projectile-bounce ((arg0 projectile-bounce))
  (let ((gp-0 (-> self root-override))
        (s4-0 (new 'stack-no-clear 'collide-query))
        (s5-0 (new 'stack-no-clear 'vector))
        )
    (projectile-bounce-update-velocity self)
    (set! (-> s5-0 quad) (-> gp-0 trans quad))
    (vector-v++! s5-0 (-> gp-0 transv))
    (when (find-ground gp-0 s4-0 (collide-spec backgnd crate obstacle hit-by-others-list pusher) 4096.0 81920.0 1024.0)
      (let ((f0-1 (+ (-> gp-0 gspot-pos y) (-> self root-override root-prim local-sphere w))))
        (when (>= f0-1 (-> s5-0 y))
          (set! (-> s5-0 y) f0-1)
          (vector-reset! (-> gp-0 transv))
          )
        )
      )
    (move-to-point! gp-0 s5-0)
    )
  (transform-post)
  0
  (none)
  )

(defstate sitting (projectile-bounce)
  :virtual #t
  :event (the-as
    (function process int symbol event-message-block object :behavior projectile-bounce)
    projectile-event-handler
    )
  :trans (behavior ()
    (noop self)
    (if (>= (- (-> self clock frame-counter) (-> self spawn-time)) (-> self timeout))
        (go-virtual impact)
        )
    (none)
    )
  :code (the-as (function none :behavior projectile-bounce) sleep-code)
  :post (the-as (function none :behavior projectile-bounce) projectile-bounce-falling-post)
  )

(defmethod noop projectile-bounce ((obj projectile-bounce))
  "Does nothing"
  0
  (none)
  )

(defstate dissipate (projectile-bounce)
  :virtual #t
  :enter (behavior ()
    (go-virtual impact)
    (none)
    )
  )

;; WARN: Return type mismatch object vs none.
(defmethod go-sitting! projectile-bounce ((obj projectile-bounce))
  (go (method-of-object obj sitting))
  (none)
  )

(defmethod spawn-impact-particles projectile-bounce ((obj projectile-bounce))
  "Spawns associated particles with the projectile if applicable"
  (ja-post)
  0
  (none)
  )

(defun projectile-bounce-move ((arg0 projectile-bounce))
  (seek-toward-heading-vec! (-> arg0 root-override) (-> arg0 root-override transv) 131072.0 (seconds 0.1))
  (quaternion*! (-> arg0 root-override quat) (-> arg0 root-override quat) (-> arg0 tumble-quat))
  (projectile-move-fill-all-dirs arg0)
  (none)
  )

(defun projectile-bounce-reaction ((arg0 control-info) (arg1 collide-query) (arg2 vector) (arg3 vector))
  (cshape-reaction-update-state arg0 arg1 arg3)
  (let ((f30-0 (vector-dot arg3 (-> arg0 surface-normal)))
        (s2-0 (new 'stack-no-clear 'vector))
        )
    (vector-float*! s2-0 (-> arg0 surface-normal) (* f30-0 (rand-vu-float-range 1.6 2.2)))
    (vector-! arg2 arg3 s2-0)
    )
  (-> arg0 status)
  )

(defmethod play-impact-sound! projectile-bounce ((obj projectile-bounce))
  "Plays impact sound
       :virtual"
  (let* ((a2-0 (-> obj root-override))
         (v1-0 (-> a2-0 status))
         )
    (if (logtest? v1-0 (collide-status touch-surface))
        (vector-float*! (-> a2-0 transv) (-> a2-0 transv) 0.6)
        )
    (when (and (logtest? v1-0 (collide-status impact-surface))
               (>= (- (-> self clock frame-counter) (-> obj played-bounce-time)) (seconds 0.3))
               )
      (set! (-> obj played-bounce-time) (-> self clock frame-counter))
      (sound-play "dark-shot-bounc")
      )
    )
  )

(defmethod init-collision! projectile-bounce ((obj projectile-bounce))
  "Init the [[projectile]]'s [[collide-shape]]"
  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-player))))
    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
    (set! (-> s5-0 reaction) projectile-bounce-reaction)
    (set! (-> s5-0 no-reaction)
          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
          )
    (set! (-> s5-0 penetrate-using) (penetrate jak-dark-shot))
    (let ((v1-7 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
      (set! (-> v1-7 prim-core action) (collide-action solid))
      (set-vector! (-> v1-7 local-sphere) 0.0 0.0 0.0 819.2)
      (set! (-> s5-0 total-prims) (the-as uint 1))
      (set! (-> s5-0 root-prim) v1-7)
      )
    (set! (-> s5-0 nav-radius) (* 0.75 (-> s5-0 root-prim local-sphere w)))
    (let ((v1-10 (-> s5-0 root-prim)))
      (set! (-> s5-0 backup-collide-as) (-> v1-10 prim-core collide-as))
      (set! (-> s5-0 backup-collide-with) (-> v1-10 prim-core collide-with))
      )
    (set! (-> s5-0 max-iteration-count) (the-as uint 2))
    (set! (-> s5-0 event-self) 'touched)
    (set! (-> obj root-override) s5-0)
    )
  (set-collide-with!
    (-> obj root-override)
    (collide-spec backgnd bot crate civilian enemy obstacle vehicle-sphere hit-by-others-list player-list pusher)
    )
  (set-collide-as! (-> obj root-override) (collide-spec projectile))
  (set! (-> obj root-override pat-ignore-mask)
        (new 'static 'pat-surface :noentity #x1 :nojak #x1 :probe #x1 :noproj #x1 :noendlessfall #x1)
        )
  (none)
  )

(defmethod init-proj-settings! projectile-bounce ((obj projectile-bounce))
  "Init relevant settings for the [[projectile]] such as gravity, speed, timeout, etc
       :virtual"
  (set! (-> obj max-speed) 450560.0)
  (set! (-> obj timeout) (seconds 1.6))
  (set! (-> obj update-velocity) projectile-bounce-update-velocity)
  (set! (-> obj move) projectile-bounce-move)
  (set! (-> obj root-override dynam gravity y) 184320.0)
  (set! (-> obj root-override dynam gravity-length) 184320.0)
  (set! (-> obj root-override dynam gravity-max) 184320.0)
  (let ((f0-4 1092.2667))
    (quaternion-axis-angle! (-> obj tumble-quat) 1.0 0.0 0.0 f0-4)
    )
  0
  (none)
  )