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

;; definition of type shover
(deftype shover (process-drawable)
  ((root-override collide-shape  :offset        112)
   (shove-up      float          :offset-assert 176)
   )
  :heap-base #x50
  :method-count-assert 20
  :size-assert         #xb4
  :flag-assert         #x14005000b4
  (:states
    shover-idle
    )
  )

;; definition for method 3 of type shover
(defmethod inspect shover ((obj shover))
  (let ((t9-0 (method-of-type process-drawable inspect)))
    (t9-0 obj)
    )
  (format #t "~T~Tshove-up: ~f~%" (-> obj shove-up))
  obj
  )

;; failed to figure out what this is:
(defskelgroup *shover-sg* shover
  0
  2
  ((1 (meters 999999)))
  :bounds (static-spherem 0 0 0 2)
  :longest-edge (meters 0)
  )

;; failed to figure out what this is:
(defstate shover-idle (shover)
  :event
  (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
    (case arg2
      (('touch 'attack)
       (when (= (-> arg0 type) target)
         (when ((method-of-type touching-shapes-entry prims-touching-action?)
                (the-as touching-shapes-entry (-> arg3 param 0))
                (-> *target* control)
                (collide-action solid)
                (collide-action)
                )
           (let ((s4-0 (new 'stack 'attack-info)))
             (dummy-41 (-> self root-override) s4-0 (-> self shove-up))
             (level-hint-spawn
               (game-text-id sunken-take-it-easy-hot-pipes)
               "sksp0134"
               (the-as entity #f)
               *entity-pool*
               (game-task none)
               )
             (cond
               ((or (= (-> *target* control unknown-surface00 mode) 'air)
                    (>= (+ (-> *display* base-frame-counter) (seconds -0.2)) (-> *target* control unknown-dword11))
                    (< 0.75 (-> *target* control poly-normal y))
                    )
                (let ((a1-6 (new 'stack-no-clear 'event-message-block)))
                  (set! (-> a1-6 from) self)
                  (set! (-> a1-6 num-params) 2)
                  (set! (-> a1-6 message) 'attack-or-shove)
                  (set! (-> a1-6 param 0) (-> arg3 param 0))
                  (let ((v1-22 (new 'static 'attack-info :mask #xa2)))
                    (set! (-> v1-22 mode) 'burn)
                    (set! (-> v1-22 vector quad) (-> s4-0 vector quad))
                    (set! (-> v1-22 shove-up) (-> s4-0 shove-up))
                    (set! (-> a1-6 param 1) (the-as uint v1-22))
                    )
                  (send-event-function arg0 a1-6)
                  )
                )
               (else
                 (let ((a1-7 (new 'stack-no-clear 'event-message-block)))
                   (set! (-> a1-7 from) self)
                   (set! (-> a1-7 num-params) 2)
                   (set! (-> a1-7 message) 'attack-or-shove)
                   (set! (-> a1-7 param 0) (-> arg3 param 0))
                   (let ((v1-26 (new 'static 'attack-info :mask #x8e2)))
                     (set! (-> v1-26 mode) 'burn)
                     (set! (-> v1-26 shove-up) 0.0)
                     (set! (-> v1-26 shove-back) 8192.0)
                     (set! (-> v1-26 vector quad) (-> *target* control poly-normal quad))
                     (set! (-> v1-26 angle) 'shove)
                     (set! (-> a1-7 param 1) (the-as uint v1-26))
                     )
                   (send-event-function arg0 a1-7)
                   )
                 )
               )
             )
           )
         )
       )
      )
    )
  :code
  (the-as (function none :behavior shover) anim-loop)
  )

;; definition for method 11 of type shover
;; INFO: Return type mismatch object vs none.
;; Used lq/sq
(defmethod init-from-entity! shover ((obj shover) (arg0 entity-actor))
  (local-vars (sv-16 res-tag))
  (set! (-> obj shove-up) (res-lump-float arg0 'shove :default 12288.0))
  (let ((s3-0 (res-lump-value arg0 'collision-mesh-id uint128))
        (s4-0 (new 'process 'collide-shape obj (collide-list-enum hit-by-player)))
        )
    (let ((s3-1 (new 'process 'collide-shape-prim-mesh s4-0 (the-as uint s3-0) (the-as uint 0))))
      (set! (-> s3-1 prim-core collide-as) (collide-kind wall-object))
      (set! (-> s3-1 collide-with) (collide-kind target))
      (set! (-> s3-1 prim-core action) (collide-action solid))
      (set! (-> s3-1 prim-core offense) (collide-offense indestructible))
      (set! (-> s3-1 transform-index) 0)
      (set-vector! (-> s3-1 local-sphere) 0.0 0.0 0.0 53248.0)
      (set-root-prim! s4-0 s3-1)
      )
    (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
    (backup-collide-with-as s4-0)
    (set! (-> obj root-override) s4-0)
    )
  (process-drawable-from-entity! obj arg0)
  (initialize-skeleton obj *shover-sg* '())
  (let ((v1-17 (new 'process 'path-control obj 'path 0.0)))
    (set! (-> obj path) v1-17)
    (logior! (-> v1-17 flags) (path-control-flag display draw-line draw-point draw-text))
    (if (<= (-> v1-17 curve num-cverts) 0)
        (go process-drawable-art-error "no path")
        )
    )
  (set! sv-16 (new 'static 'res-tag))
  (let ((v1-23 (res-lump-data arg0 'trans-offset (pointer float) :tag-ptr (& sv-16))))
    (when v1-23
      (+! (-> obj root-override trans x) (-> v1-23 0))
      (+! (-> obj root-override trans y) (-> v1-23 1))
      (+! (-> obj root-override trans z) (-> v1-23 2))
      )
    )
  (let ((f0-13 (res-lump-float arg0 'rotoffset)))
    (if (!= f0-13 0.0)
        (quaternion-rotate-y! (-> obj root-override quat) (-> obj root-override quat) f0-13)
        )
    )
  (ja-channel-set! 1)
  (let ((s5-1 (-> obj skel root-channel 0)))
    (joint-control-channel-group-eval!
      s5-1
      (the-as art-joint-anim (-> obj draw art-group data 2))
      num-func-identity
      )
    (set! (-> s5-1 frame-num) 0.0)
    )
  (ja-post)
  (update-transforms! (-> obj root-override))
  (set! *shover* obj)
  (go shover-idle)
  (none)
  )