mirror/jak-project
1
0
Fork 0
mirror of https://github.com/open-goal/jak-project synced 2026-08-18 05:48:28 -04:00
Code Issues Packages Projects Releases Wiki Activity

d/jak2: finish cty-guard-turret-button | race-h | height-map-h and a lot of rigid-body (#1957)

Browse Source 
Also cleaned up `data_decompiler.cpp` to make it a lot less verbose to
add a special case for an array field.
This commit is contained in:
Tyler Wilding
2022-10-11 23:20:36 -04:00
committed by GitHub
parent f7e1e73809
commit e3473c1902
197 changed files with 24065 additions and 614 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/decompiler/reference/jak2/levels/common/races/race-h_REF.gc
Generated Vendored
+357
View File
@@ -0,0 +1,357 @@
;;-*-Lisp-*-
(in-package goal)
;; definition of type race-turbo-pad
(deftype race-turbo-pad (structure)
((position vector :inline :offset-assert 0)
(handle uint64 :offset-assert 16)
)
:method-count-assert 9
:size-assert #x18
:flag-assert #x900000018
)
;; definition for method 3 of type race-turbo-pad
(defmethod inspect race-turbo-pad ((obj race-turbo-pad))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj 'race-turbo-pad)
(format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
(format #t "~1Thandle: ~D~%" (-> obj handle))
(label cfg-4)
obj
)
;; definition of type race-decision-point
(deftype race-decision-point (structure)
((pos float :offset-assert 0)
(decision-type uint8 :offset-assert 4)
(shortcuts uint8 :offset-assert 5)
(safe-paths uint8 :offset-assert 6)
)
:method-count-assert 9
:size-assert #x7
:flag-assert #x900000007
)
;; definition for method 3 of type race-decision-point
(defmethod inspect race-decision-point ((obj race-decision-point))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj 'race-decision-point)
(format #t "~1Tpos: ~f~%" (-> obj pos))
(format #t "~1Tdecision-type: ~D~%" (-> obj decision-type))
(format #t "~1Tshortcuts: ~D~%" (-> obj shortcuts))
(format #t "~1Tsafe-paths: ~D~%" (-> obj safe-paths))
(label cfg-4)
obj
)
;; definition of type race-racer-info
(deftype race-racer-info (structure)
((rider uint8 :offset-assert 0)
(vehicle uint8 :offset-assert 1)
(flags uint8 :offset-assert 2)
(seek-offset int8 :offset-assert 3)
)
:method-count-assert 9
:size-assert #x4
:flag-assert #x900000004
)
;; definition for method 3 of type race-racer-info
(defmethod inspect race-racer-info ((obj race-racer-info))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj 'race-racer-info)
(format #t "~1Trider: ~D~%" (-> obj rider))
(format #t "~1Tvehicle: ~D~%" (-> obj vehicle))
(format #t "~1Tflags: ~D~%" (-> obj flags))
(format #t "~1Tseek-offset: ~D~%" (-> obj seek-offset))
(label cfg-4)
obj
)
;; definition of type race-info
(deftype race-info (basic)
((race-mesh-name string :offset-assert 4)
(path-group-name string :offset-assert 8)
(task-node uint16 :offset-assert 12)
(mesh basic :offset-assert 16)
(ai-min-speed-factor float :offset-assert 20)
(ai-max-speed-factor float :offset-assert 24)
(ai-spread-factor float :offset-assert 28)
(start-sphere sphere :inline :offset-assert 32)
(start-dir vector :inline :offset-assert 48)
(finish-sphere sphere :inline :offset-assert 64)
(finish-dir vector :inline :offset-assert 80)
(player-intro-pos vector :inline :offset-assert 96)
(flags uint8 :offset-assert 112)
(score uint8 :offset-assert 113)
(lap-count int8 :offset-assert 114)
(racer-count int8 :offset-assert 115)
(turbo-pad-count int8 :offset-assert 116)
(map-index int8 :offset-assert 117)
(decision-point-count int8 :offset-assert 118)
(safe-paths uint8 :offset-assert 119)
(turbo-pad-array (inline-array race-turbo-pad) :offset-assert 120)
(racer-array (inline-array race-racer-info) :offset-assert 124)
(decision-point-array (inline-array race-decision-point) :offset-assert 128)
(level symbol :offset-assert 132)
(borrow-level symbol :offset-assert 136)
(borrow pair :offset-assert 140)
(manager uint64 :offset-assert 144)
(manager-handle-init-hack basic :offset 144)
(hatch-actor-name string :offset-assert 152)
(countdown-scene basic :offset-assert 156)
(complete-continue basic :offset-assert 160)
(start-camera string :offset-assert 164)
(go-speech uint16 :offset-assert 168)
)
:method-count-assert 10
:size-assert #xaa
:flag-assert #xa000000aa
(:methods
(race-info-method-9 (_type_) none 9)
)
)
;; definition for method 3 of type race-info
(defmethod inspect race-info ((obj race-info))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj (-> obj type))
(format #t "~1Trace-mesh-name: ~A~%" (-> obj race-mesh-name))
(format #t "~1Tpath-group-name: ~A~%" (-> obj path-group-name))
(format #t "~1Ttask-node: ~D~%" (-> obj task-node))
(format #t "~1Tmesh: ~A~%" (-> obj mesh))
(format #t "~1Tai-min-speed-factor: ~f~%" (-> obj ai-min-speed-factor))
(format #t "~1Tai-max-speed-factor: ~f~%" (-> obj ai-max-speed-factor))
(format #t "~1Tai-spread-factor: ~f~%" (-> obj ai-spread-factor))
(format #t "~1Tstart-sphere: #<sphere @ #x~X>~%" (-> obj start-sphere))
(format #t "~1Tstart-dir: #<vector @ #x~X>~%" (-> obj start-dir))
(format #t "~1Tfinish-sphere: #<sphere @ #x~X>~%" (-> obj finish-sphere))
(format #t "~1Tfinish-dir: #<vector @ #x~X>~%" (-> obj finish-dir))
(format #t "~1Tplayer-intro-pos: #<vector @ #x~X>~%" (-> obj player-intro-pos))
(format #t "~1Tflags: ~D~%" (-> obj flags))
(format #t "~1Tscore: ~D~%" (-> obj score))
(format #t "~1Tlap-count: ~D~%" (-> obj lap-count))
(format #t "~1Tracer-count: ~D~%" (-> obj racer-count))
(format #t "~1Tturbo-pad-count: ~D~%" (-> obj turbo-pad-count))
(format #t "~1Tmap-index: ~D~%" (-> obj map-index))
(format #t "~1Tdecision-point-count: ~D~%" (-> obj decision-point-count))
(format #t "~1Tsafe-paths: ~D~%" (-> obj safe-paths))
(format #t "~1Tturbo-pad-array: #x~X~%" (-> obj turbo-pad-array))
(format #t "~1Tracer-array: #x~X~%" (-> obj racer-array))
(format #t "~1Tdecision-point-array: #x~X~%" (-> obj decision-point-array))
(format #t "~1Tlevel: ~A~%" (-> obj level))
(format #t "~1Tborrow-level: ~A~%" (-> obj borrow-level))
(format #t "~1Tborrow: ~A~%" (-> obj borrow))
(format #t "~1Tmanager: ~D~%" (-> obj manager))
(format #t "~1Tmanager-handle-init-hack: ~A~%" (-> obj manager-handle-init-hack))
(format #t "~1Thatch-actor-name: ~A~%" (-> obj hatch-actor-name))
(format #t "~1Tcountdown-scene: ~A~%" (-> obj countdown-scene))
(format #t "~1Tcomplete-continue: ~A~%" (-> obj complete-continue))
(format #t "~1Tstart-camera: ~A~%" (-> obj start-camera))
(format #t "~1Tgo-speech: ~D~%" (-> obj go-speech))
(label cfg-4)
obj
)
;; definition of type racer-state
(deftype racer-state (structure)
((position vector :inline :offset-assert 0)
(racer uint64 :offset-assert 16)
(flags uint8 :offset-assert 24)
(rank int8 :offset-assert 25)
(finish-count int8 :offset-assert 26)
(lap-count int8 :offset-assert 27)
(lap-quadrant int8 :offset-assert 28)
(rider uint8 :offset-assert 29)
(lap-distance float :offset-assert 32)
(lap-distance-prev float :offset-assert 36)
(pos float :offset-assert 40)
(target-pos-offset float :offset-assert 44)
(speed-factor float :offset-assert 48)
(finish-time uint32 :offset-assert 52)
(lap-start uint32 :offset-assert 56)
(best-lap-time uint32 :offset-assert 60)
(lap-time-array float 5 :offset-assert 64)
(start-position vector :inline :offset-assert 96)
)
:method-count-assert 14
:size-assert #x70
:flag-assert #xe00000070
(:methods
(racer-state-method-9 () none 9)
(racer-state-method-10 () none 10)
(racer-state-method-11 () none 11)
(racer-state-method-12 () none 12)
(racer-state-method-13 () none 13)
)
)
;; definition for method 3 of type racer-state
(defmethod inspect racer-state ((obj racer-state))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj 'racer-state)
(format #t "~1Tposition: #<vector @ #x~X>~%" (-> obj position))
(format #t "~1Tracer: ~D~%" (-> obj racer))
(format #t "~1Tflags: ~D~%" (-> obj flags))
(format #t "~1Trank: ~D~%" (-> obj rank))
(format #t "~1Tfinish-count: ~D~%" (-> obj finish-count))
(format #t "~1Tlap-count: ~D~%" (-> obj lap-count))
(format #t "~1Tlap-quadrant: ~D~%" (-> obj lap-quadrant))
(format #t "~1Trider: ~D~%" (-> obj rider))
(format #t "~1Tlap-distance: ~f~%" (-> obj lap-distance))
(format #t "~1Tlap-distance-prev: ~f~%" (-> obj lap-distance-prev))
(format #t "~1Tpos: ~f~%" (-> obj pos))
(format #t "~1Ttarget-pos-offset: ~f~%" (-> obj target-pos-offset))
(format #t "~1Tspeed-factor: ~f~%" (-> obj speed-factor))
(format #t "~1Tfinish-time: ~D~%" (-> obj finish-time))
(format #t "~1Tlap-start: ~D~%" (-> obj lap-start))
(format #t "~1Tbest-lap-time: ~D~%" (-> obj best-lap-time))
(format #t "~1Tlap-time-array[5] @ #x~X~%" (-> obj lap-time-array))
(format #t "~1Tstart-position: #<vector @ #x~X>~%" (-> obj start-position))
(label cfg-4)
obj
)
;; definition of type race-state
(deftype race-state (structure)
((info basic :offset-assert 0)
(flags uint8 :offset-assert 4)
(state uint8 :offset-assert 5)
(racer-count int8 :offset-assert 6)
(finished-count int8 :offset-assert 7)
(i-player int8 :offset-assert 8)
(i-countdown int8 :offset-assert 9)
(manager uint64 :offset-assert 16)
(scene-player uint64 :offset-assert 24)
(race-signal uint64 :offset-assert 32)
(arrow uint64 :offset-assert 40)
(hud-timer uint64 :offset-assert 48)
(hud-lap-counter uint64 :offset-assert 56)
(hud-turbo-counter uint64 :offset-assert 64)
(hud-position uint64 :offset-assert 72)
(current-time uint32 :offset-assert 80)
(countdown-start-time uint32 :offset-assert 84)
(race-start-time uint32 :offset-assert 88)
(rankings int8 10 :offset-assert 92)
(target-pos float :offset-assert 104)
(suck-factor float :offset-assert 108)
(racer-array racer-state 10 :inline :offset-assert 112)
(player-intro-curve cubic-curve :inline :offset-assert 1232)
)
:method-count-assert 19
:size-assert #x510
:flag-assert #x1300000510
(:methods
(race-state-method-9 () none 9)
(race-state-method-10 () none 10)
(race-state-method-11 () none 11)
(race-state-method-12 () none 12)
(race-state-method-13 () none 13)
(race-state-method-14 () none 14)
(race-state-method-15 () none 15)
(race-state-method-16 () none 16)
(race-state-method-17 () none 17)
(race-state-method-18 () none 18)
)
)
;; definition for method 3 of type race-state
(defmethod inspect race-state ((obj race-state))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(format #t "[~8x] ~A~%" obj 'race-state)
(format #t "~1Tinfo: ~A~%" (-> obj info))
(format #t "~1Tflags: ~D~%" (-> obj flags))
(format #t "~1Tstate: ~D~%" (-> obj state))
(format #t "~1Tracer-count: ~D~%" (-> obj racer-count))
(format #t "~1Tfinished-count: ~D~%" (-> obj finished-count))
(format #t "~1Ti-player: ~D~%" (-> obj i-player))
(format #t "~1Ti-countdown: ~D~%" (-> obj i-countdown))
(format #t "~1Tmanager: #x~X~%" (-> obj manager))
(format #t "~1Tscene-player: #x~X~%" (-> obj scene-player))
(format #t "~1Trace-signal: #x~X~%" (-> obj race-signal))
(format #t "~1Tarrow: #x~X~%" (-> obj arrow))
(format #t "~1Thud-timer: #x~X~%" (-> obj hud-timer))
(format #t "~1Thud-lap-counter: #x~X~%" (-> obj hud-lap-counter))
(format #t "~1Thud-turbo-counter: #x~X~%" (-> obj hud-turbo-counter))
(format #t "~1Thud-position: #x~X~%" (-> obj hud-position))
(format #t "~1Tcurrent-time: ~D~%" (-> obj current-time))
(format #t "~1Tcountdown-start-time: ~D~%" (-> obj countdown-start-time))
(format #t "~1Trace-start-time: ~D~%" (-> obj race-start-time))
(format #t "~1Trankings[10] @ #x~X~%" (-> obj rankings))
(format #t "~1Ttarget-pos: ~f~%" (-> obj target-pos))
(format #t "~1Tsuck-factor: ~f~%" (-> obj suck-factor))
(format #t "~1Tracer-array[10] @ #x~X~%" (-> obj racer-array))
(format #t "~1Tplayer-intro-curve: #<cubic-curve @ #x~X>~%" (-> obj player-intro-curve))
(label cfg-4)
obj
)
;; definition of type race-manager
(deftype race-manager (process)
((race-state race-state :offset-assert 128)
(state-time time-frame :offset-assert 136)
(player-on-track-time time-frame :offset-assert 144)
(message-id uint32 :offset-assert 152)
(finish-sound-id uint32 :offset-assert 156)
)
:heap-base #x20
:method-count-assert 28
:size-assert #xa0
:flag-assert #x1c002000a0
(:methods
(idle () _type_ :state 14)
(active () _type_ :state 15)
(fail () _type_ :state 16)
(win () _type_ :state 17)
(lose () _type_ :state 18)
(die () _type_ :state 19)
(race-manager-method-20 () none 20)
(race-manager-method-21 () none 21)
(race-manager-method-22 () none 22)
(race-manager-method-23 () none 23)
(race-manager-method-24 () none 24)
(race-manager-method-25 () none 25)
(race-manager-method-26 () none 26)
(race-manager-method-27 () none 27)
)
)
;; definition for method 3 of type race-manager
(defmethod inspect race-manager ((obj race-manager))
(when (not obj)
(set! obj obj)
(goto cfg-4)
)
(let ((t9-0 (method-of-type process inspect)))
(t9-0 obj)
)
(format #t "~2Trace-state: #<race-state @ #x~X>~%" (-> obj race-state))
(format #t "~2Tstate-time: ~D~%" (-> obj state-time))
(format #t "~2Tplayer-on-track-time: ~D~%" (-> obj player-on-track-time))
(format #t "~2Tmessage-id: ~D~%" (-> obj message-id))
(format #t "~2Tfinish-sound-id: ~D~%" (-> obj finish-sound-id))
(label cfg-4)
obj
)
;; failed to figure out what this is:
0