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

;; name: hvehicle-physics.gc
;; name in dgo: hvehicle-physics
;; dgos: HGA, CWI, LFACTORY

;; DECOMP BEGINS

(defmethod vehicle-method-97 ((this hvehicle) (arg0 float) (arg1 vehicle-physics-work))
  (let ((s3-0 (-> this rbody)))
    (mem-copy! (the-as pointer (-> arg1 mat)) (the-as pointer (-> s3-0 matrix)) 64)
    (let* ((f28-0 (* -1.0 (-> this controls steering) (-> this info handling tire-steering-angle)))
           (f30-0 (cos f28-0))
           (f0-2 (sin f28-0))
           )
      (set! (-> arg1 steering-axis x) f30-0)
      (set! (-> arg1 steering-axis y) 0.0)
      (set! (-> arg1 steering-axis z) f0-2)
      )
    (vector-rotate*! (-> arg1 steering-axis) (-> arg1 steering-axis) (-> arg1 mat))
    (logior! (-> this v-flags) (vehicle-flag in-air))
    (logclear! (-> this v-flags) (vehicle-flag on-ground on-flight-level))
    (vector-reset! (-> arg1 ground-normal))
    (set! (-> arg1 ground-normal y) 1.0)
    (let ((f30-1 (-> this info handling ground-probe-distance)))
      (let ((s2-0 (new 'stack-no-clear 'collide-query)))
        (vector-reset! (-> arg1 lift-dir))
        (set! (-> arg1 lift-dir y) -1.0)
        (set! (-> arg1 speed-factor)
              (fmax 0.0 (fmin 0.9 (* 0.000008138021 (+ -40960.0 (vector-length (-> s3-0 lin-velocity))))))
              )
        (when (logtest? (-> this info flags) 1)
          (vector-float*! (-> arg1 tmp) (-> arg1 mat uvec) -1.0)
          (let ((t9-4 vector-lerp!)
                (a0-7 (-> arg1 lift-dir))
                (a1-4 (-> arg1 lift-dir))
                (a2-3 (-> arg1 tmp))
                (f0-8 (-> arg1 speed-factor))
                )
            (t9-4 a0-7 a1-4 a2-3 (* f0-8 f0-8))
            )
          (vector-normalize! (-> arg1 lift-dir) 1.0)
          )
        (vector-float*! (-> s2-0 move-dist) (-> arg1 lift-dir) (the-as float f30-1))
        (let ((v1-26 s2-0))
          (set! (-> v1-26 radius) 409.6)
          (set! (-> v1-26 collide-with) (collide-spec
                                          backgnd
                                          bot
                                          obstacle
                                          hit-by-player-list
                                          hit-by-others-list
                                          player-list
                                          water
                                          collectable
                                          blocking-plane
                                          pusher
                                          vehicle-mesh-probeable
                                          shield
                                          vehicle-sphere-no-probe
                                          )
                )
          (set! (-> v1-26 ignore-process0) #f)
          (set! (-> v1-26 ignore-process1) #f)
          (set! (-> v1-26 ignore-pat) (new 'static 'pat-surface :noentity #x1 :nopilot #x1))
          (set! (-> v1-26 action-mask) (collide-action solid))
          )
        (dotimes (s1-0 (-> this info physics-model lift-thruster-count))
          (let ((v1-29 (-> this info physics-model lift-thruster-array s1-0))
                (s0-0 (-> arg1 probe-work-array s1-0))
                )
            (vector-reset! (-> s0-0 tire-force))
            (vector-copy! (-> s0-0 local-pos) (-> v1-29 local-pos))
            (vector-copy! (-> s0-0 local-normal) (-> v1-29 rot))
            (vector-matrix*! (-> s0-0 world-pos) (-> s0-0 local-pos) (-> arg1 mat))
            (vector+*!
              (-> s0-0 probe-pos)
              (-> s0-0 world-pos)
              (-> arg1 mat uvec)
              (the-as float (-> this info handling ground-probe-offset))
              )
            (rigid-body-control-method-23 s3-0 (-> s0-0 probe-pos) (-> s0-0 velocity))
            (vector-copy! (-> s0-0 wheel-axis) (the-as vector (if (< 0.0 (-> s0-0 local-pos z))
                                                                  (-> arg1 steering-axis)
                                                                  (the-as vector (-> arg1 mat))
                                                                  )
                                                       )
                          )
            (vector-copy! (-> s0-0 ground-pos) (-> s0-0 probe-pos))
            (set! (-> s0-0 ground-pos y) 0.0)
            (vector-reset! (-> s0-0 ground-normal))
            (when (logtest? (-> this v-flags) (vehicle-flag enable-collision))
              (vector-copy! (-> s2-0 start-pos) (-> s0-0 probe-pos))
              (let ((f0-15 (probe-using-line-sphere *collide-cache* s2-0)))
                (cond
                  ((and (>= f0-15 0.0) (!= (-> s2-0 best-other-tri pat mode) 1))
                   (logclear! (-> this v-flags) (vehicle-flag in-air))
                   (logior! (-> this v-flags) (vehicle-flag on-ground))
                   (set! (-> s0-0 ground-pos y) (- (-> s0-0 probe-pos y) (* f0-15 f30-1)))
                   (vector-copy! (-> s0-0 ground-normal) (-> s2-0 best-other-tri normal))
                   (vector-copy! (-> arg1 ground-normal) (-> s0-0 ground-normal))
                   )
                  (else
                    (set! (-> s0-0 ground-pos y) (+ -81920.0 (-> s3-0 position y)))
                    )
                  )
                )
              0
              )
            )
          )
        )
      (set! (-> this lift-thrust 0) 0.0)
      (set! (-> this lift-thrust 1) 0.0)
      (set! (-> this lift-thrust 2) 0.0)
      (set! (-> this lift-thrust 3) 0.0)
      (set! (-> this roll-thrust 0) 0.0)
      (set! (-> this roll-thrust 1) 0.0)
      (when (>= 1 (-> this force-level))
        (dotimes (s2-1 (-> this info physics-model lift-thruster-count))
          (let ((s1-1 (-> arg1 probe-work-array s2-1)))
            (vector-copy! (-> arg1 world-pos) (-> s1-1 world-pos))
            (vector-copy! (-> arg1 velocity) (-> s1-1 velocity))
            (let ((f28-1 (-> s1-1 probe-pos y)))
              (when (> (-> this flight-level-index) 0)
                (set! f28-1 (- f28-1 (+ 6144.0 (-> this flight-level))))
                (when (>= 0.0 f28-1)
                  (logclear! (-> this v-flags) (vehicle-flag in-air))
                  (logior! (-> this v-flags) (vehicle-flag on-flight-level))
                  (if (= (vector-length-squared (-> s1-1 ground-normal)) 0.0)
                      (set! (-> s1-1 ground-normal y) 1.0)
                      )
                  )
                )
              (when (or (logtest? (vehicle-flag flight-level-transition) (-> this v-flags))
                        (and (> (-> this flight-level-index) 0) (< f28-1 0.0))
                        )
                (if (zero? (-> this flight-level-index))
                    (set! f28-1 40960.0)
                    )
                (let* ((f0-37 (* -1.0
                                 (-> this force-scale)
                                 (-> this info physics-model inv-lift-thruster-count)
                                 (-> this info info mass)
                                 (-> this info extra gravity)
                                 (+ 1.0 (* 2.0 (the float (-> this flight-level-index))))
                                 )
                              )
                       (f1-17 -1.0)
                       (f2-4 1.0)
                       (f3-4 16384.0)
                       (f3-7 (* f28-1 (/ 1.0 f3-4)))
                       (f4-2 0.5)
                       (f5-0 81920.0)
                       (f0-38 (* f0-37 (fmax f1-17 (fmin f2-4 (+ f3-7 (* f4-2 (/ 1.0 f5-0) (-> arg1 velocity y)))))))
                       )
                  (let ((f1-20 (fmax 0.0 f0-38)))
                    (+! (-> this lift-thrust s2-1) f1-20)
                    (when (logtest? (vehicle-flag flight-level-transition) (-> this v-flags))
                      (+! (-> this roll-thrust 0) (/ f1-20 20))
                      (+! (-> this roll-thrust 1) (/ f1-20 20))
                      )
                    )
                  (vector-reset! (-> arg1 force))
                  (set! (-> arg1 force y) f0-38)
                  )
                (apply-impact! s3-0 (-> arg1 world-pos) (-> arg1 force))
                (vector+! (-> s1-1 tire-force) (-> s1-1 tire-force) (-> arg1 force))
                )
              (let ((f0-40 (+ 4096.0 f28-1)))
                (when (or (and (logtest? (vehicle-flag flight-level-transition) (-> this v-flags))
                               (< 0.0 f0-40)
                               (< 0.0 (-> arg1 velocity y))
                               )
                          (and (> (-> this flight-level-index) 0) (< f0-40 0.0) (< (-> arg1 velocity y) 0.0))
                          )
                  (vector-reset! (-> arg1 force))
                  (let ((f0-43 (/ (-> this info physics-model inv-lift-thruster-count) -4))
                        (f1-28 arg0)
                        )
                    (set! (-> arg1 force y) (* f0-43 (/ 1.0 f1-28) (-> this info info mass) (-> arg1 velocity y)))
                    )
                  (apply-impact! s3-0 (-> arg1 world-pos) (-> arg1 force))
                  (vector+! (-> s1-1 tire-force) (-> s1-1 tire-force) (-> arg1 force))
                  )
                )
              )
            (let* ((f1-36 (fmax 4096.0 (fmin (- (-> s1-1 probe-pos y) (-> s1-1 ground-pos y)) f30-1)))
                   (f28-2 (- 1.0 (/ (+ -4096.0 f1-36) (+ -4096.0 f30-1))))
                   )
              (if (>= (-> this info handling cos-ground-effect-angle) (vector-dot (-> s1-1 ground-normal) (-> arg1 mat uvec)))
                  (set! f28-2 0.0)
                  )
              (set! (-> arg1 tmp y) 0.0)
              (set! (-> arg1 tmp x) (-> arg1 velocity z))
              (set! (-> arg1 tmp z) (- (-> arg1 velocity x)))
              (vector-normalize! (-> arg1 tmp) 1.0)
              (vector+float*!
                (-> arg1 normal)
                (-> s1-1 ground-normal)
                (-> arg1 tmp)
                (- (vector-dot (-> s1-1 ground-normal) (-> arg1 tmp)))
                )
              (let ((v1-150 (-> arg1 force))
                    (a0-55 (-> arg1 normal))
                    (f0-58 (* 2.0 f28-2))
                    (f1-41 arg0)
                    )
                (vector-float*! v1-150 a0-55 (* f0-58
                                                (/ 1.0 f1-41)
                                                (-> this info physics-model inv-lift-thruster-count)
                                                (-> this info info mass)
                                                (fmax 0.0 (- (vector-dot (-> arg1 velocity) (-> arg1 normal))))
                                                )
                                )
                )
              (apply-impact! s3-0 (-> arg1 world-pos) (-> arg1 force))
              (vector+! (-> s1-1 tire-force) (-> s1-1 tire-force) (-> arg1 force))
              (let ((f0-72 (* 8.0
                              (-> this info info mass)
                              (-> this info extra gravity)
                              (-> this info physics-model inv-lift-thruster-count)
                              (+ (* (-> this info handling spring-lift-factor) f28-2)
                                 (* 0.75 (-> this jump-thrust) (-> this info handling jump-thrust-factor))
                                 )
                              (- (+ 1.0 (* 2.0 (rand-vu) (-> this power-fluctuation-factor))) (-> this power-fluctuation-factor))
                              )
                           )
                    )
                (+! (-> this lift-thrust s2-1) f0-72)
                (vector-float*! (-> arg1 force) (-> arg1 lift-dir) (* -1.0 f0-72))
                )
              )
            (apply-impact! s3-0 (-> arg1 world-pos) (-> arg1 force))
            (vector+! (-> s1-1 tire-force) (-> s1-1 tire-force) (-> arg1 force))
            (when (and (< 0.0 (-> this info handling tire-friction-factor))
                       (< 0.0 (vector-length-squared (-> s1-1 ground-normal)))
                       )
              (vector+float*!
                (-> arg1 normal)
                (-> s1-1 wheel-axis)
                (-> s1-1 ground-normal)
                (- (vector-dot (-> s1-1 wheel-axis) (-> s1-1 ground-normal)))
                )
              (vector-normalize! (-> arg1 normal) 1.0)
              (vector-copy! (-> arg1 world-pos) (-> s3-0 position))
              (vector-copy! (-> arg1 velocity) (-> s3-0 lin-velocity))
              (vector-! (-> arg1 p-body) (-> arg1 world-pos) (-> s3-0 position))
              (vector-cross! (-> arg1 tmp) (-> arg1 p-body) (-> arg1 normal))
              (vector-rotate*! (-> arg1 tmp) (-> arg1 tmp) (-> s3-0 inv-i-world))
              (vector-cross! (-> arg1 tmp) (-> arg1 tmp) (-> arg1 p-body))
              (set! (-> arg1 vel-dot-norm) (vector-dot (-> arg1 velocity) (-> arg1 normal)))
              (let ((f0-82 (fabs (-> arg1 vel-dot-norm))))
                (set! (-> arg1 friction-coef)
                      (smooth-interp
                        (-> this info handling tire-static-friction)
                        (-> this info handling tire-dynamic-friction)
                        f0-82
                        (-> this info handling tire-static-friction-speed)
                        (-> this info handling tire-dynamic-friction-speed)
                        )
                      )
                )
              (set! (-> arg1 friction-coef)
                    (* (-> arg1 friction-coef) (+ 1.0 (* -0.75 (fmax 0.0 (fmin 1.0 (-> this engine-thrust))))))
                    )
              (let ((f0-90 (* (-> arg1 friction-coef)
                              (-> this info handling tire-friction-factor)
                              (fmax 0.0 (vector-dot (-> s1-1 ground-normal) (-> s1-1 tire-force)))
                              )
                           )
                    )
                (set! (-> arg1 impulse) (/ (/ (-> arg1 vel-dot-norm) -2)
                                           (* arg0 (+ (-> s3-0 info inv-mass) (vector-dot (-> arg1 normal) (-> arg1 tmp))))
                                           )
                      )
                (set! (-> arg1 impulse) (fmax (fmin (-> arg1 impulse) f0-90) (- f0-90)))
                )
              (vector-float*! (-> arg1 force) (-> arg1 normal) (-> arg1 impulse))
              (apply-impact! s3-0 (-> arg1 world-pos) (-> arg1 force))
              )
            )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod apply-gravity! ((this hvehicle) (arg0 float))
  (local-vars (sv-944 float) (sv-1040 float) (sv-1044 float))
  (let ((gp-0 (new 'stack-no-clear 'vehicle-physics-work))
        (s5-0 (-> this rbody))
        (s4-0 (-> this info))
        )
    (mem-copy! (the-as pointer (-> gp-0 mat)) (the-as pointer (-> s5-0 matrix)) 64)
    (when (not (logtest? (vehicle-flag dead gun-dark-2-zero-g) (-> this v-flags)))
      (vehicle-method-97 this arg0 gp-0)
      (when (>= 1 (-> this force-level))
        (set! sv-944 (* (-> s4-0 info mass) (-> s4-0 extra gravity)))
        (when (!= (-> s4-0 handling pitch-control-factor) 0.0)
          (vector-copy! (-> gp-0 axis) (-> gp-0 mat rvec))
          (set! (-> gp-0 axis y) 0.0)
          (let ((f30-0 (vector-dot (-> gp-0 axis) (-> s5-0 ang-velocity))))
            (dotimes (s1-0 (-> s4-0 physics-model lift-thruster-count))
              (let ((s0-0 (-> s4-0 physics-model lift-thruster-array s1-0)))
                (vector-matrix*! (-> gp-0 world-pos) (-> s0-0 local-pos) (-> gp-0 mat))
                (vector-rotate*! (-> gp-0 world-normal) (-> s0-0 rot) (-> gp-0 mat))
                (let* ((f0-5 -1.0)
                       (f1-2 1.0)
                       (f2-0 0.2)
                       (a0-10 (the-as number (-> s0-0 local-pos z)))
                       (a1-5 #xffffffff80000000)
                       (v1-16 #x3f800000)
                       (f0-7 (* (fmax f0-5 (fmin f1-2 (* f2-0
                                                         (the-as float (logior (logand (the-as int a0-10) a1-5) v1-16))
                                                         (-> s4-0 handling pitch-control-factor)
                                                         f30-0
                                                         )
                                                 )
                                      )
                                sv-944
                                )
                             )
                       )
                  (vector-float*! (-> gp-0 force) (-> gp-0 world-normal) (* -1.0 f0-7))
                  )
                )
              (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
              )
            )
          )
        (let ((s1-1 (new 'stack-no-clear 'inline-array 'vector 4)))
          (let ((f0-12 (* -1.0 (-> this controls steering) (-> gp-0 speed-factor) (-> s4-0 handling roll-angle))))
            (if (logtest? (-> this v-flags) (vehicle-flag in-air))
                (set! f0-12 0.0)
                )
            (quaternion-vector-angle! (the-as quaternion (-> s1-1 0)) (-> gp-0 mat fvec) f0-12)
            )
          (quaternion->matrix (the-as matrix (-> s1-1 1)) (the-as quaternion (-> s1-1 0)))
          (vector-copy! (-> gp-0 dir) (-> s1-1 2))
          )
        (let ((f0-14 (vector-dot (-> gp-0 mat rvec) (-> gp-0 dir))))
          (set! sv-1040 (* (-> s4-0 info mass) (-> s4-0 extra gravity)))
          (let ((f1-11 f0-14))
            (set! sv-1044 (+ (* f1-11 f1-11 f0-14) (* 0.075 (vector-dot (-> gp-0 mat fvec) (-> s5-0 ang-velocity)))))
            )
          )
        (dotimes (s1-2 (-> s4-0 physics-model roll-thruster-count))
          (let* ((s0-1 (-> s4-0 physics-model roll-thruster-array s1-2))
                 (f0-17 0.0)
                 (f1-16 1.0)
                 (f2-7 -1.0)
                 (a0-20 (the-as number (-> s0-1 local-pos x)))
                 (a1-10 #xffffffff80000000)
                 (v1-42 #x3f800000)
                 (f30-1
                   (fmax f0-17 (fmin f1-16 (* f2-7 (the-as float (logior (logand (the-as int a0-20) a1-10) v1-42)) sv-1044)))
                   )
                 )
            (when (< 0.0 f30-1)
              (let ((f30-2
                      (* (+ f30-1 (+ (- (-> this power-fluctuation-factor)) (* 2.0 (rand-vu) (-> this power-fluctuation-factor))))
                         (-> s4-0 handling roll-control-factor)
                         sv-1040
                         )
                      )
                    )
                (+! (-> this roll-thrust s1-2) (fmax 0.0 f30-2))
                (vector-matrix*! (-> gp-0 world-pos) (-> s0-1 local-pos) (-> gp-0 mat))
                (vector-rotate*! (-> gp-0 world-normal) (-> s0-1 rot) (-> gp-0 mat))
                (vector-float*! (-> gp-0 force) (-> gp-0 world-normal) (* -1.0 f30-2))
                )
              (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
              0
              )
            )
          )
        )
      (when #t
        (let* ((f0-30 (-> this controls steering))
               (f1-23 (-> s4-0 handling steering-thruster-half-gain-speed))
               (f2-10 (-> s4-0 handling steering-thruster-half-gain-speed))
               (v1-60 (-> s5-0 lin-velocity))
               (f2-12 (/ f1-23 (+ f2-10 (sqrtf (+ (* (-> v1-60 x) (-> v1-60 x)) (* (-> v1-60 z) (-> v1-60 z)))))))
               )
          (if (< (-> this controls throttle) 0.0)
              (set! f0-30 (* -1.0 f0-30))
              )
          (vector-copy! (-> gp-0 axis) (-> gp-0 mat uvec))
          (let* ((f0-34 (* (-> this power-level) (- (* f0-30 f2-12 (-> s4-0 handling steering-thruster-max-gain))
                                                    (vector-dot (-> gp-0 axis) (-> s5-0 ang-velocity))
                                                    )
                           )
                        )
                 (f0-35 (* 8192.0 (-> s4-0 info mass) (-> s4-0 handling steering-thruster-factor) f0-34))
                 )
            (if (logtest? (-> this v-flags) (vehicle-flag in-air))
                (set! f0-35 (* f0-35 (-> s4-0 handling air-steering-factor)))
                )
            (vector+float*! (-> gp-0 world-pos) (-> s5-0 position) (-> gp-0 mat fvec) 7782.4)
            (vector-float*! (-> gp-0 force) (-> gp-0 mat rvec) (* 2.0 f0-35))
            )
          )
        (rigid-body-control-method-22 s5-0 (-> gp-0 world-pos) (-> gp-0 force))
        )
      (seek! (-> this jump-thrust) 0.0 (* 6.0 arg0))
      (when (logtest? (vehicle-flag ignition) (-> this v-flags))
        (vector-matrix*! (-> gp-0 world-pos) (-> s4-0 physics-model engine-thrust-local-pos) (-> gp-0 mat))
        (vector-copy! (-> gp-0 dir) (-> gp-0 mat fvec))
        (let ((f0-45 (* (-> this engine-thrust)
                        (-> s4-0 handling max-engine-thrust)
                        (-> s4-0 info mass)
                        (-> this power-level)
                        (-> this force-scale)
                        )
                     )
              )
          (vector-float*! (-> gp-0 force) (-> gp-0 dir) f0-45)
          )
        (if #t
            (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
            )
        )
      (when (< 0.0 (-> this controls brake))
        (vector-matrix*! (-> gp-0 world-pos) (-> s4-0 physics-model brake-local-pos) (-> gp-0 mat))
        (rigid-body-control-method-23 s5-0 (-> gp-0 world-pos) (-> gp-0 velocity))
        (let ((v1-93 (new 'stack-no-clear 'vector)))
          (let ((a0-41 (-> gp-0 velocity)))
            (set! (-> v1-93 y) (sqrtf (+ (* (-> a0-41 x) (-> a0-41 x)) (* (-> a0-41 z) (-> a0-41 z)))))
            )
          (let ((f0-52 -1.0)
                (f1-42 98304.0)
                (f2-20 (fmax 16384.0 (-> v1-93 y)))
                )
            (set! (-> v1-93 x)
                  (* f0-52
                     (fmin (* f1-42 (/ 1.0 f2-20) (-> s4-0 handling brake-factor) (-> this controls brake)) (/ 0.5 arg0))
                     (-> s4-0 info mass)
                     )
                  )
            )
          (vector-float*! (-> gp-0 force) (-> gp-0 velocity) (-> v1-93 x))
          )
        (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
        )
      )
    (let ((s1-3 (new 'stack-no-clear 'inline-array 'vehicle-attach-point 4)))
      (quad-copy!
        (the-as pointer s1-3)
        (the-as pointer (-> s4-0 physics-model stabilizer-array))
        (* (-> s4-0 physics-model stabilizer-count) 2)
        )
      (let ((s0-2 (-> s1-3 3 rot)))
        (let ((f0-57 (* -3640.889 (-> this controls lean-z))))
          (vector-rotate-around-x! s0-2 s0-2 f0-57)
          )
        (if (logtest? (-> this v-flags) (vehicle-flag in-air))
            (set! (-> s0-2 w) (* 10.0 (-> s0-2 w)))
            )
        (if (logtest? (vehicle-flag flight-level-transition) (-> this v-flags))
            (set! (-> s0-2 w) 0.0)
            )
        )
      (let ((f30-3 (* -0.0000006103516 (-> this force-scale) (-> s4-0 info mass) (-> s4-0 handling drag-force-factor))))
        (if (logtest? (-> this v-flags) (vehicle-flag in-air))
            (set! f30-3 (* f30-3 (-> s4-0 handling air-drag-factor)))
            )
        (let ((s1-4 (-> s1-3 0)))
          (countdown (s0-3 (-> s4-0 physics-model stabilizer-count))
            (vector-matrix*! (-> gp-0 world-pos) (-> s1-4 local-pos) (-> gp-0 mat))
            (vector-rotate*! (-> gp-0 world-normal) (-> s1-4 rot) (-> gp-0 mat))
            (rigid-body-control-method-23 s5-0 (-> gp-0 world-pos) (-> gp-0 velocity))
            (let ((f0-70
                    (* -0.06125
                       (vector-dot (-> gp-0 world-normal) (-> gp-0 velocity))
                       (-> s1-4 rot w)
                       (-> this force-scale)
                       (-> s4-0 info mass)
                       (-> s4-0 handling airfoil-factor)
                       )
                    )
                  )
              (vector-float*! (-> gp-0 force) (-> gp-0 world-normal) f0-70)
              )
            (if (<= (-> this force-level) 0)
                (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
                )
            (vector-float*!
              (-> gp-0 force)
              (-> gp-0 velocity)
              (* f30-3
                 (-> s1-4 rot w)
                 (+ (* 0.15 (vector-length (-> gp-0 velocity))) (fabs (vector-dot (-> gp-0 world-normal) (-> gp-0 velocity))))
                 )
              )
            (if (<= (-> this force-level) 0)
                (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
                )
            (&+! s1-4 32)
            )
          )
        )
      )
    (when (not (logtest? (vehicle-flag gun-dark-2-zero-g) (-> this v-flags)))
      (vector-reset! (-> gp-0 force))
      (set! (-> gp-0 force y) (* -1.0
                                 (-> s4-0 extra gravity)
                                 (if (< 1 (-> this force-level))
                                     2.0
                                     1.0
                                     )
                                 (-> s4-0 info mass)
                                 )
            )
      (add-force! s5-0 (-> gp-0 force))
      )
    (when (not (logtest? (vehicle-flag gun-dark-2-zero-g) (-> this v-flags)))
      (when (logtest? (-> this v-flags) (vehicle-flag riding))
        (vector-copy! (-> gp-0 local-pos) (-> s4-0 info cm-offset-joint))
        (+! (-> gp-0 local-pos x) (* (-> this controls steering) (-> s4-0 handling player-shift-x)))
        (+! (-> gp-0 local-pos z) (* (-> this controls lean-z) (-> s4-0 handling player-shift-z)))
        (vector-matrix*! (-> gp-0 world-pos) (-> gp-0 local-pos) (-> gp-0 mat))
        (vector-reset! (-> gp-0 force))
        (set! (-> gp-0 force y) (- (-> s4-0 handling player-weight)))
        (apply-impact! s5-0 (-> gp-0 world-pos) (-> gp-0 force))
        0
        )
      (rigid-body-object-method-53 this arg0)
      )
    (vehicle-method-96 this arg0)
    (when (not (logtest? (-> this v-flags) (vehicle-flag dead)))
      (vector-copy! (-> gp-0 world-normal) (-> s5-0 lin-momentum))
      (set! (-> gp-0 world-normal y) 0.0)
      (vector-normalize! (-> gp-0 world-normal) 1.0)
      (let* ((v1-161 (-> s5-0 lin-velocity))
             (f0-90 (/ (sqrtf (+ (* (-> v1-161 x) (-> v1-161 x)) (* (-> v1-161 z) (-> v1-161 z))))
                       (-> s4-0 handling max-xz-speed)
                       )
                    )
             (v1-163 (-> gp-0 force))
             (a0-76 (-> gp-0 world-normal))
             (f1-73 -1.0)
             (f2-35 (* (-> s4-0 handling speed-limiting-drag) (vector-dot (-> s5-0 force) (-> gp-0 world-normal))))
             (f3-20 (* (fabs (-> this engine-thrust))
                       (-> s4-0 handling speed-scrubbing-drag)
                       (vector-length (-> s5-0 lin-momentum))
                       )
                    )
             (f4-6 (- 1.0 (fabs (vector-dot (-> s5-0 matrix fvec) (-> gp-0 world-normal)))))
             )
        (vector-float*! v1-163 a0-76 (* f1-73 (+ f2-35 (* f3-20 (* f4-6 f4-6))) (sqrtf f0-90)))
        )
      (add-force! s5-0 (-> gp-0 force))
      )
    )
  0
  0
  (none)
  )
