jak-project/goal_src/engine/game/game-info-h.gc

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

; ;; name: game-info-h.gc
; ;; name in dgo: game-info-h
; ;; dgos: GAME, ENGINE

;; List of each task in the game.
;; Each task has a task-control associated with it, see task-control.gc
(defenum game-task
  :type uint8
  (none 0)
  (complete 1)
  (jungle-eggtop 2)
  (jungle-lurkerm 3)
  (jungle-tower 4)
  (jungle-fishgame 5)
  (jungle-plant 6)
  (jungle-buzzer 7)
  (jungle-canyon-end 8)
  (jungle-temple-door 9)
  (village1-yakow 10)
  (village1-mayor-money 11)
  (village1-uncle-money 12)
  (village1-oracle-money1 13)
  (village1-oracle-money2 14)
  (beach-ecorocks 15)
  (beach-pelican 16)
  (beach-flutflut 17)
  (beach-seagull 18)
  (beach-cannon 19)
  (beach-buzzer 20)
  (beach-gimmie 21)
  (beach-sentinel 22)
  (misty-muse 23)
  (misty-boat 24)
  (misty-warehouse 25)
  (misty-cannon 26)
  (misty-bike 27)
  (misty-buzzer 28)
  (misty-bike-jump 29)
  (misty-eco-challenge 30)
  (village2-gambler-money 31)
  (village2-geologist-money 32)
  (village2-warrior-money 33)
  (village2-oracle-money1 34)
  (village2-oracle-money2 35)
  (swamp-billy 36)
  (swamp-flutflut 37)
  (swamp-battle 38)
  (swamp-tether-1 39)
  (swamp-tether-2 40)
  (swamp-tether-3 41)
  (swamp-tether-4 42)
  (swamp-buzzer 43)
  (sunken-platforms 44)
  (sunken-pipe 45)
  (sunken-slide 46)
  (sunken-room 47)
  (sunken-sharks 48)
  (sunken-buzzer 49)
  (sunken-top-of-helix 50)
  (sunken-spinning-room 51)
  (rolling-race 52)
  (rolling-robbers 53)
  (rolling-moles 54)
  (rolling-plants 55)
  (rolling-lake 56)
  (rolling-buzzer 57)
  (rolling-ring-chase-1 58)
  (rolling-ring-chase-2 59)
  (snow-eggtop 60)
  (snow-ram 61)
  (snow-fort 62)
  (snow-ball 63)
  (snow-bunnies 64)
  (snow-buzzer 65)
  (snow-bumpers 66)
  (snow-cage 67)
  (firecanyon-buzzer 68)
  (firecanyon-end 69)
  (citadel-sage-green 70)
  (citadel-sage-blue 71)
  (citadel-sage-red 72)
  (citadel-sage-yellow 73)
  (village3-extra1 74)
  (village1-buzzer 75)
  (village2-buzzer 76)
  (village3-buzzer 77)
  (cave-gnawers 78)
  (cave-dark-crystals 79)
  (cave-dark-climb 80)
  (cave-robot-climb 81)
  (cave-swing-poles 82)
  (cave-spider-tunnel 83)
  (cave-platforms 84)
  (cave-buzzer 85)
  (ogre-boss 86)
  (ogre-end 87)
  (ogre-buzzer 88)
  (lavatube-end 89)
  (lavatube-buzzer 90)
  (citadel-buzzer 91)
  (training-gimmie 92)
  (training-door 93)
  (training-climb 94)
  (training-buzzer 95)
  (village3-miner-money1 96)
  (village3-miner-money2 97)
  (village3-miner-money3 98)
  (village3-miner-money4 99)
  (village3-oracle-money1 100)
  (village3-oracle-money2 101)
  (firecanyon-assistant 102)
  (village2-levitator 103)
  (swamp-arm 104)
  (village3-button 105)
  (red-eggtop 106)
  (lavatube-balls 107)
  (lavatube-start 108)
  (intro 109)
  (ogre-secret 110)
  (village4-button 111)
  (finalboss-movies 112)
  (plunger-lurker-hit 113)
  (leaving-misty 114)
  (assistant-village3 115)
  (max 116)
  (*unknown* 255))

