mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 21:27:52 -04:00
235 lines
8.9 KiB
Common Lisp
235 lines
8.9 KiB
Common Lisp
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; name: fact-h.gc
|
|
;; name in dgo: fact-h
|
|
;; dgos: GAME, ENGINE
|
|
|
|
;; The fact bank is a single static object containing health/eco parameters
|
|
;; All game code should reference *FACT-bank* to determine these parameters
|
|
|
|
(deftype fact-bank (basic)
|
|
((eco-level-max float :offset-assert 4)
|
|
(eco-single-inc float :offset-assert 8)
|
|
(eco-full-inc float :offset-assert 12)
|
|
(eco-single-timeout seconds :offset-assert 16)
|
|
(eco-full-timeout seconds :offset-assert 24)
|
|
(dummy seconds :offset-assert 32)
|
|
(health-max-default float :offset-assert 40)
|
|
(health-single-inc float :offset-assert 44)
|
|
(eco-pill-max-default float :offset-assert 48)
|
|
(health-small-inc float :offset-assert 52)
|
|
(buzzer-max-default float :offset-assert 56)
|
|
(buzzer-single-inc float :offset-assert 60)
|
|
(suck-bounce-dist meters :offset-assert 64)
|
|
(suck-suck-dist meters :offset-assert 68)
|
|
(default-pill-inc float :offset-assert 72)
|
|
)
|
|
:method-count-assert 9
|
|
:size-assert #x4c
|
|
:flag-assert #x90000004c
|
|
)
|
|
|
|
(define *FACT-bank* (new 'static 'fact-bank
|
|
:eco-level-max 2.0
|
|
:eco-single-inc 1.0
|
|
:eco-full-inc 5.0
|
|
:eco-single-timeout (seconds 5)
|
|
:eco-full-timeout (seconds 20)
|
|
:dummy (seconds 15)
|
|
:health-max-default 3.0
|
|
:health-single-inc 1.0
|
|
:eco-pill-max-default 50.0
|
|
:health-small-inc 1.0
|
|
:buzzer-max-default 7.0
|
|
:buzzer-single-inc 1.0
|
|
:suck-bounce-dist (meters 18)
|
|
:suck-suck-dist (meters 7.5)
|
|
)
|
|
)
|
|
|
|
(defenum pickup-type
|
|
(none)
|
|
(eco-yellow)
|
|
(eco-red)
|
|
(eco-blue)
|
|
(eco-green)
|
|
(money)
|
|
(fuel-cell)
|
|
(eco-pill)
|
|
(buzzer)
|
|
(eco-pill-random)
|
|
)
|
|
|
|
(defun pickup-type->string ((arg0 pickup-type))
|
|
(case arg0
|
|
(((pickup-type eco-pill-random)) "eco-pill-random")
|
|
(((pickup-type buzzer)) "buzzer")
|
|
(((pickup-type eco-pill)) "eco-pill")
|
|
(((pickup-type fuel-cell)) "fuel-cell")
|
|
(((pickup-type money)) "money")
|
|
(((pickup-type eco-green)) "eco-green")
|
|
(((pickup-type eco-blue)) "eco-blue")
|
|
(((pickup-type eco-red)) "eco-red")
|
|
(((pickup-type eco-yellow)) "eco-yellow")
|
|
(((pickup-type none)) "none")
|
|
(else "*unknown*")
|
|
)
|
|
)
|
|
|
|
;; Each individual enemy and pickup process will allocate a fact-info on its process heap
|
|
;; The settings may be different per object - for example some eco pickups may have different
|
|
;; amounts or timings
|
|
;; The fact-info class stores data that is common to all fact-infos.
|
|
(deftype fact-info (basic)
|
|
((process process :offset-assert 4) ;; the process that this info is for
|
|
(pickup-type pickup-type :offset-assert 8)
|
|
(pickup-amount float :offset-assert 12) ;; eco increment on pickup
|
|
(pickup-spawn-amount float :offset-assert 16)
|
|
(options uint64 :offset-assert 24) ;; actually bitfield enum
|
|
(fade-time uint64 :offset-assert 32)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x28
|
|
:flag-assert #xc00000028
|
|
(:methods
|
|
(new (symbol type process pickup-type float) _type_ 0)
|
|
(dummy-9 () none 9)
|
|
(reset! (_type_ symbol) none 10)
|
|
(dummy-11 (_type_) float 11)
|
|
)
|
|
)
|
|
|
|
(deftype fact-info-target (fact-info)
|
|
((eco-type int32 :offset-assert 40)
|
|
(eco-level float :offset-assert 44)
|
|
(eco-pickup-time uint64 :offset-assert 48)
|
|
(eco-timeout seconds :offset-assert 56)
|
|
(health float :offset-assert 64)
|
|
(health-max float :offset-assert 68)
|
|
(buzzer float :offset-assert 72)
|
|
(buzzer-max float :offset-assert 76)
|
|
(eco-pill float :offset-assert 80)
|
|
(eco-pill-max float :offset-assert 84)
|
|
(health-pickup-time uint64 :offset-assert 88)
|
|
(eco-source uint64 :offset-assert 96)
|
|
(eco-source-time uint64 :offset-assert 104)
|
|
(money-pickup-time uint64 :offset-assert 112)
|
|
(buzzer-pickup-time uint64 :offset-assert 120)
|
|
(fuel-cell-pickup-time uint64 :offset-assert 128)
|
|
(eco-pill-pickup-time uint64 :offset-assert 136)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x90
|
|
:flag-assert #xc00000090
|
|
(:methods
|
|
(new (symbol type process pickup-type float) _type_ 0)
|
|
)
|
|
)
|
|
|
|
(deftype fact-info-enemy (fact-info)
|
|
((speed float :offset-assert 40)
|
|
(idle-distance meters :offset-assert 44)
|
|
(notice-top meters :offset-assert 48)
|
|
(notice-bottom meters :offset-assert 52)
|
|
(cam-horz meters :offset-assert 56)
|
|
(cam-vert meters :offset-assert 60)
|
|
(cam-notice-dist meters :offset-assert 64)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x44
|
|
:flag-assert #xc00000044
|
|
(:methods
|
|
(new (symbol type process pickup-type float) _type_ 0)
|
|
)
|
|
)
|
|
|
|
(defmethod new fact-info ((allocation symbol) (type-to-make type) (proc process) (pkup-type pickup-type) (pkup-amount float))
|
|
"Create information about a pickup. This should be called from a process which is a pickup. This will read settings from
|
|
the entity of the process automatically. Will attempt to read pickup-type and amount from the entity, but if this
|
|
fails will use the values in the arguments"
|
|
(local-vars (tag res-tag))
|
|
;; allocate.
|
|
(let ((obj (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(let ((ent (the res-lump (-> proc entity))))
|
|
;; confirm that we allocated successfully
|
|
(when (zero? obj)
|
|
(go process-drawable-art-error "memory")
|
|
;; this is already true...
|
|
(set! obj (the-as fact-info 0))
|
|
(goto cfg-10)
|
|
)
|
|
|
|
;; remember who we belong to
|
|
(set! (-> obj process) proc)
|
|
|
|
;; eco may override the pickup type and amount, so try to get this.
|
|
(let ((v1-6 (res-lump-data ent 'eco-info (pointer int32) :tag-ptr (& tag) :time 0.0)))
|
|
(cond
|
|
(v1-6
|
|
;; eco-info lookup succeeded,
|
|
(let ((a0-6 (-> tag elt-count)))
|
|
;; first thing is pickup type, it's always there
|
|
(set! (-> obj pickup-type) (the-as pickup-type (-> v1-6 0)))
|
|
;; pickup amount is optional.
|
|
(set! pkup-amount (if (< (the-as uint 1) (the-as uint a0-6))
|
|
(the float (-> v1-6 1))
|
|
pkup-amount
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj pickup-amount) pkup-amount)
|
|
)
|
|
(else
|
|
;; no eco-info, use stuff from args
|
|
(set! (-> obj pickup-type) pkup-type)
|
|
(set! (-> obj pickup-amount) pkup-amount)
|
|
)
|
|
)
|
|
)
|
|
|
|
;; read the options
|
|
(set! (-> obj options) (res-lump-value ent 'options uint))
|
|
|
|
;; TODO - some enum bitfield here.
|
|
(if (nonzero? (logand #x80200 (the-as int (-> obj options))))
|
|
(set! (-> obj fade-time) (the-as uint (the int (* 300.0 (res-lump-float ent 'timeout)))))
|
|
)
|
|
)
|
|
|
|
(label cfg-10)
|
|
obj
|
|
)
|
|
)
|
|
|
|
(defmethod dummy-11 fact-info ((obj fact-info))
|
|
0.0
|
|
)
|
|
|
|
(defmethod new fact-info-enemy ((allocation symbol) (type-to-make type) (proc process) (kind pickup-type) (amount float))
|
|
"Create information about an enemy. Possibly includes what the enemy will drop when it is killed?"
|
|
;; base class ctor
|
|
(let ((obj (the-as fact-info-enemy ((method-of-type fact-info new) allocation type-to-make proc kind amount))))
|
|
;; read values from the process entity
|
|
(let ((entity (the res-lump (-> obj process entity))))
|
|
(set! (-> obj speed) (res-lump-float entity 'speed :default 1.0))
|
|
(set! (-> obj idle-distance) (res-lump-float entity 'idle-distance :default 327680.0))
|
|
(set! (-> obj notice-top) (res-lump-float entity 'notice-top :default 4096000.0))
|
|
(set! (-> obj notice-bottom) (res-lump-float entity 'notice-bottom :default 4096000.0))
|
|
(set! (-> obj cam-horz) (res-lump-float entity 'cam-horz))
|
|
(set! (-> obj cam-vert) (res-lump-float entity 'cam-vert))
|
|
(set! (-> obj cam-notice-dist) (res-lump-float entity 'cam-notice-dist :default -4096.0))
|
|
)
|
|
obj
|
|
)
|
|
)
|
|
|
|
(defmethod new fact-info-target ((allocation symbol) (type-to-make type) (arg0 process) (arg1 pickup-type) (arg2 float))
|
|
"Create information about target. Not sure why this has stuff like pickup-type."
|
|
(let ((obj (the-as fact-info-target ((method-of-type fact-info new) allocation type-to-make arg0 arg1 arg2))))
|
|
(set! (-> obj eco-source) (the-as uint #f))
|
|
(reset! obj #f)
|
|
obj
|
|
)
|
|
)
|