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

;; name: ginsu.gc
;; name in dgo: ginsu
;; dgos: DMI

;; DECOMP BEGINS

(defpartgroup group-ginsu-sparks
  :id 475
  :bounds (static-bspherem 0 0 0 8)
  :parts ((sp-item 2105) (sp-item 2106 :fade-after (meters 90)))
  )

(defpart 2105
  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #x92 :page #xc))
    (sp-rnd-flt spt-num 2.0 3.0 1.0)
    (sp-flt spt-scale-x (meters 2.5))
    (sp-int spt-rot-x 4)
    (sp-flt spt-scale-y (meters 0.033))
    (sp-flt spt-r 255.0)
    (sp-flt spt-g 255.0)
    (sp-flt spt-b 255.0)
    (sp-flt spt-a 128.0)
    (sp-flt spt-omega 4.096)
    (sp-rnd-flt spt-vel-y (meters 0.06666667) (meters 0.06666667) 1.0)
    (sp-rnd-flt spt-fade-g -0.85 -1.7 1.0)
    (sp-flt spt-fade-b -8.0)
    (sp-rnd-flt spt-fade-a -0.21333334 -0.21333334 1.0)
    (sp-rnd-flt spt-accel-y -6.826667 -2.7306666 1.0)
    (sp-flt spt-friction 0.93)
    (sp-int-plain-rnd spt-timer 30 59 1)
    (sp-cpuinfo-flags sp-cpuinfo-flag-3)
    (sp-func spt-func 'sparticle-motion-blur)
    (sp-rnd-flt spt-conerot-x (degrees 0.0) (degrees 3600.0) 1.0)
    (sp-rnd-flt spt-conerot-y (degrees 0.0) (degrees 3600.0) 1.0)
    )
  )

(defpart 2106
  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
    (sp-flt spt-num 1.0)
    (sp-rnd-flt spt-x (meters 0.5) (meters 0.5) 1.0)
    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0)
    (sp-flt spt-rot-x 409.6)
    (sp-copy-from-other spt-scale-y -4)
    (sp-flt spt-r 255.0)
    (sp-flt spt-g 255.0)
    (sp-flt spt-b 255.0)
    (sp-flt spt-a 96.0)
    (sp-flt spt-omega 370688.0)
    (sp-flt spt-fade-a -4.8)
    (sp-int spt-timer 20)
    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 glow)
    (sp-flt spt-userdata 409.6)
    )
  )

(defpartgroup group-ginsu-blade
  :id 476
  :duration (seconds 0.017)
  :flags (use-local-clock)
  :bounds (static-bspherem 0 0 0 4)
  :parts ((sp-item 2107 :flags (is-3d bit6 bit7))
    (sp-item 2108 :fade-after (meters 60) :flags (bit7) :period 300 :length 5)
    (sp-item 2108 :fade-after (meters 60) :flags (bit7) :period 895 :length 5)
    (sp-item 2108 :fade-after (meters 60) :flags (bit7) :period 1490 :length 5)
    )
  )

(defpart 2107
  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :page #xa05))
    (sp-flt spt-num 1.0)
    (sp-flt spt-y (meters 0.09))
    (sp-rnd-flt spt-scale-x (meters 3) (meters 0.5) 1.0)
    (sp-flt spt-rot-x 0.0)
    (sp-flt spt-rot-y (degrees 0.0))
    (sp-flt spt-rot-z (degrees 0.0))
    (sp-copy-from-other spt-scale-y -4)
    (sp-rnd-flt spt-r 64.0 128.0 1.0)
    (sp-copy-from-other spt-g -1)
    (sp-copy-from-other spt-b -1)
    (sp-rnd-int spt-a 1115684864 2 64.0)
    (sp-int spt-timer 5)
    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12)
    (sp-flt spt-rotate-y (degrees 0.0))
    )
  )

