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

;; name: generic-obs-h.gc
;; name in dgo: generic-obs-h
;; dgos: GAME, ENGINE

(define-extern mistycam-spawn (function none))
(define-extern beachcam-spawn (function none))

(declare-type camera-tracker process)
(define-extern process-grab? (function process symbol :behavior camera-tracker))
(define-extern process-release? (function process symbol :behavior process))

(define-extern fuel-cell type)

(define-extern birth-pickup-at-point (function vector pickup-type float symbol process-tree fact-info (pointer process) :behavior process))

(declare-type collide-shape-moving basic)
(declare-type sparticle-launch-group basic)
(declare-type part-tracker process)
(declare-type collide-prim-core structure)
(define-extern part-tracker-init (function sparticle-launch-group time-frame (function part-tracker none) (pointer process-drawable) process collide-prim-core none :behavior part-tracker))

(declare-type touch-tracker process-drawable)
(define-extern touch-tracker-init (function vector float time-frame none :behavior touch-tracker))

(define-extern eco-blue-glow (function vector none))

(declare-type joint-mod basic)

;; DECOMP BEGINS

;; generic-obs has general game "objects".  It's not related to the generic renderer.

;; A manipy is a way to draw and move something. More complicated objects that want to draw multiple
;; things may create a child manipy and then send it commands.
(deftype manipy (process-drawable)
  ((new-trans-hook       (function none)         :offset-assert 176)
   (cur-trans-hook       (function none)         :offset-assert 180)
   (cur-event-hook       (function none)         :offset-assert 184)
   (new-joint-anim       art-joint-anim          :offset-assert 188)
   (new-joint-anim-blend uint64                  :offset-assert 192)
   (anim-mode            symbol                  :offset-assert 200)
   (cur-grab-handle      handle                  :offset-assert 208)
   (cur-target-handle    handle                  :offset-assert 216)
   (old-grab-pos         vector          :inline :offset-assert 224)
   (joint                joint-mod       4       :offset-assert 240)
   (new-post-hook        (function none)         :offset-assert 256)
   (cur-post-hook        (function none)         :offset-assert 260)
   (clone-copy-trans     basic                   :offset-assert 264)
   (shadow-backup        basic                   :offset-assert 268)
   (draw?                symbol                  :offset-assert 272)
   )
  :heap-base #xb0
  :method-count-assert 20
  :size-assert         #x114
  :flag-assert         #x1400b00114
  (:states
    manipy-idle
    )
  )

;; A part-spawner simply spawns particles.
(deftype part-spawner (process-drawable)
  ((mode         (pointer sparticle-launch-group)         :offset-assert 176)
   (enable       symbol                                   :offset-assert 180)
   (radius       meters                                   :offset-assert 184)
   (world-sphere sphere                           :inline :offset-assert 192)
   )
  :heap-base #x60
  :method-count-assert 21
  :size-assert         #xd0
  :flag-assert         #x15006000d0
  (:methods
    (is-visible? (_type_) symbol 20)
    )
  (:states
    part-spawner-active
    )
  )

;; a part-tracker will spawn particles, then linger for a bit, and then finally die.
;; a more complicated object can use this to manage particles that do something interesting (like follow you)
(deftype part-tracker (process)
  ((root            trsqv                                    :offset-assert 112)
   (part            sparticle-launch-control                 :offset-assert 116)
   (target          handle                                   :offset-assert 120)
   (callback        (function part-tracker vector)           :offset-assert 128)
   (linger-callback (function part-tracker vector)           :offset-assert 132)
   (duration        time-frame                               :offset-assert 136)
   (linger-duration time-frame                               :offset-assert 144)
   (start-time      time-frame                               :offset-assert 152)
   (offset          vector                         :inline   :offset-assert 160)
   (userdata        uint64                                   :offset-assert 176)
   (user-time       time-frame                     2         :offset-assert 184)
   (user-vector     vector                         2 :inline :offset-assert 208)
   (user-handle     uint32                         2         :offset-assert 240)
   )
  :heap-base #x90
  :method-count-assert 14
  :size-assert         #xf8
  :flag-assert         #xe009000f8
  (:states
    part-tracker-process
    )
  )

