mirror of
https://github.com/open-goal/jak-project
synced 2026-06-01 09:48:00 -04:00
ManDude
24578b64b9
* hardcode `time-frame`things * Update cam-states_REF.gc * Update level-info_REF.gc * update refs 1 * update refs 2 * update refs 3 * update refs 4 * update refs 5 * update detection and casting * Update FormExpressionAnalysis.cpp * update refs 6 * update mood decomp * update refs 7 * update refs 8 * remove temp entity birth code * update time-frame casts * fix compiler * hardcode stuff and fix some types * fix some bitfield detection being wrong * bug fixes * detect seconds on adds with immediate * update refs 9 * fix casts and rand-vu-int-range bugs (update refs 10) * update refs 11 * update 12 * update 13 * update 14 * Update game-info_REF.gc * improve cpad macros detection * remove unused code * update refs * clang * update source code * Update cam-states.gc * `lavatube-energy` finish * update refs * fix actor bank stuff * Update navigate.gc * reduce entity default stack size * Update transformq-h.gc * oops forgot these * fix code and tests * fix mood sound stuff * Update load-dgo.gc * Update README.md
308 lines
12 KiB
Common Lisp
Vendored
Generated
308 lines
12 KiB
Common Lisp
Vendored
Generated
;;-*-Lisp-*-
|
|
(in-package goal)
|
|
|
|
;; definition of type fact-bank
|
|
(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
|
|
)
|
|
|
|
;; definition for method 3 of type fact-bank
|
|
(defmethod inspect fact-bank ((obj fact-bank))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Teco-level-max: ~f~%" (-> obj eco-level-max))
|
|
(format #t "~Teco-single-inc: ~f~%" (-> obj eco-single-inc))
|
|
(format #t "~Teco-full-inc: ~f~%" (-> obj eco-full-inc))
|
|
(format #t "~Teco-single-timeout: (seconds ~e)~%" (-> obj eco-single-timeout))
|
|
(format #t "~Teco-full-timeout: (seconds ~e)~%" (-> obj eco-full-timeout))
|
|
(format #t "~Tdummy: (seconds ~e)~%" (-> obj dummy))
|
|
(format #t "~Thealth-max-default: ~f~%" (-> obj health-max-default))
|
|
(format #t "~Thealth-single-inc: ~f~%" (-> obj health-single-inc))
|
|
(format #t "~Teco-pill-max-default: ~f~%" (-> obj eco-pill-max-default))
|
|
(format #t "~Thealth-small-inc: ~f~%" (-> obj health-small-inc))
|
|
(format #t "~Tbuzzer-max-default: ~f~%" (-> obj buzzer-max-default))
|
|
(format #t "~Tbuzzer-single-inc: ~f~%" (-> obj buzzer-single-inc))
|
|
(format #t "~Tsuck-bounce-dist: (meters ~m)~%" (-> obj suck-bounce-dist))
|
|
(format #t "~Tsuck-suck-dist: (meters ~m)~%" (-> obj suck-suck-dist))
|
|
(format #t "~Tdefault-pill-inc: ~f~%" (-> obj default-pill-inc))
|
|
obj
|
|
)
|
|
|
|
;; definition for symbol *FACT-bank*, type fact-bank
|
|
(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)
|
|
)
|
|
)
|
|
|
|
;; definition for function pickup-type->string
|
|
(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*"
|
|
)
|
|
)
|
|
)
|
|
|
|
;; definition of type fact-info
|
|
(deftype fact-info (basic)
|
|
((process process-drawable :offset-assert 4)
|
|
(pickup-type pickup-type :offset-assert 8)
|
|
(pickup-amount float :offset-assert 12)
|
|
(pickup-spawn-amount float :offset-assert 16)
|
|
(options fact-options :offset-assert 24)
|
|
(fade-time time-frame :offset-assert 32)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x28
|
|
:flag-assert #xc00000028
|
|
(:methods
|
|
(new (symbol type process-drawable pickup-type float) _type_ 0)
|
|
(drop-pickup (_type_ symbol process-tree fact-info int) (pointer process) 9)
|
|
(reset! (_type_ symbol) none 10)
|
|
(pickup-collectable! (_type_ pickup-type float handle) float 11)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type fact-info
|
|
(defmethod inspect fact-info ((obj fact-info))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tprocess: ~A~%" (-> obj process))
|
|
(format #t "~Tpickup-type: ~D~%" (-> obj pickup-type))
|
|
(format #t "~Tpickup-amount: ~f~%" (-> obj pickup-amount))
|
|
(format #t "~Tpickup-spawn-amount: ~f~%" (-> obj pickup-spawn-amount))
|
|
(format #t "~Toptions: ~D~%" (-> obj options))
|
|
(format #t "~Tfade-time: ~D~%" (-> obj fade-time))
|
|
obj
|
|
)
|
|
|
|
;; definition of type fact-info-target
|
|
(deftype fact-info-target (fact-info)
|
|
((eco-type pickup-type :offset-assert 40)
|
|
(eco-level float :offset-assert 44)
|
|
(eco-pickup-time time-frame :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 time-frame :offset-assert 88)
|
|
(eco-source handle :offset-assert 96)
|
|
(eco-source-time time-frame :offset-assert 104)
|
|
(money-pickup-time time-frame :offset-assert 112)
|
|
(buzzer-pickup-time time-frame :offset-assert 120)
|
|
(fuel-cell-pickup-time time-frame :offset-assert 128)
|
|
(eco-pill-pickup-time time-frame :offset-assert 136)
|
|
)
|
|
:method-count-assert 12
|
|
:size-assert #x90
|
|
:flag-assert #xc00000090
|
|
(:methods
|
|
(new (symbol type process-drawable pickup-type float) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type fact-info-target
|
|
(defmethod inspect fact-info-target ((obj fact-info-target))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tprocess: ~A~%" (-> obj process))
|
|
(format #t "~Tpickup-type: ~D~%" (-> obj pickup-type))
|
|
(format #t "~Tpickup-amount: ~f~%" (-> obj pickup-amount))
|
|
(format #t "~Tpickup-spawn-amount: ~f~%" (-> obj pickup-spawn-amount))
|
|
(format #t "~Toptions: ~D~%" (-> obj options))
|
|
(format #t "~Tfade-time: ~D~%" (-> obj fade-time))
|
|
(format #t "~Teco-type: ~D~%" (-> obj eco-type))
|
|
(format #t "~Teco-level: ~f~%" (-> obj eco-level))
|
|
(format #t "~Teco-pickup-time: ~D~%" (-> obj eco-pickup-time))
|
|
(format #t "~Teco-timeout: (seconds ~e)~%" (-> obj eco-timeout))
|
|
(format #t "~Thealth: ~f~%" (-> obj health))
|
|
(format #t "~Thealth-max: ~f~%" (-> obj health-max))
|
|
(format #t "~Tbuzzer: ~f~%" (-> obj buzzer))
|
|
(format #t "~Tbuzzer-max: ~f~%" (-> obj buzzer-max))
|
|
(format #t "~Teco-pill: ~f~%" (-> obj eco-pill))
|
|
(format #t "~Teco-pill-max: ~f~%" (-> obj eco-pill-max))
|
|
(format #t "~Thealth-pickup-time: ~D~%" (-> obj health-pickup-time))
|
|
(format #t "~Teco-source: ~D~%" (-> obj eco-source))
|
|
(format #t "~Teco-source-time: ~D~%" (-> obj eco-source-time))
|
|
(format #t "~Tmoney-pickup-time: ~D~%" (-> obj money-pickup-time))
|
|
(format #t "~Tbuzzer-pickup-time: ~D~%" (-> obj buzzer-pickup-time))
|
|
(format #t "~Tfuel-cell-pickup-time: ~D~%" (-> obj fuel-cell-pickup-time))
|
|
(format #t "~Teco-pill-pickup-time: ~D~%" (-> obj eco-pill-pickup-time))
|
|
obj
|
|
)
|
|
|
|
;; definition of type fact-info-enemy
|
|
(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-drawable pickup-type float) _type_ 0)
|
|
)
|
|
)
|
|
|
|
;; definition for method 3 of type fact-info-enemy
|
|
(defmethod inspect fact-info-enemy ((obj fact-info-enemy))
|
|
(format #t "[~8x] ~A~%" obj (-> obj type))
|
|
(format #t "~Tprocess: ~A~%" (-> obj process))
|
|
(format #t "~Tpickup-type: ~D~%" (-> obj pickup-type))
|
|
(format #t "~Tpickup-amount: ~f~%" (-> obj pickup-amount))
|
|
(format #t "~Tpickup-spawn-amount: ~f~%" (-> obj pickup-spawn-amount))
|
|
(format #t "~Toptions: ~D~%" (-> obj options))
|
|
(format #t "~Tfade-time: ~D~%" (-> obj fade-time))
|
|
(format #t "~Tspeed: ~f~%" (-> obj speed))
|
|
(format #t "~Tidle-distance: (meters ~m)~%" (-> obj idle-distance))
|
|
(format #t "~Tnotice-top: (meters ~m)~%" (-> obj notice-top))
|
|
(format #t "~Tnotice-bottom: (meters ~m)~%" (-> obj notice-bottom))
|
|
(format #t "~Tcam-horz: (meters ~m)~%" (-> obj cam-horz))
|
|
(format #t "~Tcam-vert: (meters ~m)~%" (-> obj cam-vert))
|
|
(format #t "~Tcam-notice-dist: (meters ~m)~%" (-> obj cam-notice-dist))
|
|
obj
|
|
)
|
|
|
|
;; definition for method 0 of type fact-info
|
|
;; Used lq/sq
|
|
(defmethod new fact-info ((allocation symbol) (type-to-make type) (proc process-drawable) (pkup-type pickup-type) (pkup-amount float))
|
|
(local-vars (tag res-tag))
|
|
(let ((obj (object-new allocation type-to-make (the-as int (-> type-to-make size)))))
|
|
(let ((ent (-> proc entity)))
|
|
(when (zero? obj)
|
|
(go process-drawable-art-error "memory")
|
|
(set! obj (the-as fact-info 0))
|
|
(goto cfg-10)
|
|
)
|
|
(set! (-> obj process) proc)
|
|
(set! tag (new 'static 'res-tag))
|
|
(let ((v1-6 (res-lump-data ent 'eco-info (pointer int32) :tag-ptr (& tag) :time 0.0)))
|
|
(cond
|
|
(v1-6
|
|
(let ((a0-6 (-> tag elt-count)))
|
|
(set! (-> obj pickup-type) (the-as pickup-type (-> v1-6 0)))
|
|
(set! pkup-amount (cond
|
|
((< (the-as uint 1) a0-6)
|
|
(the float (-> v1-6 1))
|
|
)
|
|
(else
|
|
(empty)
|
|
pkup-amount
|
|
)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj pickup-amount) pkup-amount)
|
|
)
|
|
(else
|
|
(set! (-> obj pickup-type) pkup-type)
|
|
(set! (-> obj pickup-amount) pkup-amount)
|
|
)
|
|
)
|
|
)
|
|
(set! (-> obj options) (res-lump-value ent 'options fact-options))
|
|
(if (logtest? (fact-options fade respawn) (-> obj options))
|
|
(set! (-> obj fade-time) (the-as time-frame (the int (* 300.0 (res-lump-float ent 'timeout)))))
|
|
)
|
|
)
|
|
(label cfg-10)
|
|
obj
|
|
)
|
|
)
|
|
|
|
;; definition for method 11 of type fact-info
|
|
(defmethod pickup-collectable! fact-info ((obj fact-info) (arg0 pickup-type) (arg1 float) (arg2 handle))
|
|
0.0
|
|
)
|
|
|
|
;; definition for method 0 of type fact-info-enemy
|
|
(defmethod new fact-info-enemy ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 pickup-type) (arg2 float))
|
|
(let ((obj (the-as fact-info-enemy ((method-of-type fact-info new) allocation type-to-make arg0 arg1 arg2))))
|
|
(let ((entity (-> 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
|
|
)
|
|
)
|
|
|
|
;; definition for method 0 of type fact-info-target
|
|
(defmethod new fact-info-target ((allocation symbol) (type-to-make type) (arg0 process-drawable) (arg1 pickup-type) (arg2 float))
|
|
(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 handle #f))
|
|
(reset! obj #f)
|
|
obj
|
|
)
|
|
)
|