;; Game parameters.
(deftype game-bank (basic)
  ((life-max-default   float  :offset-assert 4)
   (life-start-default float  :offset-assert 8)
   (life-single-inc    float  :offset-assert 12)
   (money-task-inc     float  :offset-assert 16)
   (money-oracle-inc   float  :offset-assert 20)
   )
  :method-count-assert 9
  :size-assert         #x18
  :flag-assert         #x900000018
  )

(define *GAME-bank* (new 'static 'game-bank
                         :life-max-default 99.000000
                         :life-start-default 5.000000
                         :life-single-inc 1.000000
                         :money-task-inc 90.000000
                         :money-oracle-inc 120.000000
                         )
  )

;; aid
(deftype actor-id (uint32)
  ()
  :flag-assert #x900000004
  )

;; the possible state for a level.
(deftype level-buffer-state (structure)
  ((name          basic  :offset-assert 0) ;; level name
   (display?      symbol :offset-assert 4) ;; should it be drawn?
   (force-vis?    symbol :offset-assert 8) ;; ? should it have its vis loaded?
   (force-inside? symbol :offset-assert 12) ;; ?
   )
  :pack-me
  :method-count-assert 9
  :size-assert         #x10
  :flag-assert         #x900000010
  )

(deftype load-state (basic)
  ((want          level-buffer-state  2 :inline  :offset-assert 4)
   (vis-nick      symbol     :offset-assert 36)
   (command-list  pair       :offset-assert 40)
   (object-name   symbol 256 :offset-assert 44)
   (object-status basic  256 :offset-assert 1068)
   )
  :method-count-assert 21
  :size-assert         #x82c
  :flag-assert         #x150000082c
  (:methods
    (new (symbol type) _type_ 0)
    (reset! (_type_) _type_ 9)
    (update! (_type_) int 10)
    (want-levels (_type_ symbol symbol) int 11)
    (want-display-level (_type_ symbol symbol) int 12)
    (want-vis (_type_ symbol) int 13)
    (want-force-vis (_type_ symbol symbol) int 14)
    (dummy-15 () none 15)
    (dummy-16 () none 16)
    (dummy-17 () none 17)
    (dummy-18 () none 18)
    (dummy-19 () none 19)
    (dummy-20 () none 20)
    )
  )

(defmethod new load-state ((allocation symbol) (type-to-make type))
  (reset!
   (object-new allocation type-to-make (the-as int (-> type-to-make size)))
   )
  )

(define-extern *load-state* load-state)

;; a game checkpoint
(deftype continue-point (basic)
  ((name          string         :offset-assert 4)
   (level         basic          :offset-assert 8)
   (flags         uint32         :offset-assert 12)
   (trans         vector :inline :offset-assert 16)
   (quat          quaternion :inline :offset-assert 32)
   (camera-trans  vector :inline :offset-assert 48)
   (camera-rot    float  9       :offset-assert 64)
   (load-commands pair           :offset-assert 100)
   (vis-nick      basic          :offset-assert 104)
   (lev0          basic          :offset-assert 108)
   (disp0         basic          :offset-assert 112)
   (lev1          basic          :offset-assert 116)
   (disp1         basic          :offset-assert 120)
   )
  :method-count-assert 10
  :size-assert         #x7c
  :flag-assert         #xa0000007c
  (:methods
    (debug-draw! (_type_) none 9)
    )
  )

