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

;; name: traffic-util.gc
;; name in dgo: traffic-util
;; dgos: DESRESC, WWD, CWI

;; DECOMP BEGINS

(defun-debug add-debug-line-arrow ()
  0
  (none)
  )

(defmethod debug-draw ((this vis-cell))
  (local-vars (sv-48 (function _varargs_ object)))
  (dotimes (s5-0 (-> this segment-count))
    (let ((s4-0 (-> this segment-array s5-0)))
      (add-debug-line #t (bucket-id debug) (-> s4-0 vertex 0) (-> s4-0 vertex 1) *color-white* #f *color-black*)
      (let ((s3-1 (vector-float*!
                    (new 'stack-no-clear 'vector)
                    (vector+! (new 'stack-no-clear 'vector) (-> s4-0 vertex 0) (-> s4-0 vertex 1))
                    0.5
                    )
                  )
            (s2-0 add-debug-text-3d)
            (s1-0 #t)
            (s0-0 583)
            )
        (set! sv-48 format)
        (let ((a0-7 (clear *temp-string*))
              (a1-2 "~d")
              (a2-1 (-> s4-0 branch clock-type))
              )
          (sv-48 a0-7 a1-2 a2-1)
          )
        (s2-0 s1-0 (the-as bucket-id s0-0) *temp-string* s3-1 (font-color red) (the-as vector2h #f))
        )
      (add-debug-x #t (bucket-id debug) (-> s4-0 vertex 1) *color-red*)
      )
    )
  0
  (none)
  )

(defmethod reset-segment-counts ((this vis-cell))
  (set! (-> this incoming-segment-count) 0)
  (set! (-> this segment-count) 0)
  0
  (none)
  )

(defmethod setup-grid-from-bounding-box ((this grid-info) (arg0 (pointer bounding-box)) (arg1 int) (arg2 int))
  (mem-copy! (the-as pointer (-> this box)) arg0 32)
  (let ((v1-0 (new 'stack-no-clear 'vector)))
    (dotimes (a0-2 3)
      (set! (-> v1-0 data a0-2) (- (-> this box max data a0-2) (-> this box min data a0-2)))
      )
    (let ((f0-5 (sqrtf (/ (the float arg1) (* (-> v1-0 x) (-> v1-0 z) (the float arg2))))))
      (let ((a0-6 (min 126 (+ arg1 -1))))
        (set! (-> this dimension-array 0) (max 1 (min (the int (* f0-5 (-> v1-0 x))) a0-6)))
        (set! (-> this dimension-array 1) arg2)
        (set! (-> this dimension-array 2) (max 1 (min (the int (* f0-5 (-> v1-0 z))) a0-6)))
        )
      (let* ((f1-11 (* f0-5 (-> v1-0 z)))
             (f1-13 (- f1-11 (the float (the int f1-11))))
             (f0-6 (* f0-5 (-> v1-0 x)))
             )
        (cond
          ((< f1-13 (- f0-6 (the float (the int f0-6))))
           (if (>= arg1 (* (* (+ (-> this dimension-array 0) 1) (-> this dimension-array 1)) (-> this dimension-array 2)))
               (+! (-> this dimension-array 0) 1)
               )
           )
          (else
            (if (>= arg1 (* (* (-> this dimension-array 0) (-> this dimension-array 1)) (+ (-> this dimension-array 2) 1)))
                (+! (-> this dimension-array 2) 1)
                )
            )
          )
        )
      )
    (dotimes (a0-24 3)
      (set! (-> this axis-scale a0-24) (/ (the float (-> this dimension-array a0-24)) (-> v1-0 data a0-24)))
      (set! (-> this cell-size data a0-24) (/ (-> v1-0 data a0-24) (the float (-> this dimension-array a0-24))))
      )
    )
  0
  (none)
  )

(defmethod lookup-cell-for-point ((this grid-info) (arg0 vis-grid-pos) (arg1 vector))
  (set! (-> arg0 x) (max 0 (min
                             (the int (* (- (-> arg1 x) (-> this box min x)) (-> this axis-scale 0)))
                             (+ (-> this dimension-array 0) -1)
                             )
                         )
        )
  (set! (-> arg0 y) (max 0 (min
                             (the int (* (- (-> arg1 y) (-> this box min y)) (-> this axis-scale 1)))
                             (+ (-> this dimension-array 1) -1)
                             )
                         )
        )
  (set! (-> arg0 z) (max 0 (min
                             (the int (* (- (-> arg1 z) (-> this box min z)) (-> this axis-scale 2)))
                             (+ (-> this dimension-array 2) -1)
                             )
                         )
        )
  0
  (none)
  )

(defmethod lookup-box-for-sphere ((this grid-info) (arg0 vis-grid-box) (arg1 vector))
  (rlet ((vf0 :class vf)
         (vf4 :class vf)
         (vf5 :class vf)
         (vf6 :class vf)
         )
    (init-vf0-vector)
    (let ((s5-0 (new 'stack-no-clear 'bounding-box)))
      (let ((a0-1 (-> s5-0 min)))
        (let ((v1-0 arg1))
          (let ((a1-1 (- (-> arg1 w))))
            (.mov vf6 a1-1)
            )
          (.lvf vf4 (&-> v1-0 quad))
          )
        (.add.x.vf.w vf5 vf0 vf0)
        (.add.x.vf.xyz vf5 vf4 vf6)
        (.svf (&-> a0-1 quad) vf5)
        )
      (let ((a0-2 (-> s5-0 max)))
        (let ((v1-1 arg1))
          (let ((a1-2 (-> arg1 w)))
            (.mov vf6 a1-2)
            )
          (.lvf vf4 (&-> v1-1 quad))
          )
        (.add.x.vf.w vf5 vf0 vf0)
        (.add.x.vf.xyz vf5 vf4 vf6)
        (.svf (&-> a0-2 quad) vf5)
        )
      (lookup-cell-for-point this (-> arg0 min) (-> s5-0 min))
      (lookup-cell-for-point this (-> arg0 max) (-> s5-0 max))
      )
    0
    (none)
    )
  )

(defmethod debug-draw-cell ((this grid-info) (arg0 vis-grid-pos) (arg1 rgba))
  (let ((v1-0 (new 'stack-no-clear 'bounding-box)))
    (dotimes (a3-0 3)
      (set! (-> v1-0 min data a3-0)
            (+ (-> this box min data a3-0) (* (the float (-> arg0 data a3-0)) (-> this cell-size data a3-0)))
            )
      )
    (vector+! (-> v1-0 max) (-> v1-0 min) (-> this cell-size))
    (add-debug-box #t (bucket-id debug) (-> v1-0 min) (-> v1-0 max) arg1)
    )
  0
  (none)
  )

(defmethod debug-draw-grid ((this grid-info) (arg0 rgba))
  (draw-grid (-> this box min) (-> this box max) (-> this dimension-array) arg0)
  0
  (none)
  )

(defmethod try-creating-new-suppression-box ((this traffic-suppression-params))
  (cond
    ((= (-> this id) -1)
     (send-event *traffic-manager* 'new-suppression-box this)
     (!= (-> this id) -1)
     )
    (else
      #t
      )
    )
  )

(defmethod create-or-update-suppression-box ((this traffic-suppression-params))
  (cond
    ((= (-> this id) -1)
     (send-event *traffic-manager* 'new-suppression-box this)
     (!= (-> this id) -1)
     )
    (else
      (send-event *traffic-manager* 'update-suppression-box this)
      #t
      )
    )
  )

(defmethod kill-suppression-box ((this traffic-suppression-params))
  (when (!= (-> this id) -1)
    (let ((s5-0 (-> this duration)))
      (set! (-> this duration) 0)
      (send-event *traffic-manager* 'update-suppression-box this)
      (set! (-> this duration) s5-0)
      )
    (set! (-> this id) -1)
    )
  (none)
  )

(defmethod reset-boxes ((this traffic-suppressor))
  (logclear! (-> this flags) (traffic-suppressor-flag tfs0 needs-update))
  (dotimes (v1-2 16)
    (let ((a1-3 (-> this array v1-2)))
      (logclear! (-> a1-3 flags) (traffic-suppression-box-flag in-use tfsb1))
      )
    )
  0
  (none)
  )

(defmethod add-new-supression-box ((this traffic-suppressor) (arg0 traffic-suppression-params))
  (set! (-> arg0 id) -1)
  (let ((v1-1 0))
    (b! #t cfg-4 :delay (nop!))
    (label cfg-1)
    (let ((a2-2 (-> this array v1-1)))
      (b! (logtest? (-> a2-2 flags) (traffic-suppression-box-flag in-use)) cfg-3 :delay (empty-form))
      (set! (-> arg0 id) v1-1)
      (set! (-> a2-2 flags) (traffic-suppression-box-flag in-use))
      )
    (update-box-from-params this arg0)
    (b! #t cfg-6 :delay (nop!))
    (label cfg-3)
    (+! v1-1 1)
    (label cfg-4)
    (b! (< v1-1 16) cfg-1)
    )
  (label cfg-6)
  0
  (none)
  )

(defmethod remove-box-by-id ((this traffic-suppressor) (arg0 int))
  (when (!= arg0 -1)
    (logior! (-> this flags) (traffic-suppressor-flag needs-update))
    (let ((v1-6 (-> this array arg0)))
      (logclear! (-> v1-6 flags) (traffic-suppression-box-flag in-use))
      )
    )
  0
  (none)
  )

(defmethod update-box-from-params ((this traffic-suppressor) (arg0 traffic-suppression-params))
  (let ((v1-0 (-> arg0 id)))
    (when (!= v1-0 -1)
      (logior! (-> this flags) (traffic-suppressor-flag needs-update))
      (let* ((s5-0 (-> this array v1-0))
             (s4-1 (logior (-> s5-0 flags) (traffic-suppression-box-flag tfsb1)))
             )
        (mem-copy! (the-as pointer (-> s5-0 bbox)) (the-as pointer (-> arg0 bbox)) 32)
        (set! (-> s5-0 duration) (the-as uint (-> arg0 duration)))
        (set! (-> s5-0 flags) s4-1)
        )
      )
    )
  0
  (none)
  )

(defmethod debug-draw ((this traffic-suppressor))
  (let ((s5-0 (new 'stack-no-clear 'bounding-box)))
    (new 'stack-no-clear 'vector4w)
    (let ((s4-0 *color-red*))
      (dotimes (s3-0 16)
        (let ((v1-3 (-> this array s3-0)))
          (when (logtest? (-> v1-3 flags) (traffic-suppression-box-flag in-use))
            (vector-copy! (-> s5-0 min) (-> v1-3 bbox min))
            (vector-copy! (-> s5-0 max) (-> v1-3 bbox max))
            (set! (-> s5-0 min w) 1.0)
            (set! (-> s5-0 max w) 1.0)
            (add-debug-box #t (bucket-id debug-no-zbuf1) (-> s5-0 min) (-> s5-0 max) s4-0)
            )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod get-first-cell-in-box ((this city-level-info) (arg0 vis-grid-box))
  (-> this
      cell-array
      (+ (-> arg0 min x)
         (* (-> arg0 min z) (-> this grid-info dimension-array 0))
         (* (* (-> arg0 min y) (-> this grid-info dimension-array 0)) (-> this grid-info dimension-array 2))
         )
      )
  )

(defmethod sphere-in-grid? ((this city-level-info) (arg0 vector) (arg1 int))
  (let ((gp-0 #f))
    (let ((s3-0 (new 'stack-no-clear 'vis-grid-box))
          (s2-0 (new 'stack-no-clear 'vis-grid-box))
          )
      (lookup-box-for-sphere (-> this grid-info) s2-0 arg0)
      (set! (-> s3-0 min y) (-> s2-0 min y))
      (let ((v1-6 (+ (- 1 (-> s2-0 min y)) (-> s2-0 max y))))
        (b! #t cfg-13 :delay (nop!))
        (label cfg-1)
        (+! v1-6 -1)
        (set! (-> s3-0 min z) (-> s2-0 min z))
        (let ((a0-7 (+ (- 1 (-> s2-0 min z)) (-> s2-0 max z))))
          (b! #t cfg-11 :delay (nop!))
          (label cfg-2)
          (+! a0-7 -1)
          (set! (-> s3-0 min x) (-> s2-0 min x))
          (let ((a1-7 (+ (- 1 (-> s2-0 min x)) (-> s2-0 max x))))
            (b! #t cfg-9 :delay (nop!))
            (label cfg-3)
            (+! a1-7 -1)
            (let ((a3-0 this)
                  (t1-0 s3-0)
                  )
              (b!
                (not (logtest? (-> a3-0
                                   cell-array
                                   (+ (-> t1-0 min x)
                                      (* (-> t1-0 min z) (-> a3-0 grid-info dimension-array 0))
                                      (* (* (-> t1-0 min y) (-> a3-0 grid-info dimension-array 0)) (-> a3-0 grid-info dimension-array 2))
                                      )
                                   flags
                                   )
                               (ash 1 arg1)
                               )
                     )
                cfg-8
                :delay (empty-form)
                )
              )
            (set! gp-0 #t)
            (b! #t cfg-15 :delay (nop!))
            (label cfg-8)
            (+! (-> s3-0 min x) 1)
            (label cfg-9)
            (b! (nonzero? a1-7) cfg-3 :delay (nop!))
            )
          (+! (-> s3-0 min z) 1)
          (label cfg-11)
          (b! (nonzero? a0-7) cfg-2 :delay (nop!))
          )
        (+! (-> s3-0 min y) 1)
        (label cfg-13)
        (b! (nonzero? v1-6) cfg-1 :delay (nop!))
        )
      )
    (label cfg-15)
    gp-0
    )
  )

(defmethod callback-on-nav-segments-in-sphere ((this city-level-info)
                                              (arg0 vector)
                                              (arg1 int)
                                              (arg2 traffic-find-segment-struct)
                                              (arg3 (function traffic-find-segment-struct nav-segment none))
                                              )
  (local-vars
    (sv-16 city-level-info)
    (sv-20 vector)
    (sv-24 int)
    (sv-28 traffic-find-segment-struct)
    (sv-32 (function traffic-find-segment-struct nav-segment none))
    (sv-80 vis-grid-box)
    (sv-84 vis-grid-box)
    )
  (set! sv-16 this)
  (set! sv-20 arg0)
  (set! sv-24 arg1)
  (set! sv-28 arg2)
  (set! sv-32 arg3)
  (set! sv-80 (new 'stack-no-clear 'vis-grid-box))
  (set! sv-84 (new 'stack-no-clear 'vis-grid-box))
  (lookup-box-for-sphere (-> sv-16 grid-info) sv-80 sv-20)
  (set! (-> sv-84 min y) (-> sv-80 min y))
  (countdown (gp-0 (+ (- 1 (-> sv-80 min y)) (-> sv-80 max y)))
    (set! (-> sv-84 min z) (-> sv-80 min z))
    (countdown (s5-0 (+ (- 1 (-> sv-80 min z)) (-> sv-80 max z)))
      (set! (-> sv-84 min x) (-> sv-80 min x))
      (countdown (s4-0 (+ (- 1 (-> sv-80 min x)) (-> sv-80 max x)))
        (let* ((a0-17 sv-16)
               (a2-2 sv-84)
               (v1-18
                 (-> a0-17
                     cell-array
                     (+ (-> a2-2 min x)
                        (* (-> a2-2 min z) (-> a0-17 grid-info dimension-array 0))
                        (* (* (-> a2-2 min y) (-> a0-17 grid-info dimension-array 0)) (-> a0-17 grid-info dimension-array 2))
                        )
                     )
                 )
               (s3-0 (-> v1-18 segment-array 0))
               )
          (countdown (s2-0 (-> v1-18 segment-count))
            (if (and (= (-> s3-0 tracker-id) sv-24) (line-sphere-intersection? sv-20 (-> s3-0 vertex 0) (-> s3-0 vertex 1)))
                (sv-32 sv-28 s3-0)
                )
            (&+! s3-0 48)
            )
          )
        (+! (-> sv-84 min x) 1)
        )
      (+! (-> sv-84 min z) 1)
      )
    (+! (-> sv-84 min y) 1)
    )
  0
  (none)
  )

(defmethod update-suppressions-from-traffic-engine ((this city-level-info) (arg0 traffic-engine))
  (let ((v1-0 (-> this cell-count)))
    (dotimes (a0-1 (the-as int v1-0))
      (let ((a1-2 (-> this cell-array a0-1)))
        (logclear! (-> a1-2 flags) (vis-cell-flag suppress))
        )
      )
    )
  (let ((s4-0 (new 'stack-no-clear 'inline-array 'vis-grid-pos 2)))
    (dotimes (s3-0 16)
      (let ((s2-0 (-> arg0 suppressor array s3-0)))
        (when (logtest? (-> s2-0 flags) (traffic-suppression-box-flag in-use))
          (lookup-cell-for-point (-> this grid-info) (-> s4-0 1) (-> s2-0 bbox min))
          (lookup-cell-for-point (-> this grid-info) (-> s4-0 2) (-> s2-0 bbox max))
          (set! (-> s4-0 0 y) (-> s4-0 1 y))
          (countdown (v1-15 (+ (- 1 (-> s4-0 1 y)) (-> s4-0 2 y)))
            (set! (-> s4-0 0 z) (-> s4-0 1 z))
            (countdown (a0-9 (+ (- 1 (-> s4-0 1 z)) (-> s4-0 2 z)))
              (set! (-> s4-0 0 x) (-> s4-0 1 x))
              (countdown (a1-10 (+ (- 1 (-> s4-0 1 x)) (-> s4-0 2 x)))
                (let* ((a3-1 this)
                       (t1-0 (-> s4-0 0))
                       (a2-8 (-> a3-1
                                 cell-array
                                 (+ (-> t1-0 x)
                                    (* (-> t1-0 z) (-> a3-1 grid-info dimension-array 0))
                                    (* (* (-> t1-0 y) (-> a3-1 grid-info dimension-array 0)) (-> a3-1 grid-info dimension-array 2))
                                    )
                                 )
                             )
                       )
                  (logior! (-> a2-8 flags) (vis-cell-flag suppress))
                  )
                (+! (-> s4-0 0 x) 1)
                )
              (+! (-> s4-0 0 z) 1)
              )
            (+! (-> s4-0 0 y) 1)
            )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod lookup-cell-by-position ((this city-level-info) (arg0 vector))
  (let ((s5-0 (new 'stack-no-clear 'vis-grid-pos)))
    (lookup-cell-for-point (-> this grid-info) s5-0 arg0)
    (-> this
        cell-array
        (+ (-> s5-0 x)
           (* (-> s5-0 z) (-> this grid-info dimension-array 0))
           (* (* (-> s5-0 y) (-> this grid-info dimension-array 0)) (-> this grid-info dimension-array 2))
           )
        )
    )
  )

(defmethod init-vis-ray ((this city-level-info) (arg0 vis-ray) (arg1 vector) (arg2 vector))
  (vector-copy! (-> arg0 pos) arg1)
  (vector-copy! (-> arg0 dest-pos) arg2)
  (let ((v1-2 (new 'stack-no-clear 'vector)))
    (vector-! v1-2 arg2 arg1)
    (set! (-> arg0 len) (vector-length v1-2))
    (let ((a0-9 (-> arg0 dir))
          (f0-1 (-> arg0 len))
          )
      (vector-float*! a0-9 v1-2 (/ 1.0 f0-1))
      )
    )
  (lookup-cell-for-point (-> this grid-info) (-> arg0 grid-pos) arg1)
  (set! (-> arg0 cell) (lookup-cell-by-position this arg1))
  0
  (none)
  )

(defmethod city-level-info-method-11 ((this city-level-info) (arg0 vis-ray))
  (local-vars (a3-3 int))
  (let ((f0-0 (-> arg0 len))
        (s4-0 -1)
        )
    (dotimes (v1-0 2)
      (let ((a0-1 (* v1-0 2))
            (a1-1 (new 'stack-no-clear 'vector))
            )
        (set! (-> a1-1 quad) (the-as uint128 0))
        (set! (-> a1-1 data a0-1) -1.0)
        (let ((f1-1 (-> this grid-info box min data a0-1))
              (a2-6 1)
              )
          (let ((a3-2 (-> arg0 dir data a0-1)))
            (shift-arith-right-32 a3-3 a3-2 31)
            )
          (set! (-> a1-1 w)
                (+ f1-1
                   (* (the float (+ (- a2-6 (logand a3-3 1)) (-> (the-as (pointer int8) (+ a0-1 (the-as int arg0))) 64)))
                      (-> this grid-info cell-size data a0-1)
                      )
                   )
                )
          )
        (when (!= (-> arg0 dir data a0-1) 0.0)
          (let ((f1-6 (/ (- (-> a1-1 w) (-> arg0 pos data a0-1)) (-> arg0 dir data a0-1))))
            (when (< f1-6 f0-0)
              (set! f0-0 f1-6)
              (set! s4-0 a0-1)
              (set! (-> arg0 plane quad) (-> a1-1 quad))
              )
            )
          )
        )
      )
    (cond
      ((= s4-0 -1)
       (vector-copy! (-> arg0 pos) (-> arg0 dest-pos))
       (set! (-> arg0 len) 0.0)
       )
      (else
        (vector+float*! (-> arg0 pos) (-> arg0 pos) (-> arg0 dir) f0-0)
        (set! (-> arg0 len) (vector-vector-distance (-> arg0 pos) (-> arg0 dest-pos)))
        (+! (-> arg0 grid-pos data s4-0) (if (>= (-> arg0 dir data s4-0) 0.0)
                                             1
                                             -1
                                             )
            )
        (let ((a1-4 (-> arg0 grid-pos)))
          (set! (-> arg0 cell)
                (-> this
                    cell-array
                    (+ (-> a1-4 x)
                       (* (-> a1-4 z) (-> this grid-info dimension-array 0))
                       (* (* (-> a1-4 y) (-> this grid-info dimension-array 0)) (-> this grid-info dimension-array 2))
                       )
                    )
                )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod city-level-info-method-12 ((this city-level-info) (arg0 vector) (arg1 nav-branch) (arg2 vector))
  (let ((s2-0 (-> arg1 dest-node))
        (s3-0 #t)
        (s5-0 (new 'stack-no-clear 'inline-array 'vector 7))
        )
    (let ((a1-1 s2-0)
          (v1-0 (-> s5-0 2))
          )
      (vector-copy! v1-0 (-> a1-1 position))
      (set! (-> v1-0 w) 1.0)
      )
    (let ((v1-1 s2-0)
          (s1-0 (-> s5-0 3))
          )
      (let ((f0-2 (the float (-> v1-1 angle)))
            (s0-0 (new 'stack-no-clear 'vector))
            )
        (sincos! s0-0 f0-2)
        (set! (-> s1-0 x) (-> s0-0 y))
        (set! (-> s1-0 y) 0.0)
        (set! (-> s1-0 z) (- (-> s0-0 x)))
        )
      (set! (-> s1-0 w) 1.0)
      )
    (vector-! (-> s5-0 5) (-> s5-0 2) arg0)
    (vector-copy! (-> s5-0 4) (-> s5-0 3))
    (set! (-> s5-0 4 x) (-> s5-0 3 z))
    (set! (-> s5-0 4 z) (- (-> s5-0 3 x)))
    (when (< 0.0 (vector-dot (-> s5-0 5) (-> s5-0 4)))
      (set! s3-0 #f)
      (vector-float*! (-> s5-0 4) (-> s5-0 4) -1.0)
      )
    (let ((a1-8 (-> s5-0 6))
          (v1-12 (-> s5-0 2))
          (a0-9 (-> s5-0 4))
          (a2-1 s2-0)
          )
      (vector+*! a1-8 v1-12 a0-9 (* 1024.0 (the float (-> a2-1 radius))))
      )
    (set! (-> s5-0 6 w) (* 1024.0 (the float (-> s2-0 radius))))
    (vector-! (-> s5-0 0) (-> s5-0 6) arg0)
    (set! (-> s5-0 0 y) 0.0)
    (let* ((v1-17 (-> s5-0 0))
           (f30-0 (sqrtf (+ (* (-> v1-17 x) (-> v1-17 x)) (* (-> v1-17 z) (-> v1-17 z)))))
           (f28-0 (-> s5-0 6 w))
           )
      (vector-xz-normalize! (-> s5-0 0) 1.0)
      (set! (-> s5-0 1 x) (-> s5-0 0 z))
      (set! (-> s5-0 1 y) 0.0)
      (set! (-> s5-0 1 z) (- (-> s5-0 0 x)))
      (if s3-0
          (vector-float*! (-> s5-0 1) (-> s5-0 1) -1.0)
          )
      (let* ((f0-29 f30-0)
             (f0-31 (* f0-29 f0-29))
             (f1-9 f28-0)
             (f1-12 (sqrtf (fabs (- f0-31 (* f1-9 f1-9)))))
             (f0-35 (/ (* f28-0 f1-12) f30-0))
             )
        (let ((f1-15 (/ (* f1-12 f1-12) f30-0)))
          (vector-copy! arg2 arg0)
          (vector+*! arg2 arg2 (-> s5-0 0) f1-15)
          )
        (vector+*! arg2 arg2 (-> s5-0 1) f0-35)
        )
      )
    (set! (-> arg2 y) (-> s5-0 2 y))
    )
  arg2
  )

(defmethod city-level-info-method-18 ((this city-level-info))
  (local-vars (sv-48 int))
  (let ((gp-0 (new 'stack-no-clear 'bounding-box))
        (s5-0 (-> this nav-graph))
        )
    (set! sv-48 (-> s5-0 node-count))
    (dotimes (s4-0 sv-48)
      (let ((s3-0 (-> s5-0 node-array s4-0)))
        (set-id-and-link-branches-back s3-0 (the-as uint s4-0))
        (let ((a1-1 s3-0)
              (v1-4 (-> gp-0 min))
              )
          (vector-copy! v1-4 (-> a1-1 position))
          (set! (-> v1-4 w) 1.0)
          )
        (dotimes (s2-0 (-> s3-0 branch-count))
          (let ((s1-0 (-> s3-0 branch-array s2-0)))
            (let ((a1-4 (-> s1-0 dest-node))
                  (v1-6 (-> gp-0 max))
                  )
              (vector-copy! v1-6 (-> a1-4 position))
              (set! (-> v1-6 w) 1.0)
              )
            (set! (-> s1-0 max-user-count)
                  (the-as uint (max 1 (the int (/ (vector-vector-distance (-> gp-0 min) (-> gp-0 max))
                                                  (if (logtest? (-> s3-0 flags) (nav-node-flag-byte pedestrian))
                                                      24576.0
                                                      49152.0
                                                      )
                                                  )
                                           )
                                    )
                          )
                  )
            )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod city-level-info-method-9 ((this city-level-info))
  (local-vars
    (sv-96 (inline-array nav-node))
    (sv-100 int)
    (sv-104 vis-ray)
    (sv-112 int)
    (sv-160 nav-node)
    (sv-164 vector)
    (sv-168 vector)
    (sv-172 vis-cell)
    (sv-176 int)
    (sv-184 nav-branch)
    (sv-240 nav-node)
    (sv-244 vector)
    (sv-248 vector)
    (sv-252 vector)
    (sv-256 nav-segment)
    (sv-260 vis-cell)
    (sv-264 int)
    )
  (set! (-> this cell-count)
        (the-as uint (* (* (-> this grid-info dimension-array 0) (-> this grid-info dimension-array 1))
                        (-> this grid-info dimension-array 2)
                        )
                )
        )
  (let ((s5-0 (-> this cell-count)))
    (dotimes (s4-0 (the-as int s5-0))
      (reset-segment-counts (-> this cell-array s4-0))
      )
    (when (< 0.01 (-> this grid-info axis-scale 0))
      (format 0 "segments not generates~%")
      (return #t)
      )
    (set! sv-96 (-> this nav-graph node-array))
    (set! sv-100 (-> this nav-graph node-count))
    (set! sv-104 (new 'stack-no-clear 'vis-ray))
    (set! sv-112 0)
    (dotimes (s4-1 sv-100)
      (let ((s3-0 (-> sv-96 s4-1)))
        (dotimes (s2-0 (-> s3-0 branch-count))
          (let* ((a2-0 (-> s3-0 branch-array s2-0))
                 (f0-1 0.0)
                 (v1-19 a2-0)
                 )
            (when (< f0-1 (* 0.0078125 (the float (-> v1-19 density))))
              (set! sv-160 (-> a2-0 dest-node))
              (set! sv-164 (new 'stack-no-clear 'vector))
              (set! sv-168 (new 'stack-no-clear 'vector))
              (set! sv-172 (the-as vis-cell #f))
              (set! sv-176 0)
              (let ((a1-1 s3-0)
                    (v1-26 sv-168)
                    )
                (vector-copy! v1-26 (-> a1-1 position))
                (set! (-> v1-26 w) 1.0)
                )
              (cond
                ((logtest? (-> s3-0 flags) (nav-node-flag-byte pedestrian))
                 (let ((a1-4 (-> a2-0 dest-node))
                       (v1-29 sv-164)
                       )
                   (vector-copy! v1-29 (-> a1-4 position))
                   (set! (-> v1-29 w) 1.0)
                   )
                 )
                (else
                  (city-level-info-method-12 this sv-168 a2-0 sv-164)
                  )
                )
              (init-vis-ray this sv-104 sv-168 sv-164)
              (while (< 0.0 (-> sv-104 len))
                (set! sv-172 (-> sv-104 cell))
                (city-level-info-method-11 this sv-104)
                (+! (-> sv-172 segment-count) 1)
                (set! sv-112 (+ sv-112 1))
                (if (> sv-176 0)
                    (+! (-> sv-172 incoming-segment-count) 1)
                    )
                (set! sv-176 (+ sv-176 1))
                )
              )
            )
          )
        )
      )
    (format 0 "~d segments were generated~%" sv-112)
    (set! (-> this segment-array) (the-as (inline-array nav-segment) (malloc 'debug (* 48 sv-112))))
    (let ((v1-59 0))
      (dotimes (a0-20 (the-as int s5-0))
        (let ((a1-14 (-> this cell-array a0-20)))
          (set! (-> a1-14 id) (the-as uint a0-20))
          (set! (-> a1-14 segment-array) (the-as (inline-array nav-segment) #f))
          (when (> (-> a1-14 segment-count) 0)
            (set! (-> a1-14 segment-array) (the-as (inline-array nav-segment) (-> this segment-array v1-59)))
            (dotimes (a2-8 (-> a1-14 segment-count))
              (let ((a3-5 (-> a1-14 segment-array a2-8)))
                (set! (-> a3-5 id) (the-as uint v1-59))
                (set! (-> a3-5 cell-id) (the-as uint #xffff))
                )
              (+! v1-59 1)
              )
            )
          (set! (-> a1-14 flags) (the-as vis-cell-flag (-> a1-14 segment-count)))
          (set! (-> a1-14 segment-count) 0)
          (set! (-> a1-14 incoming-segment-count) 0)
          )
        0
        )
      (set! (-> this segment-count) v1-59)
      )
    )
  (dotimes (s5-1 sv-100)
    (let ((s4-2 (-> sv-96 s5-1)))
      (dotimes (s3-1 (-> s4-2 branch-count))
        (set! sv-184 (-> s4-2 branch-array s3-1))
        (let ((f0-5 0.0)
              (v1-63 sv-184)
              )
          (when (< f0-5 (* 0.0078125 (the float (-> v1-63 density))))
            (set! sv-240 (-> sv-184 dest-node))
            (set! sv-244 (new 'stack-no-clear 'vector))
            (set! sv-248 (new 'stack-no-clear 'vector))
            (set! sv-252 (new 'stack-no-clear 'vector))
            (set! sv-256 (the-as nav-segment #f))
            (set! sv-260 (the-as vis-cell #f))
            (set! sv-264 0)
            (let ((a1-16 s4-2)
                  (v1-72 sv-244)
                  )
              (vector-copy! v1-72 (-> a1-16 position))
              (set! (-> v1-72 w) 1.0)
              )
            (cond
              ((logtest? (-> s4-2 flags) (nav-node-flag-byte pedestrian))
               (let ((a1-19 (-> sv-184 dest-node))
                     (v1-76 sv-252)
                     )
                 (vector-copy! v1-76 (-> a1-19 position))
                 (set! (-> v1-76 w) 1.0)
                 )
               )
              (else
                (city-level-info-method-12 this sv-244 sv-184 sv-252)
                )
              )
            (init-vis-ray this sv-104 sv-244 sv-252)
            (while (< 0.0 (-> sv-104 len))
              (vector-copy! sv-248 (-> sv-104 pos))
              (set! sv-260 (-> sv-104 cell))
              (city-level-info-method-11 this sv-104)
              (let ((a2-14 (-> sv-260 incoming-segment-count)))
                (if (zero? sv-264)
                    (set! a2-14
                          (+ (- -1 (-> sv-260 segment-count)) (-> sv-260 incoming-segment-count) (-> sv-260 alloc-segment-count))
                          )
                    )
                (when (or (< a2-14 0) (>= a2-14 (-> sv-260 alloc-segment-count)))
                  (format
                    0
                    "******************************************************** bad i-seg ~d ************************************************~%"
                    a2-14
                    )
                  (return #f)
                  )
                (let ((s2-1 (-> sv-260 segment-array a2-14)))
                  (set! (-> s2-1 vertex 0 quad) (-> sv-248 quad))
                  (vector-copy! (-> s2-1 vertex 1) (-> sv-104 pos))
                  (set! (-> s2-1 length) (vector-vector-distance (-> s2-1 vertex 0) (-> s2-1 vertex 1)))
                  (let* ((f0-9 (if (logtest? (-> s4-2 flags) (nav-node-flag-byte pedestrian))
                                   24576.0
                                   49152.0
                                   )
                               )
                         (f1-8 -1.0)
                         (f2-4 0.0001)
                         (v1-107 sv-184)
                         (f2-5 (fmax f2-4 (* 0.0078125 (the float (-> v1-107 density)))))
                         )
                    (set! (-> s2-1 spawn-spacing) (* f0-9 (+ f1-8 (/ 1.0 f2-5))))
                    )
                  (set! (-> s2-1 cell-id) (-> sv-260 id))
                  (set! (-> s2-1 branch) sv-184)
                  (set! (-> s2-1 from-cell-id) (the-as uint #xffff))
                  (set! (-> s2-1 nav-mesh-id) (-> s4-2 nav-mesh-id))
                  (set! (-> s2-1 tracker-id) 0)
                  (if (logtest? (-> s4-2 flags) (nav-node-flag-byte pedestrian))
                      (set! (-> s2-1 tracker-id) 1)
                      )
                  (if sv-256
                      (set! (-> s2-1 from-cell-id) (-> (the-as nav-segment sv-256) cell-id))
                      )
                  (set! sv-256 s2-1)
                  )
                )
              0
              (+! (-> sv-260 segment-count) 1)
              (if (> sv-264 0)
                  (+! (-> sv-260 incoming-segment-count) 1)
                  )
              (set! sv-264 (+ sv-264 1))
              )
            )
          )
        )
      )
    )
  0
  )

(defmethod reset! ((this traffic-level-data))
  (set! (-> this city-info) (the-as city-level-info 0))
  (set! (-> this active-cell-count) (the-as uint 0))
  (set! (-> this newly-active-cell-count) (the-as uint 0))
  0
  (none)
  )

(defmethod add-active-cell ((this traffic-level-data) (arg0 vis-cell))
  (let ((v1-0 (-> this active-cell-count)))
    (when (< v1-0 (the-as uint 255))
      (set! (-> this active-cell-list v1-0) arg0)
      (+! (-> this active-cell-count) 1)
      )
    )
  0
  (none)
  )

(defmethod remove-active-cell ((this traffic-level-data) (arg0 int))
  (let ((v1-1 (+ (-> this active-cell-count) -1)))
    (when (>= v1-1 0)
      (set! (-> this active-cell-list arg0) (-> this active-cell-list v1-1))
      (+! (-> this active-cell-count) -1)
      )
    )
  0
  (none)
  )

(defmethod add-newly-active-cell ((this traffic-level-data) (arg0 vis-cell))
  (let ((v1-0 (-> this newly-active-cell-count)))
    (when (< v1-0 (the-as uint 255))
      (set! (-> this newly-active-cell-list v1-0) arg0)
      (+! (-> this newly-active-cell-count) 1)
      )
    )
  0
  (none)
  )

(defmethod per-frame-cell-update ((this traffic-level-data))
  (set! (-> this newly-active-cell-count) (the-as uint 0))
  (dotimes (v1-0 (the-as int (-> this active-cell-count)))
    (let ((a0-3 (-> this active-cell-list v1-0)))
      (set! (-> a0-3 prev-flags) (-> a0-3 flags))
      )
    )
  (let ((s5-0 (math-camera-pos))
        (f30-0 81920.0)
        (f28-0 819200.0)
        (f26-0 491520.0)
        )
    (dotimes (s4-0 (the-as int (-> this city-info cell-count)))
      (let ((s3-0 (-> this city-info cell-array s4-0)))
        (let ((f24-0 (vector-vector-distance-squared (-> s3-0 sphere) s5-0))
              (f0-1 (+ (-> s3-0 sphere r) f28-0))
              )
          (cond
            ((or (< (* f0-1 f0-1) f24-0) (let ((f0-5 (+ (-> s3-0 sphere r) f30-0)))
                                           (and (< (* f0-5 f0-5) f24-0) (not (sphere-in-view-frustum? (-> s3-0 sphere))))
                                           )
                 )
             (logclear! (-> s3-0 flags) (vis-cell-flag active-vehicle active-pedestrian))
             )
            ((let ((f0-9 (+ (-> s3-0 sphere r) f26-0)))
               (< (* f0-9 f0-9) f24-0)
               )
             (let ((v1-17 (logior (-> s3-0 flags) (vis-cell-flag active-vehicle))))
               (set! (-> s3-0 flags) (logclear v1-17 (vis-cell-flag active-pedestrian)))
               )
             )
            (else
              (logior! (-> s3-0 flags) (vis-cell-flag active-vehicle active-pedestrian))
              )
            )
          )
        (if (< (the-as uint (logand (-> s3-0 prev-flags) (vis-cell-flag active-vehicle active-pedestrian)))
               (the-as uint (logand (-> s3-0 flags) (vis-cell-flag active-vehicle active-pedestrian)))
               )
            (add-newly-active-cell this s3-0)
            )
        )
      )
    )
  (countdown (s5-1 (-> this active-cell-count))
    (let ((v1-32 (-> this active-cell-list s5-1)))
      (when (not (logtest? (-> v1-32 flags) (vis-cell-flag active-vehicle active-pedestrian)))
        (logclear! (-> v1-32 prev-flags) (vis-cell-flag active-vehicle active-pedestrian))
        (remove-active-cell this (the-as int s5-1))
        )
      )
    )
  (dotimes (s5-2 (the-as int (-> this newly-active-cell-count)))
    (let ((a1-5 (-> this newly-active-cell-list s5-2)))
      (add-active-cell this a1-5)
      )
    )
  (let ((v1-43 (-> this active-cell-box)))
    (set-vector!
      (-> v1-43 min)
      10000000000000000000000000000000000000.0
      10000000000000000000000000000000000000.0
      10000000000000000000000000000000000000.0
      1.0
      )
    (set-vector!
      (-> v1-43 max)
      -10000000000000000000000000000000000000.0
      -10000000000000000000000000000000000000.0
      -10000000000000000000000000000000000000.0
      1.0
      )
    (countdown (a0-23 (-> this active-cell-count))
      (let ((a1-16 (-> this active-cell-list a0-23)))
        (set! (-> v1-43 min x) (fmin (-> v1-43 min x) (- (-> a1-16 sphere x) (-> a1-16 sphere r))))
        (set! (-> v1-43 min y) (fmin (-> v1-43 min y) (- (-> a1-16 sphere y) (-> a1-16 sphere r))))
        (set! (-> v1-43 min z) (fmin (-> v1-43 min z) (- (-> a1-16 sphere z) (-> a1-16 sphere r))))
        (set! (-> v1-43 max x) (fmax (-> v1-43 max x) (+ (-> a1-16 sphere x) (-> a1-16 sphere r))))
        (set! (-> v1-43 max y) (fmax (-> v1-43 max y) (+ (-> a1-16 sphere y) (-> a1-16 sphere r))))
        (set! (-> v1-43 max z) (fmax (-> v1-43 max z) (+ (-> a1-16 sphere z) (-> a1-16 sphere r))))
        )
      )
    )
  0
  (none)
  )

(defmethod debug-draw ((this traffic-level-data))
  (local-vars (sv-16 nav-node) (sv-20 nav-branch) (sv-80 nav-node) (sv-84 vector) (sv-88 vector) (sv-92 vector))
  (when (and (nonzero? (-> this city-info)) (nonzero? (-> this city-info nav-graph)))
    (let ((s5-0 (-> this city-info nav-graph)))
      (let ((v1-6 (-> s5-0 node-array 0)))
        (countdown (a0-3 (-> s5-0 node-count))
          (logclear! (-> v1-6 flags) (nav-node-flag-byte visited))
          (&+! v1-6 32)
          )
        )
      (dotimes (s4-0 (the-as int (-> this active-cell-count)))
        (let ((a0-4 (-> this active-cell-list s4-0)))
          (dotimes (v1-11 (-> a0-4 segment-count))
            (let ((a1-5 (-> a0-4 segment-array v1-11 branch src-node)))
              (logior! (-> a1-5 flags) (nav-node-flag-byte visited))
              )
            )
          (debug-draw a0-4)
          )
        )
      (set! sv-16 (-> s5-0 node-array 0))
      (countdown (gp-1 (-> s5-0 node-count))
        (when (logtest? (-> sv-16 flags) (nav-node-flag-byte visited))
          (debug-draw sv-16)
          (dotimes (s5-1 (-> sv-16 branch-count))
            (set! sv-20 (-> sv-16 branch-array s5-1))
            (set! sv-80 (-> sv-20 dest-node))
            (set! sv-84 (new 'stack-no-clear 'vector))
            (set! sv-88 (new 'stack-no-clear 'vector))
            (set! sv-92 (new 'stack-no-clear 'vector))
            (let ((a1-7 sv-16)
                  (v1-35 sv-88)
                  )
              (vector-copy! v1-35 (-> a1-7 position))
              (set! (-> v1-35 w) 1.0)
              )
            (let ((a1-10 sv-80)
                  (v1-36 sv-92)
                  )
              (vector-copy! v1-36 (-> a1-10 position))
              (set! (-> v1-36 w) 1.0)
              )
            (vector-! sv-84 sv-92 sv-88)
            (vector+float*! sv-84 sv-88 sv-84 0.5)
            (let ((s4-1 add-debug-text-3d)
                  (s3-0 #t)
                  (s2-0 583)
                  )
              (format (clear *temp-string*) "~D" (-> sv-20 user-count))
              (s4-1
                s3-0
                (the-as bucket-id s2-0)
                *temp-string*
                sv-84
                (if (< (-> sv-20 user-count) (-> sv-20 max-user-count))
                    (font-color yellow)
                    (font-color red)
                    )
                (the-as vector2h #f)
                )
              )
            )
          )
        (set! sv-16 (&+ sv-16 32))
        )
      )
    )
  0
  (none)
  )
