2021-12-30 18:48:37 -05:00
;;-*-Lisp-*-
( in-package goal )
#|
This file contains code that we need for the PC port of the game specifically.
It should be included as part of the game engine package ( engine.cgo ) .
This file contains various types and functions to store PC-specific information
and also to communicate between the game ( GOAL ) and the operating system.
This way we can poll, change and display information about the system the game
is running on, such as:
- display devices and their settings, such as fullscreen, DPI, refresh rate, etc.
- audio devices and their settings, such as audio latency, channel number, etc.
- graphics devices and their settings, such as resolution, FPS, anisotropy, shaders, etc.
- input devices and their settings, such as controllers, keyboards, mice, etc.
- information about the game window ( position, size )
- PC-specific goodies, enhancements, fixes and settings.
- whatever else.
If you do not want to include these PC things, you should exclude it from the build system.
| #
( # when PC_PORT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; updates
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
( defmethod set-fullscreen! pc-settings ( ( obj pc-settings ) ( mode symbol ) )
"toggles fullscreen mode"
( if ( = ( -> obj fullscreen? ) mode ) ;; already fullscreen
( return 0 ) )
( set! ( -> obj fullscreen? ) mode )
( pc-set-fullscreen
( cond ( ( = mode 'borderless ) 2 )
( mode 1 )
( else 0 )
)
0 )
0 )
( defmethod set-size! pc-settings ( ( obj pc-settings ) ( width int ) ( height int ) )
"toggles fullscreen mode"
( pc-set-window-size width height )
0 )
( defmethod set-aspect! pc-settings ( ( obj pc-settings ) ( aw int ) ( ah int ) )
( let ( ( aspect ( / ( the float aw ) ( the float ah ) ) ) )
2022-01-08 13:39:17 -05:00
( set-aspect-ratio! obj aspect )
( set! ( -> obj aspect-ratio-auto? ) # f )
( set! ( -> obj use-vis? ) # f )
2021-12-30 18:48:37 -05:00
)
0 )
2022-01-08 13:39:17 -05:00
( defmethod set-aspect-ratio! pc-settings ( ( obj pc-settings ) ( aspect float ) )
( set! ( -> obj aspect-ratio ) aspect )
( set! ( -> obj aspect-ratio-scale ) ( / aspect ASPECT_4X3 ) )
( set! ( -> obj aspect-ratio-reciprocal ) ( / ASPECT_4X3 aspect ) )
0 )
2021-12-30 18:48:37 -05:00
( defmethod update-from-os pc-settings ( ( obj pc-settings ) )
"Update settings from the PC kernel to GOAL."
( set! ( -> obj os ) ( pc-get-os ) )
( pc-get-window-size ( &-> obj win-width ) ( &-> obj win-height ) )
( pc-get-window-scale ( &-> obj dpi-x ) ( &-> obj dpi-y ) )
( when ( -> obj use-vis? )
( if ( = ( -> *setting-control* default aspect-ratio ) 'aspect4x3 )
2022-01-08 13:39:17 -05:00
( set-aspect-ratio! obj ASPECT_4X3 )
( set-aspect-ratio! obj ASPECT_16X9 )
2021-12-30 18:48:37 -05:00
)
)
( let ( ( win-aspect ( / ( the float ( -> obj win-width ) ) ( the float ( -> obj win-height ) ) ) ) )
( cond
( ( and ( not ( -> obj use-vis? ) ) ( -> obj aspect-ratio-auto? ) )
;; the window determines the resolution
2022-01-08 13:39:17 -05:00
( set-aspect-ratio! obj win-aspect )
2021-12-30 18:48:37 -05:00
( set! ( -> obj width ) ( -> obj win-width ) )
( set! ( -> obj height ) ( -> obj win-height ) )
)
( ( > win-aspect ( -> obj aspect-ratio ) )
;; too wide
( set! ( -> obj width ) ( the int ( * ( -> obj aspect-ratio ) ( the float ( -> obj win-height ) ) ) ) )
( set! ( -> obj height ) ( -> obj win-height ) )
)
( ( < win-aspect ( -> obj aspect-ratio ) )
;; too tall
( set! ( -> obj width ) ( -> obj win-width ) )
( set! ( -> obj height ) ( the int ( / ( the float ( -> obj win-width ) ) ( -> obj aspect-ratio ) ) ) )
)
( else
;; just right
( set! ( -> obj width ) ( -> obj win-width ) )
( set! ( -> obj height ) ( -> obj win-height ) )
)
)
)
( none ) )
( defmethod update-to-os pc-settings ( ( obj pc-settings ) )
"Update settings from GOAL to the PC kernel."
( cond
( ( -> obj letterbox? )
( pc-set-letterbox ( -> obj width ) ( -> obj height ) )
)
( else
( pc-set-letterbox ( -> obj win-width ) ( -> obj win-height ) )
)
)
2022-02-07 23:53:36 -05:00
( cond
( ( -> obj discord-rpc? )
( pc-discord-rpc-set 1 )
)
( else
( pc-discord-rpc-set 0 )
)
)
2022-02-15 18:42:48 -05:00
( when # t ;; (not (-> obj ps2-lod-dist?))
( pc-renderer-tree-set-lod ( pc-renderer-tree-type tfrag3 ) ( -> obj lod-force-tfrag ) )
( pc-renderer-tree-set-lod ( pc-renderer-tree-type tie3 ) ( -> obj lod-force-tie ) )
)
2021-12-30 18:48:37 -05:00
( none ) )
( defmethod update pc-settings ( ( obj pc-settings ) )
" Update settings to/from PC kernel. Call this at the start of every frame.
This will update things like the aspect-ratio, which will be used for graphics code later. "
( update-from-os obj )
( update-to-os obj )
2022-02-07 23:53:36 -05:00
( let ( ( info ( new 'stack 'discord-info ) ) )
( set! ( -> info fuel ) ( &-> *game-info* fuel ) )
( set! ( -> info money-total ) ( &-> *game-info* money-total ) )
( set! ( -> info buzzer-total ) ( &-> *game-info* buzzer-total ) )
( set! ( -> info status ) "Playing Jak and Daxter: TPL" )
( set! ( -> info level ) ( if *target*
( symbol->string ( -> *target* current-level name ) ) ;; use target's level if it exists
( symbol->string ( -> ( level-get-target-inside *level* ) name ) ) ;; use camera's level otherwise
)
)
( set! ( -> info cutscene? ) ( movie? ) )
( pc-discord-rpc-update info )
)
2022-01-08 13:39:17 -05:00
( when ( not ( -> obj use-vis? ) )
( set! ( -> *video-parms* relative-x-scale ) ( -> obj aspect-ratio-reciprocal ) )
( set! ( -> *video-parms* relative-x-scale-reciprical ) ( -> obj aspect-ratio-scale ) )
2021-12-30 18:48:37 -05:00
( set! ( -> *font-default-matrix* vector 0 x ) ( -> *video-parms* relative-x-scale ) )
)
2022-01-08 13:39:17 -05:00
( when ( not ( -> obj use-vis? ) )
( when *progress-process*
;; adjust sizes for progress.
;; video.gc sets the sizes in the normal game.
( let ( ( pr ( -> *progress-process* ) )
( wide-adjust ( * 4.0 ( - ( / ( -> obj aspect-ratio-scale ) ASPECT_16X9_SCALE ) ( 1/ ASPECT_16X9_SCALE ) ) ) )
)
( set! ( -> pr sides-x-scale ) 1.0 )
( set! ( -> pr sides-y-scale ) 13.0 )
;(set! (-> pr left-x-offset) (+ 59 (the int (* (-> obj aspect-ratio-scale) -59))))
;(set! (-> pr right-x-offset) 26)
;(set! (-> pr button-scale) (+ 1.0 (* wide-adjust 0.1)))
)
)
)
2022-02-12 12:26:19 -05:00
( cond
( ( actor-force-visible? obj )
2022-02-07 19:15:37 -05:00
( set! ( -> *ACTOR-bank* birth-dist ) ( meters 10000 ) )
( set! ( -> *ACTOR-bank* pause-dist ) ( meters 10000 ) )
2022-02-12 12:26:19 -05:00
( set! ( -> *ACTOR-bank* birth-max ) 1000 )
2022-02-07 19:15:37 -05:00
)
2022-02-12 12:26:19 -05:00
( ( > ( -> *ACTOR-bank* birth-dist ) ( meters 220 ) )
( set! ( -> *ACTOR-bank* birth-dist ) ( meters 220 ) )
( set! ( -> *ACTOR-bank* pause-dist ) ( meters 220 ) )
) )
2021-12-30 18:48:37 -05:00
( none ) )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
( when *debug-segment*
( defmethod draw pc-settings ( ( obj pc-settings ) ( buf dma-buffer ) )
"debug draw"
( clear *pc-temp-string* )
( format *pc-temp-string* "game resolution: ~D x ~D~%" ( -> obj width ) ( -> obj height ) )
( format *pc-temp-string* "window size: ~D x ~D (~,,1f x ~,,1f)~%" ( -> obj win-width ) ( -> obj win-height ) ( -> obj dpi-x ) ( -> obj dpi-y ) )
( format *pc-temp-string* "target aspect: ~,,3f/~,,3f A: ~A/~A L: ~A~%" ( -> obj aspect-ratio ) ( / ( the float ( -> obj win-width ) ) ( the float ( -> obj win-height ) ) ) ( -> obj aspect-ratio-auto? ) ( -> obj use-vis? ) ( -> obj letterbox? ) )
( format *pc-temp-string* "fullscreen: ~A ~A~%" ( -> obj fullscreen? ) ( -> obj vsync? ) )
2022-01-08 13:39:17 -05:00
( draw-string-xy *pc-temp-string* buf 0 ( - 224 ( * 8 4 ) ) ( font-color default ) ( font-flags shadow kerning ) )
2021-12-30 18:48:37 -05:00
( none ) )
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; file IO
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
( defmacro file-stream-seek-until ( fs func-name )
` ( let ( ( done? # f )
( tell -1 ) )
( until done?
( let ( ( read ( file-stream-read , fs ( -> *pc-temp-string* data ) PC_TEMP_STRING_LEN ) ) )
( cond
( ( zero? read )
( set! ( -> *pc-temp-string* data read ) 0 )
( true! done? )
)
( else
( dotimes ( i read )
( when ( , func-name ( -> *pc-temp-string* data i ) )
( true! done? )
( set! tell ( + i ( - ( file-stream-tell , fs ) read ) ) )
( set! i read )
)
)
)
)
)
)
( if ( != tell -1 )
( file-stream-seek , fs tell SCE_SEEK_SET )
tell
)
)
)
( defmacro file-stream-read-until ( fs func-name )
` ( let ( ( read ( file-stream-read , fs ( -> *pc-temp-string* data ) PC_TEMP_STRING_LEN ) ) )
( dotimes ( i read )
( when ( , func-name ( -> *pc-temp-string* data i ) )
( set! ( -> *pc-temp-string* data i ) 0 )
( file-stream-seek , fs ( + i ( - ( file-stream-tell , fs ) read ) ) SCE_SEEK_SET )
( set! i read )
)
)
*pc-temp-string*
)
)
( defmacro is-whitespace-or-bracket? ( c )
` ( or ( is-whitespace-char? , c ) ( = #x28 , c ) ( = #x29 , c ) )
)
( defun file-stream-seek-past-whitespace ( ( file file-stream ) )
( file-stream-seek-until file not-whitespace-char? )
)
( defun file-stream-read-word ( ( file file-stream ) )
( file-stream-read-until file is-whitespace-or-bracket? )
;(format 0 "word ~A~%" *pc-temp-string*)
)
( defmacro file-stream-getc ( fs )
` ( let ( ( buf 255 ) )
( file-stream-read , fs ( & buf ) 1 )
;(format 0 "getc got #x~X~%" buf)
buf
)
)
( defun file-stream-read-int ( ( file file-stream ) )
( file-stream-seek-past-whitespace file )
( file-stream-read-word file )
( string->int *pc-temp-string* )
)
( defun file-stream-read-float ( ( file file-stream ) )
( file-stream-seek-past-whitespace file )
( file-stream-read-word file )
( string->float *pc-temp-string* )
)
( defun file-stream-read-symbol ( ( file file-stream ) )
( file-stream-seek-past-whitespace file )
( file-stream-read-word file )
2022-01-02 18:02:10 -05:00
( case-str *pc-temp-string*
( ( "#f" ) # f )
( ( "#t" ) # t )
( ( "aspect4x3" ) 'aspect4x3 )
( ( "aspect16x9" ) 'aspect16x9 )
( ( "borderless" ) 'borderless )
2021-12-30 18:48:37 -05:00
( else # t )
)
)
( defmacro pc-settings-read-throw-error ( fs msg )
"not an actual throw..."
` ( begin
( format 0 "pc settings read error: ~S~%" , msg )
( file-stream-close , fs )
( return # f )
)
)
( defmacro with-settings-scope ( bindings &rest body )
( let ( ( fs ( first bindings ) ) )
` ( begin
( file-stream-seek-past-whitespace , fs )
( when ( != #x28 ( file-stream-getc , fs ) )
( pc-settings-read-throw-error , fs "invalid char, ( not found" )
)
,@ body
( file-stream-seek-past-whitespace , fs )
( when ( != #x29 ( file-stream-getc , fs ) )
( pc-settings-read-throw-error , fs "invalid char, ) not found" )
)
)
)
)
( defmacro dosettings ( bindings &rest body )
" iterate over a list of key-value pairs like so: ( <key> <value> ) ( <key> <value> ) . . .
the name of key is stored in *pc-temp-string* "
( let ( ( fs ( first bindings ) ) )
` ( let ( ( c -1 ) )
( while ( begin ( file-stream-seek-past-whitespace , fs ) ( set! c ( file-stream-getc , fs ) ) ( = #x28 c ) )
( file-stream-read-word , fs )
,@ body
( file-stream-seek-past-whitespace , fs )
( set! c ( file-stream-getc , fs ) )
( when ( != #x29 c )
( pc-settings-read-throw-error , fs ( string-format "invalid char, ) not found, got #x~X ~A" c *pc-temp-string* ) )
)
)
( file-stream-seek , fs -1 SCE_SEEK_CUR )
)
)
)
( defmethod read-from-file pc-settings ( ( obj pc-settings ) ( filename string ) )
"read settings from a file"
( if ( not filename )
( return # f ) )
( let ( ( file ( new 'stack 'file-stream filename 'read ) ) )
( if ( not ( file-stream-valid? file ) )
( return # f ) )
( let ( ( version PC_KERNEL_VERSION ) )
( with-settings-scope ( file )
( file-stream-read-word file )
2022-01-02 18:02:10 -05:00
( case-str *pc-temp-string*
( ( "settings" )
2021-12-30 18:48:37 -05:00
( set! version ( file-stream-read-int file ) )
( dosettings ( file )
2022-01-02 18:02:10 -05:00
( case-str *pc-temp-string*
( ( "fps" ) ( set! ( -> obj target-fps ) ( file-stream-read-int file ) ) )
( ( "size" )
2021-12-30 18:48:37 -05:00
( set! ( -> obj width ) ( file-stream-read-int file ) )
( set! ( -> obj height ) ( file-stream-read-int file ) )
( set-size! obj ( -> obj width ) ( -> obj height ) )
( set-aspect! obj ( -> obj width ) ( -> obj height ) )
)
2022-01-02 18:02:10 -05:00
( ( "aspect" )
2021-12-30 18:48:37 -05:00
( set! ( -> obj aspect-custom-x ) ( file-stream-read-int file ) )
( set! ( -> obj aspect-custom-y ) ( file-stream-read-int file ) )
)
2022-01-02 18:02:10 -05:00
( ( "aspect-auto" ) ( set! ( -> obj aspect-ratio-auto? ) ( file-stream-read-symbol file ) ) )
2022-01-09 17:43:13 -05:00
( ( "aspect-game" ) ( set! ( -> obj aspect-setting ) ( file-stream-read-symbol file ) ) )
2022-01-02 18:02:10 -05:00
( ( "fullscreen" ) ( set-fullscreen! obj ( file-stream-read-symbol file ) ) )
( ( "letterbox" ) ( set! ( -> obj letterbox? ) ( file-stream-read-symbol file ) ) )
( ( "vsync" ) ( set! ( -> obj vsync? ) ( file-stream-read-symbol file ) ) )
( ( "font-scale" ) ( set! ( -> obj font-scale ) ( file-stream-read-float file ) ) )
( ( "audio-latency-ms" ) ( set! ( -> obj audio-latency-ms ) ( file-stream-read-int file ) ) )
( ( "audio-pan-override" ) ( set! ( -> obj audio-pan-override ) ( file-stream-read-float file ) ) )
( ( "audio-volume-override" ) ( set! ( -> obj audio-volume-override ) ( file-stream-read-float file ) ) )
( ( "audio-channel-nb" ) ( set! ( -> obj audio-channel-nb ) ( file-stream-read-int file ) ) )
( ( "gfx-renderer" ) ( set! ( -> obj gfx-renderer ) ( the-as pc-gfx-renderer ( file-stream-read-int file ) ) ) )
( ( "gfx-resolution" ) ( set! ( -> obj gfx-resolution ) ( file-stream-read-float file ) ) )
( ( "gfx-anisotropy" ) ( set! ( -> obj gfx-anisotropy ) ( file-stream-read-float file ) ) )
( ( "shrub-dist-mod" ) ( set! ( -> obj shrub-dist-mod ) ( file-stream-read-float file ) ) )
( ( "lod-dist-mod" ) ( set! ( -> obj lod-dist-mod ) ( file-stream-read-float file ) ) )
( ( "lod-force-tfrag" ) ( set! ( -> obj lod-force-tfrag ) ( file-stream-read-int file ) ) )
( ( "lod-force-tie" ) ( set! ( -> obj lod-force-tie ) ( file-stream-read-int file ) ) )
( ( "lod-force-ocean" ) ( set! ( -> obj lod-force-ocean ) ( file-stream-read-int file ) ) )
( ( "lod-force-actor" ) ( set! ( -> obj lod-force-actor ) ( file-stream-read-int file ) ) )
( ( "subtitle-language" ) ( set! ( -> obj subtitle-language ) ( the-as pc-subtitle-lang ( file-stream-read-int file ) ) ) )
( ( "stick-deadzone" ) ( set! ( -> obj stick-deadzone ) ( file-stream-read-float file ) ) )
( ( "ps2-read-speed?" ) ( set! ( -> obj ps2-read-speed? ) ( file-stream-read-symbol file ) ) )
( ( "ps2-parts?" ) ( set! ( -> obj ps2-parts? ) ( file-stream-read-symbol file ) ) )
( ( "ps2-music?" ) ( set! ( -> obj ps2-music? ) ( file-stream-read-symbol file ) ) )
( ( "ps2-se?" ) ( set! ( -> obj ps2-se? ) ( file-stream-read-symbol file ) ) )
( ( "ps2-hints?" ) ( set! ( -> obj ps2-hints? ) ( file-stream-read-symbol file ) ) )
( ( "ps2-lod-dist?" ) ( set! ( -> obj ps2-lod-dist? ) ( file-stream-read-symbol file ) ) )
( ( "music-fade?" ) ( set! ( -> obj music-fade? ) ( file-stream-read-symbol file ) ) )
( ( "use-vis?" ) ( set! ( -> obj use-vis? ) ( file-stream-read-symbol file ) ) )
( ( "skip-movies?" ) ( set! ( -> obj skip-movies? ) ( file-stream-read-symbol file ) ) )
( ( "subtitles?" ) ( set! ( -> obj subtitles? ) ( file-stream-read-symbol file ) ) )
( ( "hinttitles?" ) ( set! ( -> obj hinttitles? ) ( file-stream-read-symbol file ) ) )
( ( "scenes-seen" )
2021-12-30 18:48:37 -05:00
( dotimes ( i 197 )
( set! ( -> obj scenes-seen i ) ( file-stream-read-int file ) )
)
)
2022-01-02 18:02:10 -05:00
( ( "fixes" )
2021-12-30 18:48:37 -05:00
( dosettings ( file )
2022-01-02 18:02:10 -05:00
( case-str *pc-temp-string*
( ( "crash-sagecage" ) ( set! ( -> obj fixes crash-sagecage ) ( file-stream-read-symbol file ) ) )
( ( "crash-dma" ) ( set! ( -> obj fixes crash-dma ) ( file-stream-read-symbol file ) ) )
( ( "crash-light-eco" ) ( set! ( -> obj fixes crash-light-eco ) ( file-stream-read-symbol file ) ) )
( ( "lockout-pelican" ) ( set! ( -> obj fixes lockout-pelican ) ( file-stream-read-symbol file ) ) )
( ( "lockout-pipegame" ) ( set! ( -> obj fixes lockout-pipegame ) ( file-stream-read-symbol file ) ) )
( ( "lockout-gambler" ) ( set! ( -> obj fixes lockout-gambler ) ( file-stream-read-symbol file ) ) )
( ( "fix-movies" ) ( set! ( -> obj fixes fix-movies ) ( file-stream-read-symbol file ) ) )
( ( "fix-credits" ) ( set! ( -> obj fixes fix-credits ) ( file-stream-read-symbol file ) ) )
2021-12-30 18:48:37 -05:00
)
)
)
2022-01-02 18:02:10 -05:00
( ( "secrets" )
2021-12-30 18:48:37 -05:00
( dosettings ( file )
2022-01-02 18:02:10 -05:00
( case-str *pc-temp-string*
( ( "hard-rats?" ) ( set! ( -> obj secrets hard-rats? ) ( file-stream-read-symbol file ) ) )
( ( "hero-mode?" ) ( set! ( -> obj secrets hero-mode? ) ( file-stream-read-symbol file ) ) )
( ( "hud-map?" ) ( set! ( -> obj secrets hud-map? ) ( file-stream-read-symbol file ) ) )
( ( "hud-counters?" ) ( set! ( -> obj secrets hud-counters? ) ( file-stream-read-symbol file ) ) )
( ( "art" ) ( set! ( -> obj secrets art ) ( the-as pc-jak1-concept-art ( file-stream-read-int file ) ) ) )
( ( "hard-fish-hiscore" ) ( set! ( -> obj secrets hard-fish-hiscore ) ( file-stream-read-int file ) ) )
( ( "hard-rats-hiscore" ) ( set! ( -> obj secrets hard-rats-hiscore ) ( file-stream-read-int file ) ) )
( ( "hard-rats-hiwave" ) ( set! ( -> obj secrets hard-rats-hiwave ) ( file-stream-read-int file ) ) )
( ( "music" )
2021-12-30 18:48:37 -05:00
( dotimes ( i 30 )
( set! ( -> obj secrets music i ) ( file-stream-read-int file ) )
)
)
)
)
)
2022-01-02 18:02:10 -05:00
( ( "panic" )
2021-12-30 18:48:37 -05:00
( when ( file-stream-read-symbol file )
( file-stream-close file )
( reset obj )
( write-to-file obj filename )
( set-fullscreen! obj # f )
( return # f )
)
)
)
)
)
)
)
( when ( != PC_KERNEL_VERSION version )
( cond
( ( = ( logand version #xffffffff00000000 ) ( logand PC_KERNEL_VERSION #xffffffff00000000 ) )
;; minor difference
)
( else
;; major difference
( format 0 "PC kernel version mismatch! Got ~D.~D vs ~D.~D~%" PC_KERNEL_VERSION_MAJOR PC_KERNEL_VERSION_MINOR ( bit-field int version 32 16 ) ( bit-field int version 48 16 ) )
)
)
)
)
( file-stream-close file )
)
( format 0 "pc settings file read: ~A~%" filename )
# t
)
( defmethod write-to-file pc-settings ( ( obj pc-settings ) ( filename string ) )
"write settings to a file"
( if ( not filename )
( return # f ) )
( let ( ( file ( new 'stack 'file-stream filename 'write ) ) )
( if ( not ( file-stream-valid? file ) )
( return # f ) )
( format file "(settings #x~X~%" ( -> obj version ) )
( format file " (fps ~D)~%" ( -> obj target-fps ) )
( format file " (size ~D ~D)~%" ( -> obj width ) ( -> obj height ) )
( format file " (aspect ~D ~D)~%" ( -> obj aspect-custom-x ) ( -> obj aspect-custom-y ) )
( format file " (aspect-auto ~A)~%" ( -> obj aspect-ratio-auto? ) )
( format file " (aspect-game ~A)~%" ( -> *setting-control* default aspect-ratio ) )
( format file " (fullscreen ~A)~%" ( -> obj fullscreen? ) )
( format file " (letterbox ~A)~%" ( -> obj letterbox? ) )
( format file " (vsync ~A)~%" ( -> obj vsync? ) )
( format file " (font-scale ~f)~%" ( -> obj font-scale ) )
( format file " (audio-latency-ms ~D)~%" ( -> obj audio-latency-ms ) )
( format file " (audio-pan-override ~f)~%" ( -> obj audio-pan-override ) )
( format file " (audio-volume-override ~f)~%" ( -> obj audio-volume-override ) )
( format file " (audio-channel-nb ~D)~%" ( -> obj audio-channel-nb ) )
( format file " (gfx-renderer ~D)~%" ( -> obj gfx-renderer ) )
( format file " (gfx-resolution ~f)~%" ( -> obj gfx-resolution ) )
( format file " (gfx-anisotropy ~f)~%" ( -> obj gfx-anisotropy ) )
( format file " (shrub-dist-mod ~f)~%" ( -> obj shrub-dist-mod ) )
( format file " (lod-dist-mod ~f)~%" ( -> obj lod-dist-mod ) )
( format file " (lod-force-tfrag ~D)~%" ( -> obj lod-force-tfrag ) )
( format file " (lod-force-tie ~D)~%" ( -> obj lod-force-tie ) )
( format file " (lod-force-ocean ~D)~%" ( -> obj lod-force-ocean ) )
( format file " (lod-force-actor ~D)~%" ( -> obj lod-force-actor ) )
( format file " (stick-deadzone ~f)~%" ( -> obj stick-deadzone ) )
( format file " (ps2-read-speed? ~A)~%" ( -> obj ps2-read-speed? ) )
( format file " (ps2-parts? ~A)~%" ( -> obj ps2-parts? ) )
( format file " (ps2-music? ~A)~%" ( -> obj ps2-music? ) )
( format file " (ps2-se? ~A)~%" ( -> obj ps2-se? ) )
( format file " (ps2-hints? ~A)~%" ( -> obj ps2-hints? ) )
( format file " (ps2-lod-dist? ~A)~%" ( -> obj ps2-lod-dist? ) )
( format file " (music-fade? ~A)~%" ( -> obj music-fade? ) )
( format file " (use-vis? ~A)~%" ( -> obj use-vis? ) )
( format file " (skip-movies? ~A)~%" ( -> obj skip-movies? ) )
( format file " (subtitles? ~A)~%" ( -> obj subtitles? ) )
( format file " (hinttitles? ~A)~%" ( -> obj hinttitles? ) )
( format file " (subtitle-language ~D)~%" ( -> obj subtitle-language ) )
( format file " (scenes-seen" )
( dotimes ( i 197 )
( if ( zero? ( mod i 16 ) )
( format file "~% " )
)
( format file " ~D" ( -> obj scenes-seen i ) )
)
( format file "~% )~%" )
( format file " (fixes~%" )
( format file " (crash-sagecage ~A)~%" ( -> obj fixes crash-sagecage ) )
( format file " (crash-dma ~A)~%" ( -> obj fixes crash-dma ) )
( format file " (crash-light-eco ~A)~%" ( -> obj fixes crash-light-eco ) )
( format file " (lockout-pelican ~A)~%" ( -> obj fixes lockout-pelican ) )
( format file " (lockout-pipegame ~A)~%" ( -> obj fixes lockout-pipegame ) )
( format file " (lockout-gambler ~A)~%" ( -> obj fixes lockout-gambler ) )
( format file " (fix-movies ~A)~%" ( -> obj fixes fix-movies ) )
( format file " (fix-credits ~A)~%" ( -> obj fixes fix-credits ) )
( format file " )~%" )
( format file " (secrets~%" )
( format file " (art #x~X)~%" ( -> obj secrets art ) )
( format file " (hard-rats? ~A)~%" ( -> obj secrets hard-rats? ) )
( format file " (hero-mode? ~A)~%" ( -> obj secrets hero-mode? ) )
( format file " (hud-map? ~A)~%" ( -> obj secrets hud-map? ) )
( format file " (hud-counters? ~A)~%" ( -> obj secrets hud-counters? ) )
( format file " (hard-fish-hiscore ~D)~%" ( -> obj secrets hard-fish-hiscore ) )
( format file " (hard-rats-hiscore ~D)~%" ( -> obj secrets hard-rats-hiscore ) )
( format file " (hard-rats-hiwave ~D)~%" ( -> obj secrets hard-rats-hiwave ) )
( format file " (music" )
( dotimes ( i 30 )
( if ( zero? ( mod i 1 ) )
( format file "~% " )
)
( format file " #x~X" ( -> obj secrets music i ) )
)
( format file "~% )~%" )
( format file " )~%" )
( format file " )~%" )
( file-stream-close file )
)
( format 0 "pc settings file write: ~A~%" filename )
# t
)
( defmethod new pc-settings ( ( allocation symbol ) ( type-to-make type ) )
"make a new pc-settings"
( let ( ( obj ( object-new allocation type-to-make ( the-as int ( -> type-to-make size ) ) ) ) )
( reset obj )
obj
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; PC settings
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
( define *pc-settings* ( new 'global 'pc-settings ) )
2022-01-09 17:43:13 -05:00
( read-from-file *pc-settings* PC_SETTINGS_FILE_NAME )
2021-12-30 18:48:37 -05:00
2022-01-31 20:44:54 -05:00
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; entity debugging
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
( when *debug-segment*
( deftype entity-debug-inspect ( basic )
(
2022-02-07 19:15:37 -05:00
( scroll-y int16 )
( scroll-y-max int16 )
2022-01-31 20:44:54 -05:00
( entity entity )
( show-actor-info symbol )
)
( :methods
( new ( symbol type ) _type_ )
( set-entity! ( _type_ entity ) entity )
( update-pad ( _type_ int ) none )
)
)
( defmethod new entity-debug-inspect ( ( allocation symbol ) ( type-to-make type ) )
"make a new entity-debug-inspect object"
( let ( ( obj ( object-new allocation type-to-make ( the-as int ( -> type-to-make size ) ) ) ) )
( set! ( -> obj scroll-y ) 0 )
2022-02-07 19:15:37 -05:00
( set! ( -> obj scroll-y-max ) 0 )
2022-01-31 20:44:54 -05:00
( set! ( -> obj entity ) ( the entity # f ) )
( set! ( -> obj show-actor-info ) # f )
obj
)
)
( defmethod set-entity! entity-debug-inspect ( ( obj entity-debug-inspect ) ( e entity ) )
"set the entity to inspect"
( set! ( -> obj entity ) e )
( unless e
( set! *display-actor-anim* ( the string # f ) ) )
( set! ( -> obj scroll-y ) 0 )
e
)
( defmethod update-pad entity-debug-inspect ( ( obj entity-debug-inspect ) ( pad-idx int ) )
"respond to pad inputs"
2022-02-07 19:15:37 -05:00
;; scroll up
2022-01-31 20:44:54 -05:00
( if ( cpad-pressed? pad-idx l1 )
( set! ( -> obj scroll-y ) ( max 0 ( 1- ( -> obj scroll-y ) ) ) ) )
2022-02-07 19:15:37 -05:00
;; scroll down
( if ( cpad-pressed? pad-idx r1 )
( set! ( -> obj scroll-y ) ( min ( -> obj scroll-y-max ) ( 1+ ( -> obj scroll-y ) ) ) ) )
;; toggle actor info
2022-01-31 20:44:54 -05:00
( if ( cpad-pressed? pad-idx l3 )
( not! ( -> obj show-actor-info ) ) )
( none ) )
( define *entity-debug-inspect* ( new 'debug 'entity-debug-inspect ) )
)
2021-12-30 18:48:37 -05:00
)