(defpart 2108
  :init-specs ((sp-tex spt-texture (new 'static 'texture-id :index #xbb :page #xc))
    (sp-flt spt-num 1.0)
    (sp-rnd-flt spt-x (meters 0.5) (meters 0.5) 1.0)
    (sp-rnd-flt spt-scale-x (meters 1) (meters 0.5) 1.0)
    (sp-flt spt-rot-x 204.8)
    (sp-copy-from-other spt-scale-y -4)
    (sp-flt spt-r 255.0)
    (sp-flt spt-g 255.0)
    (sp-flt spt-b 255.0)
    (sp-flt spt-a 64.0)
    (sp-flt spt-omega 247808.0)
    (sp-int spt-timer 5)
    (sp-cpuinfo-flags sp-cpuinfo-flag-2 sp-cpuinfo-flag-3 sp-cpuinfo-flag-12 glow)
    (sp-flt spt-userdata 409.6)
    (sp-rnd-flt spt-rotate-y (degrees 0.0) (degrees 3600.0) 1.0)
    )
  )

(defskelgroup skel-ginsu ginsu 0 5
              ((1 (meters 20)) (2 (meters 40)) (3 (meters 999999)))
              :bounds (static-spherem 0 0 0 2.5)
              :shadow 4
              :origin-joint-index 8
              )

(deftype ginsu-anim-info (structure)
  ((anim-index int32  :offset-assert   0)
   )
  :method-count-assert 9
  :size-assert         #x4
  :flag-assert         #x900000004
  )


(deftype ginsu-global-info (basic)
  ((prev-blue-hit int8    :offset-assert   4)
   (blue-hit-anim int32 3 :offset-assert   8)
   )
  :method-count-assert 9
  :size-assert         #x14
  :flag-assert         #x900000014
  )


(deftype ginsu (nav-enemy)
  ((blade-jm            joint-mod                        :offset-assert 604)
   (blade-speed         cam-float-seeker         :inline :offset-assert 608)
   (blade-angle         float                            :offset-assert 632)
   (desired-distance    float                            :offset-assert 636)
   (spiral-time         time-frame                       :offset-assert 640)
   (blade-part          sparticle-launch-control         :offset-assert 648)
   (ambush-path         path-control                     :offset-assert 652)
   (path-pos            float                            :offset-assert 656)
   (ambush-started      symbol                           :offset-assert 660)
   (blade-sound         uint32                           :offset-assert 664)
   (blade-sound-playing symbol                           :offset-assert 668)
   (grind-sound         uint32                           :offset-assert 672)
   (grind-sound-playing symbol                           :offset-assert 676)
   (grind-timer         time-frame                       :offset-assert 680)
   )
  :heap-base #x230
  :method-count-assert 184
  :size-assert         #x2b0
  :flag-assert         #xb8023002b0
  (:methods
    (anticipate-attack () _type_ :state 178)
    (attack () _type_ :state 179)
    (ginsu-method-180 (_type_) none 180)
    (ginsu-method-181 (_type_ vector) vector 181)
    (ginsu-method-182 (_type_) none 182)
    (ginsu-method-183 (_type_ symbol) none 183)
    )
  )


(define *ginsu-global-info*
  (new 'static 'ginsu-global-info :blue-hit-anim (new 'static 'array int32 3 5 5 5))
  )

(define *ginsu-nav-enemy-info*
  (new 'static 'nav-enemy-info
    :use-die-falling #t
    :use-victory #f
    :use-jump-blocked #t
    :debug-draw-neck #f
    :jump-debug-draw #f
    :move-to-ground #t
    :hover-if-no-ground #f
    :idle-anim-script (new 'static 'array idle-control-frame 4
      (new 'static 'idle-control-frame :command (ic-cmd play) :anim #x5 :param0 #x1 :param1 #x1)
      (new 'static 'idle-control-frame)
      (new 'static 'idle-control-frame)
      (new 'static 'idle-control-frame)
      )
    :idle-anim 5
    :notice-anim 10
    :hostile-anim 5
    :hit-anim 5
    :knocked-anim 11
    :knocked-land-anim 12
    :die-anim 11
    :die-falling-anim 5
    :victory-anim 5
    :jump-wind-up-anim 5
    :jump-in-air-anim 5
    :jump-land-anim 5
    :neck-joint 7
    :look-at-joint 7
    :bullseye-joint 4
    :sound-die (static-sound-name "ginsu-die")
    :notice-distance (meters 40)
    :notice-distance-delta (meters 10)
    :proximity-notice-distance (meters 40)
    :default-hit-points 1
    :gnd-collide-with (collide-spec backgnd)
    :overlaps-others-collide-with-filter (collide-spec jak bot enemy hit-by-others-list player-list)
    :penetrate-knocked #x11fffdffa
    :movement-gravity (meters -100)
    :friction 0.8
    :attack-shove-back (meters 3)
    :attack-shove-up (meters 2)
    :attack-mode 'generic
    :attack-damage 2
    :recover-gnd-collide-with (collide-spec backgnd crate obstacle hit-by-others-list pusher)
    :jump-height-min (meters 3)
    :jump-height-factor 0.5
    :knocked-seek-ry-clamp 4551.1113
    :knocked-soft-vxz-lo 72089.6
    :knocked-soft-vxz-hi 108134.4
    :knocked-soft-vy-lo 81920.0
    :knocked-soft-vy-hi 122880.0
    :knocked-medium-vxz-lo 147456.0
    :knocked-medium-vxz-hi 196608.0
    :knocked-medium-vy-lo 135168.0
    :knocked-medium-vy-hi 151552.0
    :knocked-hard-vxz-lo 78643.2
    :knocked-hard-vxz-hi 117964.8
    :knocked-hard-vy-lo 183500.8
    :knocked-hard-vy-hi 209715.2
    :knocked-huge-vxz-lo 164659.2
    :knocked-huge-vxz-hi 249036.8
    :knocked-huge-vy-lo 183500.8
    :knocked-huge-vy-hi 217907.2
    :knocked-yellow-vxz-lo 40960.0
    :knocked-yellow-vxz-hi 49152.0
    :knocked-yellow-vy-lo 57344.0
    :knocked-yellow-vy-hi 81920.0
    :knocked-red-vxz-lo 24576.0
    :knocked-red-vxz-hi 196608.0
    :knocked-red-vy-lo 94208.0
    :knocked-red-vy-hi 151552.0
    :knocked-blue-vxz-lo 40960.0
    :knocked-blue-vxz-hi 49152.0
    :knocked-blue-vy-lo 24576.0
    :knocked-blue-vy-hi 81920.0
    :shadow-size (meters 2)
    :shadow-max-y (meters 1)
    :shadow-min-y (meters -1)
    :shadow-locus-dist (meters 150)
    :gem-joint 7
    :gem-offset (new 'static 'sphere :r 163840.0)
    :callback-info #f
    :use-momentum #f
    :use-frustration #t
    :use-stop-chase #f
    :use-circling #t
    :use-pacing #t
    :walk-anim 5
    :turn-anim 5
    :run-anim 5
    :taunt-anim -1
    :run-travel-speed (meters 16)
    :run-acceleration (meters 1)
    :run-turning-acceleration (meters 100)
    :walk-travel-speed (meters 16)
    :walk-acceleration (meters 1)
    :walk-turning-acceleration (meters 3)
    :maximum-rotation-rate (degrees 360.0)
    :notice-nav-radius (meters 1.5)
    :frustration-distance (meters 8)
    :frustration-time (seconds 4)
    :blocked-time (seconds 0.3)
    :circle-dist-lo 20480.0
    :circle-dist-hi 61440.0
    :nav-mesh #f
    )
  )

(set! (-> *ginsu-nav-enemy-info* fact-defaults) *fact-info-enemy-defaults*)

(defmethod ginsu-method-180 ginsu ((obj ginsu))
  (let ((v1-2 (if (> (-> obj skel active-channels) 0)
                  (-> obj skel root-channel 0 frame-group)
                  )
              )
        )
    (when (not (and v1-2 (or (= v1-2 (-> obj draw art-group data 11)) (= v1-2 (-> obj draw art-group data 12)))))
      (update! (-> obj blade-speed) 0.0)
      (let ((f0-1 (+ (-> obj blade-angle) (* 970903.75 (-> obj blade-speed value)))))
        (set! (-> obj blade-angle) (- f0-1 (* (the float (the int (/ f0-1 65536.0))) 65536.0)))
        )
      (quaternion-axis-angle! (-> obj blade-jm quat) 0.0 1.0 0.0 (-> obj blade-angle))
      (let ((s5-0 (new 'stack-no-clear 'matrix)))
        (let* ((a2-1 (-> obj node-list data 8 bone transform))
               (v1-14 (-> a2-1 quad 0))
               (a0-10 (-> a2-1 quad 1))
               (a1-3 (-> a2-1 quad 2))
               (a2-2 (-> a2-1 trans quad))
               )
          (set! (-> s5-0 quad 0) v1-14)
          (set! (-> s5-0 quad 1) a0-10)
          (set! (-> s5-0 quad 2) a1-3)
          (set! (-> s5-0 trans quad) a2-2)
          )
        (when (logtest? (enemy-flag dislike-combo) (-> obj enemy-flags))
          (vector-negate! (the-as vector (-> s5-0 vector)) (the-as vector (-> s5-0 vector)))
          (set! (-> s5-0 vector 0 w) 0.0)
          )
        (spawn-with-matrix (-> obj blade-part) s5-0)
        )
      )
    )
  0
  (none)
  )

(defmethod ginsu-method-181 ginsu ((obj ginsu) (arg0 vector))
  (vector-reset! arg0)
  (let ((a0-2 (handle->process (-> obj focus handle))))
    (if a0-2
        (vector-! arg0 (get-trans (the-as process-focusable a0-2) 0) (-> obj root-override2 trans))
        )
    )
  arg0
  )

;; WARN: Return type mismatch symbol vs none.
(defmethod track-target! ginsu ((obj ginsu))
  "Does a lot of various things relating to interacting with the target
- tracks when the enemy was last drawn
- looks at the target and handles attacking
@TODO Not extremely well understood yet"
  (with-pp
    (ginsu-method-180 obj)
    (let ((t9-1 (method-of-type nav-enemy track-target!)))
      (t9-1 obj)
      )
    (cond
      ((not (and (-> obj next-state) (let ((v1-6 (-> obj next-state name)))
                                       (or (= v1-6 'idle)
                                           (= v1-6 'active)
                                           (= v1-6 'dormant)
                                           (= v1-6 'ambush)
                                           (= v1-6 'knocked)
                                           (= v1-6 'idle)
                                           (= v1-6 'dormant)
                                           (= v1-6 'die)
                                           (= v1-6 'die-falling)
                                           )
                                       )
                 )
            )
       (sound-play "ginsu-loop" :id (the-as sound-id (-> obj blade-sound)) :position (-> obj root-override2 trans))
       (set! (-> obj blade-sound-playing) #t)
       )
      ((-> obj blade-sound-playing)
       (sound-stop (the-as sound-id (-> obj blade-sound)))
       (set! (-> obj blade-sound-playing) #f)
       )
      )
    (cond
      ((and (not (and (-> obj next-state) (let ((v1-17 (-> obj next-state name)))
                                            (or (= v1-17 'idle)
                                                (= v1-17 'active)
                                                (= v1-17 'dormant)
                                                (= v1-17 'ambush)
                                                (= v1-17 'knocked)
                                                (= v1-17 'idle)
                                                (= v1-17 'dormant)
                                                (= v1-17 'die)
                                                (= v1-17 'die-falling)
                                                )
                                            )
                      )
                 )
            (< (- (-> pp clock frame-counter) (-> obj grind-timer)) 0)
            )
       (sound-play "ginsu-grind" :id (the-as sound-id (-> obj grind-sound)) :position (-> obj root-override2 trans))
       (set! (-> obj grind-sound-playing) #t)
       )
      ((-> obj grind-sound-playing)
       (sound-stop (the-as sound-id (-> obj grind-sound)))
       (set! (-> obj grind-sound-playing) #f)
       )
      )
    (none)
    )
  )

(defmethod ginsu-method-182 ginsu ((obj ginsu))
  (local-vars (s5-1 art-element))
  (let ((s5-0 (new 'stack-no-clear 'vector))
        (s4-0 (new 'stack-no-clear 'matrix))
        )
    (if (> (-> obj skel active-channels) 0)
        (-> obj skel root-channel 0 frame-group)
        )
    (let* ((v1-8 (if (> (-> obj skel active-channels) 0)
                     (-> obj skel root-channel 0 frame-group)
                     )
                 )
           (f30-0 (if (and v1-8 (= v1-8 (-> obj draw art-group data 7)))
                      (cos 9102.223)
                      (cos 7281.778)
                      )
                  )
           )
      (let ((a1-0 (-> obj nav state)))
        (set! (-> s5-0 quad) (-> a1-0 velocity quad))
        )
      (quaternion->matrix s4-0 (-> obj root-override2 quat))
      (let ((f0-1 (vector-dot s5-0 (the-as vector (-> s4-0 vector)))))
        (if (logtest? (enemy-flag dislike-combo) (-> obj enemy-flags))
            (set! f0-1 (- f0-1))
            )
        (cond
          ((< (- f30-0) f0-1)
           (set! s5-1 (-> obj draw art-group data 9))
           )
          ((< f0-1 f30-0)
           (set! s5-1 (-> obj draw art-group data 8))
           )
          (else
            (set! s5-1 (-> obj draw art-group data 7))
            )
          )
        )
      )
    )
  (let ((v1-33 (if (> (-> obj skel active-channels) 0)
                   (-> obj skel root-channel 0 frame-group)
                   )
               )
        )
    (cond
      ((and v1-33 (= v1-33 s5-1))
       (let ((a0-11 (-> obj skel root-channel 0)))
         (set! (-> a0-11 param 0) 1.0)
         (joint-control-channel-group-eval! a0-11 (the-as art-joint-anim #f) num-func-loop!)
         )
       )
      (else
        (let ((f30-2 (/ (ja-frame-num 0) (the float (ja-num-frames 0)))))
          (ja-channel-push! 1 (seconds 0.5))
          (set! (-> obj skel root-channel 0 frame-group) (the-as art-joint-anim s5-1))
          (let ((gp-1 (-> obj skel root-channel 0)))
            (set! (-> gp-1 num-func) num-func-identity)
            (set! (-> gp-1 frame-num) (* f30-2 (the float (ja-num-frames 0))))
            )
          )
        )
      )
    )
  0
  (none)
  )

(defmethod nav-enemy-method-142 ginsu ((obj ginsu) (arg0 nav-control))
  (with-pp
    (let ((s3-0 (new 'stack-no-clear 'vector)))
      (let ((a0-2 (handle->process (-> obj focus handle))))
        (cond
          (a0-2
            (vector-! s3-0 (get-trans (the-as process-focusable a0-2) 0) (-> obj root-override2 trans))
            )
          (else
            (let ((a0-7 (-> arg0 state)))
              (set! (-> s3-0 quad) (-> a0-7 heading quad))
              )
            )
          )
        )
      (set! (-> s3-0 y) 0.0)
      (vector-normalize! s3-0 1.0)
      (let ((s5-3 (new 'stack-no-clear 'quaternion))
            (s4-0 (-> obj root-override2 quat))
            )
        (quaternion-set! s5-3 0.0 (sqrtf (* 0.5 (- 1.0 (-> s3-0 z)))) 0.0 (sqrtf (* 0.5 (+ 1.0 (-> s3-0 z)))))
        (if (< (-> s3-0 x) 0.0)
            (set! (-> s5-3 y) (- (-> s5-3 y)))
            )
        (quaternion-pseudo-seek
          s4-0
          s4-0
          s5-3
          (* (fmax 0.5 (* 0.00024414062 (-> obj nav state speed))) (-> pp clock seconds-per-frame))
          )
        )
      )
    0
    (none)
    )
  )

;; WARN: disable def twice: 11. This may happen when a cond (no else) is nested inside of another conditional, but it should be rare.
(defmethod general-event-handler ginsu ((obj ginsu) (arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
  "Handles various events for the enemy
@TODO - unsure if there is a pattern for the events and this should have a more specific name"
  (local-vars (v0-1 object))
  (with-pp
    (case arg2
      (('touched)
       (let ((s5-0 arg0))
         (when (if (type? s5-0 ginsu)
                   s5-0
                   )
           (let ((s5-1 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 8))))
             (let ((a0-5 (vector<-cspace! (new 'stack-no-clear 'vector) (-> obj node-list data 8))))
               (vector+! s5-1 s5-1 a0-5)
               )
             (vector-float*! s5-1 s5-1 0.5)
             (spawn (-> obj part) s5-1)
             )
           (set! v0-1 (+ (-> pp clock frame-counter) (seconds 0.125)))
           (set! (-> obj grind-timer) (the-as time-frame v0-1))
           v0-1
           )
         )
       )
      (('touch 'bonk 'attack)
       (cond
         ((or (!= arg0 *target*) (logtest? (focus-status dark) (-> *target* focus-status)))
          ((method-of-type nav-enemy general-event-handler) obj arg0 arg1 arg2 arg3)
          )
         (else
           (let ((v1-15 (new 'stack-no-clear 'event-message-block)))
             (set! (-> v1-15 from) (process->ppointer pp))
             (set! (-> v1-15 num-params) 2)
             (set! (-> v1-15 message) 'attack)
             (set! (-> v1-15 param 0) (the-as uint #f))
             (let ((a2-2 (new 'static 'attack-info :mask (attack-info-mask id))))
               (let* ((a0-19 *game-info*)
                      (a3-2 (+ (-> a0-19 attack-id) 1))
                      )
                 (set! (-> a0-19 attack-id) a3-2)
                 (set! (-> a2-2 id) a3-2)
                 )
               (set! (-> v1-15 param 1) (the-as uint a2-2))
               )
             (send-event-function arg0 v1-15)
             )
           #f
           )
         )
       )
      (('trigger)
       (set! v0-1 #t)
       (set! (-> obj ambush-started) (the-as symbol v0-1))
       v0-1
       )
      (else
        ((method-of-type nav-enemy general-event-handler) obj arg0 arg1 arg2 arg3)
        )
      )
    )
  )

(defstate circling (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy circling) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (if (< 0.5 (rand-vu))
        (set! (-> self enemy-flags) (the-as enemy-flag (logxor (shl 256 32) (the-as int (-> self enemy-flags)))))
        )
    (none)
    )
  :trans (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy circling) trans)))
      (if t9-0
          (t9-0)
          )
      )
    (ginsu-method-182 self)
    (none)
    )
  :code (the-as (function none :behavior ginsu) sleep-code)
  )

(defstate hostile (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy hostile) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (if (< 0.5 (rand-vu))
        (set! (-> self enemy-flags) (the-as enemy-flag (logxor (shl 256 32) (the-as int (-> self enemy-flags)))))
        )
    (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag enemy-flag41))))
    (set! (-> self starting-time) (-> self clock frame-counter))
    (set! (-> self spiral-time) (-> self clock frame-counter))
    (set! (-> self desired-distance) (vector-length (ginsu-method-181 self (new 'stack-no-clear 'vector))))
    (none)
    )
  :trans (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy hostile) trans)))
      (if t9-0
          (t9-0)
          )
      )
    (if (and (< (vector-length (ginsu-method-181 self (new 'stack-no-clear 'vector))) 16384.0)
             (logtest? (-> self draw status) (draw-control-status on-screen))
             )
        (go-virtual anticipate-attack)
        )
    (if (nav-enemy-method-163 self)
        (go-stare2 self)
        )
    (if (logtest? (enemy-flag enemy-flag41) (-> self enemy-flags))
        (set! (-> self enemy-flags) (the-as enemy-flag (logxor (shl 256 32) (the-as int (-> self enemy-flags)))))
        )
    (ginsu-method-182 self)
    (none)
    )
  :code (the-as (function none :behavior ginsu) sleep-code)
  :post (behavior ()
    (let ((s5-0 (ginsu-method-181 self (new 'stack-no-clear 'vector)))
          (gp-0 (new-stack-vector0))
          )
      0.0
      0.0
      (set! (-> s5-0 y) 0.0)
      (let* ((f0-3 (vector-normalize-ret-len! s5-0 1.0))
             (f1-1 (- 1.0 (* 0.0016666667 (the float (- (-> self clock frame-counter) (-> self spiral-time))))))
             (f2-3 (fmax 12288.0 (* 102400.0 f1-1)))
             (f0-4 (- f0-3 (fmin (fmax 12288.0 (* 122880.0 f1-1)) (fmax f2-3 (-> self desired-distance)))))
             (f30-0 (fmin 8192.0 (fmax -8192.0 f0-4)))
             )
        (set! (-> gp-0 x) (- (-> s5-0 z)))
        (set! (-> gp-0 z) (-> s5-0 x))
        (if (logtest? (enemy-flag enemy-flag40) (-> self enemy-flags))
            (vector-negate! gp-0 gp-0)
            )
        (vector+float*! gp-0 (-> self root-override2 trans) gp-0 20480.0)
        (vector+float*! gp-0 gp-0 s5-0 f30-0)
        )
      (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
      (if (< (vector-vector-xz-distance gp-0 (-> self root-override2 trans)) 409.6)
          (set! (-> self enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag41) (-> self enemy-flags))))
          (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag enemy-flag41))))
          )
      (let ((v1-32 (-> self nav state)))
        (logclear! (-> v1-32 flags) (nav-state-flag directional-mode))
        (logior! (-> v1-32 flags) (nav-state-flag target-poly-dirty))
        (set! (-> v1-32 target-post quad) (-> gp-0 quad))
        )
      )
    0
    (nav-enemy-method-176 self)
    (none)
    )
  )

(defstate anticipate-attack (ginsu)
  :virtual #t
  :event (the-as (function process int symbol event-message-block object :behavior ginsu) enemy-event-handler)
  :enter (behavior ()
    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
    (logior! (-> self focus-status) (focus-status dangerous))
    (let ((v1-4 (-> self nav)))
      (set! (-> v1-4 target-speed) 8192.0)
      )
    0
    (set! (-> self state-time) (-> self clock frame-counter))
    (ja-channel-push! 1 (seconds 0.2))
    (ja :group! (-> self draw art-group data 5) :num! min)
    (none)
    )
  :exit (behavior ()
    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
        (logior! (-> self focus-status) (focus-status dangerous))
        (logclear! (-> self focus-status) (focus-status dangerous))
        )
    (none)
    )
  :trans (behavior ()
    (if (not (and (handle->process (-> self focus handle))
                  (zero? (logand (-> (the-as process-focusable (handle->process (-> self focus handle))) focus-status)
                                 (focus-status disable dead ignore grabbed)
                                 )
                         )
                  )
             )
        (go-virtual circling)
        )
    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-focus))
        (go-virtual circling)
        )
    (if (>= (- (-> self clock frame-counter) (-> self state-time)) (seconds 0.75))
        (go-virtual attack)
        )
    (ja :num! (loop!))
    (none)
    )
  :code (the-as (function none :behavior ginsu) sleep-code)
  :post (behavior ()
    (let ((gp-0 (ginsu-method-181 self (new 'stack-no-clear 'vector))))
      (set! (-> gp-0 y) 0.0)
      (vector-normalize! gp-0 -819.2)
      (vector+! gp-0 gp-0 (-> self root-override2 trans))
      (cloest-point-on-mesh (-> self nav) gp-0 gp-0 (the-as nav-poly #f))
      (if (< (vector-vector-xz-distance gp-0 (-> self root-override2 trans)) 409.6)
          (set! (-> self enemy-flags) (the-as enemy-flag (logior (enemy-flag enemy-flag41) (-> self enemy-flags))))
          (set! (-> self enemy-flags) (the-as enemy-flag (logclear (-> self enemy-flags) (enemy-flag enemy-flag41))))
          )
      (let ((v1-12 (-> self nav state)))
        (logclear! (-> v1-12 flags) (nav-state-flag directional-mode))
        (logior! (-> v1-12 flags) (nav-state-flag target-poly-dirty))
        (set! (-> v1-12 target-post quad) (-> gp-0 quad))
        )
      )
    0
    (nav-enemy-method-176 self)
    (none)
    )
  )

(defstate attack (ginsu)
  :virtual #t
  :event (the-as (function process int symbol event-message-block object :behavior ginsu) enemy-event-handler)
  :enter (behavior ()
    (set! (-> self enemy-flags) (logior (enemy-flag actor-pause-backup) (-> self enemy-flags)))
    (ginsu-method-183 self #t)
    (set! (-> self root-override2 penetrate-using) (penetrate generic-attack lunge))
    (enemy-method-49 self)
    (logior! (-> self focus-status) (focus-status dangerous))
    (let* ((v1-9 *game-info*)
           (a0-5 (+ (-> v1-9 attack-id) 1))
           )
      (set! (-> v1-9 attack-id) a0-5)
      (set! (-> self attack-id) a0-5)
      )
    (let ((v1-10 (-> self nav)))
      (set! (-> v1-10 target-speed) 49152.0)
      )
    0
    (set! (-> self state-time) (-> self clock frame-counter))
    (ja :group! (-> self draw art-group data 15) :num! min)
    (none)
    )
  :exit (behavior ()
    (logclear! (-> self enemy-flags) (enemy-flag actor-pause-backup))
    (if (logtest? (-> self enemy-flags) (enemy-flag check-water))
        (logior! (-> self focus-status) (focus-status dangerous))
        (logclear! (-> self focus-status) (focus-status dangerous))
        )
    (ginsu-method-183 self #f)
    (none)
    )
  :trans (behavior ()
    (enemy-method-49 self)
    (if (not (and (handle->process (-> self focus handle))
                  (zero? (logand (-> (the-as process-focusable (handle->process (-> self focus handle))) focus-status)
                                 (focus-status disable dead ignore grabbed)
                                 )
                         )
                  )
             )
        (go-virtual circling)
        )
    (if (logtest? (-> self enemy-flags) (enemy-flag look-at-focus))
        (go-virtual circling)
        )
    (ja :num! (seek!))
    (if (ja-done? 0)
        (go-virtual circling)
        )
    (none)
    )
  :code (the-as (function none :behavior ginsu) sleep-code)
  :post (the-as (function none :behavior ginsu) nav-enemy-chase-post)
  )

(defstate ambush (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type enemy ambush) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (logclear! (-> self mask) (process-mask actor-pause))
    (logior! (-> self enemy-flags) (enemy-flag use-notice-distance))
    (ja-channel-set! 0)
    (set! (-> self root-override2 scale x) 0.01)
    (set! (-> self root-override2 scale y) 0.01)
    (set! (-> self root-override2 scale z) 0.01)
    (none)
    )
  :exit (behavior ()
    (logior! (-> self mask) (process-mask actor-pause))
    (logior! (-> self enemy-flags) (enemy-flag notice))
    (none)
    )
  :trans (behavior ()
    (let ((t9-0 (-> (method-of-type enemy ambush) trans)))
      (if t9-0
          (t9-0)
          )
      )
    (when (-> self ambush-started)
      (when (zero? (-> self skel active-channels))
        (ja-channel-push! 1 0)
        (ja :group! (-> self draw art-group data 5) :num! min)
        )
      (vector-seek! (-> self root-override2 scale) (new 'static 'vector :x 1.0 :y 1.0 :z 1.0) 0.02)
      (+! (-> self path-pos) (/ 2048.0 (total-distance (-> self ambush-path))))
      (let ((f30-1 (-> self path-pos)))
        (when (>= f30-1 1.0)
          (set! (-> self path-pos) 1.0)
          (go-hostile self)
          )
        (get-point-at-percent-along-path! (-> self ambush-path) (-> self root-override2 trans) f30-1 'interp)
        )
      (ja :num! (loop!))
      )
    (none)
    )
  :code (the-as (function none :behavior ginsu) sleep-code)
  :post (the-as (function none :behavior ginsu) enemy-simple-post)
  )

(defbehavior ginsu-sounds-off ginsu ()
  (if (-> self blade-sound-playing)
      (sound-stop (the-as sound-id (-> self blade-sound)))
      )
  (when (-> self grind-sound-playing)
    (sound-stop (the-as sound-id (-> self grind-sound)))
    (set! (-> self grind-sound-playing) #f)
    (set! (-> self grind-timer) 0)
    0
    )
  (none)
  )

(defstate idle (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy idle) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (ginsu-sounds-off)
    (none)
    )
  )

(defstate dormant (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy dormant) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (ginsu-sounds-off)
    (none)
    )
  )

(defstate die (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy die) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (ginsu-sounds-off)
    (none)
    )
  )

(defstate die-falling (ginsu)
  :virtual #t
  :enter (behavior ()
    (let ((t9-0 (-> (method-of-type nav-enemy die-falling) enter)))
      (if t9-0
          (t9-0)
          )
      )
    (ginsu-sounds-off)
    (none)
    )
  )

(defmethod go-hostile ginsu ((obj ginsu))
  (cond
    ((or (and (-> obj enemy-info-override use-frustration) (logtest? (enemy-flag enemy-flag39) (-> obj enemy-flags)))
         (nav-enemy-method-163 obj)
         )
     (go-stare2 obj)
     )
    (else
      (let* ((v1-8 (/ (the-as int (rand-uint31-gen *random-generator*)) 256))
             (v1-9 (the-as number (logior (the-as int #x3f800000) v1-8)))
             )
        (if (and (< (+ -1.0 (the-as float v1-9)) 0.1) (logtest? (-> obj draw status) (draw-control-status on-screen)))
            (go (method-of-object obj anticipate-attack))
            (go (method-of-object obj hostile))
            )
        )
      )
    )
  (none)
  )

;; WARN: Return type mismatch object vs none.
(defmethod go-idle ginsu ((obj ginsu))
  (if (not (logtest? (-> obj ambush-path flags) (path-control-flag not-found)))
      (go (method-of-object obj ambush))
      (go (method-of-object obj idle))
      )
  (none)
  )

(defmethod deactivate ginsu ((obj ginsu))
  (when (nonzero? (-> obj blade-part))
    (let ((a0-1 (-> obj blade-part)))
      ((the-as (function sparticle-launch-control none) (method-of-object a0-1 kill-and-free-particles)) a0-1)
      )
    )
  (if (-> obj blade-sound-playing)
      (sound-stop (the-as sound-id (-> obj blade-sound)))
      )
  (if (-> obj grind-sound-playing)
      (sound-stop (the-as sound-id (-> obj grind-sound)))
      )
  ((method-of-type nav-enemy deactivate) obj)
  (none)
  )

;; WARN: Return type mismatch nav-enemy vs ginsu.
(defmethod relocate ginsu ((obj ginsu) (arg0 int))
  (if (nonzero? (-> obj blade-jm))
      (&+! (-> obj blade-jm) arg0)
      )
  (if (nonzero? (-> obj blade-part))
      (&+! (-> obj blade-part) arg0)
      )
  (if (nonzero? (-> obj ambush-path))
      (&+! (-> obj ambush-path) arg0)
      )
  (the-as ginsu ((method-of-type nav-enemy relocate) obj arg0))
  )

(defmethod ginsu-method-183 ginsu ((obj ginsu) (arg0 symbol))
  (let ((v1-3 (-> (the-as collide-shape-prim-group (-> obj root-override2 root-prim)) child 1)))
    (cond
      (arg0
        (set! (-> v1-3 prim-core collide-as) (collide-spec enemy))
        (set! (-> v1-3 prim-core collide-with) (collide-spec jak bot))
        )
      (else
        (set! (-> v1-3 prim-core collide-as) (collide-spec))
        (set! (-> v1-3 prim-core collide-with) (collide-spec))
        0
        )
      )
    )
  (none)
  )

(defmethod enemy-method-46 ginsu ((obj ginsu) (arg0 int))
  "@abstract"
  (case arg0
    ((1)
     (let ((v1-2 (-> obj root-override2 root-prim)))
       (logior! (-> v1-2 prim-core action) (collide-action solid))
       (let ((v1-4 (-> (the-as collide-shape-prim-group v1-2) child 0)))
         (logior! (-> v1-4 prim-core action) (collide-action solid))
         )
       )
     )
    )
  0
  (none)
  )

(defmethod init-enemy-collision! ginsu ((obj ginsu))
  "Initializes the [[collide-shape-moving]] and any ancillary tasks to make the enemy collide properly"
  (let ((s5-0 (new 'process 'collide-shape-moving obj (collide-list-enum usually-hit-by-player))))
    (set! (-> s5-0 dynam) (copy *standard-dynamics* 'process))
    (set! (-> s5-0 reaction) cshape-reaction-default)
    (set! (-> s5-0 no-reaction)
          (the-as (function collide-shape-moving collide-query vector vector object) nothing)
          )
    (set! (-> s5-0 penetrated-by) (penetrate
                                    generic-attack
                                    lunge
                                    flop
                                    punch
                                    spin
                                    roll
                                    uppercut
                                    bonk
                                    tube
                                    vehicle
                                    flut-attack
                                    board
                                    mech-punch
                                    dark-punch
                                    dark-giant
                                    )
          )
    (let ((s4-0 (new 'process 'collide-shape-prim-group s5-0 (the-as uint 2) 0)))
      (set! (-> s5-0 total-prims) (the-as uint 3))
      (set! (-> s4-0 prim-core collide-as) (collide-spec enemy))
      (set! (-> s4-0 prim-core collide-with)
            (collide-spec backgnd jak bot crate enemy obstacle hit-by-others-list player-list)
            )
      (set! (-> s4-0 prim-core action) (collide-action deadly no-standon))
      (set! (-> s4-0 transform-index) 8)
      (set-vector! (-> s4-0 local-sphere) 0.0 0.0 0.0 9216.0)
      (set! (-> s5-0 root-prim) s4-0)
      )
    (let ((v1-14 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
      (set! (-> v1-14 prim-core collide-as) (collide-spec enemy))
      (set! (-> v1-14 prim-core collide-with)
            (collide-spec backgnd jak bot crate enemy obstacle hit-by-others-list player-list)
            )
      (set! (-> v1-14 prim-core action) (collide-action no-standon))
      (set! (-> v1-14 transform-index) 8)
      (set-vector! (-> v1-14 local-sphere) 0.0 0.0 0.0 4915.2)
      )
    (let ((v1-16 (new 'process 'collide-shape-prim-sphere s5-0 (the-as uint 0))))
      (set! (-> v1-16 prim-core collide-as) (collide-spec enemy))
      (set! (-> v1-16 prim-core collide-with) (collide-spec jak bot player-list))
      (set! (-> v1-16 prim-core action) (collide-action deadly))
      (set! (-> v1-16 transform-index) 7)
      (set-vector! (-> v1-16 local-sphere) 0.0 0.0 0.0 2662.4)
      )
    (set! (-> s5-0 nav-radius) 4505.6)
    (let ((v1-18 (-> s5-0 root-prim)))
      (set! (-> s5-0 backup-collide-as) (-> v1-18 prim-core collide-as))
      (set! (-> s5-0 backup-collide-with) (-> v1-18 prim-core collide-with))
      )
    (set! (-> s5-0 max-iteration-count) (the-as uint 3))
    (set! (-> s5-0 event-self) 'touched)
    (set! (-> obj root-override2) s5-0)
    )
  0
  (none)
  )

(defmethod init-enemy! ginsu ((obj ginsu))
  "Common method called to initialize the enemy, typically sets up default field values and calls ancillary helper methods"
  (stack-size-set! (-> obj main-thread) 256)
  (initialize-skeleton
    obj
    (the-as skeleton-group (art-group-get-by-name *level* "skel-ginsu" (the-as (pointer uint32) #f)))
    (the-as pair 0)
    )
  (set! (-> obj skel generate-frame-function) create-interpolated2-joint-animation-frame)
  (init-enemy-behaviour-and-stats! obj *ginsu-nav-enemy-info*)
  (logclear! (-> obj nav flags) (nav-control-flag update-heading-from-facing))
  (set! (-> obj enemy-flags) (the-as enemy-flag (logclear (-> obj enemy-flags) (enemy-flag enemy-flag43))))
  (logclear! (-> obj nav flags) (nav-control-flag limit-rotation-rate))
  (let ((v1-14 (-> obj neck)))
    (set! (-> v1-14 up) (the-as uint 1))
    (set! (-> v1-14 nose) (the-as uint 2))
    (set! (-> v1-14 ear) (the-as uint 0))
    (set-vector! (-> v1-14 twist-max) 10922.667 7281.778 0.0 1.0)
    (set! (-> v1-14 ignore-angle) 18204.445)
    )
  (let ((v1-16 (-> obj nav)))
    (set! (-> v1-16 speed-scale) 1.0)
    )
  0
  (set-gravity-length (-> obj root-override2 dynam) 573440.0)
  (ginsu-method-183 obj #f)
  (set! (-> obj blade-jm) (new 'process 'joint-mod (joint-mod-mode joint-set*) obj 8))
  (init (-> obj blade-speed) 1.0 0.01 0.1 0.9)
  (set! (-> obj part) (create-launch-control (-> *part-group-id-table* 475) obj))
  (set! (-> obj blade-part) (create-launch-control (-> *part-group-id-table* 476) obj))
  (set! (-> obj ambush-path) (new 'process 'curve-control obj 'intro -1000000000.0))
  (set! (-> obj ambush-started) #f)
  (set! (-> obj path-pos) 0.0)
  (if (not (logtest? (-> obj ambush-path flags) (path-control-flag not-found)))
      (logior! (-> obj ambush-path flags) (path-control-flag display draw-line draw-point draw-text))
      )
  (set! (-> obj blade-sound) (the-as uint (new-sound-id)))
  (set! (-> obj blade-sound-playing) #f)
  (set! (-> obj grind-sound) (the-as uint (new-sound-id)))
  (set! (-> obj grind-sound-playing) #f)
  (set! (-> obj grind-timer) 0)
  0
  (none)
  )