;; a camera-tracker can control the camera.
(deftype camera-tracker (process)
  ((entity-override entity-actor     :offset         52)
   (grab-target     handle           :offset        120)
   (grab-event      symbol           :offset-assert 128)
   (release-event   symbol           :offset-assert 132)
   (old-global-mask uint32           :offset-assert 136)
   (old-self-mask   uint32           :offset-assert 140)
   (old-parent-mask uint32           :offset-assert 144)
   (look-at-target  handle           :offset-assert 152)
   (pov-target      handle           :offset-assert 160)
   (work-process    handle           :offset-assert 168)
   (anim-process    handle           :offset-assert 176)
   (start-time      time-frame       :offset-assert 184)
   (callback        basic            :offset-assert 192)
   (userdata        basic            :offset-assert 196)
   (message         basic            :offset-assert 200)
   (border-value    basic            :offset-assert 204)
   (mask-to-clear   uint32           :offset-assert 208)
   (script          pair             :offset-assert 212)
   (script-line     pair             :offset-assert 216)
   (script-func     (function none)  :offset-assert 220)
   )
  :heap-base #x70
  :method-count-assert 15
  :size-assert         #xe0
  :flag-assert         #xf007000e0
  (:methods
    (eval (_type_ pair) process 14)
    )
  (:states
    camera-tracker-process
    )
  )

;; a touch tracker waits to be touched, then calls some callback function.
(deftype touch-tracker (process-drawable)
  ((root-override collide-shape-moving           :offset        112)
   (duration      time-frame                     :offset-assert 176)
   (target        handle                         :offset-assert 184)
   (event         symbol                         :offset-assert 192)
   (run-function  (function object)              :offset-assert 196)
   (callback      (function touch-tracker none)  :offset-assert 200)
   (event-mode    basic                          :offset-assert 204)
   )
  :heap-base #x60
  :method-count-assert 20
  :size-assert         #xd0
  :flag-assert         #x14006000d0
  (:states
    touch-tracker-idle
    )
  )

;; the classic pole
(deftype swingpole (process)
  ((root        trsq           :offset-assert 112)
   (dir         vector :inline :offset-assert 128)
   (range       meters         :offset-assert 144)
   (edge-length meters         :offset-assert 148)
   )
  :heap-base #x30
  :method-count-assert 14
  :size-assert         #x98
  :flag-assert         #xe00300098
  (:states
    swingpole-active
    swingpole-stance
    )
  )

;; do you want to fish?
(deftype gui-query (structure)
  ((x-position        int32   :offset-assert   0)
   (y-position        int32   :offset-assert   4)
   (message           string  :offset-assert   8)
   (decision          symbol  :offset-assert  12)
   (only-allow-cancel symbol  :offset-assert  16)
   (no-msg            string  :offset-assert  20)
   (message-space     int32   :offset-assert  24)
   )
  :pack-me
  :method-count-assert 11
  :size-assert         #x1c
  :flag-assert         #xb0000001c
  (:methods
    (init! (_type_ string int int int symbol string) none 9)
    (get-response (_type_) symbol 10)
    )
  )

;; control the camera from something else (an animation)
(deftype othercam (process)
  ((hand              handle         :offset-assert 112)
   (old-global-mask   uint32         :offset-assert 120)
   (mask-to-clear     uint32         :offset-assert 124)
   (cam-joint-index   int32          :offset-assert 128)
   (old-pos           vector :inline :offset-assert 144)
   (old-mat-z         vector :inline :offset-assert 160)
   (had-valid-frame   basic          :offset-assert 176)
   (border-value      basic          :offset-assert 180)
   (die?              symbol         :offset-assert 184)
   (survive-anim-end? symbol         :offset-assert 188)
   (spooling?         symbol         :offset-assert 192)
   )
  :heap-base #x60
  :method-count-assert 14
  :size-assert         #xc4
  :flag-assert         #xe006000c4
  (:states
    othercam-running
    )
  )


;; don't draw it! I guess used to disable things during development.
(deftype process-hidden (process)
  ()
  :method-count-assert 15
  :size-assert         #x70
  :flag-assert         #xf00000070
  (:methods
    (die () _type_ :state 14)
    )
  )


0