jak-project/test/decompiler/reference/levels/finalboss/final-door_REF.gc

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

;; definition of type fin-door
(deftype fin-door (process-hidden)
  ()
  :method-count-assert 15
  :size-assert         #x70
  :flag-assert         #xf00000070
  )

;; definition for method 3 of type fin-door
(defmethod inspect fin-door ((obj fin-door))
  (format #t "[~8x] ~A~%" obj (-> obj type))
  (format #t "~Tname: ~A~%" (-> obj name))
  (format #t "~Tmask: ~D~%" (-> obj mask))
  (format #t "~Tparent: #x~X~%" (-> obj parent))
  (format #t "~Tbrother: #x~X~%" (-> obj brother))
  (format #t "~Tchild: #x~X~%" (-> obj child))
  (format #t "~Tppointer: #x~X~%" (-> obj ppointer))
  (format #t "~Tself: ~A~%" (-> obj self))
  (format #t "~Tpool: ~A~%" (-> obj pool))
  (format #t "~Tstatus: ~A~%" (-> obj status))
  (format #t "~Tpid: ~D~%" (-> obj pid))
  (format #t "~Tmain-thread: ~A~%" (-> obj main-thread))
  (format #t "~Ttop-thread: ~A~%" (-> obj top-thread))
  (format #t "~Tentity: ~A~%" (-> obj entity))
  (format #t "~Tstate: ~A~%" (-> obj state))
  (format #t "~Ttrans-hook: ~A~%" (-> obj trans-hook))
  (format #t "~Tpost-hook: ~A~%" (-> obj post-hook))
  (format #t "~Tevent-hook: ~A~%" (-> obj event-hook))
  (format #t "~Tallocated-length: ~D~%" (-> obj allocated-length))
  (format #t "~Tnext-state: ~A~%" (-> obj next-state))
  (format #t "~Theap-base: #x~X~%" (-> obj heap-base))
  (format #t "~Theap-top: #x~X~%" (-> obj heap-top))
  (format #t "~Theap-cur: #x~X~%" (-> obj heap-cur))
  (format #t "~Tstack-frame-top: ~A~%" (-> obj stack-frame-top))
  (format #t "~Theap: #<kheap @ #x~X>~%" (&-> obj heap-base))
  (format #t "~Tconnection-list: ~`'connectable`P~%" (-> obj connection-list))
  (format #t "~Tstack[0] @ #x~X~%" (-> obj stack))
  obj
  )

;; definition of type final-door
(deftype final-door (process-drawable)
  ()
  :heap-base #x40
  :method-count-assert 23
  :size-assert         #xb0
  :flag-assert         #x17004000b0
  (:methods
    (idle () _type_ :state 20)
    (dummy-21 (_type_) none 21)
    (open () _type_ :state 22)
    )
  )

;; definition for method 3 of type final-door
(defmethod inspect final-door ((obj final-door))
  (let ((t9-0 (method-of-type process-drawable inspect)))
   (t9-0 obj)
   )
  obj
  )

;; failed to figure out what this is:
(let
  ((v1-2
    (new 'static 'skeleton-group
     :art-group-name "power-left"
     :bounds
     (new 'static 'vector :y 45056.0 :w 49152.0)
     :version #x6
     )
    )
   )
  (set! (-> v1-2 jgeo) 0)
  (set! (-> v1-2 janim) 2)
  (set! (-> v1-2 mgeo 0) (the-as uint 1))
  (set! (-> v1-2 lod-dist 0) 4095996000.0)
  (set! *power-left-sg* v1-2)
  )

;; failed to figure out what this is:
(let
  ((v1-3
    (new 'static 'skeleton-group
     :art-group-name "power-right"
     :bounds
     (new 'static 'vector :y 45056.0 :w 49152.0)
     :version #x6
     )
    )
   )
  (set! (-> v1-3 jgeo) 0)
  (set! (-> v1-3 janim) 2)
  (set! (-> v1-3 mgeo 0) (the-as uint 1))
  (set! (-> v1-3 lod-dist 0) 4095996000.0)
  (set! *power-right-sg* v1-3)
  )

;; failed to figure out what this is:
(let
  ((v1-4
    (new 'static 'skeleton-group
     :art-group-name "powercellalt"
     :bounds (new 'static 'vector :w 8192.0)
     :version #x6
     )
    )
   )
  (set! (-> v1-4 jgeo) 0)
  (set! (-> v1-4 janim) 2)
  (set! (-> v1-4 mgeo 0) (the-as uint 1))
  (set! (-> v1-4 lod-dist 0) 4095996000.0)
  (set! *powercellalt-sg* v1-4)
  )

;; failed to figure out what this is:
(defstate idle (final-door)
  :virtual #t
  :event
  (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
   (case arg2 
    (('open)
      enter-state
      (go-virtual open)
      )
    )
   )
  :code
  (behavior ()
   (transform-post)
   (logior! (-> self mask) (process-mask sleep))
   (suspend)
   0
   (none)
   )
  )

;; failed to figure out what this is:
(defstate open (final-door)
  :virtual #t
  :event
  (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
   (let ((v1-0 arg2))
    (the-as object (when (= v1-0 'brightness)
                    (let ((f0-0 (the-as float (-> arg3 param 0)))
                          (f1-0 (the-as float (-> arg3 param 1)))
                          )
                     (set-vector! (-> self draw color-mult) f0-0 f0-0 f0-0 f0-0)
                     (let ((v0-0 (-> self draw color-emissive)))
                      (set! (-> v0-0 x) f1-0)
                      (set! (-> v0-0 y) f1-0)
                      (set! (-> v0-0 z) f1-0)
                      (set! (-> v0-0 w) f1-0)
                      v0-0
                      )
                     )
                    )
     )
    )
   )
  :code
  (behavior ()
   (case (-> self type) 
    ((power-left)
      (let ((a0-1 (-> self skel root-channel 0)))
       (set!
        (-> a0-1 frame-group)
        (the-as art-joint-anim (-> self draw art-group data 2))
        )
       (set!
        (-> a0-1 param 0)
        (the
         float
         (+
          (->
           (the-as art-joint-anim (-> self draw art-group data 2))
           data
           0
           length
           )
          -1
          )
         )
        )
       (set! (-> a0-1 param 1) 0.353)
       (set! (-> a0-1 frame-num) 0.0)
       (joint-control-channel-group!
        a0-1
        (the-as art-joint-anim (-> self draw art-group data 2))
        num-func-seek!
        )
       )
      (until (ja-done? 0)
       (transform-post)
       (suspend)
       (let ((a0-2 (-> self skel root-channel 0)))
        (set!
         (-> a0-2 param 0)
         (the float (+ (-> a0-2 frame-group data 0 length) -1))
         )
        (set! (-> a0-2 param 1) 0.353)
        (joint-control-channel-group-eval!
         a0-2
         (the-as art-joint-anim #f)
         num-func-seek!
         )
        )
       )
      )
    (else
     (let ((a0-4 (-> self skel root-channel 0)))
      (set!
       (-> a0-4 frame-group)
       (the-as art-joint-anim (-> self draw art-group data 2))
       )
      (set!
       (-> a0-4 param 0)
       (the
        float
        (+
         (->
          (the-as art-joint-anim (-> self draw art-group data 2))
          data
          0
          length
          )
         -1
         )
        )
       )
      (set! (-> a0-4 param 1) 0.353)
      (set! (-> a0-4 frame-num) 0.0)
      (joint-control-channel-group!
       a0-4
       (the-as art-joint-anim (-> self draw art-group data 2))
       num-func-seek!
       )
      )
     (until (ja-done? 0)
      (transform-post)
      (suspend)
      (let ((a0-5 (-> self skel root-channel 0)))
       (set!
        (-> a0-5 param 0)
        (the float (+ (-> a0-5 frame-group data 0 length) -1))
        )
       (set! (-> a0-5 param 1) 0.353)
       (joint-control-channel-group-eval!
        a0-5
        (the-as art-joint-anim #f)
        num-func-seek!
        )
       )
      )
     )
    )
   (transform-post)
   (logior! (-> self mask) (process-mask sleep))
   (suspend)
   0
   (none)
   )
  )

;; definition for method 11 of type final-door
;; INFO: Return type mismatch object vs none.
(defmethod copy-defaults! final-door ((obj final-door) (arg0 res-lump))
  (let
   ((s4-0
     (new 'process 'collide-shape-moving obj (collide-list-enum hit-by-others))
     )
    )
   (set! (-> s4-0 dynam) (copy *standard-dynamics* 'process))
   (set! (-> s4-0 reaction) default-collision-reaction)
   (set! (-> s4-0 no-reaction) nothing)
   (let
    ((s3-0
      (new
       'process
       'collide-shape-prim-mesh
       s4-0
       (the-as uint 0)
       (the-as uint 0)
       )
      )
     )
    (set! (-> s3-0 prim-core collide-as) (the-as uint 512))
    (set! (-> s3-0 collide-with) (the-as uint 16))
    (set! (-> s3-0 prim-core action) (the-as uint 1))
    (set! (-> s3-0 prim-core offense) 4)
    (set! (-> s3-0 transform-index) 3)
    (set-vector! (-> s3-0 local-sphere) 0.0 45056.0 0.0 49152.0)
    )
   (dummy-46 s4-0)
   (set! (-> s4-0 nav-radius) (* 0.75 (-> s4-0 root-prim local-sphere w)))
   (dummy-50 s4-0)
   (set! (-> obj root) s4-0)
   )
  (process-drawable-from-entity! obj arg0)
  (dummy-21 obj)
  (go (method-of-object obj idle))
  (none)
  )

;; definition of type power-left
(deftype power-left (final-door)
  ()
  :heap-base #x40
  :method-count-assert 23
  :size-assert         #xb0
  :flag-assert         #x17004000b0
  )

;; definition for method 3 of type power-left
(defmethod inspect power-left ((obj power-left))
  (let ((t9-0 (method-of-type final-door inspect)))
   (t9-0 obj)
   )
  obj
  )

;; definition of type power-right
(deftype power-right (final-door)
  ()
  :heap-base #x40
  :method-count-assert 23
  :size-assert         #xb0
  :flag-assert         #x17004000b0
  )

;; definition for method 3 of type power-right
(defmethod inspect power-right ((obj power-right))
  (let ((t9-0 (method-of-type final-door inspect)))
   (t9-0 obj)
   )
  obj
  )

;; failed to figure out what this is:
(defstate idle (power-left)
  :virtual #t
  :code
  (behavior ()
   (ja-post)
   (while #t
    (if
     (and
      (and
       *target*
       (>=
        61440.0
        (vector-vector-distance
         (-> self root trans)
         (-> *target* control trans)
         )
        )
       )
      (and
       (zero? (logand (-> *target* state-flags) 256))
       (and
        (>= (-> *game-info* fuel) 100.0)
        (not
         (and
          (-> self entity)
          (logtest?
           (-> self entity extra perm status)
           (entity-perm-status complete)
           )
          )
         )
        (=
         (get-task-status (game-task finalboss-movies))
         (task-status need-reward-speech)
         )
        (send-event
         *target*
         'change-mode
         'final-door
         (search-process-tree *active-pool* (lambda ((arg0 final-door))
                                             (= (-> arg0 type) power-right)
                                             )
          )
         (search-process-tree *active-pool* (lambda ((arg0 final-door))
                                             (= (-> arg0 type) power-left)
                                             )
          )
         )
        )
       )
      )
     (process-entity-status! self (entity-perm-status complete) #t)
     )
    (suspend)
    )
   (none)
   )
  )

;; definition for method 21 of type power-left
;; INFO: Return type mismatch int vs none.
(defmethod dummy-21 power-left ((obj power-left))
  (dummy-14 obj *power-left-sg* '())
  0
  (none)
  )

;; definition for method 21 of type power-right
;; INFO: Return type mismatch int vs none.
(defmethod dummy-21 power-right ((obj power-right))
  (dummy-14 obj *power-right-sg* '())
  0
  (none)
  )

;; definition of type powercellalt
(deftype powercellalt (process-drawable)
  ((root-override collide-shape-moving         :offset        112)
   (jump-pos      vector               :inline :offset-assert 176)
   (base          vector               :inline :offset-assert 192)
   (index         int32                        :offset-assert 208)
   )
  :heap-base #x70
  :method-count-assert 23
  :size-assert         #xd4
  :flag-assert         #x17007000d4
  (:methods
    (dummy-20 () none 20)
    (jump () _type_ :state 21)
    (idle () _type_ :state 22)
    )
  )

;; definition for method 3 of type powercellalt
(defmethod inspect powercellalt ((obj powercellalt))
  (let ((t9-0 (method-of-type process-drawable inspect)))
   (t9-0 obj)
   )
  (format #t "~T~Tjump-pos: ~`vector`P~%" (-> obj jump-pos))
  (format #t "~T~Tbase: ~`vector`P~%" (-> obj base))
  (format #t "~T~Tindex: ~D~%" (-> obj index))
  obj
  )

;; failed to figure out what this is:
(defstate jump (powercellalt)
  :virtual #t
  :code
  (behavior ()
   (sound-play-by-name
    (static-sound-name "cell-prize")
    (new-sound-id)
    1024
    0
    0
    (the-as uint 1)
    (the-as vector #t)
    )
   (let ((gp-1 (new 'stack 'trajectory)))
    (set! (-> self base y) (-> self jump-pos y))
    (setup-from-to-duration!
     gp-1
     (-> self root-override trans)
     (-> self jump-pos)
     300.0
     -2.2755556
     )
    (set! (-> self state-time) (-> *display* base-frame-counter))
    (until (>= (- (-> *display* base-frame-counter) (-> self state-time)) 300)
     (let
      ((f0-2
        (the float (- (-> *display* base-frame-counter) (-> self state-time)))
        )
       )
      (eval-position! gp-1 f0-2 (-> self root-override trans))
      )
     (transform-post)
     (spawn
      (-> self part)
      (the-as vector (-> self root-override root-prim prim-core))
      )
     (suspend)
     (when (nonzero? (-> self skel))
      (let ((a0-7 (-> self skel root-channel 0)))
       (set! (-> a0-7 param 0) 0.5)
       (joint-control-channel-group-eval!
        a0-7
        (the-as art-joint-anim #f)
        num-func-loop!
        )
       )
      )
     )
    )
   (set! (-> self root-override trans quad) (-> self jump-pos quad))
   (set! (-> self base quad) (-> self root-override trans quad))
   (transform-post)
   (sound-play-by-name
    (static-sound-name "land-pcmetal")
    (new-sound-id)
    1024
    3048
    0
    (the-as uint 1)
    (the-as vector #t)
    )
   (let ((gp-3 (get-process *default-dead-pool* part-tracker #x4000)))
    (when gp-3
     (let ((t9-12 (method-of-type part-tracker activate)))
      (t9-12
       (the-as part-tracker gp-3)
       *entity-pool*
       'part-tracker
       (the-as pointer #x70004000)
       )
      )
     (run-now-in-process
      gp-3
      part-tracker-init
      (-> *part-group-id-table* 4)
      -1
      #f
      #f
      #f
      (-> self root-override root-prim prim-core)
      )
     (-> gp-3 ppointer)
     )
    )
   (go-virtual idle)
   (none)
   )
  )

;; failed to figure out what this is:
(defstate idle (powercellalt)
  :virtual #t
  :code
  (behavior ()
   (while #t
    (vector<-cspace!
     (-> self root-override trans)
     (->
      (the-as process-drawable (-> self parent 0))
      node-list
      data
      (-> self index)
      )
     )
    (transform-post)
    (suspend)
    )
   (none)
   )
  )

;; definition for function powercellalt-init-by-other
;; INFO: Return type mismatch object vs none.
;; Used lq/sq
(defbehavior
  powercellalt-init-by-other powercellalt
  ((arg0 entity) (arg1 vector) (arg2 vector) (arg3 int))
  (set! (-> self entity) arg0)
  (let
   ((s3-0
     (new 'process 'collide-shape-moving self (collide-list-enum hit-by-player))
     )
    )
   (set! (-> s3-0 dynam) (copy *standard-dynamics* 'process))
   (set! (-> s3-0 reaction) default-collision-reaction)
   (set! (-> s3-0 no-reaction) nothing)
   (let ((s2-0 (new 'process 'collide-shape-prim-sphere s3-0 (the-as uint 0))))
    (set! (-> s2-0 prim-core collide-as) (the-as uint 64))
    (set! (-> s2-0 collide-with) (the-as uint 16))
    (set-vector! (-> s2-0 local-sphere) 0.0 0.0 0.0 4915.2)
    )
   (dummy-46 s3-0)
   (set! (-> s3-0 nav-radius) (* 0.75 (-> s3-0 root-prim local-sphere w)))
   (dummy-50 s3-0)
   (set! (-> self root-override) s3-0)
   )
  (set! (-> self root-override trans quad) (-> arg1 quad))
  (set! (-> self jump-pos quad) (-> arg2 quad))
  (set-vector! (-> self root-override scale) 0.5 0.5 0.5 1.0)
  (set! (-> self index) arg3)
  (dummy-14 self *powercellalt-sg* '())
  (set!
   (-> self part)
   (create-launch-control (-> *part-group-id-table* 63) self)
   )
  enter-state
  (-> self root-override trans)
  (-> self jump-pos)
  (go-virtual jump)
  (none)
  )

;; failed to figure out what this is:
(defstate target-final-door (target)
  :event
  (behavior ((arg0 process) (arg1 int) (arg2 symbol) (arg3 event-message-block))
   ((-> target-grab event) arg0 arg1 arg2 arg3)
   )
  :enter
  (behavior ((arg0 basic) (arg1 handle))
   (send-event *camera* 'change-to-entity-by-name "camera-403")
   (set! (-> self control unknown-surface00) *empty-mods*)
   (logior! (-> self state-flags) 272)
   (set-setting! *setting-control* self 'allow-progress #f 0.0 0)
   (none)
   )
  :exit
  (behavior ()
   (send-event *camera* 'change-state *camera-base-mode* 60)
   (set! (-> self state-flags) (logand -273 (-> self state-flags)))
   (target-exit)
   (clear-pending-settings-from-process *setting-control* self 'allow-progress)
   (none)
   )
  :trans
  (behavior ()
   (set-letterbox-frames 5)
   (none)
   )
  :code
  (behavior ((arg0 basic) (arg1 handle))
   (local-vars
    (sv-144 process)
    (sv-160 vector)
    (sv-176 process)
    (sv-192 vector)
    )
   (let ((a0-2 (get-task-control (game-task finalboss-movies))))
    (save-reminder a0-2 (logior (get-reminder a0-2 0) 2) 0)
    )
   (TODO-RENAME-30
    (-> self control)
    (new 'static 'vector :x 11368946.0 :y 2215900.2 :z -19405602.0 :w 1.0)
    )
   (set-quaternion!
    (-> self control)
    (the-as quaternion (new 'static 'vector :y -0.8472 :w 0.5312))
    )
   (rot->dir-targ! (-> self control))
   (transform-post)
   (ja-channel-push! 1 60)
   (let ((s4-1 (-> self skel root-channel 0)))
    (set!
     (-> s4-1 frame-group)
     (the-as art-joint-anim (-> self draw art-group data 88))
     )
    (set! (-> s4-1 param 0) (ja-aframe 18.0 0))
    (set! (-> s4-1 param 1) 1.0)
    (set! (-> s4-1 frame-num) 0.0)
    (joint-control-channel-group!
     s4-1
     (the-as art-joint-anim (-> self draw art-group data 88))
     num-func-seek!
     )
    )
   (until (ja-done? 0)
    (suspend)
    (let ((s4-2 (-> self skel root-channel 0)))
     (set! (-> s4-2 param 0) (ja-aframe 18.0 0))
     (set! (-> s4-2 param 1) 1.0)
     (joint-control-channel-group-eval!
      s4-2
      (the-as art-joint-anim #f)
      num-func-seek!
      )
     )
    )
   (let ((s4-3 (-> (handle->process (the-as handle arg0)) entity))
         (s3-1
          (vector<-cspace!
           (new 'stack-no-clear 'vector)
           (-> self node-list data 7)
           )
          )
         )
    (dotimes (s2-0 50)
     (when (handle->process (the-as handle arg0))
      (let ((s1-0 (handle->process (the-as handle arg0)))
            (s0-0 (+ s2-0 4))
            )
       (set!
        sv-160
        (vector<-cspace!
         (new 'stack-no-clear 'vector)
         (-> (the-as process-drawable s1-0) node-list data s0-0)
         )
        )
       (set! sv-144 (get-process *default-dead-pool* powercellalt #x4000))
       (when sv-144
        (let ((t9-16 (method-of-type powercellalt activate)))
         (t9-16
          (the-as powercellalt sv-144)
          s1-0
          'powercellalt
          (the-as pointer #x70004000)
          )
         )
        (run-now-in-process
         sv-144
         powercellalt-init-by-other
         s4-3
         s3-1
         sv-160
         s0-0
         )
        (-> sv-144 ppointer)
        )
       )
      )
     (let ((s1-1 (-> *display* base-frame-counter)))
      (until (>= (- (-> *display* base-frame-counter) s1-1) 30)
       (suspend)
       )
      )
     (when (handle->process arg1)
      (let ((s1-2 (handle->process arg1))
            (s0-1 (+ s2-0 4))
            )
       (set!
        sv-192
        (vector<-cspace!
         (new 'stack-no-clear 'vector)
         (-> (the-as process-drawable s1-2) node-list data s0-1)
         )
        )
       (set! sv-176 (get-process *default-dead-pool* powercellalt #x4000))
       (when sv-176
        (let ((t9-20 (method-of-type powercellalt activate)))
         (t9-20
          (the-as powercellalt sv-176)
          s1-2
          'powercellalt
          (the-as pointer #x70004000)
          )
         )
        (run-now-in-process
         sv-176
         powercellalt-init-by-other
         s4-3
         s3-1
         sv-192
         s0-1
         )
        (-> sv-176 ppointer)
        )
       )
      )
     (let ((s1-3 (-> *display* base-frame-counter)))
      (until (>= (- (-> *display* base-frame-counter) s1-3) 30)
       (suspend)
       )
      )
     )
    )
   (let ((gp-1 (-> *display* base-frame-counter)))
    (until (>= (- (-> *display* base-frame-counter) gp-1) 600)
     (suspend)
     )
    )
   (let ((v0-22 (entity-by-name "sage-finalboss-1"))
         (a1-26 (new 'stack-no-clear 'event-message-block))
         )
    (set! (-> a1-26 from) self)
    (set! (-> a1-26 num-params) 0)
    (set! (-> a1-26 message) 'play-anim)
    (let ((v1-70 v0-22))
     (send-event-function (if v1-70
                           (-> v1-70 extra process)
                           )
      a1-26
      )
     )
    )
   (go target-stance)
   (none)
   )
  :post
  target-no-stick-post
  )