(declare-type entity-perm structure)
(declare-type entity-perm-array basic)
(declare-type game-save basic)
;; Game Info is the full state of the game
;; this information can be saved/loaded from a game save.
;; also, it must be manually synchronized with entity permanent state in the levels
(deftype game-info (basic)
  ((mode                  symbol                        :offset-assert   4) ;; can be play/debug
   (save-name             basic                         :offset-assert   8)
   (life                  float                         :offset-assert  12)
   (life-max              float                         :offset-assert  16)
   (money                 float                         :offset-assert  20)
   (money-total           float                         :offset-assert  24)
   (money-per-level       uint8                      32 :offset-assert  28)
   (deaths-per-level      uint8                      32 :offset-assert  60)
   (buzzer-total          float                         :offset-assert  92)
   (fuel                  float                         :offset-assert  96)
   (perm-list             entity-perm-array             :offset-assert 100) ;; permament storage for entities
   (task-perm-list        entity-perm-array             :offset-assert 104) ;; permanent storage for task entities
   (current-continue      continue-point                :offset-assert 108)
   (text-ids-seen         bit-array                     :offset-assert 112)
   (level-opened          uint8                      32 :offset-assert 116)
   (hint-control          (array level-hint-control)    :offset-assert 148)
   (task-hint-control     array                         :offset-assert 152)
   (total-deaths          int32                         :offset-assert 156)
   (continue-deaths       int32                         :offset-assert 160)
   (fuel-cell-deaths      int32                         :offset-assert 164)
   (game-start-time       uint64                        :offset-assert 168)
   (continue-time         uint64                        :offset-assert 176)
   (death-time            uint64                        :offset-assert 184)
   (hit-time              uint64                        :offset-assert 192)
   (fuel-cell-pickup-time uint64                        :offset-assert 200)
   (fuel-cell-time        (array uint64)                :offset-assert 208)
   (enter-level-time      (array uint64)                :offset-assert 212)
   (in-level-time         (array uint64)                :offset-assert 216)
   (blackout-time         uint64                        :offset-assert 224)
   (letterbox-time        uint64                        :offset-assert 232)
   (hint-play-time        uint64                        :offset-assert 240)
   (display-text-time     uint64                        :offset-assert 248)
   (display-text-handle   uint64                        :offset-assert 256)
   (death-movie-tick      int32                         :offset-assert 264)
   (want-auto-save        symbol                        :offset-assert 268)
   (auto-save-proc        handle                        :offset-assert 272)
   (auto-save-status      uint32                        :offset-assert 280)
   (auto-save-card        int32                         :offset-assert 284)
   (auto-save-which       int32                         :offset-assert 288)
   (pov-camera-handle     uint64                        :offset-assert 296)
   (other-camera-handle   uint64                        :offset-assert 304)
   (death-pos             vector-array                  :offset-assert 312)
   (dummy                 basic                         :offset-assert 316)
   (auto-save-count       int32                         :offset-assert 320)
   )
  :method-count-assert 29
  :size-assert         #x144
  :flag-assert         #x1d00000144
  (:methods
   (initialize! (_type_ symbol game-save string) _type_ 9)
   (adjust (_type_ symbol float handle) float 10)
   (task-complete? (_type_ game-task) symbol 11)
   (lookup-entity-perm-by-aid (_type_ uint) entity-perm 12)
   (get-entity-task-perm (_type_ game-task) entity-perm 13)
   (copy-perms-from-level! (_type_ level) none 14)
   (copy-perms-to-level! (_type_ level) none 15)
   (debug-print (_type_ symbol) _type_ 16)
   (get-or-create-continue! (_type_) continue-point 17)
   (get-continue-by-name (_type_ string) continue-point 18)
   (set-continue! (_type_ basic) continue-point 19)
   (buzzer-count (_type_ game-task) int 20)
   (seen-text? (_type_ game-text-id) symbol 21)
   (mark-text-as-seen (_type_ game-text-id) none 22)
   (got-buzzer? (_type_ game-task int) symbol 23)
   (dummy-24 () none 24)
   (load-game! (_type_ game-save) game-save 25)
   (clear-text-seen! (_type_ game-text-id) none 26)
   (get-death-count (_type_ symbol) int 27)
   (get-health-percent-lost (_type_) float 28)
   )
  )

(define-extern *game-info* game-info)
(when (or (not *game-info*) (zero? *game-info*))
  (let ((temp (new 'static 'game-info :mode 'debug :current-continue #f)))
    (set! (-> temp fuel-cell-time) (new 'global 'boxed-array uint64 116))
    (set! (-> temp enter-level-time) (new 'global 'boxed-array uint64 32))
    (set! (-> temp in-level-time) (new 'global 'boxed-array uint64 32))
    (set! *game-info* temp)
    )
  )

(define-extern game-task->string (function game-task string))