Compare commits

..
350 Commits
Author SHA1 Message Date
Gustaf Alhäll 89cecb88f5 Update license info 2025-12-06 19:45:35 +01:00
Gustaf Alhäll baf5c8d66b Fix music looping on digital 2025-12-06 19:45:32 +01:00
Gustaf Alhäll 72000c4546 Fix memory leak in AATree string trees 2025-12-06 19:45:29 +01:00
Gustaf Alhäll 82b774b2c3 Fix use-after-free when mobj is removed while still playing sounds 2025-12-06 19:45:27 +01:00
Gustaf Alhäll 3818b9ad1a Limit audio channels to 2 2025-12-05 00:22:09 +01:00
Alug ca8e811bd9 sdl_sound: attempt to fix sounds cutting off
i suck at explaining so just trust. :chonkbuncle:
Game sound handling has no idea which sound it is playing/checking, so a sound that ended frees its slot and it might get occupied again without the game knowing
so just encode the channel number into the sound so we can actually check
2025-12-04 17:52:38 +01:00
Alug 97ca034037 sdl_sound: handle explicit float conversions 2025-12-04 17:52:35 +01:00
Alug ac46f7ed00 add missing Fluidsynth ifdefs 2025-12-04 17:52:32 +01:00
Gustaf Alhäll 0afed59329 Fix MIDI music looping 2025-12-04 17:52:30 +01:00
Gustaf Alhäll ec3a1fee70 Tweak audio settings 2025-12-04 17:52:25 +01:00
Alug 5e8c0c3806 Add chorus and reverb settings to MIDI 2025-12-04 17:52:22 +01:00
Gustaf Alhäll 05ea898345 Fix Haiku build 2025-12-04 17:52:11 +01:00
Gustaf Alhäll 0c1fdc0be8 Fine-tune volume settings 2025-12-04 17:52:08 +01:00
Gustaf Alhäll 0e4c72e6f6 Implement MIDI seeking 2025-12-04 17:52:05 +01:00
Alug 29b83903ef delet the bird music resynching stuff
idk who even wants this, its pain, and even more pain to adapt
2025-12-04 17:52:03 +01:00
Alug 1cae09fa11 sdl_audio: use float M_PI for S_CURVE
meant for floats, prevents implicit double conversions
2025-12-04 17:51:59 +01:00
Alug 4a56819bc3 makefile: move openmpt stuff to before sdl stuff
seems to fix linking openmpt without mixer for some reason oh well
2025-12-01 16:49:11 +01:00
Alug 567a48aac3 sdl_sound: fix -Wmaybe-uninitialized warning 2025-12-01 16:49:08 +01:00
Alug d100401c5f this shouldnt be in sourcefile oops 2025-12-01 16:49:05 +01:00
Alug 6dee9fa561 add back "nearest" resampling from mixer
sdls own resampler uses linear interpolation, which sounds super muffled to me
some may like this, but i dont want to change how the game "sounds"
2025-12-01 16:49:01 +01:00
Alug 5bd7a09d9f force 44100khz sample rate
sounds better to me honestly
2025-12-01 16:48:56 +01:00
Alug 47477c2d03 make gme and tracker music slightly louder
prob needs some adjustment, but both were always quite quiet
2025-12-01 16:48:53 +01:00
Alug cd128a1084 lock audio stream in I_PlaySong
seems to fix weird crashes with gme
2025-12-01 16:48:49 +01:00
Alug 34f2afa3d9 add "audiobuffersize" handling
uses the SDL_AUDIO_DEVICE_SAMPLE_FRAMES hint
2025-12-01 16:48:46 +01:00
Alug 22f285edec disable sound precache for sdl sound 2025-12-01 16:48:43 +01:00
Alug 592abdef96 pitch is a float 2025-12-01 16:48:40 +01:00
Alug a27eee8e2f add few missing audiostream unlocks 2025-12-01 16:48:37 +01:00
Alug 904019d24b fix startup playing a super loud bit of music 2025-12-01 16:48:32 +01:00
Alug c6ca5a6f0f i_video: few type fixes for sdl3 2025-12-01 16:48:29 +01:00
Alug 2392f0484c remove hwr_shutdown call
honestly this didnt help with the issue i had, game should already release all the memory on quit anyways.
this just makes it take longer to quit
2025-12-01 16:48:26 +01:00
Alug 986a131a36 fix a few warnings 2025-12-01 16:48:23 +01:00
Alug e9685ef3e8 port srb2classics sdl audio system
still needs a little work reimplementing everything we got

from: https://codeberg.org/srb2classic/srb2classic/pulls/177
2025-12-01 16:48:18 +01:00
Alug 59f194cb9d fuckit SDL3 2025-12-01 16:48:15 +01:00
Alug 99d5590435 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-30 19:34:36 +01:00
Alug 22a6be76b5 OpenGL: fix frustum culling not accounting for spritescales
also rename "this_scale" to "thing_scale" to be more descriptive

Fixes the comically large tree disappearing when it shouldnt on "Ethereal Crystal"
2025-11-30 14:47:02 +01:00
Alug d3d25df3c5 hw_main: cleanup HWR_RenderX stuff a bit 2025-11-30 14:46:30 +01:00
Alug 2a3f9e9ee6 hw_cache:rename some stuff
more in line with the rest of the code
2025-11-30 14:45:37 +01:00
Alug 31f01fd5da Revert "Provide our own SDL2 dll files"
This reverts commit 91530c61ad.

i hate windows, i hate sdl breaking with every single update
2025-11-30 14:37:00 +01:00
indev bb9a4a0da0 Add listemotes command, also fix few emote warnings not printing newlines 2025-11-30 00:36:36 +03:00
Alug 3bac722562 m_menu: cleanup gamepad menu stuff a little 2025-11-29 19:13:12 +01:00
Alug 3769ab74ac m_menu: move onchages back to m_menu, get rid of nextmap onchange hack 2025-11-29 19:07:01 +01:00
Alug c3d6cdd272 ensure modelMatrix is initialized 2025-11-29 14:26:08 +01:00
Alug 093602fd6b comment out unused dynslope member from levelinterpolator_t struct
this wont ever work with our thinkerless dynslopes
2025-11-29 14:26:05 +01:00
Alug 9b2cfe51d6 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-28 18:24:07 +01:00
James R a80d119c58 Rename strcasestr to nongnu_strcasestr, macro strcasestr ifndef _GNU_SOURCE
Fix for GCC C++ compiler, which always defines _GNU_SOURCE.
2025-11-28 18:23:25 +01:00
Alug 66619f42f9 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-28 18:07:35 +01:00
Alug 1cdc92a62b HWR_Precache: lookup for flats that already have been precached
yes i used c++ unordered_set here, yes i suck with linked lists, lol
maybe speeds this process up a little
2025-11-28 18:07:21 +01:00
Alug 6b8de308b7 HWR_Precache: check against gl_numtextures not numtextures
in practice those should mostly be the same but the variable is for gl so
2025-11-28 16:53:12 +01:00
Alug 310e64d8be OpenGL: add a little more checks during texture free
prob not necessary but feels better
2025-11-28 16:53:10 +01:00
Alug 890677e2b5 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-27 23:33:28 +01:00
Alug d2d3afc7f4 software: clip sprites that are out of view
similar to what the frustum cull does in opengl, clips sprites that are out of view in vertical direction
2025-11-27 22:53:12 +01:00
Alug c26d2faee9 OpenGL: fixup spherefrustum culling and use it for sprites
clips sprites that are out of our view, especially with precip this may lead to significant speedup in certain cases
huge thanks to indev for helping with this <3
huge thanks to dsda-doom for the maths needed!
2025-11-27 22:53:12 +01:00
Alug 1c82c338a5 sprite gzt is float in opengl render........ 2025-11-27 18:57:21 +01:00
Alug c81cd48552 R_ProjectSprite: move fakeflat clipping before light maths
so if applicable we have slightly less work
2025-11-27 17:43:40 +01:00
Alug 306f7d455e tiny optimizations k_kart 2025-11-27 17:43:36 +01:00
indev dc40befa88 Use I_GetTime for animated emotes, so anim argument in M_DrawEmote is not needed 2025-11-27 18:49:43 +03:00
Alug 2222272d6f remove more unused/uneeded things
- delet hw_dll
- remove sector_t ceilspeed and floorspeed
- remove a bunch of stuff from viewvars_s
2025-11-27 16:49:50 +01:00
Alug 1849d5aade R_ProjectSprite: make sprite clipping work with sloped fake floors/ceilings
from eternity engine
2025-11-27 16:49:47 +01:00
Alug 3878c2f72a DoAddLine: add fast check for lines with same front and back sectors without middle tex
taken from dsda-doom
2025-11-27 16:49:44 +01:00
Alug 7cf3bceaff HWR_Subsector: avoid calling HWR_AddSprites on already processed sectors 2025-11-27 16:49:41 +01:00
Alug 1e394b0530 pass frontsector ceiling z to R_Prep3DFloors
in both cases "R_Subsector" already got the frontsectors ceiling z, so no need to get it again within R_Prep3DFloors
should save some P_GetSectorCeilingZAt per frame
2025-11-27 16:49:38 +01:00
Alug b09660204a r_bsp: move polyobj renderside check into R_AddPolyObjects
uneeded within R_AddLine as outside R_AddPolyObjects this will never be called if currecnt seg is a polyseg
2025-11-27 16:49:35 +01:00
indev 7b4592377e Make emote search case insensetive (emotes themself still are case sensetive) 2025-11-27 18:40:52 +03:00
indev 45ba69a45a Discordify emotes a bit more :chonkbunckle:
- When autocompleting emote with enter, don't send it immediately
- Don't autocomplete after typing 1 character after : (allows text emotes like ":c")
2025-11-26 22:56:04 +03:00
indev 4d9c345202 Add support for emotes in console chat mode (and support for emotes in console in general) 2025-11-26 22:45:03 +03:00
Alug 1105526eb1 fix perfstats freaking out 2025-11-26 10:10:14 +01:00
Alug d963df36f1 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-26 10:10:12 +01:00
Alug 0437952027 mark checkcoord as const 2025-11-26 10:09:55 +01:00
Alug d188839d0b move R_QuickCamDist to r_main
also mark it with PUREFUNC and R_QuickDist with FUNCMATH, so compiler may optimze it more agressively
2025-11-26 10:09:52 +01:00
Alug 86ac11f877 replace localangle assignments with P_ForceLocalAngle
just a little neater, there also was a function to force the player angle, but this most likely wouldve changed behavior
2025-11-25 22:53:30 +01:00
Alug 0f59e0e270 some mobj interp fixes
copy pasted from RR thx
2025-11-25 22:53:27 +01:00
Alug cd32270ec0 . W
:mompie:
2025-11-25 20:25:29 +01:00
Alug f2a7f9ccaa fix compile with HAVE_DISCORDRPC 2025-11-25 20:21:23 +01:00
Alug 846967cb91 fix compile with HAVE_DISCORDRPC 2025-11-25 20:21:15 +01:00
Alug 6c8862ee4b Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-25 20:16:18 +01:00
Alug 2c2ffe36d7 init a few more globals that were missed
i love globals that are in the middle of files.....
2025-11-25 20:15:27 +01:00
Alug 951b880acb d_netcmd: use cleanup macro for map and localskin command
did Command_Map_f really leak memory all the time? lul
2025-11-25 19:19:19 +01:00
Alug ecfa973e6b move M_ResetDemoList hack to G_InitNew 2025-11-25 19:19:17 +01:00
Alug 749b87b4ca bring back addon name scroll that was lost
oopsie
2025-11-25 17:46:58 +01:00
Alug 7f671e4e30 clean and fixup addon menu
Hopefully should finally fix addons not showing as loaded sometimes and other issues with warning windows being unclosable, etc

lets pray this doesent cause any issues....

add a tickroutine for menus aswell, which will be called in M_Ticker

courtesy of Ring Racers
https://gitlab.com/kart-krew-dev/ring-racers/-/commit/bc9f9d740a0262c249917a37e250ef0209185b12
https://gitlab.com/kart-krew-dev/ring-racers/-/commit/8312f12d6cae934ae8de7e46da231c311f4b4fde
https://gitlab.com/kart-krew-dev/ring-racers/-/commit/6e671d4894e56cd3af09d6e9af2635f030817361
2025-11-25 17:42:01 +01:00
indev ee0e4836f5 Fix race condition in server list search 2025-11-25 19:06:02 +03:00
Alug a01cd628ab do some more cleanup when shutting down graphics system
make sure we free all our opengl allocated stuff by calling HWR_Shutdown
make sure we also destroy our sdl texture, renderer and window if the exist
2025-11-25 16:38:19 +01:00
Alug 4a4e668d21 delet more unused/empty sdl stuff
I_WaitVBL, I_BeginRead and I_EndReada
2025-11-25 16:38:16 +01:00
Alug 03c579769c delet some duped declarations 2025-11-25 13:15:53 +01:00
Alug 2e88b6a1dd fix portal contents being culled erroneously also in software
also dont rember commenting those out in gl lul
2025-11-25 02:18:23 +01:00
Alug a49ea4defd Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-24 22:43:26 +01:00
Alug 5265b147f5 HWR_BlendMidtextureSurface: add extra guard to check linedef alpha 2025-11-24 22:42:53 +01:00
Alug b4a37a2fa4 fix performance regression in certain cases due to changed polygon order
wonky, needs testing as this may slow down other parts
2025-11-24 22:42:50 +01:00
Alug 93eb2b336d Dedicated: dont create or destroy ANY lua hud drawlist
not needed at all in dedi
2025-11-24 21:32:26 +01:00
Alug 30acdca9d3 cache SRB2BACK patch on startup
this is used in a bunch of places while being pretty small, so just cache it on start
2025-11-24 21:26:07 +01:00
Alug 677b34c174 dont free PU_PATCH_LOWPRIORITY patches in render_none
also dont cache them either!
simply not needed at all
so save us a little work
2025-11-24 21:16:17 +01:00
Alug 3c776b321d Optimize: move a few strlen calls out of loops
when applicable and the input does not get modified within the loop
needs some testing incase i oversaw something
2025-11-24 20:52:03 +01:00
Alug 1ed9bfc9b4 Merge branch 'vidmodestuff' into Saturn-Testing 2025-11-24 20:50:04 +01:00
Alug a05413d925 fix erronous "Could not set custom resolution" warning on startup
the cvars may have not been initialised yet to anything
just return -2 and ignore
2025-11-24 20:49:45 +01:00
Alug fa9637fba4 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-24 18:29:05 +01:00
Alug b3be7bcedc Player Infoscreen: if availible, display player names in their skincolor
we hijack the playerinfo data field for this, and pray to the kart gods this is unused on the ms
2025-11-24 18:20:00 +01:00
Alug 19c10be76b R_QuickCamDist & R_QuickDist: turn into function and make it fixed point
since we mostly use it in fixed point maths, this just makes alot more sense
moving it into inline functions ensures that in C code this wont evaluate its arguments multiple times
2025-11-24 17:44:20 +01:00
Alug 60222f2f00 R_AllocateTextures: remove "reallocuser"
this just does... what Z_Realloc does anyways...
Z_Realloc already zeroes out the new memory it allocates
2025-11-24 17:44:16 +01:00
Alug 34edd0a2e3 some misc cleanups
also account for a few more double evluations from min/max macros
and save a few angle to fixed conversions in spb handling
2025-11-24 17:44:13 +01:00
Alug 46b485df14 Server Infoscreen: Show server kart speed instead of "Cheats"
effectively almost all servers will get flagges as having cheats enabled, so instead show the game speed
2025-11-24 16:57:50 +01:00
Alug 8d3632caca ensure all our savebuffers are initialized
just some safety
2025-11-24 03:16:50 +01:00
Alug b5ae9ba733 remove erronous P_RunDynamicSlopes call in P_PreTicker
we dont run preticker when we netjoin so.....
2025-11-24 01:03:44 +01:00
Alug 7f50a09bcd Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-24 00:35:31 +01:00
Alug 2a823ecd60 move K_KartPlayerHUDUpdate to k_hud
how tf did i miss that lul
2025-11-24 00:35:25 +01:00
Alug 940327210f p_setup: move interpolator reset into P_FreeLevelState 2025-11-24 00:35:23 +01:00
Alug e25191d7df Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-24 00:30:49 +01:00
Alug 20a08df1e1 K_PlayerEffectsShouldBlend: also apply when player has invulnerability 2025-11-24 00:30:28 +01:00
Alug 4cf27d40e9 apply additive blending to ghosts aswell when using "playerblendeffects"
same conditions as the others
either be in sneakerboost, or go fast enough
2025-11-24 00:28:31 +01:00
Alug d18c9a257a remove erronous ";" 2025-11-24 00:15:59 +01:00
Alug f4d8a903e8 Merge branch 'vidmodestuff' into Saturn-Testing 2025-11-23 23:21:54 +01:00
Alug 8a8cbffd12 I_CheckDesktopRes: use SDL_GetCurrentDisplayMode
instead of SDL_GetDesktopDisplayMode, as the former only returns the display mode from when the window was created, which might not reflect the actual current desktop mode.
Maybe fixes some resolutions being incorrectly reported asa having visual issues
2025-11-23 23:21:47 +01:00
Alug 0adf356325 HACK: abuse batching system for sprites and drawnodes
use batching system without sorting for order sensitive things like sprites and transparent stuff
even despite not being "optimally" sorted, drawing them in one go, instead of directly still gives a nice speed increase in certain cases (on my ryzen 5600 i get around 120fps+ on teiai towers starting area!)
2025-11-23 23:08:09 +01:00
Alug 0fef290858 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-23 22:52:10 +01:00
Alug 65dc5bb1fd dont free our titlescreen patches
ever...
Fixes a crash when you take ages on server join and timeout due to it.
2025-11-23 22:31:29 +01:00
Alug e18be33c91 F_IntroDrawer: remove "highres" variable
this was ALWAYS true anyways
2025-11-23 22:02:01 +01:00
Alug 9ad6751719 make Controller Rumble strength user changable
range from 0.25 to 4
to account for all types of controllers and such
base 1 was set around what felt good on my dualsense, not entirely sure if this is the best baseline to go with
otherwise it could still be adjusted
2025-11-23 18:49:40 +01:00
Alug 86ab994408 G_DeviceRumbleTick: get rid of magic numbers
use named constants instead
2025-11-23 18:01:30 +01:00
Alug 21f0d603c3 move gamepad led and rumble tickers into g_input
not entirely sure why i placed them in d_main and p_tick respectively
but they should be here
thx neppy for making me question this lul
2025-11-23 17:59:51 +01:00
Alug 971513e7d3 HWR_BlendMidtextureSurface: fix major performance regression
big oopsie from my side
this caused textures that werent translucent to be marked with translucent in a bunch of cases, which led to them being rendered in a slower path
2025-11-23 15:47:03 +01:00
indev 03929e551f emotes: change autocompletion behavior to work like console 2025-11-23 01:31:38 +03:00
Alug db5ae247b6 LoadMobjThinker: revert faulty local player check 2025-11-22 21:54:54 +01:00
Alug d46beab34e fix signed integer overflow in polygon hash calculation
also gives a speedup on some maps lul
2025-11-22 21:47:45 +01:00
Alug 2516873ba1 fix signed integer overflow in polygon hash calculation
also gives a speedup on some maps lul
2025-11-22 18:55:30 +01:00
Alug c650394c31 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-22 18:13:54 +01:00
Alug 9a794232d7 HWR_ProcessSeg: fix cliphigh overflow 2025-11-21 19:51:00 +01:00
Alug db635e5c5b K_GetScreenCoords: fix signed overflow
why even cast that to signed......
2025-11-21 19:41:46 +01:00
indev 8a105a9679 If there is only 1 emote suggestion and user presses enter, autocomplete emote 2025-11-21 20:39:33 +03:00
indev 46b968a351 Fix autocomplete messing up emote in few cases 2025-11-21 20:34:34 +03:00
indev a9836307b2 Allow suggesting emotes if currently typed part matches inside emote, not only at beginning 2025-11-21 20:16:19 +03:00
Alug b6515bb0ae fix Wimplicit-const-int-float-conversion warning 2025-11-21 15:16:39 +01:00
Alug b8257e9037 fix memoryleak when searching for iwads
I_LocateWad returns mallocd memory that needs to be freed
and our home search does not need a tmp ptr
just do as we did before and sprintf it into returnwadpath
also check home directory before the hardcoded lists like before (might speed up startup a little on nix)
also cleanup iwad search in dedi builds and apply everything there aswell
2025-11-21 14:47:13 +01:00
Alug 1fb6c63097 fix dedi compile 2025-11-21 14:45:44 +01:00
Alug e95382075c Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-21 00:00:29 +01:00
Alug 416a2565f9 hw_batching: use polygon hash signbit to detect skywalls/horizonlines
in comparepolygons
gives a nice little performance bump of around 10-15fps in heavy cases
2025-11-20 17:52:14 +01:00
Alug fa75ad4cdd r_opengl: smol micro optimizations
not much, mostly just avoiding redoing things
2025-11-20 17:52:10 +01:00
Alug cedddaadfc r_opengl: delet byte2float lookup
just do direct division
no performance difference at all, but gets rid of that huge ass table
2025-11-20 17:52:07 +01:00
Alug 43ec517cdd small fixes for gamepad indicator led stuff
- skincolors are uint8 type not uint16
- ensure desired colour is within skincolor range
- rename G_GetSkinColor to G_GetSkinColorForGamepad
- replace pointless array with single variable for current color in D_DeviceLEDTick
- remove pointless call to G_GetSkinColorForGamepad when hotplugging gamepads (G_SetPlayerGamepadIndicatorColor will call it itself when 0/skincolor_none is passed)
2025-11-19 23:38:29 +01:00
Alug 495ad5ce06 move this back oop 2025-11-19 22:44:38 +01:00
indev 31ce643311 Check if mobj was actually spawned before setting islocal 2025-11-19 22:07:55 +03:00
Alug 2d9776d792 OpenGL: keep around our drawnodes memory
no need to constantly reallocate new memory
we dont have renderer switch, and the next level will render drawnodes anyways
those wont grow super big also, so theres no big worry about wasting tons of memory
yes i like ceepeepee vectors, how can you tell
2025-11-19 19:27:36 +01:00
Alug 7fa3d119e8 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-19 19:26:41 +01:00
Alug b5c1f21ac1 mark all batching variables with static
they are only used within this file, no need to advertise them as global
2025-11-19 18:13:32 +01:00
Alug 86c1b2cbef simplify the vector buffer stuff
honestly doesent make that much sense in most cases to grow capacity * 2 (slightly misunderstood some stuff on implementation)
and in other cases dont need to manually check for resize
2025-11-19 18:12:20 +01:00
Alug ad828b8f4b reduce scope of some fps counter vars 2025-11-19 00:26:07 +01:00
Alug 5dda681c8a clean up some more render float maths
- dont use M_PIl in double or float maths
- dont use M_PI in float maths (use M_PIf)
- use tanf instead of tan
2025-11-19 00:26:03 +01:00
Alug 92df8ffe01 remove thread.h include, use "thread_local" for everything
we enforce c++ 17, thread_local is a c++11 extension, so this should work everywhere
2025-11-18 22:38:37 +01:00
Alug 2ee8dc09d1 fix opengl portals (and its contents) being culled in some cases they shouldnt be
we do culling per our viewmatrix since a while, which wasnt properly set up for portals beforehand and used whatever was last which was then incorrectly applied to portal culling :chaobaba:
2025-11-18 22:38:32 +01:00
Alug b8f9392efd delet I_UpdateNoBlit
this didnt do anything anymore
2025-11-18 22:38:30 +01:00
Alug e65741acaa Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-18 16:33:38 +01:00
Alug b36ab31a56 Merge remote-tracking branch 'origin/vidmodestuff' into Saturn-Testing 2025-11-18 16:33:35 +01:00
Alug 99f1166eb1 p_mobj: check for common mobjs first
players first, then kart items, shadows and then some srb2 things that are commonly used
makes more sense to check for all of those first everywhere, so we may skip a crapton of pointless checks in many cases
2025-11-18 16:23:27 +01:00
Alug a335da3473 Merge branch 'Saturn-Next' into Saturn-Testing 2025-11-18 16:21:05 +01:00
indev 7ab8bf1bbf Emotes: only print 'too many frames' warning if we actually get non-empty frame 2025-11-18 12:20:33 +03:00
Alug c312380944 check if our desired screen res already is in the videomode list
before deciding to rebuild the whole list when changing the resolution cvars
2025-11-18 05:22:50 +01:00
Alug b5bb2b42bf I_FillScreenResolutionsList: shrink list if it is too large
we check against MAXMODEDESCS, which is the maximum of modes the videomode can list
just in case we really get a display with a fuckton of resolutions, which most likely wont ever be the case though
this just removes the smallest modes from the list (accounting for the canonicals), to keep things simple
2025-11-18 04:55:50 +01:00
Alug d074f375ca M_VideoModeMenu: make sure red marked modes take precedence 2025-11-18 04:55:45 +01:00
Alug 6fd14f0a80 M_VideoModeMenu: remove old video mode dupe check 2025-11-18 04:55:41 +01:00
Alug d6bbb2c1b3 use static buffer for windowedModes names
no need to worry about memory management here :chaosleep:
2025-11-18 04:55:36 +01:00
Alug fa66b87965 cmp_resolutions: compare by numbers directly
instead by comparing it with strings
2025-11-18 04:55:30 +01:00
Alug c59d5db03e Merge remote-tracking branch 'origin/Saturn-Next' into vidmodestuff 2025-11-18 04:55:22 +01:00
Alug a994d7c050 G_DoPlayDemo: fix maybe unitialized warning
in this case this wouldve been fine, tho variables using the cleanup macro should always be initzialized for safety
2025-11-17 21:59:21 +01:00
Alug d2f3d5aa4d anew the testing branch
wiped it out completely
2025-11-17 20:26:49 +01:00
Alug 913b8878d8 Optimize: Use doomednum lookup also when (re)spawning mapthings
not just for loading savegame thinkers
Actually even provides slight runtime performance improvement, but mostly makes levelload faster
2025-11-17 20:26:07 +01:00
Alug f02b9f953e Merge branch 'vidmodestuff' into Saturn-Testing 2025-11-17 20:25:49 +01:00
Alug e46d548080 testing test 2025-11-17 20:23:58 +01:00
Alug 3a7108ecfa Merge branch 'Saturn' into Saturn-Next 2025-11-17 20:23:23 +01:00
Alug bcf876a4c4 Merge branch 'Saturn-Next' into Saturn 2025-11-17 17:52:31 +01:00
Alug 8ab15b73a9 raise version to 9.1 2025-11-17 17:05:19 +01:00
Alug 301d73a30e Merge pull request #213 from Indev450/revertsdl
Revert SDL2 to 2.28.5 and revert SDL_Mixer to 2.0.4
2025-11-17 17:26:20 +01:00
Alug 2ef4e7fcba Merge branch 'Saturn-Next' into revertsdl 2025-11-17 16:00:16 +01:00
Alug 7eb118920f SOCK_Get: recvfrom returning 0 still means its not a valid packet
0 lenght packets means, nothing
0 is still failure, just graceful, ignore that shit, those are not "valid" packets
2025-11-17 15:57:06 +01:00
Alug 2f0588355e remove old xcode stuff
apparently this does not work at all, and instead cmake can be used on macos
2025-11-17 04:56:58 +01:00
Alug 3e6830fc70 remove sdlsound, provide dummy sound instead
sdl sound was completely broken, so just provide a blank dummy interface instead, when compiling without sdl or mixer
2025-11-17 04:56:55 +01:00
Alug 2faf859e32 add mapicon packets to packettypename
so they properly show in the net debugfile
2025-11-17 04:56:15 +01:00
indev 8c31fd8a34 Allow searching for files inside luafiles 2025-11-17 03:15:23 +03:00
indev 4dd6d52550 Revert "Only skip exclude_paths if we're looking for addons (allows commands like exec find configs in luafiles)"
This reverts commit 8524465767.
Right, -file exists
2025-11-17 03:14:20 +03:00
indev 8524465767 Only skip exclude_paths if we're looking for addons (allows commands like exec find configs in luafiles) 2025-11-17 03:12:00 +03:00
Alug 91530c61ad Provide our own SDL2 dll files
this is plain 2.28.5 like before, but with a fix for the right ALT-GR key backported, so non US layouts can work properly
2025-11-16 22:22:14 +01:00
Alug 89f450db27 Revert "Simplify intermission timer code"
This reverts commit ed16c4fd9f.
2025-11-16 21:56:15 +01:00
Alug 3e212ebaad Revert "Simplify intermission timer code"
This reverts commit ed16c4fd9f.
2025-11-16 21:47:21 +01:00
Alug 14af9eb82a Revert "Merge pull request #204 from Indev450/updatesdl2again"
This reverts commit 38bfb58f78, reversing
changes made to 1fa50e12a8.
2025-11-16 21:20:31 +01:00
Alug ed5dbf74f4 Revert "Merge pull request #206 from Indev450/updatemixer"
This reverts commit ca3f40ddf1, reversing
changes made to 38bfb58f78.
2025-11-16 21:20:26 +01:00
Alug 2bf0a24ab6 Revert "comment out directsound thing"
This reverts commit 37cd720dd6.
2025-11-16 21:20:14 +01:00
Alug 88a9d6c29e Fix dedicated server build
forgor about I_HandleControllerHatRepeat
fixes https://github.com/Indev450/SRB2Kart-Saturn/issues/212
2025-11-16 20:50:15 +01:00
Alug 335b7ba737 Fix dedicated server build
forgor about I_HandleControllerHatRepeat
fixes https://github.com/Indev450/SRB2Kart-Saturn/issues/212
2025-11-16 20:50:09 +01:00
Alug 37cd720dd6 comment out directsound thing
somehow this still applied on 32 bit build
2025-11-16 19:58:17 +01:00
Alug a085abe538 remove "stun.c" from sourcefile
fixes linking on windoze
will need to handle this in cmake seperately!
2025-11-16 19:58:15 +01:00
Alug 57dc099641 Update README 2025-11-16 19:51:44 +01:00
Alug 84a3503262 comment out directsound thing
somehow this still applied on 32 bit build
2025-11-16 16:54:11 +01:00
Alug 5117bf1f85 remove "stun.c" from sourcefile
fixes linking on windoze
will need to handle this in cmake seperately!
2025-11-16 16:31:23 +01:00
Alug d4a29f2a44 this aint testing anymore :3 2025-11-16 17:18:23 +01:00
Alug 6129e7c864 Merge branch 'Saturn-Next' into Saturn 2025-11-16 17:02:58 +01:00
Alug 51371dce80 delet cv_birdmusic toggle
stuff was from ages ago, we can just check for the feature toggles instead
2025-11-16 15:27:59 +01:00
Alug 4814088265 mixer_sound/s_sound: remove all the pointless "else"
+ some tiny optimizations here and there
2025-11-16 15:27:56 +01:00
Alug 2344c391d2 Renderer: port some texture skewing fixes from SRB2
- ffloors on the frontsector in opengl now support texture skewing like software
- alot of cleanups, simplifycation and optimizations
2025-11-16 15:27:36 +01:00
Alug 105267612b git pls 2025-11-14 15:30:14 +01:00
Alug 69ef78b2e8 Merge branch 'fakeseed' into Saturn-Next 2025-11-14 15:29:38 +01:00
Alug f4349988c4 smol timing related changes
avoid mixing integer maths AFTER casting to float types, even though its all double this may lead to wonky precision issues
I_GetPrecisePrecision now also doesent always call SDL_GetPerformanceFrequency everytime, since its return value will never change since its solely dependant on the platform
and also removing some dead code
2025-11-14 15:12:54 +01:00
Alug 1b42131c6f remove md5 from sourcefile list
we handle it seperately both in make and cmake, having it here just breaks compile
2025-11-14 14:51:04 +01:00
indev c8db86379d Merge pull request #210 from Indev450/lua-check-local-addon
Automatically check if lua-spawned mobj comes from "addfilelocal addon" hook
2025-11-14 16:50:04 +03:00
Alug 40d2bf816c Merge pull request #207 from Indev450/controllerfixes
Some Controller fixes
2025-11-14 14:47:27 +01:00
Alug ca3f40ddf1 Merge pull request #206 from Indev450/updatemixer
Update sdl2_mixer to 2.8.1 for Windows
2025-11-14 14:47:16 +01:00
Alug 38bfb58f78 Merge pull request #204 from Indev450/updatesdl2again
Update SDL2 to 2.32.10 on Windows builds
2025-11-14 14:46:33 +01:00
Alug 1fa50e12a8 hw_main: some smoller optimizations
- use sqrtf for fade/tint alpha for shaderless light calc
- save recalcing the cosine/sine from angle on angled flats 3 times in HWR_RenderPlane
- precalc float "int32 min/max "
2025-11-14 13:31:57 +01:00
Alug f73e616b97 fail loudly if sdl window/renderer/gl context creation fails
this will crash eitherways, so much rather get atleast a somewhat more informative error
2025-11-14 12:35:45 +01:00
Alug fe0ade1d9c fix some shadowed variables 2025-11-14 06:00:52 +01:00
Alug 1fb60e8230 fix sourcefile for src dir 2025-11-13 19:54:09 +01:00
Alug efe7009650 PT_ReceivedGamestate: add missing SATURNPAK ifdef 2025-11-13 19:31:33 +01:00
Alug 19a4e379d7 HWR_DoWipe: always draw a black screen if it returns early
otherwise this just flashes like crazy should there ever be any issue here
2025-11-13 17:38:45 +01:00
Alug 4e8865d495 cleanup some wonky float/double maths 2025-11-13 17:38:43 +01:00
Alug dfca24b370 HWR_SkyDomeVertex: tiny optimization
save a tiny bit of float division, use float sin and cos functions, handle implicit float conversions
2025-11-13 16:45:57 +01:00
Alug a4c2fd2414 Merge branch 'Saturn-Next' into updatesdl2again 2025-11-12 19:22:07 +01:00
Alug aa985823ba speed up GL_SetPalette "take 2"
ensuring bytecolor is packed nd mypalettedata is initialized this seems to now work properly on windows
2025-11-12 19:20:43 +01:00
Alug b779c9e63d ensure byteColor_t is packed
make sure it is always sized 4 bytes and not padded at all since that is assumed to be the size
2025-11-12 19:04:39 +01:00
Alug c58e54544d initialize all remaining globals
well atleast all i can find lel
2025-11-12 16:49:44 +01:00
Alug c080fc8732 GL_UpdateTexture: fix small oversight
from when i refactored it
GL_TEXFMT_AP_88 needs to increment the image data ptr even if chromakeyed
2025-11-11 22:39:31 +01:00
Alug 24163a7c92 Merge branch 'Saturn-Next' into controllerfixes 2025-11-11 14:53:40 +01:00
Alug d934197246 git merge pls 2025-11-11 14:49:11 +01:00
Alug 76747b4677 git merge pls 2025-11-11 14:48:59 +01:00
Alug 5268fc2d19 Merge branch 'Saturn-Next' into fakeseed 2025-11-11 14:42:41 +01:00
Alug bcd54110d5 only call netkeepalive between calls during gl precache
this caused some crashes in blankart, hopefully this is fine though
2025-11-11 14:19:11 +01:00
Alug 83d538b16a gl_viewludsin/viewludcos is only needed for sprite billboarding
which is not needed with shearing
2025-11-11 14:19:08 +01:00
Alug 2a6a7e1d2b smol optimization R_NoEncore
reuse secspecial for invertencore check
2025-11-11 14:19:06 +01:00
Alug c977c4fc45 initialize most of our global variables
just to be safe, not really trusting the game at this point, maybe this helps with some obscure bugs or smth lel
2025-11-11 14:19:02 +01:00
Alug b6edc90553 mark resolutions listed above the current dektop resolution in red
as they lead to visual errors in openglmode without fbo support
2025-11-09 22:20:57 +01:00
Alug 23735121ff raise MAXWINMODES to 128
YES WINDOWS THANKS VERY MUCH SUPER COOL OF YOU
2025-11-09 20:40:03 +01:00
Alug 20950b698f make sure the default 320x200 mode exists 2025-11-09 20:39:58 +01:00
Alug 44df85d6a4 reduce the scope of this 2025-11-09 20:41:24 +01:00
Alug 42d53f1f6f Merge branch 'Saturn-Next' into vidmodestuff 2025-11-09 20:36:00 +01:00
Alug 48f2d0ff83 make sure our custom res fits within MAXVIDMODES
33 are alot so this probably will never be the case (i hope)
2025-11-09 20:21:30 +01:00
Alug 517723f9c1 handle custom res differently + make VID_NumModes return actual vidmodes
custom resolutions now will be put into the resolution list
which means they are selectable from the menu
2025-11-09 20:16:44 +01:00
Alug 6915077e0f refresh the video menu list if our resolution list changes
if you move the gamewindow to a different display, the video menu will now upadate to the new resolutions
2025-11-09 19:16:36 +01:00
Alug 87e0b55f01 fix windowmoved never resetting 2025-11-09 19:13:49 +01:00
Alug 406dbf333d use a video_mode_t thing for our custom resolution
perhaps we may merge it into windowedmodes? not sure
but this works for now
2025-11-09 19:13:38 +01:00
Alug a730dfd212 fix checking for if display changed 2025-11-09 19:13:35 +01:00
Alug 3058d365f3 no need to call I_FillScreenResolutionsList everywhere
its fine after startup, and when we move our window
2025-11-09 19:13:31 +01:00
Alug ccc453e0b0 fix windowmoved never resetting 2025-11-09 19:13:28 +01:00
Alug c3d02090e4 WIP: remove hardcoded resolutions
much thanks dsda-doom for most of the code for this
TODO:
- resolution menu needs to refresh if the list changes
- clean up
- handle custom resolutions more sane
- figure out the best maximum resolution list size the menu can display
2025-11-09 19:13:25 +01:00
Alug 20cd7621c3 delet numVidModes
wasnt doing anything
2025-11-09 19:13:22 +01:00
Alug 54f5b5ebfb enable software cyan pixel "cutting" for flats by default 2025-11-08 12:30:58 +01:00
Alug b421893646 call NetKeepAlive during ogl precache
should prevent timeouts on slower systems (*cough* *cough* windoze *cough*) hopefully
thx neppy for the idea!
2025-11-07 21:28:45 +01:00
Alug 237aeb7834 use early returns for "I_Finish" stuff
i like that more, less checks for stuff
2025-11-07 21:28:42 +01:00
Alug 7dbd95d556 Merge pull request #208 from Indev450/deletglseg
Remove OpenGL adjusted "segs"
2025-11-06 21:03:38 +01:00
Alug 1e4ba39691 Merge pull request #209 from Indev450/gammastuff
Port RR´s gamma correction + split gamma and brightness
2025-11-06 21:02:37 +01:00
Alug a7805ae3f0 Merge branch 'Saturn-Next' into gammastuff 2025-11-06 21:01:49 +01:00
Alug 325338bfbf sound precache: add option to keep sounds cached but not precache them
ugh i suck so much at explaining
this is the default now pretty much
2025-11-06 20:41:07 +01:00
Alug 01a54e4d0b delete remaining M_Memcpy that were missed
those werent there in lugstuff branch oops lel
2025-11-06 19:15:59 +01:00
Alug e2df018e38 simplify srb2::floattofixed
my tired ass didnt think about just reusing shit kek
ty indev <3
2025-11-06 19:01:25 +01:00
indev 33b62cba33 Push empty string instead of null if len == 0 in lua_pushlstring 2025-11-06 20:44:29 +03:00
Alug 29b4f78b64 lib_concat: fix zero lenght string case
continue the loop, not return, it might just be an empty line, so returning might break some luas
0 lenght would make realloc allocate nothing at all, so just skip it
2025-11-06 18:44:36 +01:00
Alug bce18e3d61 delet M_Memcpy
was just a wrapper for memcpy eitherway
so should make no difference other than avoid any confusion
figured i could just use "sed" command lel
2025-11-06 17:37:19 +01:00
Alug e9c2b982c6 smol cleanup JoyAxis stuff & g_game 2025-11-06 17:37:15 +01:00
Alug 67e1793f49 software renderer: handle some float type related issues with slope drawers
there were a bunch of cases where inf and nan float results were casted and used with integer things, which is undefined in c

yes i did use ceepeepee for that crap, cause this wouldve been really annoying without templating
if someone really wants that crap to use outside ceepeepee, feel free to make a bunch of wrappers cause im too lazy for that stuff
2025-11-05 23:41:56 +01:00
Alug 80613a8a49 R_AllocClippingTables & R_AllocTextureColumnTables: fix nullptr arithmetic 2025-11-05 23:04:21 +01:00
Alug b017a72026 R_DrawPlanes: dont increment garbage ptr
does not need to be there at all eitherways
2025-11-05 23:04:18 +01:00
Alug a7c5254a32 set "-Wno-cast-qual" for clang
see comment
2025-11-05 23:04:15 +01:00
Alug 9dd1a47969 fix SINT8 write macro, fix big endian READUINT32 macro 2025-11-05 23:04:13 +01:00
Alug bbbd42e653 use "offsetof" for skydome vbo offsets
silences UBSAN complaining about accessing struct members through null ptr
2025-11-05 23:04:10 +01:00
Alug 2b7f2da5ee Mipmaps: fix translucent textures turning black
i.e. since we allow texture filtering on translucent textures now, the min filter may specifcy one of the mipmap filters, this means we NEED to call GL_GENERATE_MIPMAP and set the LODs for them, otherwise no texture will be generated
alternatively we could do a bunch of special cases for the mipmap filters, but this is simpler
2025-11-02 14:36:08 +01:00
Blue Staggo 23ba827726 Give midtextures filtering without ugly borders + Clean up padding code
Couldn't do proper translucent blending on midtextures because of wrapping.
2025-11-02 14:36:04 +01:00
Blue Staggo 326a28ec36 Oops, forgot to disable padding for nearest texture mode 2025-11-02 14:36:00 +01:00
Blue Staggo 19d6a1600e Optimise padding algorithm 2025-11-02 14:35:56 +01:00
Alug 3095303a4b Revert "simplify vhs effect interpolation"
This reverts commit e26fb91350.
2025-11-02 14:35:28 +01:00
Alug 2a1807422c Merge branch 'fastcmpstuff' into Saturn-Next 2025-11-01 23:45:22 +01:00
Alug 4676885521 fixup: replace stricmp with fasticmp
actually replace everything correctly
my dumbass forgor about the fast both strcmp and stricmp matter in sort stuff so we cannot use the fastcmp stuff there, which means we should not redifine stricmp as fasticmp in case something relies on that behaviour ugh
2025-11-01 23:45:06 +01:00
Alug 30cea37248 use npow2 screen textures if GL_ARB_texture_non_power_of_two is supported
apparently some gl drivers may use a slower path for streamed textures that only get partly updated, this tricks them into thinking this did a "full update" and resulting in using a faster renderpath
2025-11-01 23:42:35 +01:00
Alug 080d3c6b18 Merge branch 'luacvarfixes' into Saturn-Next 2025-11-01 23:38:39 +01:00
Alug df10855483 fix oopsie that broke name change 2025-11-01 23:15:38 +01:00
Alug dc6bf05f35 experiment: replace every strcasecmp with fasticmp
same as before, tho this is not twice as fast but atleast 1/3 faster
2025-11-01 23:15:26 +01:00
Alug 871545024d experiment: replace every strcmp with fastcmp
did some profiling and in basically every single test fastcmp was twice as fast as strcmp
maybe this speeds up some things
2025-11-01 23:15:21 +01:00
Alug aeb172f2ab do some smol cleanup r_skins
mostly style fixes, some minor caching for some things
2025-11-01 22:35:34 +01:00
James R ec757ceb2c Pass const pointer to all netxcmd handlers
Ensure buffer data is read-only and not modified by
handler
2025-11-01 21:21:06 +01:00
Alug e00783da82 fix stuff from merge conflict 2025-11-01 21:21:03 +01:00
toaster 52a9486974 Remove heinous pointer-sent-over-the-network hack remnants
This used to be used for `P_RelinkPointers()`, but was superseded by the far saner mobjnum. HOWEVER, its lingering effect was to leave `mobj->info` in an invalid state until a later `P_FinishMobjs()` was called. This is memory unsafety :D

After removing the last remnants of this ancient hack, it is now once again possible to connect to a server without crashing immediately. However, I did get a crash after a few seconds, so there is definitely still *something* nasty going on under the hood.
2025-11-01 21:20:58 +01:00
Alug 26b26b8f25 consolelib: fix some early returns not properly cleaning lua stack 2025-11-01 21:20:53 +01:00
James R 81f7335b05 Got_Luacmd: always read netxcmd data, even if command is not executed 2025-11-01 21:20:48 +01:00
Eidolon f603106ac8 Check Lua stack before pushing cons args
Prevents a Lua stack overrun when executing absurd console commands for
local-only lua commands.
2025-11-01 21:20:43 +01:00
James R 5675eefeb2 Got_Luacmd: ensure lua stack is large enough for command arguments 2025-11-01 21:20:39 +01:00
Monster Iestyn 1d0fb17da4 Fixes for lib_cvRegisterVar (the Lua version of CV_RegisterVar):
* Make sure the consvar's properties are all initialised to zeros as defaults
* Error if the consvar is not given a name
* Error if the consvar has CV_CALL but no call function
* Error if the consvar has CV_NOINIT but not CV_CALL
2025-11-01 21:20:31 +01:00
James R f53d37052a Replace LUA_PushLightUserdata with LUA_PushUserdata
See c92378fa and a7e20f70. I didn't realize that light
userdata's metatable is shared--like numbers or strings.
So it cannot be paired with a metatable.

I also made a few minor tweaks to Lua cvars, other than
accounting for the double pointer in the userdata.
2025-11-01 21:20:22 +01:00
Alug cae5e73d7d LUA_RawPushUserdata
"Same as LUA_PushUserdata but don't set a metatable yet."
from RR
2025-11-01 21:20:17 +01:00
Alug 4fccb48d2a fix wonky variable names 2025-11-01 20:58:04 +01:00
Alug 3e0150d4f3 remove auto/postload check variables
we can just check our counts since D_FindAddonsToAutoload will never be called again
2025-11-01 20:53:31 +01:00
Alug 7c1f17bb8d pass our file counts to W_InitMultipleFiles
smol opzimiation, skips some ptr deref
2025-11-01 20:49:03 +01:00
Alug c8ae4a89d9 throw motion blur effect stuff behind an ifdef
so we can get rid of the unused array
prob could just remove it at this point, but maybe ill fix it someday for the funnis
2025-11-01 20:08:36 +01:00
Alug 42b1f849c0 cleanup and optimize startup wad handling 2025-11-01 20:08:33 +01:00
Alug c0f24ebbbc postautoloaded can be static
not used outside of d_main
2025-11-01 20:08:30 +01:00
Alug de73c53665 optimize addon autoload handling 2025-11-01 20:08:25 +01:00
Alug 908e073628 removed unused autoload variables
M_ConnectMenuModChecks been checking an uninitialized bool the whole time Zzz...
2025-11-01 18:29:10 +01:00
Gustaf Alhäll eaee95a026 Add -workdir 2025-11-01 18:15:20 +01:00
Alug 456a380e3a HWR_PrecacheLevel: disable sprite precaching
in some cases this may lead to crashes, its mostly useless in gl eitherway due to how colourmapped sprites work
2025-11-01 16:32:27 +01:00
Alug c428472c6f dont precache anything ever in HWR_PrecacheLevel if disabled
before some cvar callbacks called this unconditionally
2025-11-01 16:32:19 +01:00
Alug feff5a7c17 make a toggle for using angleturn in replays
while this is more accurate to how the player experienced stuff in the actual game, this also can be somewhat jittery and stuttery depending on the net conditions the replay was recorded in, so make this toggable if someone wants it
2025-11-01 16:32:16 +01:00
Alug ae306351ba add cv_precachetextures to advanced video options 2025-11-01 16:32:13 +01:00
Alug 03de30df3e SV_StopServer: reset textcmdbuf
fixes an issue where in some rare cases, the game may get stuck in a weird limbo state due to the text command buffer being full and never be cleared, so net commands can never be executed
2025-11-01 03:01:40 +01:00
toaster e45c72f525 SV_StopServer: Use G_SetGamestate instead of a direct write
An apparent oversight identified while working on the previous commit.
2025-11-01 03:01:17 +01:00
Alug 36c43d89e6 GL encore: use struct for encore texture handling
struct with two sets of maptextures, one for normal another for encore textures
functionally identical, hopefully also performancewise
more explicit than doing this with just one set and indexing stuff :bloblcatpats:
2025-10-31 15:10:39 +01:00
Alug f34a47c50d HWR_PrecacheLevelFlats: only run flat encore case when having an "encoremap"
not when its just encore mode
might save some time on some maps, as we dont need to check for remapping
2025-10-31 15:10:32 +01:00
Alug 24895874ed UDP_Bind: check socket send buffer size aswell
if to small than adjust, like receive buffer
2025-10-30 18:04:04 +01:00
Gustaf Alhäll 129f88b6a7 Fix buffer underflow when querying invalid nodes 2025-10-30 18:03:47 +01:00
Alug cb5c4e482e SOCK_GetAddr: freeaddrinfo does not need to be called on getaddrinfo failure 2025-10-30 18:03:43 +01:00
Alug db2062ed1d some i_tcp fixes
- SOCK_Get return true when receiving good packet from a lan player
- SOCK_GetAddr fix handling of ipv6 addresses, so ipv6 servers can be found in the serverlist

taken from srb2/classic
2025-10-30 18:03:38 +01:00
Alug 45ee50b47d remove reduntant stuff from D_ClearState and G_StopDemo
we only need R_ExecuteSetViewSize from splitscreen_onchange, the rest doesent do anything due to SV_StopServer call earlier setting cl_mode to CL_ABORTED
SV_StopServer also calls Y_EndIntermission and Y_EndVote if necessary
2025-10-28 01:21:38 +01:00
Alug 694a8eeb69 P_TryMove: save one R_PointInSubsector call per player
by reusing the special sector calculated earlier, this didnt change for when its checked another time
also one fixedmul in P_SceneryTryMove in some cases
2025-10-28 00:50:02 +01:00
Alug 908bba2c8a rename subsector variable in P_TryCameraMove to be more descriptive 2025-10-28 00:49:58 +01:00
Alug 7325c8dbfd Merge branch 'Saturn-Next' into fakeseed 2025-10-28 00:02:35 +01:00
Alug 88363cf45d add NOHOLEPUNCH flag to disable holepunch entirely 2025-10-27 22:58:42 +01:00
Alug e5c18ae1f1 update ms listing if fakeseed was changed 2025-10-27 22:47:18 +01:00
Alug 4bb5b8fa04 add "Fake Seed" system
allow sending a fake player to the ms and serverbrowser when your dedicated server is empty
effectively functioning as a "seed" player without manual intervention and occupieng a server slot
2025-10-27 22:24:21 +01:00
Alug 509e7140e3 use strlcpy for filling playerinfo names
MAXPLAYERNAME+1 so it copies 21 and null terminates the last
2025-10-27 21:21:39 +01:00
Alug 056f919bbe DrawTiltedSpan: more micro optimize
- do pointerdiff outside the loops, no need to do them 16 times per span
- cache tiltilighting and planezlight, mark as const and restrict
2025-10-27 00:56:21 +01:00
Alug 548cad76b2 drawspan: some type fixes, mark const and reordering 2025-10-26 14:05:12 +01:00
Alug 95d8864faa fix software hiding the wrong thing in video options 2025-10-26 02:19:35 +01:00
Alug e26fb91350 simplify vhs effect interpolation 2025-10-25 22:32:58 +02:00
Alug da67f6feb8 rename most "gamma" vars to "brightness"
lots of confusion
but it does more brightness adjustment than gamma adjustments, yes this does some gamma correction but not user changable global gamma adjustments like globalgamma
uhhh
2025-10-25 22:21:37 +02:00
Alug 8cc73bc482 Port RR´s gamma correction + split gamma and brightness
port of https://gitlab.com/kart-krew-dev/ring-racers/-/commit/e27506c660933e19dbcfe9ec776caf7819952e30
not cherry picked since it differs too much it would be hellish to untangle (sry!)
Gamma is split from brightness since both do somewhat different things in the context here
2025-10-25 22:21:19 +02:00
Alug 28685ea658 fix some tooltips issues, wording and inconsistencies
fbo also now supports from gl 2.1
2025-10-25 20:39:01 +02:00
Alug a69df8807d fix some messed up whitespaces lel 2025-10-24 21:57:57 +02:00
Alug d4a130f1dc remove those memsets
not needed anymore now
2025-10-24 18:40:29 +02:00
Alug 8ccf4eb9ba this can be alot smoler 2025-10-24 18:40:25 +02:00
Alug cdb7b6fede initialize input events to something 2025-10-24 18:40:21 +02:00
Alug fcae072625 refactor controller dpad menu repeat handling
dont hack around manually checking for state checks
just use sdl provided stuff and poll if a dpad button currently is being held
2025-10-24 18:40:18 +02:00
Alug 26fc417555 forgor about localskin menu
Zzz....
2025-10-24 16:09:53 +02:00
Alug bb3dd435f0 oop didnt mean to move this 2025-10-24 15:49:40 +02:00
indev 16a531272f Skip repeating backslashes in HU_DoCEcho when printing to console 2025-10-24 16:36:50 +03:00
Alug ba5b79e48a dont double print kitchen sink message to log
we already handle this in HU_DoCEcho
2025-10-24 15:37:11 +02:00
Alug 59470ddbd4 fix oob access in D_SetupVote
check if luamaps was set before
2025-10-24 15:37:08 +02:00
Alug 82c4191516 Revert "SDLSetMode: render immediately after resolution change to avoid 1-frame of texture presented at wrong size"
This reverts commit 0e2ffdeb1d.
2025-10-24 04:09:43 +02:00
Alug 8a305d3c79 move those to D_ClearState 2025-10-24 03:47:59 +02:00
Alug 7c507c7b3b do some cleanup g_demo
:shook:
use the CLEANUP macro everywhere
init some things that may not be initialized
and make this more readable
lets hope didnt break anything Zzz...
TODO: if there are still issues with demo records and stuff crashing might consider porting some of the fixes from RR
2025-10-24 03:44:56 +02:00
Alug ca27dad6c1 use D_ClearState in G_StopDemo
actually fixes issues with crashes AND palette reset
also resets a bunch of more stuff which def is good
2025-10-24 03:44:53 +02:00
Alug 383d55cac6 smol cleanup V_DrawVhsEffect
dont need to assign all the software stuff in gl mode
2025-10-24 03:37:45 +02:00
James R. 0e2ffdeb1d SDLSetMode: render immediately after resolution change to avoid 1-frame of texture presented at wrong size 2025-10-24 01:55:20 +02:00
Alug b84d101337 initialize sdl window,renderer and texture to something 2025-10-24 01:55:17 +02:00
indev eb04271c83 Actually try to do this with hooks 2025-10-23 22:52:03 +03:00
Alug 852aa74d62 random style fixes and stuff 2025-10-23 21:01:20 +02:00
Alug aa06459c09 set special case for console key when using native keyboard input
ALWAYS make sure that remains in the same physical place
otherwise things might get very annoying
it already does so with my german layout
2025-10-23 21:01:20 +02:00
indev 54e7ad571e Check if mobj is spawned from local addon in most of lua_baselib functions related to mobjs 2025-10-23 22:00:46 +03:00
Alug 1d3dae01e9 set SDL_HINT_AUTO_UPDATE_SENSORS hint to 0
we dont need any of that so disable it
2025-10-23 20:58:01 +02:00
Alug 736a626ccf init joyinfo in I_InitJoystick 2025-10-23 20:57:58 +02:00
Alug a4cc8b0585 keep track of joystick instance index
means we dont constantly need to refetch it
needs testing on windoze
2025-10-23 20:57:55 +02:00
Alug 333c94be52 clean up controller dpad input handling
just treat them as "normal" buttons instead of manually polling for them
alot cleaner and gets rid of yet another polling loop
also clean up some other stuff
needs to be tested with multiple controllers in splitscreen but cba to do that atm
2025-10-23 20:57:52 +02:00
Alug 6f17ed0883 Merge branch 'Saturn-Next' into updatesdl2again 2025-10-16 15:07:54 +01:00
Alug 02d6fccfa9 Merge remote-tracking branch 'origin/Saturn-Next' into updatesdl2again 2025-10-10 16:40:05 +01:00
Alug 0ceaca4b2f Merge branch 'Saturn-Next' into updatesdl2again 2025-10-03 22:43:29 +01:00
Alug af9fa77501 update SDL2 to 2.32.10
Fixes keyboard input issues for certain languages when using the "native" keyboard input setting
probably fixes some other issues aswell
needs regression testing
2025-10-03 21:29:26 +01:00
Alug 21920112ee a thousand curses upon you polyobjects! 2025-10-02 18:37:18 +02:00
Alug 9b7bf5e7d8 Merge remote-tracking branch 'origin/Saturn-Next' into deletglseg 2025-10-02 18:00:59 +02:00
Alug 524168b20b experiment: remove opengl adjusted segs
in theory this should improve levelload times and reduce memory usage?
gotta see if it really does, visually so far there seems to be no difference at all
2025-10-02 17:57:52 +02:00
Alug 2049353647 move this out of maptitle condition
it does not rely on it and may even fail
idk why i threw it in there
2025-07-27 15:11:07 +02:00
217 changed files with 11312 additions and 19658 deletions

No files matched your search

+1
View File
@@ -23,6 +23,7 @@ We also have a Flatpak available on [Flathub](https://flathub.org/en/apps/org.sr
See [SRB2 Wiki/Source code compiling](http://wiki.srb2.org/wiki/Source_code_compiling). The compiling process for SRB2Kart is largely identical to SRB2.
Currently only the Makefile build system with GCC or Clang compiler is supported.
CMake is NOT supported at the moment, but will be availible again soon.
Visual C++ (MSVC) is unsupported.
+10 -6
View File
@@ -972,6 +972,14 @@ Public License instead of this License. But first, please read
Copyright (C) 1995-2018 Free Software Foundation, Inc.
https://www.gnu.org/software/gettext/
- FluidSynth
Copyright (C) 2000-2025 Peter Hanappe and others.
https://www.fluidsynth.org/
- libsndfile
Copyright (C) 1999-2016 Erik de Castro Lopo
https://libsndfile.github.io/libsndfile/
- mpg123
Copyright (c) 1995-2013 by Michael Hipp and others,
free software under the terms of the LGPL v2.1
@@ -1699,12 +1707,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
zlib License
applies to:
- Simple DirectMedia Layer
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
https://www.libsdl.org/hg.php
- SDL_mixer: An audio mixer library based on the SDL library
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
https://www.libsdl.org/projects/SDL_mixer/
Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
https://libsdl.org/
- zlib
Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+41
View File
@@ -0,0 +1,41 @@
# Find FluidSynth
# Once done, this will define
#
# FLUIDSYNTH_FOUND - system has FluidSynth
# FLUIDSYNTH_INCLUDE_DIRS - FluidSynth include directories
# FLUIDSYNTH_LIBRARIES - link libraries
include(LibFindMacros)
libfind_pkg_check_modules(FLUIDSYNTH_PKGCONF FLUIDSYNTH)
# includes
find_path(FLUIDSYNTH_INCLUDE_DIR
NAMES fluidsynth.h
PATHS
${FLUIDSYNTH_PKGCONF_INCLUDE_DIRS}
)
# library
find_library(FLUIDSYNTH_LIBRARY
NAMES fluidsynth
PATHS
${FLUIDSYNTH_PKGCONF_LIBRARY_DIRS}
"/usr/lib"
"/usr/local/lib"
)
# set include dir variables
set(FLUIDSYNTH_PROCESS_INCLUDES FLUIDSYNTH_INCLUDE_DIR)
set(FLUIDSYNTH_PROCESS_LIBS FLUIDSYNTH_LIBRARY)
libfind_process(FLUIDSYNTH)
if(FLUIDSYNTH_FOUND AND NOT TARGET FluidSynth::libfluidsynth)
add_library(FluidSynth::libfluidsynth UNKNOWN IMPORTED)
set_target_properties(
FluidSynth::libfluidsynth
PROPERTIES
IMPORTED_LOCATION "${FLUIDSYNTH_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${FLUIDSYNTH_INCLUDE_DIR}"
)
endif()
-66
View File
@@ -1,69 +1,3 @@
2.8.1:
* Added Stop/Start/Pause/Resume for Fluidsynth
2.8.0:
* Added support for loading wavpack sound files (https://www.wavpack.com/)
* Added support for loading classic console sound files using Game_Music_Emu (https://github.com/libgme/game-music-emu)
* Use minimp3 instead of dr_mp3 as the default backend for MP3 music
* Use libxmp instead of modplug as the default backend for MOD music
To use libmodplug instead, configure using --enable-music-mod-modplug --disable-music-mod-xmp
* Added support for FLAC audio in Ogg containers
* Added Mix_PauseAudio() to pause and resume all audio playback
* Added Mix_GetNumTracks() and Mix_StartTrack() for managing tracks in GME files
2.6.2:
* Updated autotools to use ax_compute_relative_paths, fixing homebrew on macOS
2.6.1:
* Fixed issue with incorrect version reported by pkg-config
2.6.0:
* Added support for building with CMake
* Added support for playing Ogg files using stb_vorbis, which is now the default Vorbis backend.
To use libvorbis instead, configure using --disable-music-ogg-stb --enable-music-ogg-vorbis
* Added support for playing FLAC files using dr_flac, which is now the default FLAC music backend.
To use libflac instead, configure using --disable-music-flac-drflac --enable-music-flac-libflac
* Added support for playing MP3 files using dr_mp3, which is now the default MP3 music backend.
To use libmpg123 instead, configure using --disable-music-mp3-drmp3 --enable-music-mp3-mpg123
* Added libxmp support for mod music playback. Modplug is still the default backend for MOD music.
To use libxmp instead, configure using --disable-music-mod-modplug --enable-music-mod-xmp
* Removed support for libmad as a MP3 music backend.
* Removed support for libmikmod as a MOD music backend.
* Added Mix_MasterVolume() for additional volume control over all channels
* Update Mix_Init() return value to match documentation, including MIXER_INIT_* flags for already-initialized modules
* Added Mix_HasMusicDecoder()
* Memory leak fixes and F32 format support to fluidsynth player
* Fixed distorted MIDI playback with FluidSynth if sample rate is out of library's limits
* Added Mix_ModMusicJumpToOrder() for mod music formats
* Enabled module internal loops in modplug player
* Respect original mp3 file offset
* Support setting soundfont via SDL_SOUNDFONTS in OSX native midi
* Fixed mp3 file detection
* Fixes to ogg playback on big-endian devices
* Added functions to get metadata information:
Mix_GetMusicTitle()
Mix_GetMusicTitleTag()
Mix_GetMusicArtistTag()
Mix_GetMusicAlbumTag()
Mix_GetMusicCopyrightTag()
* Add functions to get loop point information:
Mix_GetMusicLoopStartTime()
Mix_GetMusicLoopEndTime()
Mix_GetMusicLoopLengthTime()
* Added Mix_GetMusicVolume() and Mix_GetMusicPosition()
* Added Mix_MusicDuration() to return music duration in seconds
* Fixed music_mpg123 seek bug when sample rate of the file and the stream don't match
* Timidity improvements, added Mix_SetTimidityCfg()
* Improved mp3 tag detection/skipping
* Extended support for WAV files
* Allow rmid files be opened by native midi
* Fixed possible crash in win32 native midi
* Prevent clipping due to volume settings in modplug music
* Added looping support for Opus files
* Added looping support for FLAC files
* Improved OGG looping support
* Fixed loading Opus audio as audio chunks
2.0.4:
Ozkan Sezer - Wed, 10 Oct 2018 14:56:10
* Removed smpeg support for mp3 music, now that it's replaced by libmpg123
+20
View File
@@ -0,0 +1,20 @@
/*
SDL_mixer: An audio mixer library based on the SDL library
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
+32
View File
@@ -0,0 +1,32 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_mixer/file/default/external
---
Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007 Josh Coalson
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the Xiph.org Foundation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+5
View File
@@ -0,0 +1,5 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_mixer/file/default/external
---
ModPlug-XMMS and libmodplug are now in the public domain.
+776
View File
@@ -0,0 +1,776 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_mixer/file/default/external
---
This is the file that contains the terms of use, copying, etc. for the mpg123 distribution package.
Main message, to include in "About ..." boxes, etc:
Copyright (c) 1995-2013 by Michael Hipp and others,
free software under the terms of the LGPL v2.1
There is an attempt to cover the actual list of authors in the AUTHORS file.
Project maintainer since 2006 is Thomas Orgis and many people have contributed
since the Michael Hipp era, but he stays the initial source and it would
be impractical to count them all individually, so it's "and others".
Source files contain the phrase "the mpg123 project" to the same effect
in their license boilerplate; especially those that were added after
maintainership changed. The person mainly responsible for the first version
is usually named in the phrase "initially written by ...".
All files in the distribution that don't carry a license note on their own are
licensed under the terms of the LGPL 2.1; exceptions may apply, especially to
files not in the official distribution but in the revision control repository.
The formal license text follows.
=======================
1. The LGPL version 2.1
=======================
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
====================
2. The GPL version 2
====================
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
+32
View File
@@ -0,0 +1,32 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_image/file/default/external
---
Copyright (c) 2002-2008 Xiph.org Foundation
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the Xiph.org Foundation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+48
View File
@@ -0,0 +1,48 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_mixer/file/default/external
---
Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic,
Jean-Marc Valin, Timothy B. Terriberry,
CSIRO, Gregory Maxwell, Mark Borgerding,
Erik de Castro Lopo
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of Internet Society, IETF or IETF Trust, nor the
names of specific contributors, may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Opus is subject to the royalty-free patent licenses which are
specified at:
Xiph.Org Foundation:
https://datatracker.ietf.org/ipr/1524/
Microsoft Corporation:
https://datatracker.ietf.org/ipr/1914/
Broadcom Corporation:
https://datatracker.ietf.org/ipr/1526/
+32
View File
@@ -0,0 +1,32 @@
The source code to this library used with SDL_mixer can be found here:
https://hg.libsdl.org/SDL_mixer/file/default/external
---
Copyright (c) 1994-2013 Xiph.Org Foundation and contributors
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the Xiph.Org Foundation nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-17
View File
@@ -1,17 +0,0 @@
Copyright (C) 1997-2025 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
+39 -16
View File
@@ -1,31 +1,54 @@
SDL_mixer 2.0
The latest version of this library is available from GitHub:
https://github.com/libsdl-org/SDL_mixer/releases
The latest version of this library is available from:
http://www.libsdl.org/projects/SDL_mixer/
Due to popular demand, here is a simple multi-channel audio mixer.
It supports 8 channels of 16 bit stereo audio, plus a single channel of music. It can load FLAC, MP3, Ogg, VOC, and WAV format audio. It can also load MIDI, MOD, and Opus audio, depending on build options (see the note below for details.)
It supports 8 channels of 16 bit stereo audio, plus a single channel
of music.
See the header file SDL_mixer.h and the examples playwave.c and playmus.c for documentation on this mixer library. This documentation is also available online at https://wiki.libsdl.org/SDL2_mixer
See the header file SDL_mixer.h and the examples playwave.c and playmus.c
for documentation on this mixer library.
The process of mixing MIDI files to wave output is very CPU intensive, so if playing regular WAVE files sound great, but playing MIDI files sound choppy, try using 8-bit audio, mono audio, or lower frequencies.
The mixer can currently load Microsoft WAVE files and Creative Labs VOC
files as audio samples, it can load FLAC files with libFLAC, it can load
Ogg Vorbis files with Ogg Vorbis or Tremor libraries, it can load MP3 files
using mpg123 or libmad, and it can load MIDI files with Timidity,
FluidSynth, and natively on Windows, Mac OSX, and Linux, and finally it can
load the following file formats via ModPlug or MikMod: .MOD .S3M .IT .XM.
If you have built with FluidSynth support, you'll need to set the SDL_SOUNDFONTS environment variable to a Sound Font 2 (.sf2) file containing the musical instruments you want to use for MIDI playback.
Tremor decoding is disabled by default; you can enable it by passing
--enable-music-ogg-tremor
to configure, or by defining MUSIC_OGG and OGG_USE_TREMOR.
libmad decoding is disabled by default; you can enable it by passing
--enable-music-mp3-mad
to configure, or by defining MUSIC_MP3_MAD
vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
WARNING: The license for libmad is GPL, which means that in order to
use it your application must also be GPL!
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The process of mixing MIDI files to wave output is very CPU intensive,
so if playing regular WAVE files sound great, but playing MIDI files
sound choppy, try using 8-bit audio, mono audio, or lower frequencies.
To play MIDI files using FluidSynth, you'll need to set the SDL_SOUNDFONTS
environment variable to a Sound Font 2 (.sf2) file containing the musical
instruments you want to use for MIDI playback.
(On some Linux distributions you can install the fluid-soundfont-gm package)
To play MIDI files using Timidity, you'll need to get a complete set of GUS patches from:
To play MIDI files using Timidity, you'll need to get a complete set of
GUS patches from:
http://www.libsdl.org/projects/mixer/timidity/timidity.tar.gz
and unpack them in /usr/local/lib under UNIX, and C:\ under Win32.
This library is under the zlib license, see the file "LICENSE.txt" for details.
iOS:
In order to use this library on iOS, you should include the SDL.xcodeproj
and Xcode-iOS/SDL_mixer.xcodeproj in your application, add the SDL/include
and SDL_mixer directories to your "Header Search Paths" setting, then add the
libSDL2.a and libSDL2_mixer.a to your "Link Binary with Libraries" setting.
Note:
Support for software MIDI, MOD, and Opus are not included by default because of the size of the decode libraries, but you can get them by running external/download.sh
- When building with CMake, you can enable the appropriate SDL2MIXER_* options defined in CMakeLists.txt. SDL2MIXER_VENDORED allows switching between system and vendored libraries.
- When building with configure/make, you can build and install them normally and the configure script will detect and use them.
- When building with Visual Studio, you will need to build the libraries and then add the appropriate LOAD_* preprocessor define to the Visual Studio project.
- When building with Xcode, you can edit the config at the top of the project to enable them, and you will need to include the appropriate framework in your application.
- For Android, you can edit the config at the top of Android.mk to enable them.
This library is under the zlib license, see the file "COPYING.txt" for details.
The default MP3 support is provided using minimp3. SDL_mixer also supports using libmpg123: you can enable it by passing --enable-music-mp3-mpg123 to configure.
Binary file not shown.
File diff suppressed because it is too large. Load diff
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_FLAC QUIET flac)
find_library(FLAC_LIBRARY
NAMES FLAC
HINTS ${PC_FLAC_LIBDIR}
)
find_path(FLAC_INCLUDE_PATH
NAMES FLAC/all.h
HINTS ${PC_FLAC_INCLUDEDIR}
)
if(PC_FLAC_FOUND)
get_flags_from_pkg_config("${FLAC_LIBRARY}" "PC_FLAC" "_flac")
endif()
set(FLAC_COMPILE_OPTIONS "${_flac_compile_options}" CACHE STRING "Extra compile options of FLAC")
set(FLAC_LINK_LIBRARIES "${_flac_link_libraries}" CACHE STRING "Extra link libraries of FLAC")
set(FLAC_LINK_OPTIONS "${_flac_link_options}" CACHE STRING "Extra link flags of FLAC")
set(FLAC_LINK_DIRECTORIES "${_flac_link_directories}" CACHE PATH "Extra link directories of FLAC")
find_package_handle_standard_args(FLAC
REQUIRED_VARS FLAC_LIBRARY FLAC_INCLUDE_PATH
)
if(FLAC_FOUND)
if(NOT TARGET FLAC::FLAC)
add_library(FLAC::FLAC UNKNOWN IMPORTED)
set_target_properties(FLAC::FLAC PROPERTIES
IMPORTED_LOCATION "${FLAC_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${FLAC_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${FLAC_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${FLAC_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${FLAC_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${FLAC_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_FLUIDSYNTH QUIET fluidsynth)
find_library(FluidSynth_LIBRARY
NAMES fluidsynth libfluidsynth
HINTS ${PC_FLUIDSYNTH_LIBDIR}
)
find_path(FluidSynth_INCLUDE_PATH
NAMES fluidsynth.h
HINTS ${PC_FLUIDSYNTH_INCLUDEDIR}
)
if(PC_FLUIDSYNTH_FOUND)
get_flags_from_pkg_config("${FluidSynth_LIBRARY}" "PC_FLUIDSYNTH" "_fluidsynth")
endif()
set(FluidSynth_COMPILE_OPTIONS "${_fluidsynth_compile_options}" CACHE STRING "Extra compile options of FluidSynth")
set(FluidSynth_LINK_LIBRARIES "${_fluidsynth_link_libraries}" CACHE STRING "Extra link libraries of FluidSynth")
set(FluidSynth_LINK_OPTIONS "${_fluidsynth_link_options}" CACHE STRING "Extra link flags of FluidSynth")
set(FluidSynth_LINK_DIRECTORIES "${_fluidsynth_link_directories}" CACHE PATH "Extra link directories of FluidSynth")
find_package_handle_standard_args(FluidSynth
REQUIRED_VARS FluidSynth_LIBRARY FluidSynth_INCLUDE_PATH
)
if(FluidSynth_FOUND)
if(NOT TARGET FluidSynth::libfluidsynth)
add_library(FluidSynth::libfluidsynth UNKNOWN IMPORTED)
set_target_properties(FluidSynth::libfluidsynth PROPERTIES
IMPORTED_LOCATION "${FluidSynth_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${FluidSynth_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${FluidSynth_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${FluidSynth_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${FluidSynth_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${FluidSynth_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,49 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_OPUSFILE QUIET opusfile)
find_library(OpusFile_LIBRARY
NAMES opusfile
HINTS ${PC_OPUSFILE_LIBDIR}
)
find_path(OpusFile_INCLUDE_PATH
NAMES opusfile.h
PATH_SUFFIXES opus
HINTS ${PC_OPUSFILE_INCLUDEDIR}
)
if(PC_OPUSFILE_FOUND)
get_flags_from_pkg_config("${OpusFile_LIBRARY}" "PC_OPUSFILE" "_opusfile")
endif()
set(OpusFile_COMPILE_OPTIONS "${_opusfile_compile_options}" CACHE STRING "Extra compile options of opusfile")
set(OpusFile_LINK_LIBRARIES "${_opusfile_link_libraries}" CACHE STRING "Extra link libraries of opusfile")
set(OpusFile_LINK_OPTIONS "${_opusfile_link_options}" CACHE STRING "Extra link flags of opusfile")
set(OpusFile_LINK_DIRECTORIES "${_opusfile_link_directories}" CACHE PATH "Extra link directories of opusfile")
find_package_handle_standard_args(OpusFile
REQUIRED_VARS OpusFile_LIBRARY OpusFile_INCLUDE_PATH
)
if (OpusFile_FOUND)
set(OpusFile_dirs ${OpusFile_INCLUDE_PATH})
if(EXISTS "${OpusFile_INCLUDE_PATH}/opus")
list(APPEND OpusFile_dirs "${OpusFile_INCLUDE_PATH}/opus")
endif()
if (NOT TARGET OpusFile::opusfile)
add_library(OpusFile::opusfile UNKNOWN IMPORTED)
set_target_properties(OpusFile::opusfile PROPERTIES
IMPORTED_LOCATION "${OpusFile_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${OpusFile_dirs}"
INTERFACE_COMPILE_OPTIONS "${OpusFile_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${OpusFile_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${OpusFile_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${OpusFile_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_VORBIS QUIET vorbisfile)
find_library(Vorbis_vorbisfile_LIBRARY
NAMES vorbisfile
HINTS ${PC_VORBIS_LIBDIR}
)
find_path(Vorbis_vorbisfile_INCLUDE_PATH
NAMES vorbis/vorbisfile.h
HINTS ${PC_VORBIS_INCLUDEDIR}
)
if(PC_VORBIS_FOUND)
get_flags_from_pkg_config("${Vorbis_vorbisfile_LIBRARY}" "PC_VORBIS" "_vorbisfile")
endif()
set(Vorbis_vorbisfile_COMPILE_OPTIONS "${_vorbisfile_compile_options}" CACHE STRING "Extra compile options of vorbisfile")
set(Vorbis_vorbisfile_LINK_LIBRARIES "${_vorbisfile_link_libraries}" CACHE STRING "Extra link libraries of vorbisfile")
set(Vorbis_vorbisfile_LINK_OPTIONS "${_vorbisfile_link_options}" CACHE STRING "Extra link flags of vorbisfile")
set(Vorbis_vorbisfile_LINK_DIRECTORIES "${_vorbisfile_link_directories}" CACHE PATH "Extra link directories of vorbisfile")
find_package_handle_standard_args(Vorbis
REQUIRED_VARS Vorbis_vorbisfile_LIBRARY Vorbis_vorbisfile_INCLUDE_PATH
)
if (Vorbis_FOUND)
if (NOT TARGET Vorbis::vorbisfile)
add_library(Vorbis::vorbisfile UNKNOWN IMPORTED)
set_target_properties(Vorbis::vorbisfile PROPERTIES
IMPORTED_LOCATION "${Vorbis_vorbisfile_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_vorbisfile_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${Vorbis_vorbisfile_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${Vorbis_vorbisfile_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${Vorbis_vorbisfile_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${Vorbis_vorbisfile_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,48 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_GME QUIET libgme)
find_library(gme_LIBRARY
NAMES gme
HINTS ${PC_GME_LIBDIR}
)
find_path(gme_INCLUDE_PATH
NAMES gme/gme.h
HINTS ${PC_GME_INCLUDEDIR}
)
if(PC_GME_FOUND)
get_flags_from_pkg_config("${gme_LIBRARY}" "PC_GME" "_gme")
endif()
set(gme_COMPILE_OPTIONS "${_gme_compile_options}" CACHE STRING "Extra compile options of gme")
set(gme_LINK_LIBRARIES "${_gme_link_libraries}" CACHE STRING "Extra link libraries of gme")
set(gme_LINK_OPTIONS "${_gme_link_options}" CACHE STRING "Extra link flags of gme")
set(gme_LINK_DIRECTORIES "${_gme_link_directories}" CACHE PATH "Extra link directories of gme")
find_package_handle_standard_args(gme
REQUIRED_VARS gme_LIBRARY gme_INCLUDE_PATH
)
if(gme_FOUND)
set(gme_dirs ${gme_INCLUDE_PATH})
if(EXISTS "${gme_INCLUDE_PATH}/gme")
list(APPEND gme_dirs "${gme_INCLUDE_PATH}/gme")
endif()
if(NOT TARGET gme::gme)
add_library(gme::gme UNKNOWN IMPORTED)
set_target_properties(gme::gme PROPERTIES
IMPORTED_LOCATION "${gme_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${gme_dirs}"
INTERFACE_COMPILE_OPTIONS "${gme_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${gme_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${gme_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${gme_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,45 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_XMPLITE QUIET libxmp-lite)
find_library(libxmp_lite_LIBRARY
NAMES xmp-lite libxmp-lite
HINTS ${PC_XMPLITE_LIBDIR}
)
find_path(libxmp_lite_INCLUDE_PATH
NAMES xmp.h
PATH_SUFFIXES libxmp-lite
HINTS ${PC_XMPLITE_INCLUDEDIR}
)
if(PC_XMPLITE_FOUND)
get_flags_from_pkg_config("${libxmp_lite_LIBRARY}" "PC_XMPLITE" "_libxmp_lite")
endif()
set(libxmp_lite_COMPILE_OPTIONS "${_libxmp_lite_compile_options}" CACHE STRING "Extra compile options of libxmp_lite")
set(libxmp_lite_LINK_LIBRARIES "${_libxmp_lite_link_libraries}" CACHE STRING "Extra link libraries of libxmp_lite")
set(libxmp_lite_LINK_OPTIONS "${_libxmp_lite_link_options}" CACHE STRING "Extra link flags of libxmp_lite")
set(libxmp_lite_LINK_DIRECTORIES "${_libxmp_lite_link_directories}" CACHE PATH "Extra link directories of libxmp_lite")
find_package_handle_standard_args(libxmp-lite
REQUIRED_VARS libxmp_lite_LIBRARY libxmp_lite_INCLUDE_PATH
)
if(libxmp-lite_FOUND)
if(NOT TARGET libxmp-lite::libxmp-lite)
add_library(libxmp-lite::libxmp-lite UNKNOWN IMPORTED)
set_target_properties(libxmp-lite::libxmp-lite PROPERTIES
IMPORTED_LOCATION "${libxmp_lite_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${libxmp_lite_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${libxmp_lite_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${libxmp_lite_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${libxmp_lite_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${libxmp_lite_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_XMP QUIET libxmp)
find_library(libxmp_LIBRARY
NAMES xmp
HINTS ${PC_XMP_LIBDIR}
)
find_path(libxmp_INCLUDE_PATH
NAMES xmp.h
HINTS ${PC_XMP_INCLUDEDIR}
)
if(PC_XMP_FOUND)
get_flags_from_pkg_config("${libxmp_LIBRARY}" "PC_XMP" "_libxmp")
endif()
set(libxmp_COMPILE_OPTIONS "${_libxmp_compile_options}" CACHE STRING "Extra compile options of libxmp")
set(libxmp_LINK_LIBRARIES "${_libxmp_link_libraries}" CACHE STRING "Extra link libraries of libxmp")
set(libxmp_LINK_OPTIONS "${_libxmp_link_options}" CACHE STRING "Extra link flags of libxmp")
set(libxmp_LINK_DIRECTORIES "${_libxmp_link_directories}" CACHE PATH "Extra link flags of libxmp")
find_package_handle_standard_args(libxmp
REQUIRED_VARS libxmp_LIBRARY libxmp_INCLUDE_PATH
)
if(libxmp_FOUND)
if(NOT TARGET libxmp::libxmp)
add_library(libxmp::libxmp UNKNOWN IMPORTED)
set_target_properties(libxmp::libxmp PROPERTIES
IMPORTED_LOCATION "${libxmp_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${libxmp_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${libxmp_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${libxmp_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${libxmp_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${libxmp_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,43 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_MODPLUG QUIET libmodplug)
find_library(modplug_LIBRARY
NAMES modplug
)
find_path(modplug_INCLUDE_PATH
NAMES libmodplug/modplug.h
)
if(PC_MODPLUG_FOUND)
get_flags_from_pkg_config("${modplug_LIBRARY}" "PC_MODPLUG" "_modplug")
endif()
set(modplug_COMPILE_OPTIONS "${_modplug_compile_options}" CACHE STRING "Extra compile options of modplug")
set(modplug_LINK_LIBRARIES "${_modplug_link_libraries}" CACHE STRING "Extra link libraries of modplug")
set(modplug_LINK_OPTIONS "${_modplug_link_options}" CACHE STRING "Extra link flags of modplug")
set(modplug_LINK_DIRECTORIES "${_modplug_link_directories}" CACHE PATH "Extra link directories of modplug")
find_package_handle_standard_args(modplug
REQUIRED_VARS modplug_LIBRARY modplug_INCLUDE_PATH
)
if (modplug_FOUND)
if (NOT TARGET modplug::modplug)
add_library(modplug::modplug UNKNOWN IMPORTED)
set_target_properties(modplug::modplug PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_LOCATION "${modplug_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${modplug_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${modplug_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${modplug_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${modplug_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${modplug_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_MPG123 QUIET libmpg123)
find_library(mpg123_LIBRARY
NAMES mpg123
HINTS ${PC_MPG123_LIBDIR}
)
find_path(mpg123_INCLUDE_PATH
NAMES mpg123.h
HINTS ${PC_MPG123_INCLUDEDIR}
)
if(PC_MPG123_FOUND)
get_flags_from_pkg_config("${mpg123_LIBRARY}" "PC_MPG123" "_mpg123")
endif()
set(mpg123_COMPILE_OPTIONS "${_mpg123_compile_options}" CACHE STRING "Extra compile options of mpg123")
set(mpg123_LINK_LIBRARIES "${_mpg123_link_libraries}" CACHE STRING "Extra link libraries of mpg123")
set(mpg123_LINK_OPTIONS "${_mpg123_link_options}" CACHE STRING "Extra link flags of mpg123")
set(mpg123_LINK_DIRECTORIES "${_mpg123_link_directories}" CACHE PATH "Extra link directories of mpg123")
find_package_handle_standard_args(mpg123
REQUIRED_VARS mpg123_LIBRARY mpg123_INCLUDE_PATH
)
if(mpg123_FOUND)
if(NOT TARGET MPG123::libmpg123)
add_library(MPG123::libmpg123 UNKNOWN IMPORTED)
set_target_properties(MPG123::libmpg123 PROPERTIES
IMPORTED_LOCATION "${mpg123_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${mpg123_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${mpg123_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${mpg123_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${mpg123_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${mpg123_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_TREMOR QUIET vorbisidec)
find_library(tremor_LIBRARY
NAMES vorbisidec libvorbisidec
HINTS ${PC_TREMOR_LIBDIR}
)
find_path(tremor_INCLUDE_PATH
NAMES tremor/ivorbisfile.h
HINTS ${PC_TREMOR_INCLUDEDIR}
)
if(PC_TREMOR_FOUND)
get_flags_from_pkg_config("${tremor_LIBRARY}" "PC_TREMOR" "_tremor")
endif()
set(tremor_COMPILE_OPTIONS "${_tremor_compile_options}" CACHE STRING "Extra compile options of vorbis")
set(tremor_LINK_LIBRARIES "${_tremor_link_libraries}" CACHE STRING "Extra link libraries of vorbis")
set(tremor_LINK_OPTIONS "${_tremor_link_options}" CACHE STRING "Extra link flags of vorbis")
set(tremor_LINK_DIRECTORIES "${_tremor_link_directories}" CACHE PATH "Extra link directories of vorbis")
find_package_handle_standard_args(tremor
REQUIRED_VARS tremor_LIBRARY tremor_INCLUDE_PATH
)
if (tremor_FOUND)
if (NOT TARGET tremor::tremor)
add_library(tremor::tremor UNKNOWN IMPORTED)
set_target_properties(tremor::tremor PROPERTIES
IMPORTED_LOCATION "${tremor_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${tremor_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${tremor_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${tremor_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${tremor_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${tremor_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,37 +0,0 @@
include(FindPackageHandleStandardArgs)
if(WIN32)
set(wavpack_find_names wavpack libwavpack wavpackdll)
else()
set(wavpack_find_names wavpack)
endif()
find_library(wavpack_LIBRARY
NAMES ${wavpack_find_names}
)
find_path(wavpack_INCLUDE_PATH
NAMES wavpack/wavpack.h
)
set(wavpack_COMPILE_OPTIONS "" CACHE STRING "Extra compile options of wavpack")
set(wavpack_LINK_LIBRARIES "" CACHE STRING "Extra link libraries of wavpack")
set(wavpack_LINK_OPTIONS "" CACHE STRING "Extra link flags of wavpack")
find_package_handle_standard_args(wavpack
REQUIRED_VARS wavpack_LIBRARY wavpack_INCLUDE_PATH
)
if (wavpack_FOUND)
if (NOT TARGET WavPack::WavPack)
add_library(WavPack::WavPack UNKNOWN IMPORTED)
set_target_properties(WavPack::WavPack PROPERTIES
IMPORTED_LOCATION "${wavpack_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${wavpack_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${wavpack_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${wavpack_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${wavpack_LINK_OPTIONS}"
)
endif()
endif()
@@ -1,34 +0,0 @@
# Helper for Find modules
function(get_flags_from_pkg_config _library _pc_prefix _out_prefix)
if("${_library}" MATCHES "${CMAKE_STATIC_LIBRARY_SUFFIX}$")
set(_cflags ${_pc_prefix}_STATIC_CFLAGS_OTHER)
set(_link_libraries ${_pc_prefix}_STATIC_LIBRARIES)
set(_link_options ${_pc_prefix}_STATIC_LDFLAGS_OTHER)
set(_library_dirs ${_pc_prefix}_STATIC_LIBRARY_DIRS)
else()
set(_cflags ${_pc_prefix}_CFLAGS_OTHER)
set(_link_libraries ${_pc_prefix}_LIBRARIES)
set(_link_options ${_pc_prefix}_LDFLAGS_OTHER)
set(_library_dirs ${_pc_prefix}_LIBRARY_DIRS)
endif()
# The *_LIBRARIES lists always start with the library itself
list(POP_FRONT "${_link_libraries}")
# Work around CMake's flag deduplication when pc files use `-framework A` instead of `-Wl,-framework,A`
string(REPLACE "-framework;" "-Wl,-framework," "_filtered_link_options" "${${_link_options}}")
set(${_out_prefix}_compile_options
"${${_cflags}}"
PARENT_SCOPE)
set(${_out_prefix}_link_libraries
"${${_link_libraries}}"
PARENT_SCOPE)
set(${_out_prefix}_link_options
"${_filtered_link_options}"
PARENT_SCOPE)
set(${_out_prefix}_link_directories
"${${_library_dirs}}"
PARENT_SCOPE)
endfunction()
@@ -1,12 +0,0 @@
# sdl2_mixer cmake project-config-version input for ./configure scripts
set(PACKAGE_VERSION "2.8.1")
if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
set(PACKAGE_VERSION_COMPATIBLE TRUE)
if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
set(PACKAGE_VERSION_EXACT TRUE)
endif()
endif()
@@ -1,195 +0,0 @@
# sdl2_mixer cmake project-config input for ./configure scripts
include(FeatureSummary)
set_package_properties(SDL2_mixer PROPERTIES
URL "https://www.libsdl.org/projects/SDL_mixer/"
DESCRIPTION "SDL_mixer is a sample multi-channel audio mixer library"
)
set(SDL2_mixer_FOUND TRUE)
set(SDL2MIXER_VENDORED 0)
set(SDL2MIXER_CMD 0)
set(SDL2MIXER_FLAC_LIBFLAC 0)
set(SDL2MIXER_FLAC_DRFLAC 1)
if(SDL2MIXER_FLAC_LIBFLAC OR SDL2MIXER_FLAC_DRFLAC)
set(SDL2MIXER_FLAC 1)
else()
set(SDL2MIXER_FLAC 0)
endif()
set(SDL2MIXER_GME 1)
set(SDL2MIXER_MOD_MODPLUG 0)
set(SDL2MIXER_MOD_XMP 1)
set(SDL2MIXER_MOD_XMP_LITE 0)
if(SDL2MIXER_MOD_MODPLUG OR SDL2MIXER_MOD_XMP OR SDL2MIXER_MOD_XMP_LITE)
set(SDL2MIXER_MOD 1)
else()
set(SDL2MIXER_MOD 0)
endif()
set(SDL2MIXER_MP3_MINIMP3 1)
set(SDL2MIXER_MP3_MPG123 0)
if(SDL2MIXER_MP3_MINIMP3 OR SDL2MIXER_MP3_MPG123)
set(SDL2MIXER_MP3 1)
else()
set(SDL2MIXER_MP3 0)
endif()
set(SDL2MIXER_MIDI_FLUIDSYNTH 0)
set(SDL2MIXER_MIDI_NATIVE 1)
set(SDL2MIXER_MIDI_TIMIDITY 1)
if(SDL2MIXER_MIDI_FLUIDSYNTH OR SDL2MIXER_MIDI_NATIVE OR SDL2MIXER_MIDI_TIMIDITY)
set(SDL2MIXER_MIDI 1)
else()
set(SDL2MIXER_MIDI 0)
endif()
set(SDL2MIXER_OPUS 1)
set(SDL2MIXER_VORBIS)
set(SDL2MIXER_VORBIS_STB 1)
set(SDL2MIXER_VORBIS_VORBISFILE 0)
set(SDL2MIXER_VORBIS_TREMOR 0)
if(SDL2MIXER_VORBIS_STB)
set(SDL2MIXER_VORBIS STB)
endif()
if(SDL2MIXER_VORBIS_VORBISFILE)
set(SDL2MIXER_VORBIS VORBISFILE)
endif()
if(SDL2MIXER_VORBIS_TREMOR)
set(SDL2MIXER_VORBIS TREMOR)
endif()
set(SDL2MIXER_WAVE 1)
set(SDL2MIXER_WAVPACK 1)
set(SDL2MIXER_SDL2_REQUIRED_VERSION 2.0.9)
get_filename_component(CMAKE_CURRENT_LIST_DIR ${CMAKE_CURRENT_LIST_DIR} REALPATH)
get_filename_component(prefix "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE)
set(exec_prefix "${prefix}")
set(bindir "${prefix}/bin")
set(includedir "${prefix}/include")
set(libdir "${prefix}/lib")
set(_sdl2mixer_extra_static_libraries ";winmm")
string(REGEX REPLACE "(^[;]+|[;]+$)" "" _sdl2mixer_extra_static_libraries "${_sdl2mixer_extra_static_libraries}")
set(_sdl2mixer_bindir "${bindir}")
set(_sdl2mixer_libdir "${libdir}")
set(_sdl2mixer_incdir "${includedir}/SDL2")
include(CMakeFindDependencyMacro)
set(_original_cmake_module_path "${CMAKE_MODULE_PATH}")
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
include("${CMAKE_CURRENT_LIST_DIR}/PkgConfigHelper.cmake")
if("modplug::modplug" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(modplug)
endif()
if("libxmp::libxmp" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(libxmp)
endif()
if("libxmp-lite::libxmp-lite" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(libxmp-lite)
endif()
if("FluidSynth::libfluidsynth" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(FluidSynth)
endif()
if("Vorbis::vorbisfile" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(Vorbis)
endif()
if("tremor::tremor" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(tremor)
endif()
if("FLAC::FLAC" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(FLAC)
endif()
if("MPG123::libmpg123" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(mpg123)
endif()
if("OpusFile::opusfile" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(OpusFile)
endif()
if("WavPack::WavPack" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(wavpack)
endif()
set(CMAKE_MODULE_PATH "${_original_cmake_module_path}")
unset(_original_cmake_module_path)
unset(prefix)
unset(exec_prefix)
unset(bindir)
unset(includedir)
unset(libdir)
include(CMakeFindDependencyMacro)
if(NOT TARGET SDL2_mixer::SDL2_mixer)
if(WIN32)
set(_sdl2mixer_dll "${_sdl2mixer_bindir}/SDL2_mixer.dll")
set(_sdl2mixer_imp "${_sdl2mixer_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_mixer.dll${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_dll}" AND EXISTS "${_sdl2mixer_imp}")
add_library(SDL2_mixer::SDL2_mixer SHARED IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
IMPORTED_LOCATION "${_sdl2mixer_dll}"
IMPORTED_IMPLIB "${_sdl2mixer_imp}"
)
endif()
unset(_sdl2mixer_dll)
unset(_sdl2mixer_imp)
else()
set(_sdl2mixer_shl "${_sdl2mixer_libdir}/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2_mixer${CMAKE_SHARED_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_shl}")
add_library(SDL2_mixer::SDL2_mixer SHARED IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
IMPORTED_LOCATION "${_sdl2mixer_shl}"
)
endif()
endif()
if(TARGET SDL2_mixer::SDL2_mixer)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_sdl2mixer_incdir}"
COMPATIBLE_INTERFACE_BOOL "SDL2_SHARED"
INTERFACE_SDL2_SHARED "ON"
)
endif()
endif()
if(NOT TARGET SDL2_mixer::SDL2_mixer-static)
set(_sdl2mixer_stl "${_sdl2mixer_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_mixer${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_stl}")
add_library(SDL2_mixer::SDL2_mixer-static STATIC IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer-static
PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_sdl2mixer_incdir}"
IMPORTED_LOCATION "${_sdl2mixer_stl}"
INTERFACE_LINK_LIBRARIES "${_sdl2mixer_extra_static_libraries}"
)
endif()
unset(_sdl2mixer_stl)
endif()
unset(_sdl2mixer_extra_static_libraries)
unset(_sdl2mixer_bindir)
unset(_sdl2mixer_libdir)
unset(_sdl2mixer_incdir)
Binary file not shown.
@@ -17,15 +17,15 @@ old_library='libSDL2_mixer.a'
inherited_linker_flags=''
# Libraries that this one depends upon.
dependency_libs=' -L/tmp/tardir/SDL2_mixer-2.8.1/VisualC/external/optional/x86 -L/home/runner/work/SDL_mixer/SDL_mixer/deps/mingw-deps/i686-w64-mingw32/lib -lmingw32 /home/runner/work/SDL_mixer/SDL_mixer/deps/mingw-deps/i686-w64-mingw32/lib/libSDL2.la -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid -lwinmm'
dependency_libs=' -L/opt/local/i686-w64-mingw32/lib -lmingw32 /opt/local/i686-w64-mingw32/lib/libSDL2.la -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid -lwinmm'
# Names of additional weak libraries provided by this library
weak_library_names=''
# Version information for libSDL2_mixer.
current=800
age=800
revision=1
current=2
age=2
revision=2
# Is this an already installed library?
installed=yes
@@ -38,4 +38,4 @@ dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='/tmp/tardir/SDL2_mixer-2.8.1/build-mingw/install-i686-w64-mingw32/lib'
libdir='/Users/valve/release/SDL_mixer/SDL2_mixer-2.0.4/i686-w64-mingw32/lib'
@@ -1,13 +1,12 @@
prefix=/tmp/tardir/SDL2_mixer-2.8.1/build-mingw/install-i686-w64-mingw32
prefix=/opt/local/i686-w64-mingw32
exec_prefix=${prefix}
libdir=${prefix}/lib
libdir=${exec_prefix}/lib
includedir=${prefix}/include
Name: SDL2_mixer
Description: mixer library for Simple DirectMedia Layer
Version: 2.8.1
Requires: sdl2 >= 2.0.9
Version: 2.0.4
Requires: sdl2 >= 2.0.7
Libs: -L${libdir} -lSDL2_mixer
Cflags: -I${includedir}/SDL2
Requires.private:
Libs.private: -lwinmm
File diff suppressed because it is too large. Load diff
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_FLAC QUIET flac)
find_library(FLAC_LIBRARY
NAMES FLAC
HINTS ${PC_FLAC_LIBDIR}
)
find_path(FLAC_INCLUDE_PATH
NAMES FLAC/all.h
HINTS ${PC_FLAC_INCLUDEDIR}
)
if(PC_FLAC_FOUND)
get_flags_from_pkg_config("${FLAC_LIBRARY}" "PC_FLAC" "_flac")
endif()
set(FLAC_COMPILE_OPTIONS "${_flac_compile_options}" CACHE STRING "Extra compile options of FLAC")
set(FLAC_LINK_LIBRARIES "${_flac_link_libraries}" CACHE STRING "Extra link libraries of FLAC")
set(FLAC_LINK_OPTIONS "${_flac_link_options}" CACHE STRING "Extra link flags of FLAC")
set(FLAC_LINK_DIRECTORIES "${_flac_link_directories}" CACHE PATH "Extra link directories of FLAC")
find_package_handle_standard_args(FLAC
REQUIRED_VARS FLAC_LIBRARY FLAC_INCLUDE_PATH
)
if(FLAC_FOUND)
if(NOT TARGET FLAC::FLAC)
add_library(FLAC::FLAC UNKNOWN IMPORTED)
set_target_properties(FLAC::FLAC PROPERTIES
IMPORTED_LOCATION "${FLAC_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${FLAC_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${FLAC_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${FLAC_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${FLAC_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${FLAC_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_FLUIDSYNTH QUIET fluidsynth)
find_library(FluidSynth_LIBRARY
NAMES fluidsynth libfluidsynth
HINTS ${PC_FLUIDSYNTH_LIBDIR}
)
find_path(FluidSynth_INCLUDE_PATH
NAMES fluidsynth.h
HINTS ${PC_FLUIDSYNTH_INCLUDEDIR}
)
if(PC_FLUIDSYNTH_FOUND)
get_flags_from_pkg_config("${FluidSynth_LIBRARY}" "PC_FLUIDSYNTH" "_fluidsynth")
endif()
set(FluidSynth_COMPILE_OPTIONS "${_fluidsynth_compile_options}" CACHE STRING "Extra compile options of FluidSynth")
set(FluidSynth_LINK_LIBRARIES "${_fluidsynth_link_libraries}" CACHE STRING "Extra link libraries of FluidSynth")
set(FluidSynth_LINK_OPTIONS "${_fluidsynth_link_options}" CACHE STRING "Extra link flags of FluidSynth")
set(FluidSynth_LINK_DIRECTORIES "${_fluidsynth_link_directories}" CACHE PATH "Extra link directories of FluidSynth")
find_package_handle_standard_args(FluidSynth
REQUIRED_VARS FluidSynth_LIBRARY FluidSynth_INCLUDE_PATH
)
if(FluidSynth_FOUND)
if(NOT TARGET FluidSynth::libfluidsynth)
add_library(FluidSynth::libfluidsynth UNKNOWN IMPORTED)
set_target_properties(FluidSynth::libfluidsynth PROPERTIES
IMPORTED_LOCATION "${FluidSynth_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${FluidSynth_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${FluidSynth_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${FluidSynth_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${FluidSynth_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${FluidSynth_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,49 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_OPUSFILE QUIET opusfile)
find_library(OpusFile_LIBRARY
NAMES opusfile
HINTS ${PC_OPUSFILE_LIBDIR}
)
find_path(OpusFile_INCLUDE_PATH
NAMES opusfile.h
PATH_SUFFIXES opus
HINTS ${PC_OPUSFILE_INCLUDEDIR}
)
if(PC_OPUSFILE_FOUND)
get_flags_from_pkg_config("${OpusFile_LIBRARY}" "PC_OPUSFILE" "_opusfile")
endif()
set(OpusFile_COMPILE_OPTIONS "${_opusfile_compile_options}" CACHE STRING "Extra compile options of opusfile")
set(OpusFile_LINK_LIBRARIES "${_opusfile_link_libraries}" CACHE STRING "Extra link libraries of opusfile")
set(OpusFile_LINK_OPTIONS "${_opusfile_link_options}" CACHE STRING "Extra link flags of opusfile")
set(OpusFile_LINK_DIRECTORIES "${_opusfile_link_directories}" CACHE PATH "Extra link directories of opusfile")
find_package_handle_standard_args(OpusFile
REQUIRED_VARS OpusFile_LIBRARY OpusFile_INCLUDE_PATH
)
if (OpusFile_FOUND)
set(OpusFile_dirs ${OpusFile_INCLUDE_PATH})
if(EXISTS "${OpusFile_INCLUDE_PATH}/opus")
list(APPEND OpusFile_dirs "${OpusFile_INCLUDE_PATH}/opus")
endif()
if (NOT TARGET OpusFile::opusfile)
add_library(OpusFile::opusfile UNKNOWN IMPORTED)
set_target_properties(OpusFile::opusfile PROPERTIES
IMPORTED_LOCATION "${OpusFile_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${OpusFile_dirs}"
INTERFACE_COMPILE_OPTIONS "${OpusFile_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${OpusFile_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${OpusFile_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${OpusFile_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_VORBIS QUIET vorbisfile)
find_library(Vorbis_vorbisfile_LIBRARY
NAMES vorbisfile
HINTS ${PC_VORBIS_LIBDIR}
)
find_path(Vorbis_vorbisfile_INCLUDE_PATH
NAMES vorbis/vorbisfile.h
HINTS ${PC_VORBIS_INCLUDEDIR}
)
if(PC_VORBIS_FOUND)
get_flags_from_pkg_config("${Vorbis_vorbisfile_LIBRARY}" "PC_VORBIS" "_vorbisfile")
endif()
set(Vorbis_vorbisfile_COMPILE_OPTIONS "${_vorbisfile_compile_options}" CACHE STRING "Extra compile options of vorbisfile")
set(Vorbis_vorbisfile_LINK_LIBRARIES "${_vorbisfile_link_libraries}" CACHE STRING "Extra link libraries of vorbisfile")
set(Vorbis_vorbisfile_LINK_OPTIONS "${_vorbisfile_link_options}" CACHE STRING "Extra link flags of vorbisfile")
set(Vorbis_vorbisfile_LINK_DIRECTORIES "${_vorbisfile_link_directories}" CACHE PATH "Extra link directories of vorbisfile")
find_package_handle_standard_args(Vorbis
REQUIRED_VARS Vorbis_vorbisfile_LIBRARY Vorbis_vorbisfile_INCLUDE_PATH
)
if (Vorbis_FOUND)
if (NOT TARGET Vorbis::vorbisfile)
add_library(Vorbis::vorbisfile UNKNOWN IMPORTED)
set_target_properties(Vorbis::vorbisfile PROPERTIES
IMPORTED_LOCATION "${Vorbis_vorbisfile_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${Vorbis_vorbisfile_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${Vorbis_vorbisfile_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${Vorbis_vorbisfile_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${Vorbis_vorbisfile_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${Vorbis_vorbisfile_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,48 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_GME QUIET libgme)
find_library(gme_LIBRARY
NAMES gme
HINTS ${PC_GME_LIBDIR}
)
find_path(gme_INCLUDE_PATH
NAMES gme/gme.h
HINTS ${PC_GME_INCLUDEDIR}
)
if(PC_GME_FOUND)
get_flags_from_pkg_config("${gme_LIBRARY}" "PC_GME" "_gme")
endif()
set(gme_COMPILE_OPTIONS "${_gme_compile_options}" CACHE STRING "Extra compile options of gme")
set(gme_LINK_LIBRARIES "${_gme_link_libraries}" CACHE STRING "Extra link libraries of gme")
set(gme_LINK_OPTIONS "${_gme_link_options}" CACHE STRING "Extra link flags of gme")
set(gme_LINK_DIRECTORIES "${_gme_link_directories}" CACHE PATH "Extra link directories of gme")
find_package_handle_standard_args(gme
REQUIRED_VARS gme_LIBRARY gme_INCLUDE_PATH
)
if(gme_FOUND)
set(gme_dirs ${gme_INCLUDE_PATH})
if(EXISTS "${gme_INCLUDE_PATH}/gme")
list(APPEND gme_dirs "${gme_INCLUDE_PATH}/gme")
endif()
if(NOT TARGET gme::gme)
add_library(gme::gme UNKNOWN IMPORTED)
set_target_properties(gme::gme PROPERTIES
IMPORTED_LOCATION "${gme_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${gme_dirs}"
INTERFACE_COMPILE_OPTIONS "${gme_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${gme_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${gme_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${gme_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,45 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_XMPLITE QUIET libxmp-lite)
find_library(libxmp_lite_LIBRARY
NAMES xmp-lite libxmp-lite
HINTS ${PC_XMPLITE_LIBDIR}
)
find_path(libxmp_lite_INCLUDE_PATH
NAMES xmp.h
PATH_SUFFIXES libxmp-lite
HINTS ${PC_XMPLITE_INCLUDEDIR}
)
if(PC_XMPLITE_FOUND)
get_flags_from_pkg_config("${libxmp_lite_LIBRARY}" "PC_XMPLITE" "_libxmp_lite")
endif()
set(libxmp_lite_COMPILE_OPTIONS "${_libxmp_lite_compile_options}" CACHE STRING "Extra compile options of libxmp_lite")
set(libxmp_lite_LINK_LIBRARIES "${_libxmp_lite_link_libraries}" CACHE STRING "Extra link libraries of libxmp_lite")
set(libxmp_lite_LINK_OPTIONS "${_libxmp_lite_link_options}" CACHE STRING "Extra link flags of libxmp_lite")
set(libxmp_lite_LINK_DIRECTORIES "${_libxmp_lite_link_directories}" CACHE PATH "Extra link directories of libxmp_lite")
find_package_handle_standard_args(libxmp-lite
REQUIRED_VARS libxmp_lite_LIBRARY libxmp_lite_INCLUDE_PATH
)
if(libxmp-lite_FOUND)
if(NOT TARGET libxmp-lite::libxmp-lite)
add_library(libxmp-lite::libxmp-lite UNKNOWN IMPORTED)
set_target_properties(libxmp-lite::libxmp-lite PROPERTIES
IMPORTED_LOCATION "${libxmp_lite_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${libxmp_lite_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${libxmp_lite_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${libxmp_lite_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${libxmp_lite_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${libxmp_lite_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_XMP QUIET libxmp)
find_library(libxmp_LIBRARY
NAMES xmp
HINTS ${PC_XMP_LIBDIR}
)
find_path(libxmp_INCLUDE_PATH
NAMES xmp.h
HINTS ${PC_XMP_INCLUDEDIR}
)
if(PC_XMP_FOUND)
get_flags_from_pkg_config("${libxmp_LIBRARY}" "PC_XMP" "_libxmp")
endif()
set(libxmp_COMPILE_OPTIONS "${_libxmp_compile_options}" CACHE STRING "Extra compile options of libxmp")
set(libxmp_LINK_LIBRARIES "${_libxmp_link_libraries}" CACHE STRING "Extra link libraries of libxmp")
set(libxmp_LINK_OPTIONS "${_libxmp_link_options}" CACHE STRING "Extra link flags of libxmp")
set(libxmp_LINK_DIRECTORIES "${_libxmp_link_directories}" CACHE PATH "Extra link flags of libxmp")
find_package_handle_standard_args(libxmp
REQUIRED_VARS libxmp_LIBRARY libxmp_INCLUDE_PATH
)
if(libxmp_FOUND)
if(NOT TARGET libxmp::libxmp)
add_library(libxmp::libxmp UNKNOWN IMPORTED)
set_target_properties(libxmp::libxmp PROPERTIES
IMPORTED_LOCATION "${libxmp_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${libxmp_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${libxmp_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${libxmp_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${libxmp_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${libxmp_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,43 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_MODPLUG QUIET libmodplug)
find_library(modplug_LIBRARY
NAMES modplug
)
find_path(modplug_INCLUDE_PATH
NAMES libmodplug/modplug.h
)
if(PC_MODPLUG_FOUND)
get_flags_from_pkg_config("${modplug_LIBRARY}" "PC_MODPLUG" "_modplug")
endif()
set(modplug_COMPILE_OPTIONS "${_modplug_compile_options}" CACHE STRING "Extra compile options of modplug")
set(modplug_LINK_LIBRARIES "${_modplug_link_libraries}" CACHE STRING "Extra link libraries of modplug")
set(modplug_LINK_OPTIONS "${_modplug_link_options}" CACHE STRING "Extra link flags of modplug")
set(modplug_LINK_DIRECTORIES "${_modplug_link_directories}" CACHE PATH "Extra link directories of modplug")
find_package_handle_standard_args(modplug
REQUIRED_VARS modplug_LIBRARY modplug_INCLUDE_PATH
)
if (modplug_FOUND)
if (NOT TARGET modplug::modplug)
add_library(modplug::modplug UNKNOWN IMPORTED)
set_target_properties(modplug::modplug PROPERTIES
IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
IMPORTED_LOCATION "${modplug_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${modplug_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${modplug_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${modplug_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${modplug_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${modplug_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_MPG123 QUIET libmpg123)
find_library(mpg123_LIBRARY
NAMES mpg123
HINTS ${PC_MPG123_LIBDIR}
)
find_path(mpg123_INCLUDE_PATH
NAMES mpg123.h
HINTS ${PC_MPG123_INCLUDEDIR}
)
if(PC_MPG123_FOUND)
get_flags_from_pkg_config("${mpg123_LIBRARY}" "PC_MPG123" "_mpg123")
endif()
set(mpg123_COMPILE_OPTIONS "${_mpg123_compile_options}" CACHE STRING "Extra compile options of mpg123")
set(mpg123_LINK_LIBRARIES "${_mpg123_link_libraries}" CACHE STRING "Extra link libraries of mpg123")
set(mpg123_LINK_OPTIONS "${_mpg123_link_options}" CACHE STRING "Extra link flags of mpg123")
set(mpg123_LINK_DIRECTORIES "${_mpg123_link_directories}" CACHE PATH "Extra link directories of mpg123")
find_package_handle_standard_args(mpg123
REQUIRED_VARS mpg123_LIBRARY mpg123_INCLUDE_PATH
)
if(mpg123_FOUND)
if(NOT TARGET MPG123::libmpg123)
add_library(MPG123::libmpg123 UNKNOWN IMPORTED)
set_target_properties(MPG123::libmpg123 PROPERTIES
IMPORTED_LOCATION "${mpg123_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${mpg123_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${mpg123_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${mpg123_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${mpg123_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${mpg123_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,44 +0,0 @@
include(FindPackageHandleStandardArgs)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_TREMOR QUIET vorbisidec)
find_library(tremor_LIBRARY
NAMES vorbisidec libvorbisidec
HINTS ${PC_TREMOR_LIBDIR}
)
find_path(tremor_INCLUDE_PATH
NAMES tremor/ivorbisfile.h
HINTS ${PC_TREMOR_INCLUDEDIR}
)
if(PC_TREMOR_FOUND)
get_flags_from_pkg_config("${tremor_LIBRARY}" "PC_TREMOR" "_tremor")
endif()
set(tremor_COMPILE_OPTIONS "${_tremor_compile_options}" CACHE STRING "Extra compile options of vorbis")
set(tremor_LINK_LIBRARIES "${_tremor_link_libraries}" CACHE STRING "Extra link libraries of vorbis")
set(tremor_LINK_OPTIONS "${_tremor_link_options}" CACHE STRING "Extra link flags of vorbis")
set(tremor_LINK_DIRECTORIES "${_tremor_link_directories}" CACHE PATH "Extra link directories of vorbis")
find_package_handle_standard_args(tremor
REQUIRED_VARS tremor_LIBRARY tremor_INCLUDE_PATH
)
if (tremor_FOUND)
if (NOT TARGET tremor::tremor)
add_library(tremor::tremor UNKNOWN IMPORTED)
set_target_properties(tremor::tremor PROPERTIES
IMPORTED_LOCATION "${tremor_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${tremor_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${tremor_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${tremor_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${tremor_LINK_OPTIONS}"
INTERFACE_LINK_DIRECTORIES "${tremor_LINK_DIRECTORIES}"
)
endif()
endif()
@@ -1,37 +0,0 @@
include(FindPackageHandleStandardArgs)
if(WIN32)
set(wavpack_find_names wavpack libwavpack wavpackdll)
else()
set(wavpack_find_names wavpack)
endif()
find_library(wavpack_LIBRARY
NAMES ${wavpack_find_names}
)
find_path(wavpack_INCLUDE_PATH
NAMES wavpack/wavpack.h
)
set(wavpack_COMPILE_OPTIONS "" CACHE STRING "Extra compile options of wavpack")
set(wavpack_LINK_LIBRARIES "" CACHE STRING "Extra link libraries of wavpack")
set(wavpack_LINK_OPTIONS "" CACHE STRING "Extra link flags of wavpack")
find_package_handle_standard_args(wavpack
REQUIRED_VARS wavpack_LIBRARY wavpack_INCLUDE_PATH
)
if (wavpack_FOUND)
if (NOT TARGET WavPack::WavPack)
add_library(WavPack::WavPack UNKNOWN IMPORTED)
set_target_properties(WavPack::WavPack PROPERTIES
IMPORTED_LOCATION "${wavpack_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${wavpack_INCLUDE_PATH}"
INTERFACE_COMPILE_OPTIONS "${wavpack_COMPILE_OPTIONS}"
INTERFACE_LINK_LIBRARIES "${wavpack_LINK_LIBRARIES}"
INTERFACE_LINK_OPTIONS "${wavpack_LINK_OPTIONS}"
)
endif()
endif()
@@ -1,34 +0,0 @@
# Helper for Find modules
function(get_flags_from_pkg_config _library _pc_prefix _out_prefix)
if("${_library}" MATCHES "${CMAKE_STATIC_LIBRARY_SUFFIX}$")
set(_cflags ${_pc_prefix}_STATIC_CFLAGS_OTHER)
set(_link_libraries ${_pc_prefix}_STATIC_LIBRARIES)
set(_link_options ${_pc_prefix}_STATIC_LDFLAGS_OTHER)
set(_library_dirs ${_pc_prefix}_STATIC_LIBRARY_DIRS)
else()
set(_cflags ${_pc_prefix}_CFLAGS_OTHER)
set(_link_libraries ${_pc_prefix}_LIBRARIES)
set(_link_options ${_pc_prefix}_LDFLAGS_OTHER)
set(_library_dirs ${_pc_prefix}_LIBRARY_DIRS)
endif()
# The *_LIBRARIES lists always start with the library itself
list(POP_FRONT "${_link_libraries}")
# Work around CMake's flag deduplication when pc files use `-framework A` instead of `-Wl,-framework,A`
string(REPLACE "-framework;" "-Wl,-framework," "_filtered_link_options" "${${_link_options}}")
set(${_out_prefix}_compile_options
"${${_cflags}}"
PARENT_SCOPE)
set(${_out_prefix}_link_libraries
"${${_link_libraries}}"
PARENT_SCOPE)
set(${_out_prefix}_link_options
"${_filtered_link_options}"
PARENT_SCOPE)
set(${_out_prefix}_link_directories
"${${_library_dirs}}"
PARENT_SCOPE)
endfunction()
@@ -1,12 +0,0 @@
# sdl2_mixer cmake project-config-version input for ./configure scripts
set(PACKAGE_VERSION "2.8.1")
if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
set(PACKAGE_VERSION_COMPATIBLE FALSE)
else()
set(PACKAGE_VERSION_COMPATIBLE TRUE)
if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
set(PACKAGE_VERSION_EXACT TRUE)
endif()
endif()
@@ -1,195 +0,0 @@
# sdl2_mixer cmake project-config input for ./configure scripts
include(FeatureSummary)
set_package_properties(SDL2_mixer PROPERTIES
URL "https://www.libsdl.org/projects/SDL_mixer/"
DESCRIPTION "SDL_mixer is a sample multi-channel audio mixer library"
)
set(SDL2_mixer_FOUND TRUE)
set(SDL2MIXER_VENDORED 0)
set(SDL2MIXER_CMD 0)
set(SDL2MIXER_FLAC_LIBFLAC 0)
set(SDL2MIXER_FLAC_DRFLAC 1)
if(SDL2MIXER_FLAC_LIBFLAC OR SDL2MIXER_FLAC_DRFLAC)
set(SDL2MIXER_FLAC 1)
else()
set(SDL2MIXER_FLAC 0)
endif()
set(SDL2MIXER_GME 1)
set(SDL2MIXER_MOD_MODPLUG 0)
set(SDL2MIXER_MOD_XMP 1)
set(SDL2MIXER_MOD_XMP_LITE 0)
if(SDL2MIXER_MOD_MODPLUG OR SDL2MIXER_MOD_XMP OR SDL2MIXER_MOD_XMP_LITE)
set(SDL2MIXER_MOD 1)
else()
set(SDL2MIXER_MOD 0)
endif()
set(SDL2MIXER_MP3_MINIMP3 1)
set(SDL2MIXER_MP3_MPG123 0)
if(SDL2MIXER_MP3_MINIMP3 OR SDL2MIXER_MP3_MPG123)
set(SDL2MIXER_MP3 1)
else()
set(SDL2MIXER_MP3 0)
endif()
set(SDL2MIXER_MIDI_FLUIDSYNTH 0)
set(SDL2MIXER_MIDI_NATIVE 1)
set(SDL2MIXER_MIDI_TIMIDITY 1)
if(SDL2MIXER_MIDI_FLUIDSYNTH OR SDL2MIXER_MIDI_NATIVE OR SDL2MIXER_MIDI_TIMIDITY)
set(SDL2MIXER_MIDI 1)
else()
set(SDL2MIXER_MIDI 0)
endif()
set(SDL2MIXER_OPUS 1)
set(SDL2MIXER_VORBIS)
set(SDL2MIXER_VORBIS_STB 1)
set(SDL2MIXER_VORBIS_VORBISFILE 0)
set(SDL2MIXER_VORBIS_TREMOR 0)
if(SDL2MIXER_VORBIS_STB)
set(SDL2MIXER_VORBIS STB)
endif()
if(SDL2MIXER_VORBIS_VORBISFILE)
set(SDL2MIXER_VORBIS VORBISFILE)
endif()
if(SDL2MIXER_VORBIS_TREMOR)
set(SDL2MIXER_VORBIS TREMOR)
endif()
set(SDL2MIXER_WAVE 1)
set(SDL2MIXER_WAVPACK 1)
set(SDL2MIXER_SDL2_REQUIRED_VERSION 2.0.9)
get_filename_component(CMAKE_CURRENT_LIST_DIR ${CMAKE_CURRENT_LIST_DIR} REALPATH)
get_filename_component(prefix "${CMAKE_CURRENT_LIST_DIR}/../../.." ABSOLUTE)
set(exec_prefix "${prefix}")
set(bindir "${prefix}/bin")
set(includedir "${prefix}/include")
set(libdir "${prefix}/lib")
set(_sdl2mixer_extra_static_libraries ";winmm")
string(REGEX REPLACE "(^[;]+|[;]+$)" "" _sdl2mixer_extra_static_libraries "${_sdl2mixer_extra_static_libraries}")
set(_sdl2mixer_bindir "${bindir}")
set(_sdl2mixer_libdir "${libdir}")
set(_sdl2mixer_incdir "${includedir}/SDL2")
include(CMakeFindDependencyMacro)
set(_original_cmake_module_path "${CMAKE_MODULE_PATH}")
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
include("${CMAKE_CURRENT_LIST_DIR}/PkgConfigHelper.cmake")
if("modplug::modplug" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(modplug)
endif()
if("libxmp::libxmp" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(libxmp)
endif()
if("libxmp-lite::libxmp-lite" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(libxmp-lite)
endif()
if("FluidSynth::libfluidsynth" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(FluidSynth)
endif()
if("Vorbis::vorbisfile" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(Vorbis)
endif()
if("tremor::tremor" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(tremor)
endif()
if("FLAC::FLAC" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(FLAC)
endif()
if("MPG123::libmpg123" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(mpg123)
endif()
if("OpusFile::opusfile" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(OpusFile)
endif()
if("WavPack::WavPack" IN_LIST _sdl2mixer_extra_static_libraries)
find_dependency(wavpack)
endif()
set(CMAKE_MODULE_PATH "${_original_cmake_module_path}")
unset(_original_cmake_module_path)
unset(prefix)
unset(exec_prefix)
unset(bindir)
unset(includedir)
unset(libdir)
include(CMakeFindDependencyMacro)
if(NOT TARGET SDL2_mixer::SDL2_mixer)
if(WIN32)
set(_sdl2mixer_dll "${_sdl2mixer_bindir}/SDL2_mixer.dll")
set(_sdl2mixer_imp "${_sdl2mixer_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_mixer.dll${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_dll}" AND EXISTS "${_sdl2mixer_imp}")
add_library(SDL2_mixer::SDL2_mixer SHARED IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
IMPORTED_LOCATION "${_sdl2mixer_dll}"
IMPORTED_IMPLIB "${_sdl2mixer_imp}"
)
endif()
unset(_sdl2mixer_dll)
unset(_sdl2mixer_imp)
else()
set(_sdl2mixer_shl "${_sdl2mixer_libdir}/${CMAKE_SHARED_LIBRARY_PREFIX}SDL2_mixer${CMAKE_SHARED_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_shl}")
add_library(SDL2_mixer::SDL2_mixer SHARED IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
IMPORTED_LOCATION "${_sdl2mixer_shl}"
)
endif()
endif()
if(TARGET SDL2_mixer::SDL2_mixer)
set_target_properties(SDL2_mixer::SDL2_mixer
PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_sdl2mixer_incdir}"
COMPATIBLE_INTERFACE_BOOL "SDL2_SHARED"
INTERFACE_SDL2_SHARED "ON"
)
endif()
endif()
if(NOT TARGET SDL2_mixer::SDL2_mixer-static)
set(_sdl2mixer_stl "${_sdl2mixer_libdir}/${CMAKE_STATIC_LIBRARY_PREFIX}SDL2_mixer${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(EXISTS "${_sdl2mixer_stl}")
add_library(SDL2_mixer::SDL2_mixer-static STATIC IMPORTED)
set_target_properties(SDL2_mixer::SDL2_mixer-static
PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_sdl2mixer_incdir}"
IMPORTED_LOCATION "${_sdl2mixer_stl}"
INTERFACE_LINK_LIBRARIES "${_sdl2mixer_extra_static_libraries}"
)
endif()
unset(_sdl2mixer_stl)
endif()
unset(_sdl2mixer_extra_static_libraries)
unset(_sdl2mixer_bindir)
unset(_sdl2mixer_libdir)
unset(_sdl2mixer_incdir)
@@ -17,15 +17,15 @@ old_library='libSDL2_mixer.a'
inherited_linker_flags=''
# Libraries that this one depends upon.
dependency_libs=' -L/tmp/tardir/SDL2_mixer-2.8.1/VisualC/external/optional/x64 -L/home/runner/work/SDL_mixer/SDL_mixer/deps/mingw-deps/x86_64-w64-mingw32/lib -lmingw32 /home/runner/work/SDL_mixer/SDL_mixer/deps/mingw-deps/x86_64-w64-mingw32/lib/libSDL2.la -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid -lwinmm'
dependency_libs=' -L/opt/local/x86_64-w64-mingw32/lib -lmingw32 /opt/local/x86_64-w64-mingw32/lib/libSDL2.la -ldinput8 -ldxguid -ldxerr8 -luser32 -lgdi32 -limm32 -lole32 -loleaut32 -lshell32 -lsetupapi -lversion -luuid -lwinmm'
# Names of additional weak libraries provided by this library
weak_library_names=''
# Version information for libSDL2_mixer.
current=800
age=800
revision=1
current=2
age=2
revision=2
# Is this an already installed library?
installed=yes
@@ -38,4 +38,4 @@ dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='/tmp/tardir/SDL2_mixer-2.8.1/build-mingw/install-x86_64-w64-mingw32/lib'
libdir='/Users/valve/release/SDL_mixer/SDL2_mixer-2.0.4/x86_64-w64-mingw32/lib'
@@ -1,13 +1,12 @@
prefix=/tmp/tardir/SDL2_mixer-2.8.1/build-mingw/install-x86_64-w64-mingw32
prefix=/opt/local/x86_64-w64-mingw32
exec_prefix=${prefix}
libdir=${prefix}/lib
libdir=${exec_prefix}/lib
includedir=${prefix}/include
Name: SDL2_mixer
Description: mixer library for Simple DirectMedia Layer
Version: 2.8.1
Requires: sdl2 >= 2.0.9
Version: 2.0.4
Requires: sdl2 >= 2.0.7
Libs: -L${libdir} -lSDL2_mixer
Cflags: -I${includedir}/SDL2
Requires.private:
Libs.private: -lwinmm
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+1
View File
@@ -49,6 +49,7 @@
# Already enabled by default for 32-bit
# Windows.
# NOCURL=1 - Disable libcurl--HTTP capability.
# NOHOLEPUNCH=1 - Disable holepunch capability.
# NOLIBGME=1 - Disable game music emu, retro VGM support.
# NOOPENMPT=1 - Disable module (tracker) music support.
# NOMIXER=1 - Disable SDL Mixer (audio playback).
+3 -2
View File
@@ -6,7 +6,9 @@ passthru_opts+=\
NOHW NOMD5 NOPOSTPROCESSING\
MOBJCONSISTANCY PACKETDROP ZDEBUG\
HAVE_MINIUPNPC\
HAVE_DISCORDRPC DEVELOP
HAVE_DISCORDRPC DEVELOP\
NOHOLEPUNCH\
NOOPENMPT\
# build with debugging information
ifdef DEBUGMODE
@@ -90,7 +92,6 @@ endif
default_packages:=\
LIBGME/libgme/LIBGME\
OPENMPT/libopenmpt/LIBOPENMPT\
ZLIB/zlib\
$(foreach p,$(default_packages),\
+12 -8
View File
@@ -29,8 +29,19 @@ ifndef NOHW
sources+=sdl/ogl_sdl.c
endif
ifndef NOOPENMPT
LIBOPENMPT_PKGCONFIG?=libopenmpt
$(eval $(call Use_pkg_config,LIBOPENMPT))
opts+=-DHAVE_OPENMPT
endif
NOMIXER=1
ifdef NOMIXER
#sources+=sdl/dummy_sound.c
sources+=sdl/sdl_sound.c
SNDFILE_PKGCONFIG?=sndfile
$(eval $(call Use_pkg_config,SNDFILE))
else
opts+=-DHAVE_MIXER
sources+=sdl/mixer_sound.c
@@ -45,15 +56,8 @@ opts+=-DHAVE_THREADS
sources+=sdl/i_threads.c
endif
ifdef SDL_PKGCONFIG
SDL_PKGCONFIG?=sdl3
$(eval $(call Use_pkg_config,SDL))
else
SDL_CONFIG?=$(call Prefix,sdl2-config)
SDL_CFLAGS?=$(shell $(SDL_CONFIG) --cflags)
SDL_LDFLAGS?=$(shell $(SDL_CONFIG) \
$(if $(STATIC),--static-libs,--libs))
$(eval $(call Propogate_flags,SDL))
endif
ifdef MINGW
ifndef NOSDLMAIN
+4 -2
View File
@@ -144,8 +144,10 @@ ifdef GCC81
WFLAGS+=-Wno-error=multistatement-macros
endif
ifeq ($(CC),clang)
WFLAGS+= -Wno-unknown-pragmas -Wno-cast-align
ifneq (,$(filter $(CC) $(CXX),clang clang++))
WFLAGS+= -Wno-unknown-pragmas
WFLAGS+= -Wno-cast-align
WFLAGS+= -Wno-cast-qual # not a fan, but clang really hates our read macros
endif
ifdef NONX86
+3 -3
View File
@@ -79,14 +79,14 @@ $(eval $(call _set,LIBOPENMPT))
lib:=../libs/SDL2_mixer/$(mingw)
ifdef SDL
mixer_opts:=-I$(lib)/include/SDL2
mixer_opts:=-I$(lib)/include/SDL3
mixer_libs:=-L$(lib)/lib
lib:=../libs/SDL2/$(mingw)
SDL_opts:=-I$(lib)/include/SDL2\
SDL_opts:=-I$(lib)/include/SDL3\
$(mixer_opts) -Dmain=SDL_main
SDL_libs:=-L$(lib)/lib $(mixer_libs)\
-lmingw32 -lSDL2main -lSDL2 -mwindows
-lmingw32 -lSDL3main -lSDL3 -mwindows
$(eval $(call _set,SDL))
endif
+3 -3
View File
@@ -48,13 +48,13 @@ v_video.c
w_wad.c
y_inter.c
z_zone.cpp
r_bsp.c
r_bsp.cpp
r_data.c
r_draw.c
r_draw.cpp
r_fps.cpp
r_main.cpp
r_patch.cpp
r_patchrotation.c
r_patchrotation.cpp
r_plane.cpp
r_segs.cpp
r_skins.c
+2 -12
View File
@@ -50,25 +50,15 @@ const char *VID_GetModeName(INT32 modenum)
return "A320x240";
}
void I_UpdateNoBlit(void){}
void I_FinishUpdate(void) {
void I_FinishUpdate(void)
{
LOGD("FRAME!");
(*jni_env)->CallVoidMethod(jni_env, androidVideo, videoFrameCB);
}
void I_UpdateNoVsync(void) {}
void I_WaitVBL(INT32 count)
{
(void)count;
}
void I_ReadScreen(UINT8 * restrict scr, INT32 scale)
{
(void)scr;
}
void I_BeginRead(void){}
void I_EndRead(void){}
+1 -1
View File
@@ -434,7 +434,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {
LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
lua_lock(L);
luaC_checkGC(L);
setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
setsvalue2s(L, L->top, (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len));
api_incr_top(L);
lua_unlock(L);
}
+4 -2
View File
@@ -24,6 +24,8 @@
#include "lauxlib.h"
#include "../doomdef.h"
#define FREELIST_REF 0 /* free list of references */
@@ -40,7 +42,7 @@ LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {
if (!lua_getstack(L, 0, &ar)) /* no stack frame? */
return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);
lua_getinfo(L, "n", &ar);
if (strcmp(ar.namewhat, "method") == 0) {
if (fastcmp(ar.namewhat, "method")) {
narg--; /* do not count `self' */
if (narg == 0) /* error is in the self argument itself? */
return luaL_error(L, "calling " LUA_QS " on bad self (%s)",
@@ -97,7 +99,7 @@ LUALIB_API int luaL_checkoption (lua_State *L, int narg, const char *def,
luaL_checkstring(L, narg);
int i;
for (i=0; lst[i]; i++)
if (strcmp(lst[i], name) == 0)
if (fastcmp(lst[i], name))
return i;
return luaL_argerror(L, narg,
lua_pushfstring(L, "invalid option " LUA_QS, name));
+5 -3
View File
@@ -161,12 +161,13 @@ static int io_tostring (lua_State *L) {
static int StartsWith(const char *a, const char *b) // this is wolfs being lazy yet again
{
if(strncmp(a, b, strlen(b)) == 0) return 1;
if (strncmp(a, b, strlen(b)) == 0) return 1;
return 0;
}
static int io_open (lua_State *L) {
static int io_open(lua_State *L)
{
FILE **pf;
const char *filename = luaL_checkstring(L, 1);
int pass = 0;
@@ -178,12 +179,13 @@ static int io_open (lua_State *L) {
for (i = 0; i < (sizeof (whitelist) / sizeof(const char *)); i++)
{
if (!stricmp(&filename[length - strlen(whitelist[i])], whitelist[i]))
if (fasticmp(&filename[length - strlen(whitelist[i])], whitelist[i]))
{
pass = 1;
break;
}
}
if (l_unlikely(strstr(filename, "..") || strchr(filename, ':') || StartsWith(filename, "\\")
|| StartsWith(filename, "/") || !pass))
{
+33 -31
View File
@@ -1,7 +1,8 @@
// SONIC ROBO BLAST 2
// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 1998-2000 by DooM Legacy Team.
// Copyright (C) 1999-2025 by Sonic Team Junior.
// Copyright (C) 2025 by Kart Krew.
// Copyright (C) 2020 by Sonic Team Junior.
// Copyright (C) 2000 by DooM Legacy Team.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
@@ -24,8 +25,9 @@ extern "C" {
//
// Little-endian machines
//
#define WRITEUINT8(p,b) do { UINT8 *p_tmp = ( UINT8 *)p; const UINT8 tv = ( UINT8)(b); memcpy(p, &tv, sizeof( UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
#define WRITESINT8(p,b) do { SINT8 *p_tmp = ( SINT8 *)p; const SINT8 tv = ( UINT8)(b); memcpy(p, &tv, sizeof( UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
#define WRITESINT8(p,b) do { SINT8 *p_tmp = ( SINT8 *)p; const SINT8 tv = ( SINT8)(b); memcpy(p, &tv, sizeof( SINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
#define WRITEINT16(p,b) do { INT16 *p_tmp = ( INT16 *)p; const INT16 tv = ( INT16)(b); memcpy(p, &tv, sizeof( INT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
#define WRITEUINT16(p,b) do { UINT16 *p_tmp = ( UINT16 *)p; const UINT16 tv = ( UINT16)(b); memcpy(p, &tv, sizeof( UINT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
#define WRITEINT32(p,b) do { INT32 *p_tmp = ( INT32 *)p; const INT32 tv = ( INT32)(b); memcpy(p, &tv, sizeof( INT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; } while (0)
@@ -36,25 +38,25 @@ extern "C" {
// what is this?
#if defined (__GNUC__)
#define READUINT8(p) ({ UINT8 *p_tmp = (UINT8 *)p; UINT8 b; memcpy(&b, p, sizeof( UINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READSINT8(p) ({ SINT8 *p_tmp = (SINT8 *)p; SINT8 b; memcpy(&b, p, sizeof( SINT8)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READINT16(p) ({ INT16 *p_tmp = (INT16 *)p; INT16 b; memcpy(&b, p, sizeof( INT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READUINT16(p) ({ UINT16 *p_tmp = (UINT16 *)p; UINT16 b; memcpy(&b, p, sizeof( UINT16)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READINT32(p) ({ INT32 *p_tmp = (INT32 *)p; INT32 b; memcpy(&b, p, sizeof( INT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READUINT32(p) ({ UINT32 *p_tmp = (UINT32 *)p; UINT32 b; memcpy(&b, p, sizeof( UINT32)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READCHAR(p) ({ char *p_tmp = (char *)p; char b; memcpy(&b, p, sizeof( char)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READFIXED(p) ({ fixed_t *p_tmp = (fixed_t *)p; fixed_t b; memcpy(&b, p, sizeof(fixed_t)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READANGLE(p) ({ angle_t *p_tmp = (angle_t *)p; angle_t b; memcpy(&b, p, sizeof(angle_t)); p_tmp++; *(void**)(&(p)) = (void *)p_tmp; b; })
#define READUINT8(p) ({ const UINT8 *p_tmp = (const UINT8 *)p; UINT8 b; memcpy(&b, p, sizeof( UINT8)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READSINT8(p) ({ const SINT8 *p_tmp = (const SINT8 *)p; SINT8 b; memcpy(&b, p, sizeof( SINT8)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READINT16(p) ({ const INT16 *p_tmp = (const INT16 *)p; INT16 b; memcpy(&b, p, sizeof( INT16)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READUINT16(p) ({ const UINT16 *p_tmp = (const UINT16 *)p; UINT16 b; memcpy(&b, p, sizeof( UINT16)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READINT32(p) ({ const INT32 *p_tmp = (const INT32 *)p; INT32 b; memcpy(&b, p, sizeof( INT32)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READUINT32(p) ({ const UINT32 *p_tmp = (const UINT32 *)p; UINT32 b; memcpy(&b, p, sizeof( UINT32)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READCHAR(p) ({ const char *p_tmp = (const char *)p; char b; memcpy(&b, p, sizeof( char)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READFIXED(p) ({ const fixed_t *p_tmp = (const fixed_t *)p; fixed_t b; memcpy(&b, p, sizeof(fixed_t)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#define READANGLE(p) ({ const angle_t *p_tmp = (const angle_t *)p; angle_t b; memcpy(&b, p, sizeof(angle_t)); p_tmp++; *(const void**)(&(p)) = (const void *)p_tmp; b; })
#else
#define READUINT8(p) ((UINT8*)(*(void**)(&(p)) = (void*)&((UINT8*)(p))[1]))[-1]
#define READSINT8(p) ((SINT8*)(*(void**)(&(p)) = (void*)&((SINT8*)(p))[1]))[-1]
#define READINT16(p) ((INT16*)(*(void**)(&(p)) = (void*)&((INT16*)(p))[1]))[-1]
#define READUINT16(p) ((UINT16*)(*(void**)(&(p)) = (void*)&((UINT16*)(p))[1]))[-1]
#define READINT32(p) ((INT32*)(*(void**)(&(p)) = (void*)&((INT32*)(p))[1]))[-1]
#define READUINT32(p) ((UINT32*)(*(void**)(&(p)) = (void*)&((UINT32*)(p))[1]))[-1]
#define READCHAR(p) ((char*)(*(void**)(&(p)) = (void*)&((char*)(p))[1]))[-1]
#define READFIXED(p) ((fixed_t*)(*(void**)(&(p)) = (void*)&((fixed_t*)(p))[1]))[-1]
#define READANGLE(p) ((angle_t*)(*(void**)(&(p)) = (void*)&((angle_t*)(p))[1]))[-1]
#define READUINT8(p) ((const UINT8*) (*(const void**)(&(p)) = (const void*)&((const UINT8*) (p))[1]))[-1]
#define READSINT8(p) ((const SINT8*) (*(const void**)(&(p)) = (const void*)&((const SINT8*) (p))[1]))[-1]
#define READINT16(p) ((const INT16*) (*(const void**)(&(p)) = (const void*)&((const INT16*) (p))[1]))[-1]
#define READUINT16(p) ((const UINT16*) (*(const void**)(&(p)) = (const void*)&((const UINT16*) (p))[1]))[-1]
#define READINT32(p) ((const INT32*) (*(const void**)(&(p)) = (const void*)&((const INT32*) (p))[1]))[-1]
#define READUINT32(p) ((const UINT32*) (*(const void**)(&(p)) = (const void*)&((const UINT32*) (p))[1]))[-1]
#define READCHAR(p) ((const char*) (*(const void**)(&(p)) = (const void*)&((const char*) (p))[1]))[-1]
#define READFIXED(p) ((const fixed_t*)(*(const void**)(&(p)) = (const void*)&((const fixed_t*)(p))[1]))[-1]
#define READANGLE(p) ((const angle_t*)(*(const void**)(&(p)) = (const void*)&((const angle_t*)(p))[1]))[-1]
#endif
#else //SRB2_BIG_ENDIAN
@@ -117,15 +119,15 @@ FUNCINLINE static ATTRINLINE UINT32 readulong(void *ptr)
return (ucp[3] << 24) | (ucp[2] << 16) | (ucp[1] << 8) | ucp[0];
}
#define READUINT8(p) ((UINT8*)(p = (void*)&((UINT8*)p)[1]))[-1]
#define READSINT8(p) ((SINT8*)(p = (void*)&((SINT8*)p)[1]))[-1]
#define READINT16(p) readshort(&((INT16*)(p = (void*)&((INT16*)p)[1]))[-1])
#define READUINT16(p) readushort(&((UINT16*)(p = (void*)&((UINT16*)p)[1]))[-1])
#define READINT32(p) readlong(&((INT32*)(p = (void*)&((INT32*)p)[1]))[-1])
#define READUINT32(p) readulong(&((UINT32*)(p = (void*)&((UINT32*)p)[1]))
#define READCHAR(p) ((char*)(p = (void*)&((char*)p)[1]))[-1]
#define READFIXED(p) readlong(&((fixed_t*)(p = (void*)&((fixed_t*)p)[1]))[-1])
#define READANGLE(p) readulong(&((angle_t*)(p = (void*)&((angle_t*)p)[1]))[-1])
#define READUINT8(p) ((const UINT8*)(p = (const void*)&((const UINT8*)p)[1]))[-1]
#define READSINT8(p) ((const SINT8*)(p = (const void*)&((const SINT8*)p)[1]))[-1]
#define READINT16(p) readshort(&((const INT16*)(p = (const void*)&((const INT16*)p)[1]))[-1])
#define READUINT16(p) readushort(&((const UINT16*)(p = (const void*)&((const UINT16*)p)[1]))[-1])
#define READINT32(p) readlong(&((const INT32*)(p = (const void*)&((const INT32*)p)[1]))[-1])
#define READUINT32(p) readulong(&((const UINT32*)(p = (const void*)&((const UINT32*)p)[1]))[-1])
#define READCHAR(p) ((const char*)(p = (const void*)&((const char*)p)[1]))[-1]
#define READFIXED(p) readlong(&((const fixed_t*)(p = (const void*)&((const fixed_t*)p)[1]))[-1])
#define READANGLE(p) readulong(&((const angle_t*)(p = (const void*)&((const angle_t*)p)[1]))[-1])
#endif //SRB2_BIG_ENDIAN
#define WRITESTRINGN(p, s, n) do { \
+65 -59
View File
@@ -57,7 +57,6 @@ static void CV_EnforceExecVersion(void);
static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr);
static boolean CV_Command(void);
consvar_t *CV_FindVar(const char *name);
static const char *CV_StringValue(const char *var_name);
static consvar_t *consvar_vars; // list of registered console variables
@@ -142,7 +141,7 @@ void COM_BufInsertText(const char *ptext)
templen = com_text.cursize;
if (templen)
{
temp = M_Memcpy(ZZ_Alloc(templen), com_text.data, templen);
temp = memcpy(ZZ_Alloc(templen), com_text.data, templen);
VS_Clear(&com_text);
}
@@ -199,7 +198,7 @@ void COM_BufExecute(void)
break;
}
M_Memcpy(line, ptext, i);
memcpy(line, ptext, i);
line[i] = 0;
// flush the command text from the command buffer, _BEFORE_
@@ -238,10 +237,13 @@ void COM_ImmedExecute(const char *ptext)
char line[1024] = "";
INT32 quotes;
while (i < strlen(ptext))
const size_t txtlength = strlen(ptext);
while (i < txtlength)
{
quotes = 0;
for (j = 0; i < strlen(ptext); i++,j++)
for (j = 0; i < txtlength; i++,j++)
{
if (ptext[i] == '\"' && !quotes && i > 0 && ptext[i-1] != ' ') // Malformed command
return;
@@ -277,11 +279,11 @@ static xcommand_t *com_commands = NULL; // current commands
#define MAX_ARGS 80
static size_t com_argc;
char *com_argv[MAX_ARGS];
char *com_argv[MAX_ARGS] = {};
static const char *com_null_string = "";
static char *com_args = NULL; // current command args or NULL
static void Got_NetVar(UINT8 **p, INT32 playernum);
static void Got_NetVar(const UINT8 **p, INT32 playernum);
/** Initializes command buffer and adds basic commands.
*/
@@ -359,7 +361,7 @@ size_t COM_CheckParm(const char *check)
size_t i;
for (i = 1; i < com_argc; i++)
if (!strcasecmp(check, com_argv[i]))
if (fasticmp(check, com_argv[i]))
return i;
return 0;
}
@@ -456,7 +458,7 @@ void COM_AddCommand(const char *name, com_func_t func)
// fail if the command already exists
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (!stricmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
if (fasticmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
{
// don't I_Error for Lua commands
// Lua commands can replace game commands, and they have priority.
@@ -492,7 +494,7 @@ int COM_AddLuaCommand(const char *name)
// command already exists
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (!stricmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
if (fasticmp(name, cmd->name)) //case insensitive now that we have lower and uppercase!
{
// replace the built in command.
cmd->function = COM_Lua_f;
@@ -519,7 +521,7 @@ static boolean COM_Exists(const char *com_name)
xcommand_t *cmd;
for (cmd = com_commands; cmd; cmd = cmd->next)
if (!stricmp(com_name, cmd->name))
if (fasticmp(com_name, cmd->name))
return true;
return false;
@@ -571,7 +573,7 @@ static void COM_ExecuteString(char *ptext)
// check functions
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (!stricmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
if (fasticmp(com_argv[0], cmd->name)) //case insensitive now that we have lower and uppercase!
{
cmd->function();
return;
@@ -581,7 +583,7 @@ static void COM_ExecuteString(char *ptext)
// check aliases
for (a = com_alias; a; a = a->next)
{
if (!stricmp(com_argv[0], a->name))
if (fasticmp(com_argv[0], a->name))
{
if (recursion > MAX_ALIAS_RECURSION)
CONS_Alert(CONS_WARNING, M_GetText("Alias recursion cycle detected!\n"));
@@ -836,7 +838,7 @@ static void COM_Help_f(void)
if (cvar->PossibleValue)
{
{
if (!stricmp(cvar->PossibleValue[0].strvalue, "MIN") && !stricmp(cvar->PossibleValue[1].strvalue, "MAX"))
if (fasticmp(cvar->PossibleValue[0].strvalue, "MIN") && fasticmp(cvar->PossibleValue[1].strvalue, "MAX"))
{
if (floatmode)
{
@@ -879,7 +881,7 @@ static void COM_Help_f(void)
{
for (cmd = com_commands; cmd; cmd = cmd->next)
{
if (strcmp(cmd->name, help))
if (!fastcmp(cmd->name, help))
continue;
CONS_Printf("\x82""Command %s:\n", cmd->name);
@@ -1129,7 +1131,7 @@ void *VS_GetSpace(vsbuf_t *buf, size_t length)
*/
void VS_Write(vsbuf_t *buf, const void *data, size_t length)
{
M_Memcpy(VS_GetSpace(buf, length), data, length);
memcpy(VS_GetSpace(buf, length), data, length);
}
/** Prints text in a variable buffer. Like VS_Write() plus a
@@ -1146,9 +1148,9 @@ void VS_Print(vsbuf_t *buf, const char *data)
len = strlen(data) + 1;
if (buf->data[buf->cursize-1])
M_Memcpy((UINT8 *)VS_GetSpace(buf, len), data, len); // no trailing 0
memcpy((UINT8 *)VS_GetSpace(buf, len), data, len); // no trailing 0
else
M_Memcpy((UINT8 *)VS_GetSpace(buf, len-1) - 1, data, len); // write over trailing 0
memcpy((UINT8 *)VS_GetSpace(buf, len-1) - 1, data, len); // write over trailing 0
}
// =========================================================================
@@ -1176,7 +1178,7 @@ consvar_t *CV_FindVar(const char *name)
consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if (!stricmp(name,cvar->name))
if (fasticmp(name,cvar->name))
return cvar;
return NULL;
@@ -1366,7 +1368,7 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
v = INT32_MIN; // Invalid integer trigger
}
if (var->PossibleValue[0].strvalue && !stricmp(var->PossibleValue[0].strvalue, "MIN")) // bounded cvar
if (var->PossibleValue[0].strvalue && fasticmp(var->PossibleValue[0].strvalue, "MIN")) // bounded cvar
{
#define MINVAL 0
#define MAXVAL 1
@@ -1379,21 +1381,21 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
// search for other
for (i = MAXVAL+1; var->PossibleValue[i].strvalue; i++)
if (v == var->PossibleValue[i].value || !stricmp(var->PossibleValue[i].strvalue, valstr))
if (v == var->PossibleValue[i].value || fasticmp(var->PossibleValue[i].strvalue, valstr))
{
var->value = var->PossibleValue[i].value;
var->string = var->PossibleValue[i].strvalue;
goto finish;
}
if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || !stricmp(valstr, "MIN"))
if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || fasticmp(valstr, "MIN"))
{
v = var->PossibleValue[MINVAL].value;
valstr = var->PossibleValue[MINVAL].strvalue;
override = true;
overrideval = v;
}
else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || !stricmp(valstr, "MAX"))
else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || fasticmp(valstr, "MAX"))
{
v = var->PossibleValue[MAXVAL].value;
valstr = var->PossibleValue[MAXVAL].strvalue;
@@ -1411,7 +1413,7 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
// check first strings
for (i = 0; var->PossibleValue[i].strvalue; i++)
if (!stricmp(var->PossibleValue[i].strvalue, valstr))
if (fasticmp(var->PossibleValue[i].strvalue, valstr))
goto found;
if (v != INT32_MIN)
{
@@ -1424,9 +1426,9 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
if (var->PossibleValue == CV_OnOff || var->PossibleValue == CV_YesNo)
{
overrideval = -1;
if (!stricmp(valstr, "on") || !stricmp(valstr, "yes"))
if (fasticmp(valstr, "on") || fasticmp(valstr, "yes"))
overrideval = 1;
else if (!stricmp(valstr, "off") || !stricmp(valstr, "no"))
else if (fasticmp(valstr, "off") || fasticmp(valstr, "no"))
overrideval = 0;
if (overrideval != -1)
@@ -1474,7 +1476,7 @@ finish:
var->flags |= CV_MODIFIED;
// raise 'on change' code
LUA_CVarChanged(var->name); // let consolelib know what cvar this is.
LUA_CVarChanged(var); // let consolelib know what cvar this is.
if (var->flags & CV_CALL && !stealth)
var->func();
@@ -1500,11 +1502,11 @@ badinput:
static boolean serverloading = false;
static void Got_NetVar(UINT8 **p, INT32 playernum)
static void Got_NetVar(const UINT8 **p, INT32 playernum)
{
consvar_t *cvar;
UINT16 netid;
char *svalue;
const char *svalue;
UINT8 stealth = false;
if (playernum != serverplayer && !IsPlayerAdmin(playernum) && !serverloading)
@@ -1518,9 +1520,10 @@ static void Got_NetVar(UINT8 **p, INT32 playernum)
}
return;
}
netid = READUINT16(*p);
cvar = CV_FindNetVar(netid);
svalue = (char *)*p;
svalue = (const char *)*p;
SKIPSTRING(*p);
stealth = READUINT8(*p);
@@ -1576,8 +1579,9 @@ void CV_SaveNetVars(UINT8 **p, boolean isdemorecording)
WRITEUINT16(count_p, count);
}
void CV_LoadNetVars(UINT8 **p)
size_t CV_LoadNetVars(const UINT8 *bufstart)
{
const UINT8 *p = bufstart;
consvar_t *cvar;
UINT16 count;
@@ -1588,11 +1592,13 @@ void CV_LoadNetVars(UINT8 **p)
if (cvar->flags & CV_NETVAR)
Setvalue(cvar, cvar->defaultvalue, true);
count = READUINT16(*p);
count = READUINT16(p);
while (count--)
Got_NetVar(p, 0);
Got_NetVar(&p, 0);
serverloading = false;
return p - bufstart;
}
static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth);
@@ -1610,7 +1616,7 @@ void CV_ResetCheatNetVars(void)
// Returns true if the variable's current value is its default value
boolean CV_IsSetToDefault(consvar_t *v)
{
return (!(strcmp(v->defaultvalue, v->string)));
return (fastcmp(v->defaultvalue, v->string));
}
// If any cheats CVars are not at their default settings, return true.
@@ -1622,7 +1628,7 @@ UINT8 CV_CheatsEnabled(void)
consvar_t *cvar;
for (cvar = consvar_vars; cvar; cvar = cvar->next)
if ((cvar->flags & CV_CHEAT) && strcmp(cvar->defaultvalue, cvar->string))
if ((cvar->flags & CV_CHEAT) && !fastcmp(cvar->defaultvalue, cvar->string))
return 1;
return 0;
}
@@ -1643,7 +1649,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
if (!var->string)
I_Error("CV_Set: %s no string set!\n", var->name);
#endif
if (!var || !var->string || !value || !stricmp(var->string, value))
if (!var || !var->string || !value || fasticmp(var->string, value))
return; // no changes
if (var->flags & CV_NETVAR)
@@ -1665,7 +1671,7 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
if (var == &cv_kartspeed && !M_SecretUnlocked(SECRET_HARDSPEED))
{
if (!stricmp(value, "Hard") || atoi(value) == 2)
if (fasticmp(value, "Hard") || atoi(value) == 2)
{
CONS_Alert(CONS_NOTICE, "You haven't unlocked this yet!\n");
return;
@@ -1799,7 +1805,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
}
#define MINVAL 0
#define MAXVAL 1
else if (var->PossibleValue[MINVAL].strvalue && !strcmp(var->PossibleValue[MINVAL].strvalue, "MIN"))
else if (var->PossibleValue[MINVAL].strvalue && fastcmp(var->PossibleValue[MINVAL].strvalue, "MIN"))
{ // SRB2Kart
#ifdef PARANOIA
if (!var->PossibleValue[MAXVAL].strvalue)
@@ -1971,12 +1977,12 @@ static boolean CV_FilterJoyAxisVars(consvar_t *v, const char *valstr)
{
if (joyaxis_default[i])
{
if (!stricmp(v->name, "joyaxis_fire"))
if (fasticmp(v->name, "joyaxis_fire"))
{
if (joyaxis_count[i] > 7) return false;
else if (joyaxis_count[i] == 7) return true;
if (!stricmp(valstr, "None")) joyaxis_count[i]++;
if (fasticmp(valstr, "None")) joyaxis_count[i]++;
else joyaxis_default[i] = false;
}
// reset all axis settings to defaults
@@ -2008,37 +2014,37 @@ static boolean CV_FilterJoyAxisVars(consvar_t *v, const char *valstr)
// Block the Xbox DInput default axes and reset to the current defaults
static boolean CV_FilterJoyAxisVars2(consvar_t *v, const char *valstr)
{
if (!stricmp(v->name, "joyaxis_turn") && !stricmp(valstr, "X-Axis"))
if (fasticmp(v->name, "joyaxis_turn") && fasticmp(valstr, "X-Axis"))
return false;
if (!stricmp(v->name, "joyaxis2_turn") && !stricmp(valstr, "X-Axis"))
if (fasticmp(v->name, "joyaxis2_turn") && fasticmp(valstr, "X-Axis"))
return false;
if (!stricmp(v->name, "joyaxis3_turn") && !stricmp(valstr, "X-Axis"))
if (fasticmp(v->name, "joyaxis3_turn") && fasticmp(valstr, "X-Axis"))
return false;
if (!stricmp(v->name, "joyaxis4_turn") && !stricmp(valstr, "X-Axis"))
if (fasticmp(v->name, "joyaxis4_turn") && fasticmp(valstr, "X-Axis"))
return false;
if (!stricmp(v->name, "joyaxis_aim") && !stricmp(valstr, "Y-Axis"))
if (fasticmp(v->name, "joyaxis_aim") && fasticmp(valstr, "Y-Axis"))
return false;
if (!stricmp(v->name, "joyaxis2_aim") && !stricmp(valstr, "Y-Axis"))
if (fasticmp(v->name, "joyaxis2_aim") && fasticmp(valstr, "Y-Axis"))
return false;
if (!stricmp(v->name, "joyaxis3_aim") && !stricmp(valstr, "Y-Axis"))
if (fasticmp(v->name, "joyaxis3_aim") && fasticmp(valstr, "Y-Axis"))
return false;
if (!stricmp(v->name, "joyaxis4_aim") && !stricmp(valstr, "Y-Axis"))
if (fasticmp(v->name, "joyaxis4_aim") && fasticmp(valstr, "Y-Axis"))
return false;
if (!stricmp(v->name, "joyaxis_fire") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis_fire") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis2_fire") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis2_fire") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis3_fire") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis3_fire") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis4_fire") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis4_fire") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis_drift") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis_drift") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis2_drift") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis2_drift") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis3_drift") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis3_drift") && fasticmp(valstr, "None"))
return false;
if (!stricmp(v->name, "joyaxis4_drift") && !stricmp(valstr, "None"))
if (fasticmp(v->name, "joyaxis4_drift") && fasticmp(valstr, "None"))
return false;
return true;
@@ -2055,8 +2061,8 @@ static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr)
if (GETMAJOREXECVERSION(cv_execversion.value) < 8) // 8 = 1.4
{
if (!stricmp(v->name, "masterserver") // Replaces a hack in MasterServer_OnChange for the original SRB2 MS.
|| !stricmp(v->name, "gamma")) // Too easy to accidentially change in prior versions.
if (fasticmp(v->name, "masterserver") // Replaces a hack in MasterServer_OnChange for the original SRB2 MS.
|| fasticmp(v->name, "gamma")) // Too easy to accidentially change in prior versions.
return false;
}
@@ -2139,7 +2145,7 @@ void CV_SaveVariables(FILE *f)
char stringtowrite[MAXTEXTCMD+1];
// Silly hack for Min/Max vars
if (!strcmp(cvar->string, "MAX") || !strcmp(cvar->string, "MIN"))
if (fastcmp(cvar->string, "MAX") || fastcmp(cvar->string, "MIN"))
{
if (cvar->flags & CV_FLOAT)
sprintf(stringtowrite, "%f", FixedToFloat(cvar->value));
+1 -1
View File
@@ -182,7 +182,7 @@ void CV_SaveVariables(FILE *f);
// load/save gamesate (load and save option and for network join in game)
void CV_SaveNetVars(UINT8 **p, boolean isdemorecording);
void CV_LoadNetVars(UINT8 **p);
size_t CV_LoadNetVars(const UINT8 *p);
// reset cheat netvars after cheats is deactivated
void CV_ResetCheatNetVars(void);
+34 -9
View File
@@ -33,6 +33,8 @@
#include "d_main.h"
#include "m_menu.h"
#include "m_textinput.h"
#include "m_emotes.h"
#include "i_time.h"
#include "filesrch.h"
#ifdef HWRENDER
@@ -58,7 +60,7 @@ I_mutex con_mutex;
static boolean con_started = false; // console has been initialised
boolean con_startup = false; // true at game startup, screen need refreshing
static boolean con_forcepic = true; // at startup toggle console translucency when first off
boolean con_recalc; // set true when screen size has changed
boolean con_recalc = false; // set true when screen size has changed
static tic_t con_tick; // console ticker for anim or blinking prompt cursor
// con_scrollup should use time (currenttime - lasttime)..
@@ -66,8 +68,8 @@ static tic_t con_tick; // console ticker for anim or blinking prompt cursor
static boolean consoletoggle; // true when console key pushed, ticker will handle
static boolean consoleready; // console prompt is ready
INT32 con_destlines; // vid lines used by console at final position
static INT32 con_curlines; // vid lines currently used by console
INT32 con_destlines = 0; // vid lines used by console at final position
static INT32 con_curlines; // vid lines currently used by console
static UINT8 con_hudlines; // number of console heads up message lines
static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
@@ -83,7 +85,7 @@ static size_t con_totallines; // lines of console text into the console buf
static size_t con_width; // columns of chars, depend on vid mode width
static size_t con_scrollup; // how many rows of text to scroll up (pgup/pgdn)
UINT32 con_scalefactor; // text size scale factor
UINT32 con_scalefactor = 0; // text size scale factor
// hold 32 last lines of input for history
#define CON_MAXPROMPTCHARS 256
@@ -521,7 +523,7 @@ static void CON_RecalcSize(void)
oldcon_width = con_width;
oldnumlines = con_totallines;
oldcon_cy = con_cy;
M_Memcpy(tmp_buffer, con_buffer, CON_BUFFERSIZE);
memcpy(tmp_buffer, con_buffer, CON_BUFFERSIZE);
if (conw < 1)
con_width = (BASEVIDWIDTH>>3) - 2;
@@ -547,7 +549,7 @@ static void CON_RecalcSize(void)
{
if (tmp_buffer[(i%oldnumlines)*oldcon_width])
{
M_Memcpy(string, &tmp_buffer[(i%oldnumlines)*oldcon_width], oldcon_width);
memcpy(string, &tmp_buffer[(i%oldnumlines)*oldcon_width], oldcon_width);
conw = oldcon_width - 1;
while (string[conw] == ' ' && conw)
conw--;
@@ -1010,7 +1012,7 @@ boolean CON_Responder(event_t *ev)
Lock_state();
// Only add command to history if it differs from previous one
if (strcmp(input.buffer, inputlines[(inputline-1) & 31]))
if (!fastcmp(input.buffer, inputlines[(inputline-1) & 31]))
{
inputline = (inputline+1) & 31;
M_TextInputInit(&input, inputlines[inputline], CON_MAXPROMPTCHARS);
@@ -1453,7 +1455,18 @@ static void CON_DrawHudlines(void)
}
if (c >= con_width)
break;
if (*p < HU_FONTSTART)
int emotelen;
emote_t *emote;
if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
{
M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
p += emotelen-1;
c += emotelen-1;
continue;
}
else if (*p < HU_FONTSTART)
;//charwidth = 4 * con_scalefactor;
else
{
@@ -1485,7 +1498,7 @@ static void CON_DrawConsole(void)
// draw console background
if (cons_backpic.value || con_forcepic)
{
patch_t *con_backpic = W_CachePatchName("KARTKREW", PU_PATCH_LOWPRIORITY);
patch_t *con_backpic = W_CachePatchName("KARTKREW", PU_PATCH);
// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, con_backpic, NULL);
@@ -1527,8 +1540,20 @@ static void CON_DrawConsole(void)
p++;
c++;
}
if (c >= con_width)
break;
int emotelen;
emote_t *emote;
if ((emote = M_VerifyEmote((const char *)p, &emotelen)))
{
M_DrawScaledEmote(x<<FRACBITS, (y+2*con_scalefactor)<<FRACBITS, charwidth*FRACUNIT/EMOTEWIDTH, emote, V_NOSCALESTART|V_NOSCALEPATCH);
p += emotelen-1;
c += emotelen-1;
continue;
}
V_DrawCharacter(x, y, (INT32)(*p) | charflags | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
}
}
+45
View File
@@ -147,6 +147,51 @@ public:
template <class T>
NotNull(T) -> NotNull<T>;
// does a super safe cast from floating point to interger types
// this prob could be better since i suck at ceepeepee
// but atleast we can just template shit to our desired types
template <typename FloatT, typename IntT>
static inline IntT floattoint(FloatT val)
{
// :chaosleep:
static_assert(std::is_floating_point_v<FloatT>, "Input must be a floating-point type");
static_assert(std::is_integral_v<IntT>, "Output must be a integer type");
if (std::fpclassify(val) == FP_NAN)
return 0; // if stuffs not a number we sure screwed up lmao
// treat inifinity as "int min/max"
if (std::fpclassify(val) == FP_INFINITE)
{
// yes infinity can be signed kek
if (std::signbit(val))
return std::numeric_limits<IntT>::min(); // negative infinity, so return min
else
return std::numeric_limits<IntT>::max();
}
// make sure we fit into our targettype uwu
if (val > static_cast<FloatT>(std::numeric_limits<IntT>::max()))
return std::numeric_limits<IntT>::max();
else if (val < static_cast<FloatT>(std::numeric_limits<IntT>::min()))
return std::numeric_limits<IntT>::min();
return static_cast<IntT>(val);
}
// safe float to fixed
// which handles nan and inf
// pretty much the same stuff as the above, but uh, idk how id use the above with this
template <typename FloatT> // can use both float and doubles yay
static inline int32_t floattofixed(FloatT val)
{
// :chaosleep:
static_assert(std::is_floating_point_v<FloatT>, "Input must be a floating-point type");
// fixed_t is just an int32_t, i dont wanna include doomtype here if it can be avoided
return floattoint<FloatT, int32_t>(val * 65535.);
}
} // namespace srb2
#endif // __SRB2_CXXUTIL_HPP__
+165 -74
View File
@@ -53,6 +53,8 @@
#include "m_perfstats.h"
#include "d_main.h"
#include "r_fps.h"
#include "filesrch.h" // refreshdirmenu
// cl loading screen
#include "v_video.h"
@@ -78,14 +80,14 @@
#define MAX_REASONLENGTH 30
#define FORCECLOSE 0x8000
static long long unsigned packetstat[NUMPACKETTYPE+1] = {0};
static long long unsigned packetstat[NUMPACKETTYPE+1] = {};
boolean server = true; // true or false but !server == client
#define client (!server)
boolean nodownload = false;
boolean serverrunning = false;
INT32 serverplayer = 0;
char motd[254], server_context[8]; // Message of the Day, Unique Context (even without Mumble support)
char motd[254] = {}, server_context[8] = {}; // Message of the Day, Unique Context (even without Mumble support)
#define MAP_ICON_REQUEST_FREQUENCY 8
@@ -98,14 +100,13 @@ static int map_icon_request_count; // current count of icon requests sent
static UINT8 *map_icon_data;
static patch_t *map_icon;
plrinfo playerinfo[MAXPLAYERS];
plrinfo playerinfo[MAXPLAYERS] = {};
SINT8 joinnode = 0; // used for CL_VIEWSERVER
boolean player_muted[MAXPLAYERS] = {0};
boolean player_muted[MAXPLAYERS] = {};
// Server specific vars
UINT8 playernode[MAXPLAYERS];
UINT8 playernode[MAXPLAYERS] = {};
// Minimum timeout for sending the savegame
// The actual timeout will be longer depending on the savegame length
@@ -118,15 +119,15 @@ static tic_t savegameresendcooldown[MAXNETNODES]; // How long before we can rese
static tic_t freezetimeout[MAXNETNODES]; // Until when can this node freeze the server before getting a timeout?
UINT16 pingmeasurecount = 1;
UINT32 realpingtable[MAXPLAYERS]; //the base table of ping where an average will be sent to everyone.
UINT32 playerpingtable[MAXPLAYERS]; //table of player latency values.
UINT32 realpingtable[MAXPLAYERS] = {}; //the base table of ping where an average will be sent to everyone.
UINT32 playerpingtable[MAXPLAYERS] = {}; //table of player latency values.
#define GENTLEMANSMOOTHING (TICRATE)
static tic_t reference_lag;
static tic_t reference_lag = 0;
static UINT8 spike_time;
tic_t lowest_lag;
tic_t simulated_lag;
boolean server_lagless;
tic_t lowest_lag = 0;
tic_t simulated_lag = 0;
boolean server_lagless = true;
static void Lagless_OnChange(void)
{
@@ -144,12 +145,17 @@ static CV_PossibleValue_t mindelay_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL
consvar_t cv_mindelay = {"mindelay", "0", CV_SAVE, mindelay_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_gentlemens = {"gentlemensdelay", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, Lagless_OnChange, 0, NULL, NULL, 0, 0, NULL}; // this should be a netvar Zzz...
SINT8 nodetoplayer[MAXNETNODES];
SINT8 nodetoplayer2[MAXNETNODES]; // say the numplayer for this node if any (splitscreen)
SINT8 nodetoplayer3[MAXNETNODES]; // say the numplayer for this node if any (splitscreen == 2)
SINT8 nodetoplayer4[MAXNETNODES]; // say the numplayer for this node if any (splitscreen == 3)
UINT8 playerpernode[MAXNETNODES]; // used specialy for splitscreen
boolean nodeingame[MAXNETNODES]; // set false as nodes leave game
// allows a fake player to appear on the ms and serverlist when your dedi server is empty
static void FakeSeed_OnChange(void);
consvar_t cv_usefakeseed = {"fakeseed", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, FakeSeed_OnChange, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_fakeseedname = {"fakeseedname", "Player 1", CV_SAVE|CV_CALL|CV_NOINIT, NULL, FakeSeed_OnChange, 0, NULL, NULL, 0, 0, NULL};
SINT8 nodetoplayer[MAXNETNODES] = {};
SINT8 nodetoplayer2[MAXNETNODES] = {}; // say the numplayer for this node if any (splitscreen)
SINT8 nodetoplayer3[MAXNETNODES] = {}; // say the numplayer for this node if any (splitscreen == 2)
SINT8 nodetoplayer4[MAXNETNODES] = {}; // say the numplayer for this node if any (splitscreen == 3)
UINT8 playerpernode[MAXNETNODES] = {}; // used specialy for splitscreen
boolean nodeingame[MAXNETNODES] = {}; // set false as nodes leave game
tic_t servermaxping = 20; // server's max delay, in frames. Defaults to 20
static tic_t nettics[MAXNETNODES]; // what tic the client have received
@@ -196,7 +202,7 @@ boolean is_client_saturn[MAXNETNODES];
static UINT8 localtextcmd[MAXSPLITSCREENPLAYERS][MAXTEXTCMD];
static tic_t neededtic;
SINT8 servernode = 0; // the number of the server node
char connectedservername[MAXSERVERNAME+1];
char connectedservername[MAXSERVERNAME+1] = {};
/// \brief do we accept new players?
/// \todo WORK!
boolean acceptnewnode = true;
@@ -227,7 +233,7 @@ struct textcmdbuf_s
static textcmdbuf_t *textcmdbuf[MAXSPLITSCREENPLAYERS] = {NULL};
static ticcmd_t playercmds[MAXPLAYERS];
ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS];
ticcmd_t netcmds[BACKUPTICS][MAXPLAYERS] = {};
static textcmdtic_t *textcmds[TEXTCMD_HASH_SIZE] = {NULL};
consvar_t cv_showjoinaddress = {"showjoinaddress", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -241,6 +247,13 @@ consvar_t cv_httpsource = {"http_source", "", CV_SAVE, NULL, NULL, 0, NULL, NULL
consvar_t cv_kicktime = {"kicktime", "10", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL};
static void FakeSeed_OnChange(void)
{
#ifdef MASTERSERVER
Update_MS();
#endif
}
static boolean UseLocalDelay(void)
{
if (dedicated || (server && server_lagless && !cv_mindelay.value) || modeattacking == ATTACKING_RECORD)
@@ -285,7 +298,7 @@ static inline void *G_ScpyTiccmd(ticcmd_t* dest, void* src, const size_t n)
// Some software don't support largest packet
// (original sersetup, not exactely, but the probability of sending a packet
// of 512 bytes is like 0.1)
UINT16 software_MAXPACKETLENGTH;
UINT16 software_MAXPACKETLENGTH = 0;
/** Guesses the value of a tic from its lowest byte and from maketic
*
@@ -312,9 +325,9 @@ static inline tic_t ExpandTics(INT32 low, tic_t basetic)
// Some extra data function for handle textcmd buffer
// -----------------------------------------------------------------
static void (*listnetxcmd[MAXNETXCMD])(UINT8 **p, INT32 playernum);
static void (*listnetxcmd[MAXNETXCMD])(const UINT8 **p, INT32 playernum);
void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum))
void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(const UINT8 **p, INT32 playernum))
{
#ifdef PARANOIA
if (id >= MAXNETXCMD)
@@ -331,7 +344,7 @@ static void WriteNetXCmd(UINT8 *cmd, netxcmd_t id, const void *param, size_t npa
cmd[cmd[0]] = (UINT8)id;
if (param && nparam)
{
M_Memcpy(&cmd[cmd[0]+1], param, nparam);
memcpy(&cmd[cmd[0]+1], param, nparam);
cmd[0] = (UINT8)(cmd[0] + (UINT8)nparam);
}
}
@@ -460,12 +473,12 @@ static void ExtraDataTicker(void)
{
if (playeringame[i] || i == 0)
{
UINT8 *bufferstart = D_GetExistingTextcmd(gametic, i);
const UINT8 *bufferstart = D_GetExistingTextcmd(gametic, i);
if (bufferstart)
{
UINT8 *curpos = bufferstart;
UINT8 *bufferend = &curpos[curpos[0]+1];
const UINT8 *curpos = bufferstart;
const UINT8 *bufferend = &curpos[curpos[0]+1];
curpos++;
while (curpos < bufferend)
@@ -494,10 +507,12 @@ static void ExtraDataTicker(void)
}
// If you are a client, you can safely forget the net commands for this tic
// If you are the server, you need to remember them until every client has been aknowledged,
// because if you need to resend a PT_SERVERTICS packet, you need to put the commands in it
// If you are the server, you need to remember them until every client has been acknowledged,
// because if you need to resend a PT_SERVERTICS packet, you will need to put the commands in it
if (client)
{
D_FreeTextcmd(gametic);
}
}
static void D_Clearticcmd(tic_t tic)
@@ -1356,10 +1371,19 @@ static inline void CL_DrawConnectionStatus(void)
V_DrawThinString(12 + 80, 58, V_ALLOWLOWERCASE|V_YELLOWMAP, "Vanilla");
}
if (serverlist[joinnode].info.cheatsenabled)
const UINT8 serverkartspeed = (serverlist[joinnode].info.kartvars & SV_SPEEDMASK);
if (serverkartspeed == 2)
V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, 58, V_ALLOWLOWERCASE|V_REDMAP, "Hard Speed");
else if (serverkartspeed == 1)
V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, 58, V_ALLOWLOWERCASE|V_BLUEMAP, "Normal Speed");
else
V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, 58, V_ALLOWLOWERCASE|V_GREENMAP, "Easy Speed");
/*if (serverlist[joinnode].info.cheatsenabled)
{
V_DrawRightAlignedThinString(BASEVIDWIDTH - 12, 58, V_ALLOWLOWERCASE|V_GREENMAP, "Cheats");
}
}*/
V_DrawFill(8, 72, BASEVIDWIDTH - 16, 112, 239);
@@ -1379,10 +1403,16 @@ static inline void CL_DrawConnectionStatus(void)
if (playerinfo[i].node < 255)
{
strncpy(player_name, playerinfo[i].name, MAXPLAYERNAME);
V_DrawThinString(x + 10, y, V_ALLOWLOWERCASE|V_6WIDTHSPACE, player_name);
// if we get a skin color
// try to colourize the player name
if (playerinfo[i].data > 0 && playerinfo[i].data < MAXSKINCOLORS)
V_DrawThinString(x + 10, y, V_ALLOWLOWERCASE|V_6WIDTHSPACE, va("%s%s ", HU_SkinColorToConsoleColor(playerinfo[i].data), player_name));
else
V_DrawThinString(x + 10, y, V_ALLOWLOWERCASE|V_6WIDTHSPACE, player_name);
if (playerinfo[i].team == 0) { statuscolor = 184; } // playing
if (playerinfo[i].data & 0x20) { statuscolor = 86; } // tag IT
//if (playerinfo[i].data & 0x20) { statuscolor = 86; } // tag IT
if (playerinfo[i].team == 1) { statuscolor = 128; } // ctf red team
if (playerinfo[i].team == 2) { statuscolor = 232; } // ctf blue team
if (playerinfo[i].team == 255) { statuscolor = 16; } // spectator or non-team
@@ -1427,12 +1457,14 @@ static inline void CL_DrawConnectionStatus(void)
V_DrawFill(BASEVIDWIDTH/2-128, BASEVIDHEIGHT-58, dldlength, 8, 160);
memset(tempname, 0, sizeof(tempname));
// offset filename to just the name only part
filename += strlen(filename) - nameonlylength(filename);
const size_t filenamelength = strlen(filename);
if (strlen(filename) > sizeof(tempname)-1) // too long to display fully
if (filenamelength > sizeof(tempname)-1) // too long to display fully
{
size_t endhalfpos = strlen(filename)-10;
size_t endhalfpos = filenamelength-10;
// display as first 14 chars + ... + last 10 chars
// which should add up to 27 if our math(s) is correct
snprintf(tempname, sizeof(tempname), "%.14s...%.10s", filename, filename+endhalfpos);
@@ -1545,6 +1577,12 @@ static boolean CL_SendJoin(void)
return HSendPacket(servernode, false, 0, sizeof(clientconfig_pak));
}
static boolean UseFakeSeed(void)
{
// due to complexity this will disable the moment a real player joins
return (dedicated && cv_usefakeseed.value && D_NumPlayers() == 0);
}
static void SV_SendServerInfo(INT32 node, tic_t servertime)
{
UINT8 *p;
@@ -1567,7 +1605,12 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
// force 1 player
if (UseFakeSeed())
netbuffer->u.serverinfo.numberofplayer = (UINT8)1;
else
netbuffer->u.serverinfo.numberofplayer = (UINT8)D_NumPlayers();
netbuffer->u.serverinfo.maxplayer = (UINT8)(min((dedicated ? MAXPLAYERS-1 : MAXPLAYERS), cv_maxplayers.value));
// SRB2Kart: Vanilla's gametype constants for MS support
@@ -1585,7 +1628,7 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
MAXSERVERNAME);
strncpy(netbuffer->u.serverinfo.mapname, G_BuildMapName(gamemap), sizeof(netbuffer->u.serverinfo.mapname)-1);
M_Memcpy(netbuffer->u.serverinfo.mapmd5, mapmd5, sizeof(netbuffer->u.serverinfo.mapmd5));
memcpy(netbuffer->u.serverinfo.mapmd5, mapmd5, sizeof(netbuffer->u.serverinfo.mapmd5));
netbuffer->u.serverinfo.iszone = 0;
@@ -1646,6 +1689,37 @@ static void SV_SendPlayerInfo(INT32 node)
netbuffer->packettype = PT_PLAYERINFO;
// send a fake player to trick ms and serverbrowser
if (UseFakeSeed())
{
//printf("sending fake player lmao\n");
netbuffer->u.playerinfo[0].node = 0;
// fallback to smth, make sure this is always set
if (!cv_fakeseedname.string[0])
CV_Set(&cv_fakeseedname, "Player 1");
strlcpy(netbuffer->u.playerinfo[0].name, cv_fakeseedname.string, MAXPLAYERNAME+1);
memset(netbuffer->u.playerinfo[0].address, 0, 4);
// make it appear as spectator
netbuffer->u.playerinfo[0].team = 255;
// doesent really matter what we put here lel
netbuffer->u.playerinfo[0].score = LONG(42069);
netbuffer->u.playerinfo[0].timeinserver = SHORT(42069);
netbuffer->u.playerinfo[0].skin = (UINT8)1; // no clue wtf skin 1 is, tails maybe?
netbuffer->u.playerinfo[0].data = 0;
// mark every other slot as empty
for (i = 1; i < MSCOMPAT_MAXPLAYERS; i++)
netbuffer->u.playerinfo[i].node = 255;
HSendPacket(node, false, 0, sizeof(plrinfo) * MSCOMPAT_MAXPLAYERS);
return;
}
for (i = 0; i < MSCOMPAT_MAXPLAYERS; i++)
{
if ((i >= MAXPLAYERS) || !playeringame[i])
@@ -1656,12 +1730,7 @@ static void SV_SendPlayerInfo(INT32 node)
netbuffer->u.playerinfo[i].node = i;
// Can't really change this because net compatibility, but the warning is annoying
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation"
strncpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
#pragma GCC diagnostic pop
netbuffer->u.playerinfo[i].name[MAXPLAYERNAME] = '\0';
strlcpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
//fetch IP address
//No, don't do that, you fuckface.
@@ -1688,16 +1757,19 @@ static void SV_SendPlayerInfo(INT32 node)
// Extra data
// Kart has extra skincolors, so we can't use this
netbuffer->u.playerinfo[i].data = 0; //netbuffer->u.playerinfo[i].data = players[i].skincolor;
//netbuffer->u.playerinfo[i].data = 0; //netbuffer->u.playerinfo[i].data = players[i].skincolor;
if (players[i].pflags & PF_TAGIT)
netbuffer->u.playerinfo[i].data |= 0x20;
// well why not, we only got like 100 of these?
netbuffer->u.playerinfo[i].data = players[i].skincolor;
if (players[i].gotflag)
netbuffer->u.playerinfo[i].data |= 0x40;
//if (players[i].pflags & PF_TAGIT)
//netbuffer->u.playerinfo[i].data |= 0x20;
if (players[i].powers[pw_super])
netbuffer->u.playerinfo[i].data |= 0x80;
//if (players[i].gotflag)
//netbuffer->u.playerinfo[i].data |= 0x40;
//if (players[i].powers[pw_super])
//netbuffer->u.playerinfo[i].data |= 0x80;
}
HSendPacket(node, false, 0, sizeof(plrinfo) * MSCOMPAT_MAXPLAYERS);
@@ -1880,7 +1952,7 @@ static boolean SV_ResendingSavegameToAnyone(void)
static void SV_SendSaveGame(INT32 node, boolean resending)
{
size_t length, compressedlen;
savebuffer_t save;
savebuffer_t save = {0};
UINT8 *compressedsave;
UINT8 *buffertosend;
@@ -1950,7 +2022,7 @@ static consvar_t cv_dumpconsistency = {"dumpconsistency", "Off", CV_NETVAR, CV_O
static void SV_SavedGame(void)
{
size_t length;
savebuffer_t save;
savebuffer_t save = {0};
char tmpsave[264];
if (!cv_dumpconsistency.value)
@@ -1990,7 +2062,7 @@ static void SV_SavedGame(void)
static void CL_LoadReceivedSavegame(boolean reloading)
{
savebuffer_t save;
savebuffer_t save = {0};
size_t length, decompressedlen;
char tmpsave[264];
@@ -2082,7 +2154,7 @@ static void CL_ReloadReceivedSavegame(void)
// we dont have P_ForceLocalAngle so were setting it manually here
for (i = 0; i <= splitscreen; i++)
{
localangle[i] = (angle_t)(players[displayplayers[i]].cmd.angleturn << 16);
P_ForceLocalAngle(&players[displayplayers[i]], (angle_t)(players[displayplayers[i]].cmd.angleturn << 16));
}
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
@@ -2179,7 +2251,7 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
if (info->subversion != SUBVERSION)
return; // Close, but no cigar.
if (strcmp(info->application, SRB2APPLICATION))
if (!fastcmp(info->application, SRB2APPLICATION))
return;/* that's a different mod */
i = serverlistcount++;
@@ -2224,7 +2296,7 @@ void CL_QueryServerList (msg_server_t *server_list)
// thwart nefarious servers who lie to the MS.
/* lol bruh, that version COMES from the servers */
//if (strcmp(version, server_list[i].version) == 0)
//if (fastcmp(version, server_list[i].version))
{
INT32 node = I_NetMakeNodewPort(server_list[i].ip, server_list[i].port);
if (node == -1)
@@ -3220,7 +3292,7 @@ static void Command_connect(void)
server = false;
if (!stricmp(COM_Argv(1), "self"))
if (fasticmp(COM_Argv(1), "self"))
{
servernode = 0;
server = true;
@@ -3230,7 +3302,7 @@ static void Command_connect(void)
else
{
// used in menu to connect to a server in the list
if (netgame && !stricmp(COM_Argv(1), "node"))
if (netgame && fasticmp(COM_Argv(1), "node"))
{
servernode = (SINT8)atoi(COM_Argv(2));
}
@@ -3245,7 +3317,7 @@ static void Command_connect(void)
netgame = true;
multiplayer = true;
if (!stricmp(COM_Argv(1), "any"))
if (fasticmp(COM_Argv(1), "any"))
servernode = BROADCASTADDR;
else if (I_NetMakeNodewPort && COM_Argc() >= 3)
servernode = I_NetMakeNodewPort(COM_Argv(1), COM_Argv(2));
@@ -3269,6 +3341,7 @@ static void Command_connect(void)
splitscreen = cv_splitplayers.value-1;
SplitScreen_OnChange();
}
botingame = false;
botskin = 0;
CL_ConnectToServer();
@@ -3761,7 +3834,7 @@ static void Command_Kick(void)
CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
}
static void Got_KickCmd(UINT8 **p, INT32 playernum)
static void Got_KickCmd(const UINT8 **p, INT32 playernum)
{
INT32 pnum, msg;
char buf[3 + MAX_REASONLENGTH];
@@ -4151,8 +4224,8 @@ consvar_t cv_connectawaittime = {"connectawaittime", "5", CV_SAVE, connectawaitt
consvar_t cv_serverinfoscreen = {"serverinfoscreen", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
static void Got_AddPlayer(UINT8 **p, INT32 playernum);
static void Got_RemovePlayer(UINT8 **p, INT32 playernum);
static void Got_AddPlayer(const UINT8 **p, INT32 playernum);
static void Got_RemovePlayer(const UINT8 **p, INT32 playernum);
static void Joinable_OnChange(void)
{
@@ -4404,7 +4477,7 @@ static inline void SV_AddNode(INT32 node)
}
// Xcmd XD_ADDPLAYER
static void Got_AddPlayer(UINT8 **p, INT32 playernum)
static void Got_AddPlayer(const UINT8 **p, INT32 playernum)
{
INT16 node, newplayernum;
UINT8 splitscreenplayer = 0;
@@ -4454,6 +4527,8 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
DEBFILE("spawning me\n");
}
P_ForceLocalAngle(&players[newplayernum], (angle_t)(players[newplayernum].cmd.angleturn << 16));
D_SendPlayerConfig();
addedtogame = true;
}
@@ -4491,7 +4566,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
}
// Xcmd XD_REMOVEPLAYER
static void Got_RemovePlayer(UINT8 **p, INT32 playernum)
static void Got_RemovePlayer(const UINT8 **p, INT32 playernum)
{
SINT8 pnum, reason;
@@ -4652,13 +4727,26 @@ void SV_StopServer(void)
if (gamestate == GS_INTERMISSION)
Y_EndIntermission();
if (gamestate == GS_VOTING)
else if (gamestate == GS_VOTING)
Y_EndVote();
gamestate = wipegamestate = GS_NULL;
G_SetGamestate(GS_NULL);
wipegamestate = GS_NULL;
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
localtextcmd[i][0] = 0;
while (textcmdbuf[i] != NULL)
{
textcmdbuf_t *buf = textcmdbuf[i];
textcmdbuf[i] = textcmdbuf[i]->next;
Z_Free(buf);
}
textcmdbuf[i] = NULL;
}
for (i = firstticstosend; i < firstticstosend + BACKUPTICS; i++)
D_Clearticcmd(i);
@@ -5220,7 +5308,7 @@ static void PT_ServerCFG(SINT8 node)
scp = netbuffer->u.servercfg.varlengthinputs;
CV_LoadPlayerNames(&scp);
CV_LoadNetVars(&scp);
scp += CV_LoadNetVars(scp);
/// \note Wait. What if a Lua script uses some global custom variables synched with the NetVars hook?
/// Shouldn't them be downloaded even at intermission time?
@@ -5680,7 +5768,7 @@ static void PT_TextCmd(INT32 netconsole, SINT8 node)
DEBFILE(va("textcmd put in tic %u at position %d (player %d) ftts %u mk %u\n",
tic, textcmd[0]+1, netconsole, firstticstosend, maketic));
M_Memcpy(&textcmd[textcmd[0]+1], netbuffer->u.textcmd+1, netbuffer->u.textcmd[0]);
memcpy(&textcmd[textcmd[0]+1], netbuffer->u.textcmd+1, netbuffer->u.textcmd[0]);
textcmd[0] += (UINT8)netbuffer->u.textcmd[0];
}
}
@@ -5787,7 +5875,7 @@ static void PT_ServerTics(SINT8 node)
}
if (i >= gametic) // Don't copy old net commands
M_Memcpy(D_GetTextcmd(i, playernum), txtpak, txtsize);
memcpy(D_GetTextcmd(i, playernum), txtpak, txtsize);
txtpak += txtsize;
}
}
@@ -5846,12 +5934,14 @@ static void PT_FileFragmentFromPlayer(SINT8 node)
Got_Filetxpak();
}
#ifdef SATURNPAK
static void PT_ReceivedGamestate(SINT8 node)
{
sendingsavegame[node] = false;
resendingsavegame[node] = 0;
savegameresendcooldown[node] = I_GetTime() + cv_resynchcooldown.value * TICRATE; // I_GetTime() + 5 * TICRATE;
}
#endif
/** Handles a packet received from a node that is in game
*
@@ -6325,7 +6415,7 @@ static void CL_SendClientCmd(void)
break;
}
M_Memcpy(netbuffer->u.textcmd, localtextcmd[i], localtextcmd[i][0]+1);
memcpy(netbuffer->u.textcmd, localtextcmd[i], localtextcmd[i][0]+1);
// All extra data have been sent
if (HSendPacket(servernode, true, 0, localtextcmd[i][0]+1)) // Send can fail...
@@ -6335,7 +6425,7 @@ static void CL_SendClientCmd(void)
if (textcmdbuf[i] != NULL)
{
textcmdbuf_t *buf = textcmdbuf[i];
M_Memcpy(localtextcmd[i], textcmdbuf[i]->cmd, textcmdbuf[i]->cmd[0]+1);
memcpy(localtextcmd[i], textcmdbuf[i]->cmd, textcmdbuf[i]->cmd[0]+1);
textcmdbuf[i] = textcmdbuf[i]->next;
Z_Free(buf);
}
@@ -6448,7 +6538,7 @@ static void SV_SendTics(void)
{
(*ntextcmd)++;
WRITEUINT8(bufpos, j);
M_Memcpy(bufpos, textcmd, size + 1);
memcpy(bufpos, textcmd, size + 1);
bufpos += size + 1;
}
}
@@ -7111,6 +7201,7 @@ void NetUpdate(void)
I_lock_mutex(&m_menu_mutex);
#endif
M_Ticker();
refreshdirmenu = 0;
#ifdef HAVE_THREADS
I_unlock_mutex(m_menu_mutex);
#endif
@@ -7157,7 +7248,7 @@ void CL_ClearRewinds(void)
rewind_t *CL_SaveRewindPoint(size_t demopos)
{
savebuffer_t save;
savebuffer_t save = {0};
rewind_t *rewind;
if (rewindhead && rewindhead->leveltime + REWIND_POINT_INTERVAL > leveltime)
@@ -7180,7 +7271,7 @@ rewind_t *CL_SaveRewindPoint(size_t demopos)
rewind_t *CL_RewindToTime(tic_t time)
{
savebuffer_t save;
savebuffer_t save = {0};
rewind_t *rewind;
while (rewindhead && rewindhead->leveltime > time)
+3 -1
View File
@@ -582,6 +582,8 @@ extern tic_t simulated_lag;
extern tic_t lowest_lag;
extern consvar_t cv_mindelay, cv_gentlemens;
extern consvar_t cv_usefakeseed, cv_fakeseedname;
extern consvar_t
cv_netticbuffer, cv_allownewplayer,
#ifdef SATURNJOIN
@@ -604,7 +606,7 @@ extern consvar_t cv_serverinfoscreen;
void D_ClientServerInit(void);
// Initialise the other field
void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(UINT8 **p, INT32 playernum));
void RegisterNetXCmd(netxcmd_t id, void (*cmd_f)(const UINT8 **p, INT32 playernum));
void SendNetXCmdForPlayer(UINT8 playerid, netxcmd_t id, const void *param, size_t nparam);
#define SendNetXCmd(id, param, nparam) SendNetXCmdForPlayer(0, id, param, nparam) // Shortcut for P1
void SendKick(UINT8 playernum, UINT8 msg);
+178 -234
View File
@@ -46,6 +46,7 @@
#include "i_time.h"
#include "i_threads.h"
#include "i_video.h"
#include "hu_stuff.h"
#include "m_argv.h"
#include "m_menu.h"
#include "m_misc.h"
@@ -69,7 +70,7 @@
#include "fastcmp.h"
#include "r_fps.h" // Frame interpolation/uncapped
#include "keys.h"
#include "filesrch.h" // refreshdirmenu, pathisdirectory
#include "filesrch.h" // pathisdirectory
#include "d_protocol.h"
#include "m_perfstats.h"
#include "k_kart.h"
@@ -97,15 +98,15 @@
UINT8 window_notinfocus = false;
static char *startupiwadfiles[MAX_WADFILES];
static size_t startupiwadcount = 0;
static char *startuppwads[MAX_WADFILES];
static size_t startuppwadcount = 0;
// autoloading
static char *autoloadwadfiles[MAX_WADFILES];
static char *autoloadwadfilespost[MAX_WADFILES];
boolean autoloading;
boolean autoloaded;
boolean postautoloaded = false;
boolean wasautoloaded = false;
static size_t autoloadcount = 0;
static size_t postloadcount = 0;
//
boolean devparm = false; // started game with -devparm
@@ -113,7 +114,9 @@ boolean devparm = false; // started game with -devparm
boolean singletics = false; // timedemo
boolean lastdraw = false;
#ifdef MOTIONBLUR
INT32 postimgparam[MAXSPLITSCREENPLAYERS];
#endif
// These variables are only true if
// whether the respective sound system is disabled
@@ -140,8 +143,8 @@ static char addonsdir[MAX_WADPATH];
// Events can be discarded if no responder claims them
// referenced from i_system.c for I_GetKey()
event_t events[MAXEVENTS];
INT32 eventhead, eventtail;
event_t events[MAXEVENTS] = {};
INT32 eventhead = 0, eventtail = 0;
boolean dedicated = false;
@@ -159,93 +162,10 @@ void D_PostEvent(const event_t *ev)
// modifier keys
// Now handled in I_OsPolling
UINT8 shiftdown = 0; // 0x1 left, 0x2 right
UINT8 ctrldown = 0; // 0x1 left, 0x2 right
UINT8 altdown = 0; // 0x1 left, 0x2 right
boolean capslock = 0; // gee i wonder what this does.
static void D_PadMenuScrollInput(UINT8 input)
{
event_t dpadev;
memset(&dpadev, 0, sizeof(event_t));
dpadev.type = ev_keydown;
switch (input)
{
case DPAD_UP:
dpadev.data1 = KEY_UPARROW;
break;
case DPAD_DOWN:
dpadev.data1 = KEY_DOWNARROW;
break;
case DPAD_LEFT:
dpadev.data1 = KEY_LEFTARROW;
break;
case DPAD_RIGHT:
dpadev.data1 = KEY_RIGHTARROW;
break;
}
D_PostEvent(&dpadev); // put into eventlist
}
#define SCROLLDELAY 19
// Check if any dpad button is held
// and pass it to the eventlist
static void D_GamePadMenuScrollTicker(void)
{
UINT8 i;
static UINT8 menuInputDelayTimer = 0;
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
if (dpadscrollstate[i])
{
if (menuInputDelayTimer < SCROLLDELAY)
menuInputDelayTimer++;
else if (menuInputDelayTimer == SCROLLDELAY)
D_PadMenuScrollInput(i);
return;
}
}
menuInputDelayTimer = 0;
}
#undef SCROLLDELAY
static UINT16 curcolor[MAXSPLITSCREENPLAYERS] = {0};
static void D_DeviceLEDTick(void)
{
UINT8 i;
static UINT16 color[MAXSPLITSCREENPLAYERS] = {0};
if (numcontrollers == 0)
{
return;
}
for (i = 0; i <= splitscreen; i++)
{
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
continue;
color[i] = G_GetSkinColor(i);
if (curcolor[i] == color[i]) // dont update if same colour
continue;
G_SetPlayerGamepadIndicatorColor(i, color[i]);
curcolor[i] = color[i];
}
}
void D_ResetDeviceLED(void)
{
memset(curcolor, 0, sizeof(curcolor));
}
UINT8 shiftdown = 0; // 0x1 left, 0x2 right
UINT8 ctrldown = 0; // 0x1 left, 0x2 right
UINT8 altdown = 0; // 0x1 left, 0x2 right
boolean capslock = 0; // gee i wonder what this does.
//
// D_ProcessEvents
@@ -388,8 +308,7 @@ static void D_Renderview(void)
}
else if (rendermode == render_soft)
#endif
R_RenderPlayerView(&players[displayplayers[i]]);
R_RenderPlayerView(&players[displayplayers[i]]);
}
if (rendermode == render_soft)
@@ -397,7 +316,11 @@ static void D_Renderview(void)
if (i == 0)
R_ApplyViewMorph();
#ifdef MOTIONBLUR
V_DoPostProcessor(i, postimgparam[i]);
#else
V_DoPostProcessor(i, 0);
#endif
}
}
@@ -405,13 +328,12 @@ static void D_Renderview(void)
if (splitscreen == 2)
{
// V_DrawPatchFill, but for the fourth screen only
patch_t *pat = W_CachePatchName("SRB2BACK", PU_PATCH);
INT32 x, y, pw = SHORT(pat->width) * vid.dup, ph = SHORT(pat->height) * vid.dup;
INT32 x, y, pw = SHORT(srb2back->width) * vid.dup, ph = SHORT(srb2back->height) * vid.dup;
for (x = vid.width>>1; x < vid.width; x += pw)
{
for (y = vid.height>>1; y < vid.height; y += ph)
V_DrawScaledPatch(x, y, V_NOSCALESTART, pat);
V_DrawScaledPatch(x, y, V_NOSCALESTART, srb2back);
}
}
@@ -453,10 +375,6 @@ static boolean D_Display(void)
R_ExecuteSetViewSize();
forcerefresh = true; // force background redraw
}
// draw buffered stuff to screen
// Used only by linux GGI version
I_UpdateNoBlit();
}
// save the current screen if about to wipe
@@ -714,13 +632,14 @@ static boolean D_Display(void)
// D_SRB2Loop
// =========================================================================
tic_t rendergametic;
tic_t rendergametic = 0;
void D_SRB2Loop(void)
{
tic_t entertic = 0, oldentertics = 0, realtics = 0, rendertimeout = INFTICS;
double deltatics = 0.0;
double deltasecs = 0.0;
UINT64 precision;
boolean interp = false;
boolean doDisplay = false;
@@ -753,21 +672,26 @@ void D_SRB2Loop(void)
COM_ImmedExecute("cls;version");
if (rendermode == render_soft)
V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, W_CachePatchNum(W_GetNumForName("KARTKREW"), PU_PATCH_LOWPRIORITY), NULL);
V_DrawFixedPatch(0, 0, FRACUNIT/2, 0, W_CachePatchNum(W_GetNumForName("KARTKREW"), PU_PATCH), NULL);
I_FinishUpdate(); // page flip or blit buffer
precision = I_GetPrecisePrecision();
for (;;)
{
// capbudget is the minimum precise_t duration of a single loop iteration
precise_t capbudget;
precise_t enterprecise = I_GetPreciseTime();
precise_t elapsed;
precise_t enterprecise, finishprecise;
enterprecise = I_GetPreciseTime();
memset(&g_dc, 0, sizeof(g_dc));
Z_Frame_Reset();
// Casting the return value of a function is bad practice (apparently)
double budget = ((R_GetFramerateCap() == 0) ? 0.0 : round((1.0 / R_GetFramerateCap()) * I_GetPrecisePrecision()));
capbudget = (precise_t)budget;
const UINT32 framecap = R_GetFramerateCap();
capbudget = (framecap == 0) ? 0 : (precise_t)((double)precision / (double)framecap + 0.5); // + 0.5 instead of round
boolean ranwipe = false;
@@ -801,8 +725,6 @@ void D_SRB2Loop(void)
renderisnewtic = (realtics > 0 || singletics);
refreshdirmenu = 0; // not sure where to put this, here as good as any?
if (renderisnewtic)
{
// don't skip more than 10 frames at a time
@@ -839,18 +761,13 @@ void D_SRB2Loop(void)
if (!dedicated)
{
if (menuactive)
{
D_GamePadMenuScrollTicker();
}
D_DeviceLEDTick();
G_DeviceLEDTick();
}
}
if (interp)
{
renderdeltatics = FloatToFixed(deltatics);
renderdeltatics = DoubleToFixed(deltatics);
// I looked at the possibility of putting in a float drawer for
// perfstats and it's very complicated, so we'll just do this instead...
@@ -899,12 +816,13 @@ void D_SRB2Loop(void)
}
#endif
// Fully completed frame made.
precise_t finishprecise = I_GetPreciseTime();
finishprecise = I_GetPreciseTime();
// Use the time before sleep for frameskip calculations:
// post-sleep time is literally being intentionally wasted
deltasecs = (double)((INT64)(finishprecise - enterprecise)) / I_GetPrecisePrecision();
deltatics = deltasecs * NEWTICRATE;
elapsed = finishprecise - enterprecise;
deltasecs = (double)elapsed / (double)precision;
deltatics = deltasecs * (double)NEWTICRATE;
// If time spent this game loop exceeds a single tic,
// it's probably because of rendering.
@@ -932,12 +850,10 @@ void D_SRB2Loop(void)
if (!singletics)
{
INT64 elapsed = (INT64)(finishprecise - enterprecise);
// in the case of "match refresh rate" + vsync, don't sleep at all
const boolean vsync_with_match_refresh = cv_vidwait.value && cv_fpscap.value == 0;
if ((elapsed > 0) && ((INT64)capbudget > elapsed) && !vsync_with_match_refresh)
if ((elapsed > 0) && (capbudget > elapsed) && !vsync_with_match_refresh)
{
I_SleepDuration(capbudget - elapsed);
}
@@ -945,8 +861,9 @@ void D_SRB2Loop(void)
// Capture the time once more to get the real delta time.
finishprecise = I_GetPreciseTime();
deltasecs = (double)((INT64)(finishprecise - enterprecise)) / I_GetPrecisePrecision();
deltatics = deltasecs * NEWTICRATE;
elapsed = finishprecise - enterprecise;
deltasecs = (double)elapsed / (double)precision;
deltatics = deltasecs * (double)NEWTICRATE;
}
}
@@ -961,8 +878,11 @@ void D_ClearState(void)
{
INT32 i;
demo.title = false;
// okay, stop now
// (otherwise the game still thinks we're playing!)
CURLAbortFile();
SV_StopServer();
SV_ResetServer();
serverlistultimatecount = 0;
@@ -971,7 +891,10 @@ void D_ClearState(void)
CL_ClearPlayer(i);
splitscreen = 0;
SplitScreen_OnChange();
// recompute screen size
R_ExecuteSetViewSize();
botingame = false;
botskin = 0;
cv_debug = 0;
@@ -990,7 +913,6 @@ void D_ClearState(void)
gameaction = ga_nothing;
memset(displayplayers, 0, sizeof(displayplayers));
consoleplayer = 0;
//demosequence = -1;
gametype = GT_RACE; // SRB2kart
paused = false;
@@ -1013,6 +935,11 @@ void D_ClearState(void)
G_SetGamestate(GS_NULL);
wipegamestate = GS_NULL;
M_ClearMenus(true);
// map palettes affect this
G_ResetDeviceLED();
}
//
@@ -1020,25 +947,18 @@ void D_ClearState(void)
//
void D_StartTitle(void)
{
demo.title = false;
D_ClearState();
netgame = false; // title menu shouldnt be a netgame lmao
M_ClearMenus(true);
multiplayer = netgame = false; // title menu shouldnt be a netgame or multiplayer lmao
F_StartTitleScreen();
D_ResetDeviceLED();
}
//
// D_AddFile
//
static void D_AddFile(const char *file, char **filearray)
static void D_AddFile(const char *file, char **filearray, size_t index)
{
size_t pnumwadfiles;
char *newfile;
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
;
newfile = malloc(strlen(file) + 1);
if (!newfile)
{
@@ -1046,16 +966,17 @@ static void D_AddFile(const char *file, char **filearray)
}
strcpy(newfile, file);
filearray[pnumwadfiles] = newfile;
filearray[index] = newfile;
}
static void D_CleanFile(char **filearray)
static void D_CleanFile(char **filearray, size_t count)
{
size_t pnumwadfiles;
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
size_t i;
for (i = 0; i < count; i++)
{
free(filearray[pnumwadfiles]);
filearray[pnumwadfiles] = NULL;
free(filearray[i]);
filearray[i] = NULL;
}
}
@@ -1068,28 +989,27 @@ static INT32 D_DetectFileType(const char* filename)
const size_t len = strlen(filename);
if (!stricmp(&filename[len - 4], ".wad"))
if (fasticmp(&filename[len - 4], ".wad"))
return 2;
else if (!stricmp(&filename[len - 4], ".pk3"))
else if (fasticmp(&filename[len - 4], ".pk3"))
return 3;
else if (!stricmp(&filename[len - 5], ".kart"))
else if (fasticmp(&filename[len - 5], ".kart"))
return 4;
else if (!stricmp(&filename[len - 4], ".lua"))
else if (fasticmp(&filename[len - 4], ".lua"))
return 5;
else if (!stricmp(&filename[len - 4], ".soc"))
else if (fasticmp(&filename[len - 4], ".soc"))
return 6;
else if (!stricmp(&filename[len - 4], ".cfg"))
else if (fasticmp(&filename[len - 4], ".cfg"))
return 7;
else if (!stricmp(&filename[len - 4], ".txt"))
else if (fasticmp(&filename[len - 4], ".txt"))
return 8;
return 0;
}
// autoload that shit
static void D_AutoloadFile(const char *file, char **filearray)
static void D_AutoloadFile(const char *file, char **filearray, size_t index)
{
size_t pnumwadfiles;
char *newfile;
INT32 fileType = D_DetectFileType(file);
@@ -1099,9 +1019,6 @@ static void D_AutoloadFile(const char *file, char **filearray)
return;
}
for (pnumwadfiles = 0; filearray[pnumwadfiles]; pnumwadfiles++)
;
if (fileType <= 6)
{
newfile = malloc(strlen(file) + 1);
@@ -1109,7 +1026,7 @@ static void D_AutoloadFile(const char *file, char **filearray)
I_Error("No more free memory to AutoloadFile %s",file);
strcpy(newfile, file);
filearray[pnumwadfiles] = newfile;
filearray[index] = newfile;
}
else
{
@@ -1139,42 +1056,44 @@ static void D_FindAddonsToAutoload(void)
{
FILE *autoloadconfigfile;
const char *autoloadpath;
char *newline;
boolean postload;
INT32 i;
char wadsToAutoload[256] = "";
// does it exist tho
autoloadpath = va("%s"PATHSEP"%s",srb2home,AUTOLOADCONFIGFILENAME);
autoloadpath = va("%s"PATHSEP"%s", srb2home, AUTOLOADCONFIGFILENAME);
autoloadconfigfile = fopen(autoloadpath, "r");
// If the file is found, run our shit
if (!autoloadconfigfile) // nope outta here
{
wasautoloaded = postautoloaded = true; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
autoloadcount = postloadcount = 0; // so D_AddAutoloadFiles can skip everything since nothings there to autoload
return;
}
while (fgets(wadsToAutoload, sizeof wadsToAutoload, autoloadconfigfile) != NULL)
while (fgets(wadsToAutoload, sizeof(wadsToAutoload), autoloadconfigfile) != NULL)
{
postload = false;
// skip if commented or empty
if ((wadsToAutoload[1] == '\0' || wadsToAutoload[1] == '\n')
|| (wadsToAutoload[0] == '#'))
if (wadsToAutoload[0] == '\n' ||
wadsToAutoload[0] == '#' ||
wadsToAutoload[0] == '\0')
continue;
// this marks it so that it loads after loading server addons
else if (fastncmp(wadsToAutoload, "postload ", 9))
if (fastncmp(wadsToAutoload, "postload ", 9))
{
strremove(wadsToAutoload, "postload ");
postload = true;
}
// Remove Any Empty or Skipped Lines
for (i = 0; wadsToAutoload[i] != '\0'; i++)
{
if (wadsToAutoload[i] == '\n')
wadsToAutoload[i] = '\0';
}
newline = strchr(wadsToAutoload, '\n');
if (newline)
*newline = '\0';
if (!postload && W_CheckPostLoadList(wadsToAutoload))
{
@@ -1184,56 +1103,67 @@ static void D_FindAddonsToAutoload(void)
// LOAD IT
if (!postload)
D_AutoloadFile(wadsToAutoload, autoloadwadfiles);
{
D_AutoloadFile(wadsToAutoload, autoloadwadfiles, autoloadcount);
autoloadcount++;
}
else
D_AutoloadFile(wadsToAutoload, autoloadwadfilespost);
// end it here
for (i = 0; wadsToAutoload[i] != '\0'; i++)
wadsToAutoload[i] = '\0';
{
D_AutoloadFile(wadsToAutoload, autoloadwadfilespost, postloadcount);
postloadcount++;
}
}
autoloadwadfiles[autoloadcount] = NULL;
autoloadwadfilespost[postloadcount] = NULL;
// we dont want memory leaks around here do we?
fclose(autoloadconfigfile);
}
static void D_AddAutoloadFiles(void)
{
if (wasautoloaded)
// nothing to autoload
if (autoloadcount == 0)
return;
CONS_Printf("D_AutoloadFile(): Loading autoloaded addons...\n");
if (W_AddAutoloadedLocalFiles(autoloadwadfiles) == 0)
CONS_Printf("D_AutoloadFile(): Are you sure you put in valid files or what?\n");
D_CleanFile(autoloadwadfiles);
wasautoloaded = true;
D_CleanFile(autoloadwadfiles, autoloadcount);
autoloadcount = 0;
}
void D_AddPostloadFiles(void)
{
if (postautoloaded || !netgame)
// nothing to postload
if (postloadcount == 0 || !netgame)
return;
CONS_Printf("D_AddPostloadFiles(): Loading postloaded addons...\n");
if (W_AddAutoloadedLocalFiles(autoloadwadfilespost) == 0)
CONS_Printf("D_AddPostloadFiles(): Are you sure you put in valid files or what?\n");
D_CleanFile(autoloadwadfilespost);
postautoloaded = true;
D_CleanFile(autoloadwadfilespost, postloadcount);
postloadcount = 0;
}
// ==========================================================================
// Identify the SRB2 version, and IWAD file to use.
// ==========================================================================
static boolean AddIWAD(void)
static boolean AddIWAD(const char * file, const char *dir)
{
char * path = va(pandf, srb2path, "srb2.srb");
char * path = va(pandf, dir, file);
if (FIL_ReadFileOK(path))
{
D_AddFile(path, startupiwadfiles);
D_AddFile(path, startupiwadfiles, startupiwadcount++);
return true;
}
@@ -1250,8 +1180,10 @@ static void IdentifyVersion(void)
const char *srb2waddir = NULL;
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
CLEANUP(pfree) const char *allocwaddir = NULL; // here so we dont potentially free stack memory
// change to the directory where 'srb2.srb' is found
srb2waddir = I_LocateWad();
allocwaddir = I_LocateWad();
srb2waddir = allocwaddir;
#endif
char tempsrb2path[256] = ".";
@@ -1269,14 +1201,14 @@ static void IdentifyVersion(void)
}
#if (1) // reduce the amount of findfile by only using full cwd in this func
if (strcmp(tempsrb2path, srb2waddir))
if (!fastcmp(tempsrb2path, srb2waddir))
#endif
{
strlcpy(srb2path, srb2waddir, sizeof (srb2path));
}
// Load the IWAD
if (!AddIWAD())
if (!AddIWAD("srb2.srb", srb2path)) // not sure why this uses srb2path and not srb2waddir?
{
I_Error("SRB2.SRB not found! Expected in %s\n", srb2waddir);
}
@@ -1290,57 +1222,60 @@ static void IdentifyVersion(void)
#ifdef USE_PATCH_DTA
// Add our crappy patches to fix our bugs
D_AddFile(va(pandf,srb2waddir,"patch.dta"));
if (!AddIWAD("patch.dta", srb2waddir))
{
I_Error("patch.dta not found! Expected in %s\n", srb2waddir);
}
#endif
if (!AddIWAD("gfx.kart", srb2waddir))
{
I_Error("gfx.kart not found! Expected in %s\n", srb2waddir);
}
D_AddFile(va(pandf, srb2waddir, "gfx.kart"), startupiwadfiles);
D_AddFile(va(pandf, srb2waddir, "textures.kart"), startupiwadfiles);
D_AddFile(va(pandf, srb2waddir, "chars.kart"), startupiwadfiles);
D_AddFile(va(pandf, srb2waddir, "maps.kart"), startupiwadfiles);
if (!AddIWAD("textures.kart", srb2waddir))
{
I_Error("textures.kart not found! Expected in %s\n", srb2waddir);
}
if (!AddIWAD("chars.kart", srb2waddir))
{
I_Error("chars.kart not found! Expected in %s\n", srb2waddir);
}
if (!AddIWAD("maps.kart", srb2waddir))
{
I_Error("maps.kart not found! Expected in %s\n", srb2waddir);
}
#ifdef USE_PATCH_KART
D_AddFile(va(pandf,srb2waddir,"patch.kart"), startupiwadfiles);
if (!AddIWAD("patch.kart", srb2waddir))
{
I_Error("patch.kart not found! Expected in %s\n", srb2waddir);
}
#endif
const char *path = NULL;
path = va(pandf, srb2waddir, "extra.kart");
// completely optional
if (FIL_ReadFileOK(path))
{
D_AddFile(path, startupiwadfiles);
if (AddIWAD("extra.kart", srb2waddir))
found_extra_kart = true;
}
path = va(pandf, srb2waddir, "extra2.kart");
// completely optional 2: Back with a vengence
if (FIL_ReadFileOK(path))
{
D_AddFile(path, startupiwadfiles);
if (AddIWAD("extra2.kart", srb2waddir))
found_extra2_kart = true;
}
path = va(pandf, srb2waddir, "extra3.kart");
if (FIL_ReadFileOK(path))
{
D_AddFile(path, startupiwadfiles);
if (AddIWAD("extra3.kart", srb2waddir))
found_extra3_kart = true;
}
#if !defined (HAVE_SDL) || defined (HAVE_MIXER)
#if defined (HAVE_SDL)
#define MUSICTEST(str) \
musicpath = va(pandf,srb2waddir,str);\
musicpath = va(pandf, srb2waddir, str);\
handle = W_OpenWadFile(&musicpath, false); \
if (handle) \
{\
{ \
int ms = W_VerifyNMUSlumps(musicpath, handle, false); \
fclose(handle); \
if (ms == 0) \
I_Error("File " str " has been modified with non-music/sound lumps"); \
if (ms == 1) \
D_AddFile(musicpath, startupiwadfiles); \
D_AddFile(musicpath, startupiwadfiles, startupiwadcount++); \
}
{
const char *musicpath;
@@ -1714,8 +1649,14 @@ void D_SRB2Main(void)
else
{
// use user specific config file
if (M_CheckParm("-workdir") && M_IsNextParm())
snprintf(srb2home, sizeof srb2home, "%s", M_GetNextParm());
else
#ifdef DEFAULTDIR
snprintf(srb2home, sizeof srb2home, "%s" PATHSEP DEFAULTDIR, userhome);
snprintf(srb2home, sizeof srb2home, "%s" PATHSEP DEFAULTDIR, userhome);
#else // DEFAULTDIR
snprintf(srb2home, sizeof srb2home, "%s", userhome);
#endif // DEFAULTDIR
snprintf(downloaddir, sizeof downloaddir, "%s" PATHSEP "DOWNLOAD", srb2home);
if (dedicated)
snprintf(configfile, sizeof configfile, "%s" PATHSEP "d"CONFIGFILENAME, srb2home);
@@ -1724,17 +1665,6 @@ void D_SRB2Main(void)
// can't use sprintf since there is %u in savegamename
strcatbf(savegamename, srb2home, PATHSEP);
#else
snprintf(srb2home, sizeof srb2home, "%s", userhome);
snprintf(downloaddir, sizeof downloaddir, "%s", userhome);
if (dedicated)
snprintf(configfile, sizeof configfile, "%s" PATHSEP "d"CONFIGFILENAME, userhome);
else
snprintf(configfile, sizeof configfile, "%s" PATHSEP CONFIGFILENAME, userhome);
// can't use sprintf since there is %u in savegamename
strcatbf(savegamename, userhome, PATHSEP);
#endif
}
configfile[sizeof configfile - 1] = '\0';
@@ -1760,6 +1690,9 @@ void D_SRB2Main(void)
}
}
// make sure workdir exists
I_mkdir(srb2home, 0755);
// Create addons dir
snprintf(addonsdir, sizeof addonsdir, "%s%s%s", srb2home, PATHSEP, "addons");
I_mkdir(addonsdir, 0755);
@@ -1788,7 +1721,7 @@ void D_SRB2Main(void)
const char *s = M_GetNextParm();
if (s) // Check for NULL?
D_AddFile(s, startuppwads);
D_AddFile(s, startuppwads, startuppwadcount++);
}
}
}
@@ -1821,8 +1754,10 @@ void D_SRB2Main(void)
// load wad, including the main wad file
CONS_Printf("W_InitMultipleFiles(): Adding IWAD and main PWADs.\n");
W_InitMultipleFiles(startupiwadfiles, false);
D_CleanFile(startupiwadfiles);
W_InitMultipleFiles(startupiwadfiles, startupiwadcount, false);
//mainwads = startupiwadcount - musicwads;
D_CleanFile(startupiwadfiles, startupiwadcount);
startupiwadcount = 0;
mainwads = 0;
#ifndef DEVELOP
@@ -1861,15 +1796,16 @@ void D_SRB2Main(void)
D_CheckMaps(false);
W_InitMultipleFiles(startuppwads, true);
W_InitMultipleFiles(startuppwads, startuppwadcount, true);
// Only search for pwad maps if we actually have a pwad added
if (startuppwads[0] != NULL)
if (startuppwadcount > 0)
{
D_CheckMaps(true);
}
D_CleanFile(startuppwads);
D_CleanFile(startuppwads, startuppwadcount);
startuppwadcount = 0;
cht_Init();
@@ -1954,6 +1890,10 @@ void D_SRB2Main(void)
CONS_Printf("R_Init(): Init SRB2 refresh daemon.\n");
R_Init();
#if SOUND==SOUND_DUMMY
sound_disabled = true;
music_disabled = true;
#else
// setting up sound
if (dedicated || M_CheckParm("-noaudio")) // combines -nosound and -nomusic
{
@@ -1975,6 +1915,7 @@ void D_SRB2Main(void)
I_InitMusic();
S_InitSfxChannels(cv_soundvolume.value);
}
#endif
S_InitMusicDefs();
@@ -2133,11 +2074,14 @@ void D_SRB2Main(void)
const char *sskill = M_GetNextParm();
for (j = 0; kartspeed_cons_t[j].strvalue; j++)
if (!strcasecmp(kartspeed_cons_t[j].strvalue, sskill))
{
if (fasticmp(kartspeed_cons_t[j].strvalue, sskill))
{
newskill = (INT16)kartspeed_cons_t[j].value;
break;
}
}
if (!kartspeed_cons_t[j].strvalue) // reached end of the list with no match
{
j = atoi(sskill); // assume they gave us a skill number, which is okay too
-5
View File
@@ -61,9 +61,6 @@ extern boolean minilighticon; // mkwii-style minimap headlight
//
// autoload stuff
extern boolean autoloading;
extern boolean autoloaded;
extern boolean postautoloaded;
void D_AddPostloadFiles(void);
// the infinite loop of D_SRB2Loop() called from win_main for windows version
@@ -83,8 +80,6 @@ void D_ProcessEvents(void);
const char *D_Home(void);
void D_ResetDeviceLED(void);
//
// BASE LEVEL
//
+14 -15
View File
@@ -95,9 +95,9 @@ static INT32 sendackpacket = 0, getackpacket = 0;
INT32 ticruned = 0, ticmiss = 0;
// globals
INT32 getbps, sendbps;
float lostpercent, duppercent, gamelostpercent;
INT32 packetheaderlength;
INT32 getbps = 0, sendbps = 0;
float lostpercent = 0, duppercent = 0, gamelostpercent = 0;
INT32 packetheaderlength = 0;
boolean Net_GetNetStat(void)
{
@@ -243,7 +243,7 @@ static boolean GetFreeAcknum(UINT8 *freeack)
ackpak[i].length = doomcom->datalength;
ackpak[i].senttime = I_GetTime();
ackpak[i].resentnum = 0;
M_Memcpy(ackpak[i].pak.raw, netbuffer, ackpak[i].length);
memcpy(ackpak[i].pak.raw, netbuffer, ackpak[i].length);
*freeack = ackpak[i].acknum;
@@ -412,7 +412,7 @@ void Net_SendAcks(INT32 node)
{
doomdata_t *netbuffer = DOOMCOM_DATA(doomcom);
netbuffer->packettype = PT_NOTHING;
M_Memcpy(netbuffer->u.textcmd, nodes[node].acktosend, MAXACKTOSEND);
memcpy(netbuffer->u.textcmd, nodes[node].acktosend, MAXACKTOSEND);
HSendPacket(node, false, 0, MAXACKTOSEND);
}
@@ -494,7 +494,7 @@ void Net_AckTicker(void)
}
DEBFILE(va("Resend ack %d, %u<%d at %u\n", ackpak[i].acknum, ackpak[i].senttime,
NODETIMEOUT, I_GetTime()));
M_Memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
ackpak[i].senttime = I_GetTime();
ackpak[i].resentnum++;
ackpak[i].nextacknum = node->nextacknum;
@@ -805,16 +805,16 @@ const char *packettypename[NUMPACKETTYPE] =
"TELLFILESNEEDED",
"MOREFILESNEEDED",
"PING"
"PING",
#ifdef SATURNPAK
,
"WILLRESENDGAMESTATE",
"CANRECEIVEGAMESTATE",
"RECEIVEDGAMESTATE",
"ISSATURN" // special packet to identify saturn clients
"ISSATURN", // special packet to identify saturn clients
#endif
"MAPICON", // Send map image icon (gamespy).
"NEEDMAPICON" // Request missed map icon (gamespy).
};
const char *Net_GetPacketName(UINT8 packettype)
@@ -1021,7 +1021,7 @@ boolean HSendPacket(INT32 node, boolean reliable, UINT8 acknum, size_t packetlen
return false;
}
netbuffer->ack = netbuffer->ackreturn = 0; // don't hold over values from last packet sent/received
M_Memcpy(&reboundstore[rebound_head], netbuffer,
memcpy(&reboundstore[rebound_head], netbuffer,
doomcom->datalength);
reboundsize[rebound_head] = doomcom->datalength;
rebound_head = (rebound_head+1) % MAXREBOUND;
@@ -1107,7 +1107,7 @@ boolean HGetPacket(void)
// Get a packet from self
if (rebound_tail != rebound_head)
{
M_Memcpy(netbuffer, &reboundstore[rebound_tail], reboundsize[rebound_tail]);
memcpy(netbuffer, &reboundstore[rebound_tail], reboundsize[rebound_tail]);
doomcom->datalength = reboundsize[rebound_tail];
if (netbuffer->packettype == PT_NODETIMEOUT)
doomcom->remotenode = netbuffer->u.textcmd[0];
@@ -1127,9 +1127,7 @@ boolean HGetPacket(void)
while (true)
{
I_NetGet();
if (doomcom->remotenode == -1) // No packet received
if (!I_NetGet()) // No packets received
return false;
getbytes += packetheaderlength + doomcom->datalength; // For stat
@@ -1165,6 +1163,7 @@ boolean HGetPacket(void)
GotAcks();
continue;
}
doomcom->datalength -= BASEPACKETSIZE;
break;
}
+109 -113
View File
@@ -68,22 +68,22 @@
// protos
// ------
static void Got_NameAndColor(UINT8 **cp, INT32 playernum);
static void Got_WeaponPref(UINT8 **cp, INT32 playernum);
static void Got_Mapcmd(UINT8 **cp, INT32 playernum);
static void Got_ExitLevelcmd(UINT8 **cp, INT32 playernum);
static void Got_SetupVotecmd(UINT8 **cp, INT32 playernum);
static void Got_ModifyVotecmd(UINT8 **cp, INT32 playernum);
static void Got_PickVotecmd(UINT8 **cp, INT32 playernum);
static void Got_RequestAddfilecmd(UINT8 **cp, INT32 playernum);
static void Got_Addfilecmd(UINT8 **cp, INT32 playernum);
static void Got_Pause(UINT8 **cp, INT32 playernum);
static void Got_Respawn(UINT8 **cp, INT32 playernum);
static void Got_RandomSeed(UINT8 **cp, INT32 playernum);
static void Got_RunSOCcmd(UINT8 **cp, INT32 playernum);
static void Got_Teamchange(UINT8 **cp, INT32 playernum);
static void Got_Clearscores(UINT8 **cp, INT32 playernum);
static void Got_DiscordInfo(UINT8 **cp, INT32 playernum);
static void Got_NameAndColor(const UINT8 **cp, INT32 playernum);
static void Got_WeaponPref(const UINT8 **cp, INT32 playernum);
static void Got_Mapcmd(const UINT8 **cp, INT32 playernum);
static void Got_ExitLevelcmd(const UINT8 **cp, INT32 playernum);
static void Got_SetupVotecmd(const UINT8 **cp, INT32 playernum);
static void Got_ModifyVotecmd(const UINT8 **cp, INT32 playernum);
static void Got_PickVotecmd(const UINT8 **cp, INT32 playernum);
static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum);
static void Got_Addfilecmd(const UINT8 **cp, INT32 playernum);
static void Got_Pause(const UINT8 **cp, INT32 playernum);
static void Got_Respawn(const UINT8 **cp, INT32 playernum);
static void Got_RandomSeed(const UINT8 **cp, INT32 playernum);
static void Got_RunSOCcmd(const UINT8 **cp, INT32 playernum);
static void Got_Teamchange(const UINT8 **cp, INT32 playernum);
static void Got_Clearscores(const UINT8 **cp, INT32 playernum);
static void Got_DiscordInfo(const UINT8 **cp, INT32 playernum);
static void PointLimit_OnChange(void);
static void TimeLimit_OnChange(void);
@@ -178,13 +178,13 @@ static void Command_Clearscores_f(void);
// Remote Administration
static void Command_Changepassword_f(void);
static void Command_Login_f(void);
static void Got_Login(UINT8 **cp, INT32 playernum);
static void Got_Verification(UINT8 **cp, INT32 playernum);
static void Got_Removal(UINT8 **cp, INT32 playernum);
static void Got_Login(const UINT8 **cp, INT32 playernum);
static void Got_Verification(const UINT8 **cp, INT32 playernum);
static void Got_Removal(const UINT8 **cp, INT32 playernum);
static void Command_Verify_f(void);
static void Command_RemoveAdmin_f(void);
static void Command_MotD_f(void);
static void Got_MotD_f(UINT8 **cp, INT32 playernum);
static void Got_MotD_f(const UINT8 **cp, INT32 playernum);
static void Command_ShowScores_f(void);
static void Command_ShowTime_f(void);
@@ -274,7 +274,7 @@ consvar_t cv_showlocalskinmenus = {"showlocalskinmenus", "Yes", CV_SAVE, CV_YesN
consvar_t cv_skipmapcheck = {"skipmapcheck", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
INT32 cv_debug;
INT32 cv_debug = 0;
static void UseMouse_OnChange(void);
consvar_t cv_usemouse = {"use_mouse", "Off", CV_SAVE|CV_CALL, usemouse_cons_t, UseMouse_OnChange, 0, NULL, NULL, 0, 0, NULL};
@@ -292,6 +292,10 @@ consvar_t cv_mouseturn = {"mouseturn", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL,
// Lagless camera! Yay!
consvar_t cv_laglesscam = {"lagless_camera", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
// makes the camera use the saved angleturn in replays instead of the players angle
// more accurate to how the recording player seen things in game, but may be jittery if they encountered net issues
consvar_t cv_demoangturn = {"useangleturninreplays", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_verticallook[MAXSPLITSCREENPLAYERS] = {
{"verticallook", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"verticallook2", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
@@ -527,7 +531,7 @@ boolean forceresetplayers = false;
boolean deferencoremode = false;
UINT8 splitscreen = 0;
boolean circuitmap = true; // SRB2kart
INT32 adminplayers[MAXPLAYERS];
INT32 adminplayers[MAXPLAYERS] = {};
/// \warning Keep this up-to-date if you add/remove/rename net text commands
const char *netxcmdnames[MAXNETXCMD - 1] =
@@ -756,6 +760,9 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_showping);
CV_RegisterVar(&cv_pingmeasurement);
CV_RegisterVar(&cv_usefakeseed);
CV_RegisterVar(&cv_fakeseedname);
#ifdef SEENAMES
CV_RegisterVar(&cv_allowseenames);
#endif
@@ -990,6 +997,7 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_usejoystick[i]);
CV_RegisterVar(&cv_joyscale[i]);
CV_RegisterVar(&cv_rumble[i]);
CV_RegisterVar(&cv_rumblestrength[i]);
CV_RegisterVar(&cv_gamepadled[i]);
}
@@ -1043,6 +1051,7 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_betainterscreen);
CV_RegisterVar(&cv_laglesscam);
CV_RegisterVar(&cv_demoangturn);
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
@@ -1214,7 +1223,7 @@ static boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
for (ix = 0; ix < MAXPLAYERS; ix++)
{
if (ix != playernum && playeringame[ix]
&& strcasecmp(name, player_names[ix]) == 0)
&& fasticmp(name, player_names[ix]))
{
// We shouldn't kick people out just because
// they joined the game with the same name
@@ -1331,7 +1340,7 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
for (i = 0; i < MAXPLAYERS; i++)
{
if (i != playernum && playeringame[i]
&& strcasecmp(tmpname, player_names[i]) == 0)
&& fasticmp(tmpname, player_names[i]))
{
break;
}
@@ -1381,7 +1390,7 @@ static void SetPlayerName(INT32 playernum, char *newname)
{
if (EnsurePlayerNameIsGood(newname, playernum))
{
if (strcasecmp(newname, player_names[playernum]) != 0)
if (!fasticmp(newname, player_names[playernum]))
{
if (netgame)
HU_AddChatText(va("\x82*%s renamed to %s", player_names[playernum], newname), false);
@@ -1503,9 +1512,9 @@ static void SendNameAndColor(void)
CV_StealthSet(&cv_playercolor, cv_playercolor.defaultvalue);
}
if (!strcmp(cv_playername.string, player_names[consoleplayer])
if (fastcmp(cv_playername.string, player_names[consoleplayer])
&& cv_playercolor.value == players[consoleplayer].skincolor
&& !strcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
&& fastcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
return;
// We'll handle it later if we're not playing.
@@ -1908,7 +1917,7 @@ static void SendNameAndColor4(void)
SendNetXCmdForPlayer(3, XD_NAMEANDCOLOR, buf, p - buf);
}
static void Got_NameAndColor(UINT8 **cp, INT32 playernum)
static void Got_NameAndColor(const UINT8 **cp, INT32 playernum)
{
player_t *p = &players[playernum];
char name[MAXPLAYERNAME+1];
@@ -1940,7 +1949,7 @@ static void Got_NameAndColor(UINT8 **cp, INT32 playernum)
// set name
if (player_name_changes[playernum] < MAXNAMECHANGES)
{
if (strcasecmp(player_names[playernum], name) != 0)
if (!fasticmp(player_names[playernum], name))
SetPlayerName(playernum, name);
}
@@ -2036,15 +2045,17 @@ void SendWeaponPref4(void)
SendNetXCmdForPlayer(3, XD_WEAPONPREF, buf, 1);
}
static void Got_WeaponPref(UINT8 **cp,INT32 playernum)
static void Got_WeaponPref(const UINT8 **cp, INT32 playernum)
{
player_t *player = &players[playernum];
UINT8 prefs = READUINT8(*cp);
players[playernum].pflags &= ~(PF_FLIPCAM|PF_ANALOGMODE);
player->pflags &= ~(PF_FLIPCAM|PF_ANALOGMODE);
if (prefs & 1)
players[playernum].pflags |= PF_FLIPCAM;
player->pflags |= PF_FLIPCAM;
if (prefs & 2)
players[playernum].pflags |= PF_ANALOGMODE;
player->pflags |= PF_ANALOGMODE;
}
void D_SendPlayerConfig(void)
@@ -2317,8 +2328,8 @@ static void Command_Playdemo_f(void)
CONS_Printf(M_GetText("Playing back demo '%s'.\n"), name);
demo.loadfiles = strcmp(COM_Argv(2), "-addfiles") == 0;
demo.ignorefiles = strcmp(COM_Argv(2), "-force") == 0;
demo.loadfiles = fastcmp(COM_Argv(2), "-addfiles");
demo.ignorefiles = fastcmp(COM_Argv(2), "-force");
// Internal if no extension, external if one exists
// If external, convert the file name to a path in SRB2's home directory
@@ -2487,15 +2498,18 @@ void D_SetupVote(void)
INT32 i;
UINT8 gt = (cv_kartgametypepreference.value == -1) ? gametype : cv_kartgametypepreference.value;
UINT8 secondgt = G_SometimesGetDifferentGametype(gt);
INT16 votebuffer[4] = {-1,-1,-1,0};
INT16 votebuffer[4] = {-1,-1,-1, 0};
INT16 luamaps[4] = {0, 0, 0, 0};
LUA_HookSetupVote(luamaps, sizeof(luamaps)/sizeof(luamaps[0]), gt, secondgt);
// Correct secondgt if needed
UINT8 typeoflevel = mapheaderinfo[luamaps[2]-1]->typeoflevel;
if (luamaps[2] && (typeoflevel & G_TOLFlag(secondgt&(~0x80))) == 0)
secondgt = ((typeoflevel & TOL_RACE) ? GT_RACE : GT_MATCH)|(secondgt&0x80);
if (luamaps[2])
{
UINT8 typeoflevel = mapheaderinfo[luamaps[2]-1]->typeoflevel;
if ((typeoflevel & G_TOLFlag(secondgt&(~0x80))) == 0)
secondgt = ((typeoflevel & TOL_RACE) ? GT_RACE : GT_MATCH)|(secondgt&0x80);
}
if (cv_kartencore.value && gt == GT_RACE)
WRITEUINT8(p, (gt|0x80));
@@ -2575,8 +2589,7 @@ void D_PickVote(void)
SendNetXCmd(XD_PICKVOTE, &buf, 2);
}
static char *
ConcatCommandArgv (int start, int end)
static char *ConcatCommandArgv(int start, int end)
{
char *final;
@@ -2649,8 +2662,8 @@ static void Command_Map_f(void)
INT32 newmapnum;
char * mapname;
char *realmapname = NULL;
CLEANUP(Z_Pfree) char * mapname = NULL;
CLEANUP(Z_Pfree) char *realmapname = NULL;
INT32 newgametype = gametype;
boolean newencoremode = cv_kartencore.value;
@@ -2719,7 +2732,6 @@ static void Command_Map_f(void)
if (newmapnum == 0)
{
CONS_Alert(CONS_ERROR, M_GetText("Could not find any map described as '%s'.\n"), mapname);
Z_Free(mapname);
return;
}
@@ -2751,8 +2763,6 @@ static void Command_Map_f(void)
" 0 and %d inclusive. ...Or just use the name. :v\n",
d,
NUMGAMETYPES-1);
Z_Free(realmapname);
Z_Free(mapname);
return;
}
}
@@ -2761,8 +2771,6 @@ static void Command_Map_f(void)
CONS_Alert(CONS_ERROR,
"'%s' is not a gametype.\n",
gametypename);
Z_Free(realmapname);
Z_Free(mapname);
return;
}
}
@@ -2780,8 +2788,6 @@ static void Command_Map_f(void)
if (!mapheaderinfo[newmapnum-1])
{
CONS_Alert(CONS_WARNING, M_GetText("Invalid mapheaderinfo for Course %s (%s)\n"), realmapname, G_BuildMapName(newmapnum));
Z_Free(realmapname);
Z_Free(mapname);
return;
}
@@ -2789,8 +2795,6 @@ static void Command_Map_f(void)
{
CONS_Alert(CONS_WARNING, M_GetText("Course %s (%s) doesn't support %s mode!\n(Use -force to override)\n"), realmapname, G_BuildMapName(newmapnum),
(multiplayer ? gametype_cons_t[newgametype].strvalue : "Single Player"));
Z_Free(realmapname);
Z_Free(mapname);
return;
}
}
@@ -2802,8 +2806,6 @@ static void Command_Map_f(void)
if (!dedicated && M_MapLocked(newmapnum))
{
CONS_Alert(CONS_NOTICE, M_GetText("You need to unlock this level before you can warp to it!\n"));
Z_Free(realmapname);
Z_Free(mapname);
return;
}
@@ -2829,8 +2831,6 @@ static void Command_Map_f(void)
fromlevelselect = false;
D_MapChange(newmapnum, newgametype, newencoremode, newresetplayers, 0, false, false);
Z_Free(realmapname);
}
/** Receives a map command and changes the map.
@@ -2840,7 +2840,7 @@ static void Command_Map_f(void)
* ::serverplayer or ::adminplayer.
* \sa D_MapChange
*/
static void Got_Mapcmd(UINT8 **cp, INT32 playernum)
static void Got_Mapcmd(const UINT8 **cp, INT32 playernum)
{
char mapname[MAX_WADPATH+1];
UINT8 flags;
@@ -2959,7 +2959,7 @@ static void Command_Pause(void)
CONS_Printf(M_GetText("Only the server or a remote admin can use this.\n"));
}
static void Got_Pause(UINT8 **cp, INT32 playernum)
static void Got_Pause(const UINT8 **cp, INT32 playernum)
{
UINT8 dedicatedpause = false;
const char *playername;
@@ -3071,7 +3071,7 @@ static void Command_Respawn(void)
SendNetXCmd(XD_RESPAWN, &buf, 4);
}
static void Got_Respawn(UINT8 **cp, INT32 playernum)
static void Got_Respawn(const UINT8 **cp, INT32 playernum)
{
INT32 respawnplayer = READINT32(*cp);
@@ -3106,7 +3106,7 @@ static void Got_Respawn(UINT8 **cp, INT32 playernum)
* \param playernum Player responsible for the message. Must be ::serverplayer.
* \author Graue <graue@oceanbase.org>
*/
static void Got_RandomSeed(UINT8 **cp, INT32 playernum)
static void Got_RandomSeed(const UINT8 **cp, INT32 playernum)
{
UINT32 seed;
@@ -3141,7 +3141,7 @@ static void Command_Clearscores_f(void)
* \sa XD_CLEARSCORES, Command_Clearscores_f
* \author SSNTails <http://www.ssntails.org>
*/
static void Got_Clearscores(UINT8 **cp, INT32 playernum)
static void Got_Clearscores(const UINT8 **cp, INT32 playernum)
{
INT32 i;
@@ -3186,20 +3186,20 @@ static void Command_Teamchange_f(void)
if (G_GametypeHasTeams())
{
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasSpectators())
{
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 3;
else
error = true;
@@ -3276,20 +3276,20 @@ static void Command_Teamchange2_f(void)
if (G_GametypeHasTeams())
{
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasSpectators())
{
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 3;
else
error = true;
@@ -3367,20 +3367,20 @@ static void Command_Teamchange3_f(void)
if (G_GametypeHasTeams())
{
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasSpectators())
{
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 3;
else
error = true;
@@ -3458,20 +3458,20 @@ static void Command_Teamchange4_f(void)
if (G_GametypeHasTeams())
{
if (!strcasecmp(COM_Argv(1), "red") || !strcasecmp(COM_Argv(1), "1"))
if (fasticmp(COM_Argv(1), "red") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(1), "blue") || !strcasecmp(COM_Argv(1), "2"))
else if (fasticmp(COM_Argv(1), "blue") || fasticmp(COM_Argv(1), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
else if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasSpectators())
{
if (!strcasecmp(COM_Argv(1), "spectator") || !strcasecmp(COM_Argv(1), "0"))
if (fasticmp(COM_Argv(1), "spectator") || fasticmp(COM_Argv(1), "0"))
NetPacket.packet.newteam = 0;
else if (!strcasecmp(COM_Argv(1), "playing") || !strcasecmp(COM_Argv(1), "1"))
else if (fasticmp(COM_Argv(1), "playing") || fasticmp(COM_Argv(1), "1"))
NetPacket.packet.newteam = 3;
else
error = true;
@@ -3557,33 +3557,33 @@ static void Command_ServerTeamChange_f(void)
if (G_TagGametype())
{
if (!strcasecmp(COM_Argv(2), "it") || !strcasecmp(COM_Argv(2), "1"))
if (fasticmp(COM_Argv(2), "it") || fasticmp(COM_Argv(2), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(2), "notit") || !strcasecmp(COM_Argv(2), "2"))
else if (fasticmp(COM_Argv(2), "notit") || fasticmp(COM_Argv(2), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(2), "playing") || !strcasecmp(COM_Argv(2), "3"))
else if (fasticmp(COM_Argv(2), "playing") || fasticmp(COM_Argv(2), "3"))
NetPacket.packet.newteam = 3;
else if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
else if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasTeams())
{
if (!strcasecmp(COM_Argv(2), "red") || !strcasecmp(COM_Argv(2), "1"))
if (fasticmp(COM_Argv(2), "red") || fasticmp(COM_Argv(2), "1"))
NetPacket.packet.newteam = 1;
else if (!strcasecmp(COM_Argv(2), "blue") || !strcasecmp(COM_Argv(2), "2"))
else if (fasticmp(COM_Argv(2), "blue") || fasticmp(COM_Argv(2), "2"))
NetPacket.packet.newteam = 2;
else if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
else if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
NetPacket.packet.newteam = 0;
else
error = true;
}
else if (G_GametypeHasSpectators())
{
if (!strcasecmp(COM_Argv(2), "spectator") || !strcasecmp(COM_Argv(2), "0"))
if (fasticmp(COM_Argv(2), "spectator") || fasticmp(COM_Argv(2), "0"))
NetPacket.packet.newteam = 0;
else if (!strcasecmp(COM_Argv(2), "playing") || !strcasecmp(COM_Argv(2), "1"))
else if (fasticmp(COM_Argv(2), "playing") || fasticmp(COM_Argv(2), "1"))
NetPacket.packet.newteam = 3;
else
error = true;
@@ -3658,7 +3658,7 @@ static void Command_ServerTeamChange_f(void)
}
//todo: This and the other teamchange functions are getting too long and messy. Needs cleaning.
static void Got_Teamchange(UINT8 **cp, INT32 playernum)
static void Got_Teamchange(const UINT8 **cp, INT32 playernum)
{
changeteam_union NetPacket;
boolean error = false, wasspectator = false;
@@ -3898,6 +3898,7 @@ static void Got_Teamchange(UINT8 **cp, INT32 playernum)
if (G_BattleGametype()) // SRB2kart
{
players[playernum].marescore = 0;
if (K_IsPlayerWanted(&players[playernum]))
K_CalculateBattleWanted();
}
@@ -4015,7 +4016,7 @@ static void Command_Login_f(void)
#endif
}
static void Got_Login(UINT8 **cp, INT32 playernum)
static void Got_Login(const UINT8 **cp, INT32 playernum)
{
#ifdef NOMD5
// If we have no MD5 support then completely disable XD_LOGIN responses for security.
@@ -4125,7 +4126,7 @@ static void Command_Verify_f(void)
SendNetXCmd(XD_VERIFIED, buf, 1);
}
static void Got_Verification(UINT8 **cp, INT32 playernum)
static void Got_Verification(const UINT8 **cp, INT32 playernum)
{
INT16 num = READUINT8(*cp);
@@ -4177,7 +4178,7 @@ static void Command_RemoveAdmin_f(void)
SendNetXCmd(XD_DEMOTED, buf, 1);
}
static void Got_Removal(UINT8 **cp, INT32 playernum)
static void Got_Removal(const UINT8 **cp, INT32 playernum)
{
INT16 num = READUINT8(*cp);
@@ -4253,7 +4254,7 @@ static void Command_MotD_f(void)
Z_Free(mymotd);
}
static void Got_MotD_f(UINT8 **cp, INT32 playernum)
static void Got_MotD_f(const UINT8 **cp, INT32 playernum)
{
char *mymotd = Z_Malloc(sizeof(motd), PU_STATIC, NULL);
INT32 i;
@@ -4320,7 +4321,7 @@ static void Command_RunSOC(void)
SendNetXCmd(XD_RUNSOC, buf, length);
}
static void Got_RunSOCcmd(UINT8 **cp, INT32 playernum)
static void Got_RunSOCcmd(const UINT8 **cp, INT32 playernum)
{
char filename[256];
filestatus_t ncs = FS_NOTCHECKED;
@@ -4495,7 +4496,7 @@ static void Command_Addskins(void)
CONS_Printf("addskins has been deprecated\nuse addfilelocal instead!\n");
}
static void Command_GLocalSkin (void)
static void Command_GLocalSkin(void)
{
size_t first_option;
size_t option_display;
@@ -4506,7 +4507,7 @@ static void Command_GLocalSkin (void)
option_display = COM_CheckPartialParm("-d");
option_all = COM_CheckPartialParm("-a");
char* fuck; // local skin name
CLEANUP(Z_Pfree) char* fuck = NULL; // local skin name
if (!(first_option = COM_FirstOption()))
first_option = COM_Argc();
@@ -4547,7 +4548,6 @@ static void Command_GLocalSkin (void)
CONS_Printf("Successfully applied localskin to displayed player.\n");
Z_Free(fuck);
return;
}
else if (option_all) // -all
@@ -4562,7 +4562,6 @@ static void Command_GLocalSkin (void)
}
CONS_Printf("Successfully applied localskin to all players.\n");
Z_Free(fuck);
return;
}
else // -player or no other arguments
@@ -4579,7 +4578,6 @@ static void Command_GLocalSkin (void)
}
CONS_Printf("Successfully applied localskin to specified player.\n");
Z_Free(fuck);
return;
}
else
@@ -4587,18 +4585,16 @@ static void Command_GLocalSkin (void)
SetLocalPlayerSkin(consoleplayer, fuck, &cv_localskin);
CONS_Printf("Successfully applied localskin.\n");
Z_Free(fuck);
return;
}
CONS_Printf("Could not apply localskin.\n");
Z_Free(fuck);
return;
}
}
static void Got_RequestAddfilecmd(UINT8 **cp, INT32 playernum)
static void Got_RequestAddfilecmd(const UINT8 **cp, INT32 playernum)
{
char filename[241];
filestatus_t ncs = FS_NOTCHECKED;
@@ -4657,7 +4653,7 @@ static void Got_RequestAddfilecmd(UINT8 **cp, INT32 playernum)
COM_BufAddText(va("addfile %s\n", filename));
}
static void Got_Addfilecmd(UINT8 **cp, INT32 playernum)
static void Got_Addfilecmd(const UINT8 **cp, INT32 playernum)
{
char filename[241];
filestatus_t ncs = FS_NOTCHECKED;
@@ -5201,14 +5197,14 @@ static void Ringslinger_OnChange(void)
static void Gravity_OnChange(void)
{
if (!M_SecretUnlocked(SECRET_PANDORA) && !netgame && !cv_debug
&& strcmp(cv_gravity.string, cv_gravity.defaultvalue))
&& !fastcmp(cv_gravity.string, cv_gravity.defaultvalue))
{
CONS_Printf(M_GetText("You haven't earned this yet.\n"));
CV_StealthSet(&cv_gravity, cv_gravity.defaultvalue);
return;
}
#ifndef NETGAME_GRAVITY
if(netgame)
if (netgame)
{
CV_StealthSet(&cv_gravity, cv_gravity.defaultvalue);
return;
@@ -5457,7 +5453,7 @@ static void Command_ExitLevel_f(void)
SendNetXCmd(XD_EXITLEVEL, NULL, 0);
}
static void Got_ExitLevelcmd(UINT8 **cp, INT32 playernum)
static void Got_ExitLevelcmd(const UINT8 **cp, INT32 playernum)
{
(void)cp;
@@ -5478,7 +5474,7 @@ static void Got_ExitLevelcmd(UINT8 **cp, INT32 playernum)
G_ExitLevel();
}
static void Got_SetupVotecmd(UINT8 **cp, INT32 playernum)
static void Got_SetupVotecmd(const UINT8 **cp, INT32 playernum)
{
INT32 i;
UINT8 gt, secondgt;
@@ -5530,7 +5526,7 @@ static void Got_SetupVotecmd(UINT8 **cp, INT32 playernum)
Y_StartVote();
}
static void Got_ModifyVotecmd(UINT8 **cp, INT32 playernum)
static void Got_ModifyVotecmd(const UINT8 **cp, INT32 playernum)
{
SINT8 voted = READSINT8(*cp);
UINT8 p = READUINT8(*cp);
@@ -5539,7 +5535,7 @@ static void Got_ModifyVotecmd(UINT8 **cp, INT32 playernum)
votes[p] = voted;
}
static void Got_PickVotecmd(UINT8 **cp, INT32 playernum)
static void Got_PickVotecmd(const UINT8 **cp, INT32 playernum)
{
SINT8 pick = READSINT8(*cp);
SINT8 level = READSINT8(*cp);
@@ -5676,7 +5672,7 @@ static void Command_Togglemodified_f(void)
static void Command_Archivetest_f(void)
{
savebuffer_t save;
savebuffer_t save = {0};
UINT32 i, wrote;
thinker_t *th;
if (gamestate != GS_LEVEL)
@@ -6179,7 +6175,7 @@ static void KartEliminateLast_OnChange(void)
P_CheckRacers();
}
void Got_DiscordInfo(UINT8 **p, INT32 playernum)
void Got_DiscordInfo(const UINT8 **p, INT32 playernum)
{
if (playernum != serverplayer /*&& !IsPlayerAdmin(playernum)*/)
{
+2
View File
@@ -209,6 +209,8 @@ extern consvar_t cv_betainterscreen;
extern consvar_t cv_laglesscam;
extern consvar_t cv_demoangturn;
typedef enum
{
SKINMENUTYPE_SCROLL = 0,
+28 -27
View File
@@ -64,7 +64,6 @@
static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid);
#ifdef HAVE_CURL
size_t curlwrite_data(void *ptr, size_t size, size_t nmemb, FILE *stream);
#if (LIBCURL_VERSION_MAJOR <= 7) && (LIBCURL_VERSION_MINOR < 35)
static int curlprogress_callback(void *clientp, double dltotal, double dlnow, double ultotal, double ulnow);
#else
@@ -110,14 +109,14 @@ static fileused_t transferFiles[UINT8_MAX + 1];
// Write time of file: utime
// Receiver structure
INT32 fileneedednum; // Number of files needed to join the server
fileneeded_t fileneeded[MAX_WADFILES]; // List of needed files
INT32 fileneedednum = 0; // Number of files needed to join the server
fileneeded_t fileneeded[MAX_WADFILES] = {}; // List of needed files
#ifdef HAVE_THREADS
static I_mutex downloadmutex;
#endif
char downloaddir[512] = "DOWNLOAD";
file_download_t filedownload;
file_download_t filedownload = {};
#ifdef HAVE_CURL
static CURL *http_handle;
@@ -131,7 +130,7 @@ static UINT32 curl_origfilesize;
static UINT32 curl_origtotalfilesize;
static char *curl_realname = NULL;
fileneeded_t *curl_curfile = NULL;
HTTP_login *curl_logins;
HTTP_login *curl_logins = NULL;
#endif
/** Fills a serverinfo packet with information about wad files loaded.
@@ -550,7 +549,8 @@ INT32 CL_CheckFiles(void)
for (j = mainwads+1; j < numwadfiles; j++)
{
nameonly(strcpy(wadfilename, wadfiles[j]->filename));
if (!stricmp(wadfilename, fileneeded[i].filename) &&
if (fasticmp(wadfilename, fileneeded[i].filename) &&
!memcmp(wadfiles[j]->md5sum, fileneeded[i].md5sum, 16))
{
CONS_Debug(DBG_NETPLAY, "already loaded\n");
@@ -665,7 +665,7 @@ static boolean SV_SendFile(INT32 node, const char *filename, UINT8 fileid)
strlcpy(wadfilename, wadfiles[wadnum]->filename, MAX_WADPATH);
nameonly(wadfilename);
if (!stricmp(wadfilename, p->id.filename))
if (fasticmp(wadfilename, p->id.filename))
{
// Copy file name with full path
strlcpy(p->id.filename, wadfiles[wadnum]->filename, MAX_WADPATH);
@@ -901,7 +901,7 @@ void SV_FileSendTicker(void)
if (ram)
{
M_Memcpy(p->data, &f->id.ram[transfer[i].position], size);
memcpy(p->data, &f->id.ram[transfer[i].position], size);
}
else if (fread(p->data, 1, size, transferFiles[f->fileid].file) != size)
{
@@ -946,17 +946,17 @@ void Got_Filetxpak(void)
char *filename = file->filename;
static INT32 filetime = 0;
if (!(strcmp(filename, "srb2.srb")
//&& strcmp(filename, "srb2.wad")
//&& strcmp(filename, "patch.dta")
//&& strcmp(filename, "music.dta")
&& strcmp(filename, "gfx.kart")
&& strcmp(filename, "textures.kart")
&& strcmp(filename, "chars.kart")
&& strcmp(filename, "maps.kart")
&& strcmp(filename, "sounds.kart")
&& strcmp(filename, "music.kart")
&& strcmp(filename, "patch.kart")
if ((fastcmp(filename, "srb2.srb")
//|| fastcmp(filename, "srb2.wad")
//|| fastcmp(filename, "patch.dta")
//|| fastcmp(filename, "music.dta")
|| fastcmp(filename, "gfx.kart")
|| fastcmp(filename, "textures.kart")
|| fastcmp(filename, "chars.kart")
|| fastcmp(filename, "maps.kart")
|| fastcmp(filename, "sounds.kart")
|| fastcmp(filename, "music.kart")
|| fastcmp(filename, "patch.kart")
))
I_Error("Tried to download \"%s\"", filename);
@@ -1079,12 +1079,14 @@ void CloseNetFile(void)
// Receiving a file?
for (i = 0; i < MAX_WADFILES; i++)
{
if (fileneeded[i].status == FS_DOWNLOADING && fileneeded[i].file)
{
fclose(fileneeded[i].file);
// File is not complete delete it
remove(fileneeded[i].filename);
}
}
// Remove PT_FILEFRAGMENT from acknowledge list
Net_AbortPacketType(PT_FILEFRAGMENT);
@@ -1098,17 +1100,16 @@ void nameonly(char *s)
void *ns;
for (j = strlen(s); j != (size_t)-1; j--)
{
if ((s[j] == '\\') || (s[j] == ':') || (s[j] == '/'))
{
ns = &(s[j+1]);
len = strlen(ns);
#if 0
M_Memcpy(s, ns, len+1);
#else
memmove(s, ns, len+1);
#endif
memmove(s, ns, len+1);
return;
}
}
}
// Returns the length in characters of the last element of a path.
@@ -1197,7 +1198,7 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
}
// next, check SRB2's "home" directory (if non-'.')
if (strcmp(srb2home, "."))
if (!fastcmp(srb2home, "."))
{
homecheck = filesearch(filename, srb2home, wantedmd5sum, completepath, 10);
@@ -1209,7 +1210,7 @@ filestatus_t findfile(char *filename, const UINT8 *wantedmd5sum, boolean complet
}
// next, check SRB2's "path" directory (also if non-'.')
if (strcmp(srb2path, "."))
if (!fastcmp(srb2path, "."))
{
homecheck = filesearch(filename, srb2path, wantedmd5sum, completepath, 10);
@@ -1554,7 +1555,7 @@ CURLGetLogin (const char *url, HTTP_login ***return_prev_next)
( login = (*prev_next));
prev_next = &login->next
){
if (strcmp(login->url, url) == 0)
if (fastcmp(login->url, url) != 0)
{
if (return_prev_next)
(*return_prev_next) = prev_next;
+2 -2
View File
@@ -211,12 +211,12 @@ void D_SetupProtocol(void)
if (result)
{
if (strcmp(buffer, "no") == 0)
if (!fastcmp(buffer, "no"))
{
fclose(fp);
return;
}
else if (strcmp(buffer, exe_path) != 0)
else if (fastcmp(buffer, exe_path))
{
// overwrite
fclose(fp);
+84 -146
View File
@@ -127,16 +127,32 @@ typedef LPVOID (WINAPI *p_MapViewOfFile) (HANDLE, DWORD, DWORD, DWORD, SIZE_T);
#include <time.h>
// Locations for searching the srb2.srb
/// Locations to directly check for srb2.srb in
const char *wadDefaultPaths[] = {
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
#define DEFAULTWADLOCATION1 "/usr/local/share/games/SRB2Kart"
#define DEFAULTWADLOCATION2 "/usr/local/games/SRB2Kart"
#define DEFAULTWADLOCATION3 "/usr/share/games/SRB2Kart"
#define DEFAULTWADLOCATION4 "/usr/games/SRB2Kart"
#define DEFAULTSEARCHPATH1 "/usr/local/games"
#define DEFAULTSEARCHPATH2 "/usr/games"
#define DEFAULTSEARCHPATH3 "/usr/local"
"/usr/local/share/games/SRB2Kart",
"/usr/local/games/SRB2Kart",
"/usr/share/games/SRB2Kart",
"/usr/games/SRB2Kart",
#elif defined (_WIN32)
"c:\\games\\srb2kart",
"\\games\\srb2kart",
#endif
NULL
};
// Folders to recurse through looking for srb2.srb
const char *wadSearchPaths[] = {
#if defined (__unix__) || defined(__APPLE__) || defined (UNIXCOMMON)
"/usr/local/games",
"/usr/games",
"/usr/local",
#elif defined (_WIN32)
"c:\\games",
"\\games",
#endif
NULL
};
/** \brief WAD file to look for
*/
@@ -808,20 +824,23 @@ static void I_SetupMumble(void)
void I_UpdateMumble(const mobj_t *mobj, const listener_t listener)
{
#ifdef HAVE_MUMBLE
double angle;
float angle;
fixed_t anglef;
if (!mumble)
return;
if (mumble->uiVersion != 2) {
wcsncpy(mumble->name, L"SRB2Kart "VERSIONSTRINGW, 256);
if (mumble->uiVersion != 2)
{
wcsncpy(mumble->name, L"SRB2Kart " VERSIONSTRINGW, 256);
wcsncpy(mumble->description, L"Sonic Robo Blast 2 Kart with integrated Mumble Link support.", 2048);
mumble->uiVersion = 2;
}
mumble->uiTick++;
if (!netgame || gamestate != GS_LEVEL) { // Zero out, but never delink.
// Zero out, but never delink.
if (!netgame || gamestate != GS_LEVEL)
{
mumble->fAvatarPosition[0] = mumble->fAvatarPosition[1] = mumble->fAvatarPosition[2] = 0.0f;
mumble->fAvatarFront[0] = 1.0f;
mumble->fAvatarFront[1] = mumble->fAvatarFront[2] = 0.0f;
@@ -838,31 +857,34 @@ void I_UpdateMumble(const mobj_t *mobj, const listener_t listener)
mumble->context_len = (UINT32)(p - mumble->context);
}
if (mobj) {
mumble->fAvatarPosition[0] = FIXED_TO_FLOAT(mobj->x) / MUMBLEUNIT;
mumble->fAvatarPosition[1] = FIXED_TO_FLOAT(mobj->z) / MUMBLEUNIT;
mumble->fAvatarPosition[2] = FIXED_TO_FLOAT(mobj->y) / MUMBLEUNIT;
if (mobj)
{
mumble->fAvatarPosition[0] = FixedToFloat(mobj->x) / MUMBLEUNIT;
mumble->fAvatarPosition[1] = FixedToFloat(mobj->z) / MUMBLEUNIT;
mumble->fAvatarPosition[2] = FixedToFloat(mobj->y) / MUMBLEUNIT;
anglef = AngleFixed(mobj->angle);
angle = FIXED_TO_FLOAT(anglef)*DEG2RAD;
mumble->fAvatarFront[0] = (float)cos(angle);
angle = (float)(FixedToFloat(anglef) * DEG2RAD);
mumble->fAvatarFront[0] = cosf(angle);
mumble->fAvatarFront[1] = 0.0f;
mumble->fAvatarFront[2] = (float)sin(angle);
} else {
mumble->fAvatarFront[2] = sinf(angle);
}
else
{
mumble->fAvatarPosition[0] = mumble->fAvatarPosition[1] = mumble->fAvatarPosition[2] = 0.0f;
mumble->fAvatarFront[0] = 1.0f;
mumble->fAvatarFront[1] = mumble->fAvatarFront[2] = 0.0f;
}
mumble->fCameraPosition[0] = FIXED_TO_FLOAT(listener.x) / MUMBLEUNIT;
mumble->fCameraPosition[1] = FIXED_TO_FLOAT(listener.z) / MUMBLEUNIT;
mumble->fCameraPosition[2] = FIXED_TO_FLOAT(listener.y) / MUMBLEUNIT;
mumble->fCameraPosition[0] = FixedToFloat(listener.x) / MUMBLEUNIT;
mumble->fCameraPosition[1] = FixedToFloat(listener.z) / MUMBLEUNIT;
mumble->fCameraPosition[2] = FixedToFloat(listener.y) / MUMBLEUNIT;
anglef = AngleFixed(listener.angle);
angle = FIXED_TO_FLOAT(anglef)*DEG2RAD;
mumble->fCameraFront[0] = (float)cos(angle);
angle = (float)(FixedToFloat(anglef) * DEG2RAD);
mumble->fCameraFront[0] = cosf(angle);
mumble->fCameraFront[1] = 0.0f;
mumble->fCameraFront[2] = (float)sin(angle);
mumble->fCameraFront[2] = sinf(angle);
#else
(void)mobj;
(void)listener;
@@ -1417,20 +1439,6 @@ death:
exit(0);
}
void I_WaitVBL(INT32 count)
{
count = 1;
I_Sleep(count);
}
void I_BeginRead(void)
{
}
void I_EndRead(void)
{
}
//
// I_Error
//
@@ -1709,9 +1717,9 @@ char *I_GetUserName(void)
strncpy(username, p, MAXPLAYERNAME);
}
if (strcmp(username, "") != 0)
if (!fastcmp(username, ""))
return username;
return NULL; // dummy for platform independent version
}
@@ -1821,16 +1829,23 @@ static const char *searchWad(const char *searchDir)
return tempsw;
}
strcpy(tempsw, WADKEYWORD2);
fstemp = filesearch(tempsw, searchDir, NULL, true, 20);
if (fstemp == FS_FOUND)
{
pathonly(tempsw);
return tempsw;
}
return NULL;
}
#define CHECKWADPATH(ret) \
do { \
I_OutputMsg(",%s", ret); \
if (isWadPathOk(ret)) \
return ret; \
} while (0)
#define SEARCHWAD(str) \
do { \
WadPath = searchWad(str); \
if (WadPath) \
return WadPath; \
} while (0)
/** \brief go through all possible paths and look for srb2.srb
\return path to srb2.srb if any
@@ -1839,6 +1854,7 @@ static const char *locateWad(void)
{
const char *envstr;
const char *WadPath;
int i;
I_OutputMsg("SRB2WADDIR");
// does SRB2WADDIR exist?
@@ -1846,132 +1862,51 @@ static const char *locateWad(void)
return envstr;
#ifndef NOCWD
I_OutputMsg(",.");
// examine current dir
strcpy(returnWadPath, ".");
I_OutputMsg(",%s", returnWadPath);
if (isWadPathOk(returnWadPath))
return NULL;
#endif
#ifndef NOHOME
#ifdef DEFAULTDIR
I_OutputMsg(",HOME/" DEFAULTDIR);
// examine user jart directory
if ((envstr = I_GetEnv("HOME")) != NULL)
{
sprintf(returnWadPath, "%s" PATHSEP DEFAULTDIR, envstr);
if (isWadPathOk(returnWadPath))
return returnWadPath;
}
#endif
#ifdef CMAKECONFIG
#ifndef NDEBUG
I_OutputMsg(","CMAKE_ASSETS_DIR);
strcpy(returnWadPath, CMAKE_ASSETS_DIR);
if (isWadPathOk(returnWadPath))
{
return returnWadPath;
CHECKWADPATH(returnWadPath);
}
#endif
#endif
#ifdef __APPLE__
OSX_GetResourcesPath(returnWadPath);
I_OutputMsg(",%s", returnWadPath);
if (isWadPathOk(returnWadPath))
{
return returnWadPath;
}
CHECKWADPATH(returnWadPath);
#endif
// examine default dirs
#ifdef DEFAULTWADLOCATION1
I_OutputMsg(","DEFAULTWADLOCATION1);
strcpy(returnWadPath, DEFAULTWADLOCATION1);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION2
I_OutputMsg(","DEFAULTWADLOCATION2);
strcpy(returnWadPath, DEFAULTWADLOCATION2);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION3
I_OutputMsg(","DEFAULTWADLOCATION3);
strcpy(returnWadPath, DEFAULTWADLOCATION3);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION4
I_OutputMsg(","DEFAULTWADLOCATION4);
strcpy(returnWadPath, DEFAULTWADLOCATION4);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION5
I_OutputMsg(","DEFAULTWADLOCATION5);
strcpy(returnWadPath, DEFAULTWADLOCATION5);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION6
I_OutputMsg(","DEFAULTWADLOCATION6);
strcpy(returnWadPath, DEFAULTWADLOCATION6);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifdef DEFAULTWADLOCATION7
I_OutputMsg(","DEFAULTWADLOCATION7);
strcpy(returnWadPath, DEFAULTWADLOCATION7);
if (isWadPathOk(returnWadPath))
return returnWadPath;
#endif
#ifndef NOHOME
// find in $HOME
I_OutputMsg(",HOME/" DEFAULTDIR);
if ((envstr = I_GetEnv("HOME")) != NULL)
for (i = 0; wadDefaultPaths[i]; i++)
{
char *tmp = malloc(strlen(envstr) + sizeof(PATHSEP) + sizeof(DEFAULTDIR));
strcpy(tmp, envstr);
strcat(tmp, PATHSEP);
strcat(tmp, DEFAULTDIR);
WadPath = searchWad(tmp);
free(tmp);
if (WadPath)
return WadPath;
strcpy(returnWadPath, wadDefaultPaths[i]);
CHECKWADPATH(returnWadPath);
}
#endif
#ifdef DEFAULTSEARCHPATH1
// find in /usr/local
I_OutputMsg(", in:"DEFAULTSEARCHPATH1);
WadPath = searchWad(DEFAULTSEARCHPATH1);
if (WadPath)
return WadPath;
#endif
#ifdef DEFAULTSEARCHPATH2
// find in /usr/games
I_OutputMsg(", in:"DEFAULTSEARCHPATH2);
WadPath = searchWad(DEFAULTSEARCHPATH2);
if (WadPath)
return WadPath;
#endif
#ifdef DEFAULTSEARCHPATH3
// find in ???
I_OutputMsg(", in:"DEFAULTSEARCHPATH3);
WadPath = searchWad(DEFAULTSEARCHPATH3);
if (WadPath)
return WadPath;
#endif
// search paths
for (i = 0; wadSearchPaths[i]; i++)
{
I_OutputMsg(", in:%s", wadSearchPaths[i]);
SEARCHWAD(wadSearchPaths[i]);
}
// if nothing was found
return NULL;
}
const char *I_LocateWad(void)
{
const char *waddir;
const char *waddir = NULL;
I_OutputMsg("Looking for WADs in: ");
waddir = locateWad();
@@ -1981,12 +1916,15 @@ const char *I_LocateWad(void)
{
// change to the directory where we found srb2.srb
#if defined (_WIN32)
waddir = _fullpath(NULL, waddir, MAX_PATH);
SetCurrentDirectoryA(waddir);
#else
waddir = realpath(waddir, NULL);
if (waddir == NULL || chdir(waddir) == -1)
I_OutputMsg("Couldn't change working directory\n");
#endif
}
return waddir;
}
+8 -8
View File
@@ -65,13 +65,6 @@ void I_OsPolling(void)
I_GetConsoleEvents();
}
//
// I_UpdateNoBlit
//
void I_UpdateNoBlit(void)
{
}
//
// I_FinishUpdate
//
@@ -122,6 +115,10 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h)
return -1;
}
void VID_RefreshModeList(void)
{
}
void VID_PrepareModeList(void)
{
}
@@ -155,7 +152,10 @@ boolean I_UseNativeKeyboard(void)
return false;
}
void I_HandleControllerHatRepeat(void)
{
}
void I_SetBorderlessWindow(void)
{
}
+3 -3
View File
@@ -47,9 +47,9 @@
// Free slot names
// The crazy word-reading stuff uses these.
char *FREE_STATES[NUMSTATEFREESLOTS];
char *FREE_MOBJS[NUMMOBJFREESLOTS];
UINT8 used_spr[(NUMSPRITEFREESLOTS / 8) + 1]; // Bitwise flag for sprite freeslot in use! I would use ceil() here if I could, but it only saves 1 byte of memory anyway.
char *FREE_STATES[NUMSTATEFREESLOTS] = {};
char *FREE_MOBJS[NUMMOBJFREESLOTS] = {};
UINT8 used_spr[(NUMSPRITEFREESLOTS / 8) + 1] = {}; // Bitwise flag for sprite freeslot in use! I would use ceil() here if I could, but it only saves 1 byte of memory anyway.
#define initfreeslots() {\
memset(FREE_STATES,0,sizeof(char *) * NUMSTATEFREESLOTS);\
+3 -3
View File
@@ -277,7 +277,7 @@ static void DRPC_HandleJoinRequest(const DiscordUser *requestUser)
while (append != NULL)
{
// CHECK FOR DUPES!! Ignore any that already exist from the same user.
if (!strcmp(newRequest->userID, append->userID))
if (fastcmp(newRequest->userID, append->userID))
{
Discord_Respond(newRequest->userID, DISCORD_REPLY_IGNORE);
DRPC_RemoveRequest(newRequest);
@@ -419,7 +419,7 @@ static const char *DRPC_GetServerIP(void)
// If you're connected
if (I_GetNodeAddress && (address = I_GetNodeAddress(servernode)) != NULL)
{
if (strcmp(address, "self"))
if (!fastcmp(address, "self"))
{
// We're not the server, so we could successfully get the IP!
// No need to do anything else :)
@@ -684,7 +684,7 @@ void DRPC_UpdatePresence(void)
// Character image
while (supportedSkins[checkSkin] != NULL)
{
if (!strcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
if (fastcmp(skins[players[consoleplayer].skin].name, supportedSkins[checkSkin]))
{
snprintf(charimg, 21, "char%s", supportedSkins[checkSkin]);
discordPresence.smallImageKey = charimg;
+17 -20
View File
@@ -19,25 +19,19 @@
// This should actually be in the makefile,
// but I can't stand that gibberish. D:
#define SOUND_DUMMY 0
#define SOUND_SDL 1
#define SOUND_MIXER 2
#define SOUND_MIXER 1
#define SOUND_SDL 2
#ifndef SOUND
#ifdef HAVE_SDL
// Use Mixer interface?
#ifdef HAVE_MIXER
#define SOUND SOUND_MIXER
#else
#define SOUND SOUND_SDL
#endif
// Use generic SDL interface.
#ifndef SOUND
#define SOUND SOUND_SDL
#endif
#else // No SDL.
// No more interfaces. :(
#define SOUND SOUND_DUMMY
#else
#define SOUND SOUND_DUMMY
#endif
#endif
@@ -69,6 +63,8 @@ extern "C" {
#include <sys/stat.h>
#include <ctype.h>
#include "fastcmp.h"
#ifdef _WIN32
#include <io.h>
#endif
@@ -112,8 +108,8 @@ extern char logfilename[1024];
#else
#define VERSION 1 // Game version
#define SUBVERSION 6 // more precise version number
#define VERSIONSTRING "Saturn v9"
#define VERSIONSTRINGW L"Saturn v9"
#define VERSIONSTRING "Saturn v9.x - Testing"
#define VERSIONSTRINGW L"Saturn v9.x - Testing "
#define SATURN_TESTING // comment out for saturn release builds!
@@ -451,11 +447,6 @@ extern char savegamename[256];
//TODO: delet this
#define M_GetText(x) (x)
FUNCINLINE static ATTRINLINE void *M_Memcpy(void *dest, const void *src, size_t n)
{
return memcpy(dest, src, n);
}
char *va(const char *format, ...) FUNCPRINTF;
char *M_GetToken(const char *inputString);
char *sizeu1(size_t num);
@@ -487,7 +478,7 @@ extern INT32 cv_debug;
// Misc stuff for later...
// =======================
#define ANG2RAD(angle) ((float)((angle)*M_PI)/ANGLE_180)
#define ANG2RAD(angle) ((float)((angle)*M_PIf) / (float)ANGLE_180)
// Modifier key variables, accessible anywhere
extern UINT8 shiftdown, ctrldown, altdown;
@@ -536,6 +527,10 @@ UINT32 quickncasehash (const char *p, size_t n)
#define M_PIl 3.1415926535897932384626433832795029L
#endif
#ifndef M_PIf
#define M_PIf 3.14159265f
#endif
// Floating point comparison epsilons from float.h
#ifndef FLT_EPSILON
#define FLT_EPSILON 1.1920928955078125e-7f
@@ -651,7 +646,9 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
#if defined (HAVE_CURL)
#define MASTERSERVER
#ifndef NOHOLEPUNCH
#define HOLEPUNCH
#endif
#else
#undef UPDATE_ALERT
#endif
+3
View File
@@ -116,7 +116,10 @@ extern UINT8 window_notinfocus; // are we in focus? (backend independant -- hand
extern boolean nodrawers;
extern boolean noblit;
extern boolean lastdraw;
#ifdef MOTIONBLUR
extern INT32 postimgparam[MAXSPLITSCREENPLAYERS];
#endif
extern INT32 viewwindowx, viewwindowy;
extern INT32 viewwidth;
+6 -4
View File
@@ -68,11 +68,13 @@ extern "C" {
#define strnicmp(x,y,n) strncasecmp(x,y,n)
#endif
#ifndef __cplusplus
char *strcasestr(const char *in, const char *what);
#define stristr strcasestr
char *nongnu_strcasestr(const char *in, const char *what);
#ifndef _GNU_SOURCE
#define strcasestr nongnu_strcasestr
#endif
#define stristr strcasestr
#if defined (macintosh) //|| defined (__APPLE__) //skip all boolean/Boolean crap
#define true 1
#define false 0
@@ -293,7 +295,7 @@ typedef struct
UINT8 green;
UINT8 blue;
UINT8 alpha;
} byteColor_t;
} ATTRPACK byteColor_t;
union FColorRGBA
{
+33 -38
View File
@@ -166,8 +166,8 @@ static void F_SkyScroll(INT32 scrollspeed)
patch_t *pat, *pat2;
INT32 anim2 = 0;
pat = W_CachePatchName("TITLEBG1", PU_PATCH_LOWPRIORITY);
pat2 = W_CachePatchName("TITLEBG2", PU_PATCH_LOWPRIORITY);
pat = W_CachePatchName("TITLEBG1", PU_PATCH);
pat2 = W_CachePatchName("TITLEBG2", PU_PATCH);
w = (vid.scaledwidth << FRACBITS);
@@ -208,16 +208,13 @@ static void F_SkyScroll(INT32 scrollspeed)
INT32 intro_scenenum = 0;
INT32 intro_curtime = 0;
const char *introtext[NUMINTROSCENES];
const char *introtext[NUMINTROSCENES] = {};
static tic_t introscenetime[NUMINTROSCENES] =
{
4*TICRATE, // KART KR(eW
};
// custom intros
void F_StartCustomCutscene(INT32 cutscenenum, boolean precutscene, boolean resetplayer);
void F_StartIntro(void)
{
if (gamestate)
@@ -257,26 +254,21 @@ void F_StartIntro(void)
//
void F_IntroDrawer(void)
{
boolean highres = false;
INT32 cx = 8, cy = 128;
patch_t *background = NULL;
INT32 bgxoffs = 0;
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 120);
// DRAW A FULL PIC INSTEAD OF FLAT!
if (intro_scenenum == 0)
{
background = W_CachePatchName("KARTKREW", PU_PATCH_LOWPRIORITY);
highres = true;
}
background = W_CachePatchName("KARTKREW", PU_PATCH);
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 120);
if (background)
{
if (highres)
if (background)
{
V_DrawSmallScaledPatch(bgxoffs, 0, 0, background);
else
V_DrawScaledPatch(bgxoffs, 0, 0, background);
}
}
W_UnlockCachedPatch(background);
@@ -324,6 +316,7 @@ void F_IntroTicker(void)
D_StartTitle();
return;
}
if (finalecount == 8)
S_StartSound(NULL, sfx_vroom);
else if (finalecount == 47)
@@ -626,7 +619,6 @@ void F_StartCredits(void)
timetonext = 2*TICRATE;
}
void F_CreditDrawer(void)
{
UINT16 i;
@@ -652,7 +644,7 @@ void F_CreditDrawer(void)
sc = FRACUNIT; // quick hack so I don't have to add another field to credits_pics
}
V_DrawFixedPatch(credits_pics[i].x<<FRACBITS, (credits_pics[i].y<<FRACBITS) - 4*(animtimer<<FRACBITS)/5, sc, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH), colormap);
V_DrawFixedPatch(credits_pics[i].x<<FRACBITS, (credits_pics[i].y<<FRACBITS) - 4*(animtimer<<FRACBITS)/5, sc, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH_LOWPRIORITY), colormap);
}
// Dim the background
@@ -661,22 +653,23 @@ void F_CreditDrawer(void)
// Draw credits text on top
for (i = 0; credits[i]; i++)
{
switch(credits[i][0])
switch (credits[i][0])
{
case 0:
y += 80<<FRACBITS;
break;
case 1:
if (y>>FRACBITS > -20)
V_DrawCreditString((160 - (V_CreditStringWidth(&credits[i][1])>>1))<<FRACBITS, y, 0, &credits[i][1]);
y += 30<<FRACBITS;
break;
default:
if (y>>FRACBITS > -10)
V_DrawStringAtFixed(32<<FRACBITS, y, V_ALLOWLOWERCASE, credits[i]);
y += 12<<FRACBITS;
break;
case 0:
y += 80<<FRACBITS;
break;
case 1:
if (y>>FRACBITS > -20)
V_DrawCreditString((160 - (V_CreditStringWidth(&credits[i][1])>>1))<<FRACBITS, y, 0, &credits[i][1]);
y += 30<<FRACBITS;
break;
default:
if (y>>FRACBITS > -10)
V_DrawStringAtFixed(32<<FRACBITS, y, V_ALLOWLOWERCASE, credits[i]);
y += 12<<FRACBITS;
break;
}
if (((y>>FRACBITS) * vid.dup) > vid.height)
break;
}
@@ -701,7 +694,7 @@ void F_CreditTicker(void)
// Draw credits text on top
for (i = 0; credits[i]; i++)
{
switch(credits[i][0])
switch (credits[i][0])
{
case 0: y += 80<<FRACBITS; break;
case 1: y += 30<<FRACBITS; break;
@@ -963,6 +956,7 @@ void F_StartTitleScreen(void)
finalecount = 0;
else
wipegamestate = GS_TITLESCREEN;
G_SetGamestate(GS_TITLESCREEN);
CON_ClearHUD();
@@ -978,10 +972,10 @@ void F_StartTitleScreen(void)
demoDelayLeft = demoDelayTime;
demoIdleLeft = demoIdleTime;
ttbanner = W_CachePatchName("TTKBANNR", PU_PATCH_LOWPRIORITY);
ttkart = W_CachePatchName("TTKART", PU_PATCH_LOWPRIORITY);
ttcheckers = W_CachePatchName("TTCHECK", PU_PATCH_LOWPRIORITY);
ttkflash = W_CachePatchName("TTKFLASH", PU_PATCH_LOWPRIORITY);
ttbanner = W_CachePatchName("TTKBANNR", PU_PATCH);
ttkart = W_CachePatchName("TTKART", PU_PATCH);
ttcheckers = W_CachePatchName("TTCHECK", PU_PATCH);
ttkflash = W_CachePatchName("TTKFLASH", PU_PATCH);
}
// (no longer) De-Demo'd Title Screen
@@ -1418,6 +1412,7 @@ void F_EndCutScene(void)
}
}
// custom intros
void F_StartCustomCutscene(INT32 cutscenenum, boolean precutscene, boolean resetplayer)
{
if (!cutscenes[cutscenenum])
+8 -5
View File
@@ -98,7 +98,8 @@ static fixed_t paldiv;
* \param lump Lump name to get data from
* \return fademask_t for lump
*/
static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum) {
static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum)
{
static char lumpname[9] = "FADEmmss";
static fademask_t fm = {NULL,0,0,0,0,0};
lumpnum_t lumpnum;
@@ -148,6 +149,7 @@ static fademask_t *F_GetFadeMask(UINT8 masknum, UINT8 scrnnum) {
case 0: // end marker (not bad!, but still need clearing)
goto freemask;
}
if (lsize != fm.size)
fm.mask = Z_Realloc(fm.mask, lsize, PU_STATIC, NULL);
fm.size = lsize;
@@ -257,7 +259,7 @@ static void F_DoWipe(fademask_t *fademask)
// shortcut - memcpy source to work
while (draw_linestogo--)
{
M_Memcpy(w_base+relativepos, s_base+relativepos, draw_rowend-draw_rowstart);
memcpy(w_base+relativepos, s_base+relativepos, draw_rowend-draw_rowstart);
relativepos += vid.width;
}
}
@@ -266,7 +268,7 @@ static void F_DoWipe(fademask_t *fademask)
// shortcut - memcpy target to work
while (draw_linestogo--)
{
M_Memcpy(w_base+relativepos, e_base+relativepos, draw_rowend-draw_rowstart);
memcpy(w_base+relativepos, e_base+relativepos, draw_rowend-draw_rowstart);
relativepos += vid.width;
}
}
@@ -361,6 +363,7 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
{
// get fademask first so we can tell if it exists or not
fmask = F_GetFadeMask(wipetype, wipeframe++);
if (!fmask)
break;
@@ -377,11 +380,10 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
HWR_DoWipe(wipetype, wipeframe-1); // send in the wipe type and wipeframe because we need to cache the graphic
else
#endif
if (rendermode != render_none) //this allows F_RunWipe to be called in dedicated servers
if (rendermode != render_none) // this allows F_RunWipe to be called in dedicated servers
F_DoWipe(fmask);
I_OsPolling();
I_UpdateNoBlit();
if (rendermode != render_none && drawMenu)
{
@@ -401,6 +403,7 @@ void F_RunWipe(UINT8 wipetype, boolean drawMenu)
NetKeepAlive(); // Update the network so we don't cause timeouts
}
WipeInAction = false;
#endif
}
+17 -18
View File
@@ -44,16 +44,16 @@ consvar_t cv_addons_search_case = {"addons_search_case", "No", CV_SAVE, CV_YesNo
static CV_PossibleValue_t addons_search_type_cons_t[] = {{0, "Start"}, {1, "Anywhere"}, {0, NULL}};
consvar_t cv_addons_search_type = {"addons_search_type", "Anywhere", CV_SAVE, addons_search_type_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
char menupath[MAXFILEPATH];
size_t menupathindex[menudepth];
char menupath[MAXFILEPATH] = {};
size_t menupathindex[menudepth] = {};
size_t menudepthleft = menudepth;
char menusearchbuf[MAXSTRINGLENGTH+1];
textinput_t menusearch;
char **dirmenu, **coredirmenu; // core only local for this file
size_t sizedirmenu, sizecoredirmenu; // ditto
size_t dir_on[menudepth];
char **dirmenu = NULL, **coredirmenu = NULL; // core only local for this file
size_t sizedirmenu = 0, sizecoredirmenu = 0; // ditto
size_t dir_on[menudepth] = {};
UINT8 refreshdirmenu = 0;
char *refreshdirname = NULL;
@@ -92,7 +92,6 @@ INT32 pathisdirectory(const char *path)
// skip those folders, they will not have any addons
static const char *exclude_paths[] = {
"logs",
"luafiles",
"replay",
"mdls",
"gifs",
@@ -198,7 +197,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
for (; *path != NULL; path++)
{
if (strcasecmp(*path, dent->d_name) == 0)
if (fasticmp(*path, dent->d_name))
{
skipfolder = true;
break;
@@ -212,7 +211,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
}
}
if (strcasecmp(".git", dent->d_name) // sanity if you're weird like me
if (!fasticmp(".git", dent->d_name) // sanity if you're weird like me
&& (dirhandle[depthleft-1] = opendir(searchpath)) != NULL)
{
// Got read permissions!
@@ -227,7 +226,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
// I am a file!
if (strcasecmp(searchname, dent->d_name))
if (!fasticmp(searchname, dent->d_name))
continue; // Not what we're looking for!
switch (checkfilemd5(searchpath, wantedmd5sum))
@@ -353,7 +352,7 @@ void searchfilemenu(char *tempname)
{
for (i = first; i < sizedirmenu; i++)
{
if (!strcmp(dirmenu[i]+DIR_STRING, tempname))
if (fastcmp(dirmenu[i]+DIR_STRING, tempname))
{
dir_on[menudepthleft] = i;
break;
@@ -400,7 +399,7 @@ void searchfilemenu(char *tempname)
{
if (filemenucmp(coredirmenu[i]+DIR_STRING, localmenusearch))
{
if (tempname && !strcmp(coredirmenu[i]+DIR_STRING, tempname))
if (tempname && fastcmp(coredirmenu[i]+DIR_STRING, tempname))
{
dir_on[menudepthleft] = sizedirmenu;
Z_Free(tempname);
@@ -478,14 +477,14 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
if (replayhut)
{
if (strcasecmp(".lmp", dent->d_name+len-5))
if (!fasticmp(".lmp", dent->d_name+len-5))
continue; // Not a replay
}
else if (!cv_addons_showall.value)
{
UINT8 ext;
for (ext = 0; ext < NUM_EXT_TABLE; ext++)
if (!strcasecmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
if (fasticmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
break; // extension comparison
if (ext == NUM_EXT_TABLE)
@@ -559,7 +558,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
if (replayhut)
{
if (strcasecmp(".lmp", dent->d_name+len-5))
if (!fasticmp(".lmp", dent->d_name+len-5))
continue; // Not a replay
ext = EXT_TXT; // This isn't used anywhere but better safe than sorry for messing with this...
@@ -567,7 +566,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
else
{
for (; ext < NUM_EXT_TABLE; ext++)
if (!strcasecmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
if (fasticmp(exttable[ext]+1, dent->d_name+len-(exttable[ext][0])))
break; // extension comparison
if (ext == NUM_EXT_TABLE && !cv_addons_showall.value)
@@ -587,7 +586,7 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
nameonly(filenamebuf[i]);
}
if (strcmp(dent->d_name, filenamebuf[i]))
if (!fastcmp(dent->d_name, filenamebuf[i]))
continue;
if (cv_addons_md5.value && !checkfilemd5(menupath, wadfiles[i]->md5sum))
@@ -598,11 +597,11 @@ boolean preparefilemenu(boolean samedepth, boolean replayhut)
}
else if (ext == EXT_TXT)
{
if (!strncmp(dent->d_name, "log-", 4) || !strcmp(dent->d_name, "errorlog.txt"))
if (!strncmp(dent->d_name, "log-", 4) || fastcmp(dent->d_name, "errorlog.txt"))
ext |= EXT_LOADED;
}
if (!strcmp(dent->d_name, configfile))
if (fastcmp(dent->d_name, configfile))
ext |= EXT_LOADED;
}
+432 -365
View File
File diff suppressed because it is too large. Load diff
+195 -183
View File
@@ -59,15 +59,15 @@
#include "discord.h"
#endif
gameaction_t gameaction;
gameaction_t gameaction = 0;
gamestate_t gamestate = GS_NULL;
UINT8 ultimatemode = false;
boolean botingame;
UINT8 botskin;
UINT8 botcolor;
boolean botingame = false;
UINT8 botskin = 0;
UINT8 botcolor = 0;
JoyType_t Joystick[MAXSPLITSCREENPLAYERS];
JoyType_t Joystick[MAXSPLITSCREENPLAYERS] = {};
// 1024 bytes is plenty for a savegame
#define SAVEGAMESIZE (1024)
@@ -83,10 +83,10 @@ static void G_DoContinued(void);
static void G_DoWorldDone(void);
static void G_DoStartVote(void);
music_t mapmusic;
music_t mapmusic = {};
INT16 gamemap = 1;
INT16 maptol;
INT16 maptol = 0;
UINT8 globalweather = 0;
INT32 curWeather = PRECIP_NONE;
INT32 cursaveslot = -1; // Auto-save 1p savegame slot
@@ -97,29 +97,29 @@ UINT16 mainwads = 0;
boolean modifiedgame = false; // Set if homebrew PWAD stuff has been added.
boolean majormods = false; // Set if Lua/Gameplay SOC/replacement map has been added.
boolean savemoddata = false;
UINT8 paused;
UINT8 paused = 0;
UINT8 modeattacking = ATTACKING_NONE;
boolean imcontinuing = false;
boolean runemeraldmanager = false;
boolean netgame; // only true if packets are broadcast
boolean multiplayer;
boolean playeringame[MAXPLAYERS];
boolean addedtogame;
player_t players[MAXPLAYERS];
boolean netgame = false; // only true if packets are broadcast
boolean multiplayer = false;
boolean playeringame[MAXPLAYERS] = {};
boolean addedtogame = false;
player_t players[MAXPLAYERS] = {};
INT32 consoleplayer; // player taking events and displaying
INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {0}; // view being displayed
INT32 consoleplayer = 0; // player taking events and displaying
INT32 displayplayers[MAXSPLITSCREENPLAYERS] = {}; // view being displayed
tic_t gametic;
tic_t levelstarttic; // gametic at level start
UINT32 totalrings; // for intermission
INT16 lastmap; // last level you were at (returning from special stages)
tic_t timeinmap; // Ticker for time spent in level (used for levelcard display)
tic_t gametic = 0;
tic_t levelstarttic = 0; // gametic at level start
UINT32 totalrings = 0; // for intermission
INT16 lastmap = 0; // last level you were at (returning from special stages)
tic_t timeinmap = 0; // Ticker for time spent in level (used for levelcard display)
INT16 spstage_start;
INT16 sstage_start;
INT16 sstage_end;
INT16 spstage_start = 0;
INT16 sstage_start = 0;
INT16 sstage_end = 0;
boolean looptitle = true;
boolean useNightsSS = false;
@@ -134,42 +134,42 @@ boolean countdowntimeup = false;
cutscene_t *cutscenes[128];
INT16 nextmapoverride;
boolean skipstats;
INT16 nextmapoverride = 0;
boolean skipstats = false;
// Pointers to each CTF flag
mobj_t *redflag;
mobj_t *blueflag;
mobj_t *redflag = NULL;
mobj_t *blueflag = NULL;
// Pointers to CTF spawn location
mapthing_t *rflagpoint;
mapthing_t *bflagpoint;
mapthing_t *rflagpoint = NULL;
mapthing_t *bflagpoint = NULL;
struct quake quake;
// Map Header Information
mapheader_t* mapheaderinfo[NUMMAPS] = {NULL};
mapheader_t* mapheaderinfo[NUMMAPS] = {};
static boolean exitgame = false;
static boolean retrying = false;
UINT8 stagefailed; // Used for GEMS BONUS? Also to see if you beat the stage.
UINT8 stagefailed = 0; // Used for GEMS BONUS? Also to see if you beat the stage.
UINT16 emeralds;
UINT32 token; // Number of tokens collected in a level
UINT32 tokenlist; // List of tokens collected
INT32 tokenbits; // Used for setting token bits
UINT16 emeralds = 0;
UINT32 token = 0; // Number of tokens collected in a level
UINT32 tokenlist = 0; // List of tokens collected
INT32 tokenbits = 0; // Used for setting token bits
// Old Special Stage
INT32 sstimer; // Time allotted in the special stage
INT32 sstimer = 0; // Time allotted in the special stage
boolean gamedataloaded = false;
// Time attack data for levels
// These are dynamically allocated for space reasons now
recorddata_t *mainrecords[NUMMAPS] = {NULL};
UINT8 mapvisited[NUMMAPS];
recorddata_t *mainrecords[NUMMAPS] = {};
UINT8 mapvisited[NUMMAPS] = {};
UINT32 bluescore, redscore; // CTF and Team Match team scores
UINT32 bluescore = 0, redscore = 0; // CTF and Team Match team scores
// ring count... for PERFECT!
INT32 nummaprings = 0;
@@ -179,12 +179,12 @@ INT32 nummapboxes = 0;
INT32 numgotboxes = 0;
// Elminates unnecessary searching.
boolean CheckForBustableBlocks;
boolean CheckForBouncySector;
boolean CheckForQuicksand;
boolean CheckForMarioBlocks;
boolean CheckForFloatBob;
boolean CheckForReverseGravity;
boolean CheckForBustableBlocks = false;
boolean CheckForBouncySector = false;
boolean CheckForQuicksand = false;
boolean CheckForMarioBlocks = false;
boolean CheckForFloatBob = false;
boolean CheckForReverseGravity = false;
// Powerup durations
UINT16 invulntics = 20*TICRATE;
@@ -215,73 +215,66 @@ INT32 gameovertics = 15*TICRATE;
UINT8 use1upSound = 0;
UINT8 maxXtraLife = 2; // Max extra lives from rings
UINT8 introtoplay;
UINT8 creditscutscene;
UINT8 introtoplay = 0;
UINT8 creditscutscene = 0;
// Emerald locations
mobj_t *hunt1;
mobj_t *hunt2;
mobj_t *hunt3;
mobj_t *hunt1 = NULL;
mobj_t *hunt2 = NULL;
mobj_t *hunt3 = NULL;
tic_t racecountdown, exitcountdown; // for racing
tic_t racecountdown = 0, exitcountdown = 0; // for racing
fixed_t gravity;
fixed_t mapobjectscale;
fixed_t gravity = 0;
fixed_t mapobjectscale = FRACUNIT;
struct maplighting maplighting;
INT16 autobalance; //for CTF team balance
INT16 teamscramble; //for CTF team scramble
INT16 scrambleplayers[MAXPLAYERS]; //for CTF team scramble
INT16 scrambleteams[MAXPLAYERS]; //for CTF team scramble
INT16 scrambletotal; //for CTF team scramble
INT16 scramblecount; //for CTF team scramble
INT16 autobalance = 0; //for CTF team balance
INT16 teamscramble = 0; //for CTF team scramble
INT16 scrambleplayers[MAXPLAYERS] = {}; //for CTF team scramble
INT16 scrambleteams[MAXPLAYERS] = {}; //for CTF team scramble
INT16 scrambletotal = 0; //for CTF team scramble
INT16 scramblecount = 0; //for CTF team scramble
INT32 cheats; //for multiplayer cheat commands
INT32 cheats = 0; //for multiplayer cheat commands
// SRB2Kart
// Cvars that we don't want changed mid-game
UINT8 gamespeed; // Game's current speed (or difficulty, or cc, or etc); 0 for easy, 1 for normal, 2 for hard
UINT8 gamespeed = 0; // Game's current speed (or difficulty, or cc, or etc); 0 for easy, 1 for normal, 2 for hard
boolean encoremode = false; // Encore Mode currently enabled?
boolean prevencoremode;
boolean franticitems; // Frantic items currently enabled?
boolean comeback; // Battle Mode's karma comeback is on/off
boolean prevencoremode = 0;
boolean franticitems = 0; // Frantic items currently enabled?
boolean comeback = 0; // Battle Mode's karma comeback is on/off
// Voting system
INT16 votelevels[4][2]; // Levels that were rolled by the host
SINT8 votes[MAXPLAYERS]; // Each player's vote
SINT8 pickedvote; // What vote the host rolls
INT16 votelevels[4][2] = {}; // Levels that were rolled by the host
SINT8 votes[MAXPLAYERS] = {}; // Each player's vote
SINT8 pickedvote = 0; // What vote the host rolls
// Server-sided, synched variables
SINT8 battlewanted[4]; // WANTED players in battle, worth x2 points
tic_t wantedcalcdelay; // Time before it recalculates WANTED
tic_t indirectitemcooldown; // Cooldown before any more Shrink, SPB, or any other item that works indirectly is awarded
tic_t hyubgone; // Cooldown before hyudoro is allowed to be rerolled
tic_t mapreset; // Map reset delay when enough players have joined an empty game
UINT8 nospectategrief; // How many players need to be in-game to eliminate last; for preventing spectate griefing
boolean thwompsactive; // Thwomps activate on lap 2
SINT8 spbplace; // SPB exists, give the person behind better items
boolean startedInFreePlay; // Map was started in free play
SINT8 battlewanted[4] = {}; // WANTED players in battle, worth x2 points
tic_t wantedcalcdelay = 0; // Time before it recalculates WANTED
tic_t indirectitemcooldown = 0; // Cooldown before any more Shrink, SPB, or any other item that works indirectly is awarded
tic_t hyubgone = 0; // Cooldown before hyudoro is allowed to be rerolled
tic_t mapreset = 0; // Map reset delay when enough players have joined an empty game
UINT8 nospectategrief = 0; // How many players need to be in-game to eliminate last; for preventing spectate griefing
boolean thwompsactive = 0; // Thwomps activate on lap 2
SINT8 spbplace = 0; // SPB exists, give the person behind better items
boolean startedInFreePlay = false; // Map was started in free play
// Client-sided, unsynched variables (NEVER use in anything that needs to be synced with other players)
boolean legitimateexit; // Did this client actually finish the match?
boolean comebackshowninfo; // Have you already seen the "ATTACK OR PROTECT" message?
static INT16 randmapbuffer[NUMMAPS+1]; // Buffer for maps RandMap is allowed to roll
boolean legitimateexit = 0; // Did this client actually finish the match?
boolean comebackshowninfo = 0; // Have you already seen the "ATTACK OR PROTECT" message?
static INT16 randmapbuffer[NUMMAPS+1] = {}; // Buffer for maps RandMap is allowed to roll
tic_t hidetime;
tic_t hidetime = 0;
// Grading
UINT32 timesBeaten;
UINT32 timesBeatenWithEmeralds;
//UINT32 timesBeatenUltimate;
UINT32 timesBeaten = 0;
UINT32 timesBeatenWithEmeralds = 0;
INT16 prevmap, nextmap;
// Analog Control
void SendWeaponPref(void);
void SendWeaponPref2(void);
void SendWeaponPref3(void);
void SendWeaponPref4(void);
INT16 prevmap = 0, nextmap = 0;
// don't mind me putting these here, I was lazy to figure out where else I could put those without blowing up the compiler.
@@ -470,7 +463,7 @@ consvar_t cv_cechotoggle = {"show_cecho", "On", CV_SAVE, cechotoggle_t, NULL, 0,
#endif
#ifdef SEENAMES
player_t *seenplayer; // player we're aiming at right now
player_t *seenplayer = NULL; // player we're aiming at right now
#endif
char player_names[MAXPLAYERS][MAXPLAYERNAME+1] =
@@ -493,7 +486,7 @@ char player_names[MAXPLAYERS][MAXPLAYERNAME+1] =
"Player 16"
}; // SRB2kart - removed Players 17 through 32
INT32 player_name_changes[MAXPLAYERS];
INT32 player_name_changes[MAXPLAYERS] = {};
INT16 rw_maximums[NUM_WEAPONS] =
{
@@ -570,6 +563,7 @@ static void G_SetSaveGameModified(void)
{
if (!unlockables[i].conditionset)
continue;
if (!unlockables[i].unlocked)
{
unlockables[i].unlocked = true;
@@ -595,7 +589,7 @@ void G_SetGameModified(boolean silent, boolean major)
G_SetSaveGameModified();
if (!silent)
CONS_Alert(CONS_NOTICE, M_GetText("Record Attack data will be saved to a seperate save file.\n"));
CONS_Alert(CONS_NOTICE, "Record Attack data will be saved to a seperate save file.\n");
// If in record attack recording, cancel it.
if (modeattacking)
@@ -634,6 +628,7 @@ const char *G_BuildMapName(INT32 map)
map = gamemap-1;
else
map = prevmap;
map = G_RandMap(G_TOLFlag(cv_newgametype.value), map, false, 0, false, NULL)+1;
}
@@ -687,11 +682,12 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
{
INT32 retaxis;
INT32 axisval;
INT32 deadzone;
boolean flp = false;
UINT8 pnum = player-1;
//find what axis to get
// find what axis to get
switch (axissel)
{
case AXISTURN:
@@ -750,45 +746,33 @@ INT32 JoyAxis(axis_input_e axissel, UINT8 player)
{
axisval /= 2;
retaxis = joyxmove[pnum][axisval];
if (retaxis < (-JOYAXISRANGE))
retaxis = -JOYAXISRANGE;
if (retaxis > (+JOYAXISRANGE))
retaxis = +JOYAXISRANGE;
if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
{
const INT32 jdeadzone = ((JOYAXISRANGE-1) * cv_xdeadzone[pnum].value) >> FRACBITS;
if (abs(retaxis) <= jdeadzone)
return 0;
}
if (flp)
retaxis = -retaxis; // flip it around
return retaxis;
deadzone = cv_xdeadzone[pnum].value;
}
else
{
axisval--;
axisval /= 2;
retaxis = joyymove[pnum][axisval];
if (retaxis < (-JOYAXISRANGE))
retaxis = -JOYAXISRANGE;
if (retaxis > (+JOYAXISRANGE))
retaxis = +JOYAXISRANGE;
if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
{
const INT32 jdeadzone = ((JOYAXISRANGE-1) * cv_ydeadzone[pnum].value) >> FRACBITS;
if (abs(retaxis) <= jdeadzone)
return 0;
}
if (flp)
retaxis = -retaxis; // flip it around
return retaxis;
deadzone = cv_ydeadzone[pnum].value;
}
if (retaxis < (-JOYAXISRANGE))
retaxis = -JOYAXISRANGE;
if (retaxis > (+JOYAXISRANGE))
retaxis = +JOYAXISRANGE;
if (!Joystick[pnum].bGamepadStyle && axissel < AXISDEAD)
{
const INT32 jdeadzone = ((JOYAXISRANGE-1) * deadzone) >> FRACBITS;
if (abs(retaxis) <= jdeadzone)
return 0;
}
if (flp)
retaxis = -retaxis; // flip it around
return retaxis;
}
boolean InputDown(INT32 gc, UINT8 p)
@@ -806,9 +790,9 @@ boolean InputDown(INT32 gc, UINT8 p)
}
}
INT32 localaiming[MAXSPLITSCREENPLAYERS];
angle_t localangle[MAXSPLITSCREENPLAYERS];
boolean camspin[MAXSPLITSCREENPLAYERS];
INT32 localaiming[MAXSPLITSCREENPLAYERS] = {};
angle_t localangle[MAXSPLITSCREENPLAYERS] = {};
boolean camspin[MAXSPLITSCREENPLAYERS] = {};
static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
static fixed_t sidemove[2] = {2<<FRACBITS>>16, 4<<FRACBITS>>16};
@@ -1210,7 +1194,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
if (gamestate == GS_LEVEL)
LUA_HookTiccmd(player, cmd, HOOK(PlayerCmd));
//Reset away view if a command is given.
// Reset away view if a command is given.
if (displayplayers[0] != consoleplayer && ssplayer == 1
&& (cmd->forwardmove || cmd->sidemove || cmd->buttons))
{
@@ -1219,12 +1203,12 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
}
}
ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
ticcmd_t *G_CopyTiccmd(ticcmd_t* restrict dest, const ticcmd_t* restrict src, const size_t n)
{
return M_Memcpy(dest, src, n*sizeof(*src));
return memcpy(dest, src, n*sizeof(*src));
}
ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
ticcmd_t *G_MoveTiccmd(ticcmd_t* restrict dest, const ticcmd_t* restrict src, const size_t n)
{
size_t i;
for (i = 0; i < n; i++)
@@ -1261,7 +1245,7 @@ static void G_DoLoadLevel(boolean resetplayer)
if (gamestate == GS_INTERMISSION)
Y_EndIntermission();
if (gamestate == GS_VOTING)
else if (gamestate == GS_VOTING)
Y_EndVote();
G_SetGamestate(GS_LEVEL);
@@ -2298,7 +2282,7 @@ void G_PlayerReborn(INT32 player)
}
/* I'm putting this here because lol */
fade = (cv_birdmusic.value && cv_fading.value && P_IsLocalPlayer(p));
fade = (cv_fading.value && P_IsLocalPlayer(p));
if (fade)
{
@@ -2329,12 +2313,6 @@ void G_PlayerReborn(INT32 player)
if (gametype == GT_COOP)
P_FindEmerald(); // scan for emeralds to hunt for
// Reset Nights score and max link to 0 on death
p->maxlink = 0;
// If NiGHTS, find lowest mare to start with.
p->mare = 0;
}
//
@@ -2353,22 +2331,25 @@ static boolean G_CheckSpot(INT32 playernum, mapthing_t *mthing)
if (!mthing)
return false;
x = mthing->x << FRACBITS;
y = mthing->y << FRACBITS;
if (!players[playernum].mo)
{
// first spawn of level
for (i = 0; i < playernum; i++)
{
if (playeringame[i] && players[i].mo
&& players[i].mo->x == mthing->x << FRACBITS
&& players[i].mo->y == mthing->y << FRACBITS)
&& players[i].mo->x == x
&& players[i].mo->y == y)
{
return false;
}
}
return true;
}
x = mthing->x << FRACBITS;
y = mthing->y << FRACBITS;
if (!K_CheckPlayersRespawnColliding(playernum, x, y))
return false;
@@ -2768,7 +2749,7 @@ INT32 G_GetGametypeByName(const char *gametypestr)
INT32 i;
for (i = 0; i < NUMGAMETYPES; i++)
if (!stricmp(gametypestr, Gametype_Names[i]))
if (fasticmp(gametypestr, Gametype_Names[i]))
return i;
return -1; // unknown gametype
@@ -2870,17 +2851,23 @@ UINT8 G_GetGametypeColor(INT16 gt)
*/
INT16 G_TOLFlag(INT32 pgametype)
{
if (!multiplayer) return TOL_SP;
if (pgametype == GT_COOP) return TOL_RACE; // SRB2kart
if (pgametype == GT_COMPETITION) return TOL_COMPETITION;
if (pgametype == GT_RACE) return TOL_RACE;
if (pgametype == GT_MATCH) return TOL_MATCH;
if (pgametype == GT_TEAMMATCH) return TOL_MATCH;
if (pgametype == GT_TAG) return TOL_TAG;
if (pgametype == GT_HIDEANDSEEK) return TOL_TAG;
if (pgametype == GT_CTF) return TOL_CTF;
if (!multiplayer) return TOL_SP;
switch (pgametype)
{
case GT_COOP: return TOL_RACE; // SRB2kart
case GT_COMPETITION: return TOL_COMPETITION;
case GT_RACE: return TOL_RACE;
case GT_MATCH: return TOL_MATCH;
case GT_TEAMMATCH: return TOL_MATCH;
case GT_TAG: return TOL_TAG;
case GT_HIDEANDSEEK: return TOL_TAG;
case GT_CTF: return TOL_CTF;
default:
CONS_Alert(CONS_ERROR, "Unknown gametype! %d\n", pgametype);
break;
}
CONS_Alert(CONS_ERROR, M_GetText("Unknown gametype! %d\n"), pgametype);
return INT16_MAX;
}
@@ -3032,7 +3019,8 @@ tryagain:
void G_AddMapToBuffer(INT16 map)
{
INT16 bufx, refreshnum = max(0, TOLMaps(G_TOLFlag(gametype))-3);
const INT32 tolmaps = TOLMaps(G_TOLFlag(gametype));
INT16 bufx, refreshnum = max(0, tolmaps-3);
// Add the map to the buffer.
for (bufx = NUMMAPS-1; bufx > 0; bufx--)
@@ -3063,6 +3051,7 @@ static void G_DoCompleted(void)
K_StatRound();
for (i = 0; i < MAXPLAYERS; i++)
{
if (playeringame[i])
{
// SRB2Kart: exitlevel shouldn't get you the points
@@ -3072,8 +3061,10 @@ static void G_DoCompleted(void)
if (P_IsLocalPlayer(&players[i]))
j++;
}
G_PlayerFinishLevel(i); // take away cards and stuff
}
}
// play some generic music if there's no win/cool/lose music going on (for exitlevel commands)
if (G_RaceGametype() && ((multiplayer && demo.playback) || j == splitscreen+1) && (cv_inttime.value > 0))
@@ -3217,10 +3208,14 @@ void G_AfterIntermission(void)
return;
}
else if (demo.recording && (modeattacking || demo.savemode != DSM_NOTSAVING))
G_SaveDemo();
else if (demo.recording)
G_ResetDemoRecording();
if (demo.recording)
{
if (modeattacking || demo.savemode != DSM_NOTSAVING)
G_SaveDemo();
else
G_ResetDemoRecording();
}
if (modeattacking) // End the run.
{
@@ -3229,7 +3224,9 @@ void G_AfterIntermission(void)
}
if (mapheaderinfo[gamemap-1]->cutscenenum) // Start a custom cutscene.
{
F_StartCustomCutscene(mapheaderinfo[gamemap-1]->cutscenenum-1, false, false);
}
else
{
if (nextmap < 1100-1)
@@ -3366,10 +3363,13 @@ static void G_DoContinued(void)
// when something new is added.
void G_EndGame(void)
{
if (demo.recording && (modeattacking || demo.savemode != DSM_NOTSAVING))
G_SaveDemo();
else if (demo.recording)
G_ResetDemoRecording();
if (demo.recording)
{
if (modeattacking || demo.savemode != DSM_NOTSAVING)
G_SaveDemo();
else
G_ResetDemoRecording();
}
// Only do evaluation and credits in coop games.
if (gametype == GT_COOP)
@@ -3379,6 +3379,7 @@ void G_EndGame(void)
F_StartCredits();
return;
}
if (nextmap == 1101-1) // end game with evaluation
{
F_StartGameEvaluation();
@@ -3432,7 +3433,7 @@ void G_LoadGameData(void)
INT32 i, j;
UINT8 modded = false;
UINT8 rtemp;
savebuffer_t save;
savebuffer_t save = {0};
//For records
tic_t rectime;
@@ -3463,7 +3464,8 @@ void G_LoadGameData(void)
if (READUINT32(save.p) != 0xFCAFE211)
{
const char *gdfolder = "the SRB2Kart folder";
if (strcmp(srb2home,"."))
if (!fastcmp(srb2home,"."))
gdfolder = srb2home;
Z_Free(save.buffer);
@@ -3477,9 +3479,8 @@ void G_LoadGameData(void)
modded = READUINT8(save.p);
// Aha! Someone's been screwing with the save file!
if ((modded && !savemoddata))
goto datacorrupt;
else if (modded != true && modded != false)
if ((modded && !savemoddata) ||
(modded != true && modded != false))
goto datacorrupt;
// TODO put another cipher on these things? meh, I don't care...
@@ -3544,10 +3545,11 @@ void G_LoadGameData(void)
return;
// Landing point for corrupt gamedata
datacorrupt:
datacorrupt:
{
const char *gdfolder = "the SRB2Kart folder";
if (strcmp(srb2home,"."))
if (!fastcmp(srb2home,"."))
gdfolder = srb2home;
Z_Free(save.buffer);
@@ -3564,7 +3566,7 @@ void G_SaveGameData(boolean force)
size_t length;
INT32 i, j;
UINT8 btemp;
savebuffer_t save;
savebuffer_t save = {0};
(void)force;
char backupfile[MAX_WADPATH+4];
@@ -3735,7 +3737,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
size_t length;
char vcheck[VERSIONSIZE];
char savename[255];
savebuffer_t save;
savebuffer_t save = {0};
// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
memset(&savedata, 0, sizeof(savedata));
@@ -3758,7 +3760,8 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
memset(vcheck, 0, sizeof (vcheck));
sprintf(vcheck, "version %d", VERSION);
if (strcmp((const char *)save.p, (const char *)vcheck))
if (!fastcmp((const char *)save.p, (const char *)vcheck))
{
#ifdef SAVEGAME_OTHERVERSIONS
M_StartMessage(M_GetText("Save game from different version.\nYou can load this savegame, but\nsaving afterwards will be disabled.\n\nDo you want to continue anyway?\n\n(Press 'Y' to confirm)\n"),
@@ -3820,7 +3823,7 @@ void G_SaveGame(UINT32 savegameslot)
boolean saved;
char savename[256] = "";
const char *backup;
savebuffer_t save;
savebuffer_t save = {0};
sprintf(savename, savegamename, savegameslot);
backup = va("%s",savename);
@@ -4004,6 +4007,12 @@ void G_InitNew(UINT8 pencoremode, const char *mapname, boolean resetplayer, bool
automapactive = false;
imcontinuing = false;
// HACK: this doesent reset if you change the map from within a replay and may cause crashes or the replayhut to be non functional
if (!demo.playback && demo.inreplayhut)
{
M_ResetDemoList();
}
if (!skipprecutscene && mapheaderinfo[gamemap-1]->precutscenenum && !modeattacking) // Start a custom cutscene.
F_StartCustomCutscene(mapheaderinfo[gamemap-1]->precutscenenum-1, true, resetplayer);
else
@@ -4036,7 +4045,7 @@ char *G_BuildMapTitle(INT32 mapnum)
if (!mapheaderinfo[mapnum-1])
P_AllocMapHeader(mapnum-1);
if (strcmp(mapheaderinfo[mapnum-1]->lvlttl, ""))
if (!fastcmp(mapheaderinfo[mapnum-1]->lvlttl, ""))
{
size_t len = 1;
const char *zonetext = NULL;
@@ -4263,18 +4272,21 @@ INT32 G_FindMapByNameOrCode(const char *mapname, char **realmapnamep)
{
if (mapname[0] == '*') // current map
return gamemap;
else if (mapname[0] == '?' && mapheaderinfo[gamemap-1])
if (mapname[0] == '?' && mapheaderinfo[gamemap-1])
return G_RandMap(G_TOLFlag(gametype), gamemap-1, false, 0, false, NULL)+1;
else if (mapname[0] == '+' && mapheaderinfo[gamemap-1]) // next map
if (mapname[0] == '+' && mapheaderinfo[gamemap-1]) // next map
{
newmapnum = mapheaderinfo[gamemap-1]->nextlevel;
if (newmapnum < 1 || newmapnum > NUMMAPS)
{
CONS_Alert(CONS_ERROR, M_GetText("NextLevel (%d) is not a valid map.\n"), newmapnum);
CONS_Alert(CONS_ERROR, "NextLevel (%d) is not a valid map.\n", newmapnum);
return 0;
}
else
return newmapnum;
return newmapnum;
}
}
else if (mapnamelen == 2)/* maybe two digit code */
+1 -1
View File
@@ -160,7 +160,7 @@ typedef enum
const char *G_BuildMapName(INT32 map);
void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
// copy ticcmd_t to and fro the normal way
// copy ticcmd_t to and from the normal way
ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n);
// copy ticcmd_t to and fro network packets
ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n);
+190 -17
View File
@@ -58,12 +58,21 @@ static void led_off_handle3(void);
static void led_off_handle4(void);
consvar_t cv_rumble[MAXSPLITSCREENPLAYERS] = {
{"rumble", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle, 0, NULL, NULL, 0, 0, NULL},
{"rumble", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle, 0, NULL, NULL, 0, 0, NULL},
{"rumble2", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle2, 0, NULL, NULL, 0, 0, NULL},
{"rumble3", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle3, 0, NULL, NULL, 0, 0, NULL},
{"rumble4", "Off", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, rumble_off_handle4, 0, NULL, NULL, 0, 0, NULL}
};
static CV_PossibleValue_t rumblestrength_cons_t[] = {{FRACUNIT/4, "MIN"}, {FRACUNIT*4, "MAX"}, {0, NULL}};
consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS] = {
{"rumblestrength", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"rumblestrength2", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"rumblestrength3", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"rumblestrength4", "1.0", CV_SAVE|CV_FLOAT, rumblestrength_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
};
static CV_PossibleValue_t gamepadled_cons_t[] = {{0, "Off"}, {1, "Skincolor"}, {2, "Mobjcolor"}, {0, NULL}};
consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS] = {
{"gamepadled", "Skincolor", CV_SAVE|CV_CALL|CV_NOINIT, gamepadled_cons_t, led_off_handle, 0, NULL, NULL, 0, 0, NULL},
@@ -262,9 +271,6 @@ void G_ResetControls(void)
memset(joyxmove, 0, sizeof(joyxmove));
memset(joyymove, 0, sizeof(joyymove));
// reset those just in case the game missed the keyup event
memset(dpadscrollstate, false, sizeof(dpadscrollstate));
}
//
@@ -878,11 +884,13 @@ static const char *gamecontrolname[num_gamecontrols] =
#include "k_kart.h"
UINT16 G_GetSkinColor(INT32 playernum)
UINT8 G_GetSkinColorForGamepad(INT32 playernum)
{
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (gamestate == GS_LEVEL)
{
player_t *player = &players[displayplayers[playernum]];
const player_t *player = &players[displayplayers[playernum]];
if (player)
{
@@ -900,13 +908,13 @@ UINT16 G_GetSkinColor(INT32 playernum)
switch (playernum)
{
case 0:
return cv_playercolor.value;
return (UINT8)cv_playercolor.value;
case 1:
return cv_playercolor2.value;
return (UINT8)cv_playercolor2.value;
case 2:
return cv_playercolor3.value;
return (UINT8)cv_playercolor3.value;
case 3:
return cv_playercolor4.value;
return (UINT8)cv_playercolor4.value;
default:
return 0;
}
@@ -914,19 +922,23 @@ UINT16 G_GetSkinColor(INT32 playernum)
return 0;
}
void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color)
// Sets the Indicator LED on supported gamepads to a desired skincolor
// pass SKINCOLOR_NONE/0 to set the players skin color
void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color)
{
UINT16 skincolor;
UINT8 skincolor;
byteColor_t byte_color;
I_Assert(playernum >= 0 && playernum < MAXSPLITSCREENPLAYERS);
if (cv_gamepadled[playernum].value == 0)
if (cv_gamepadled[playernum].value == 0
|| color >= MAXTRANSLATIONS)
{
return;
}
skincolor = color ? color : G_GetSkinColor(playernum);
// so we can override this
skincolor = color ? color : G_GetSkinColorForGamepad(playernum);
byte_color = V_GetColor(colortranslations[skincolor][8]).s;
I_SetGamepadIndicatorColor(playernum, byte_color.red, byte_color.green, byte_color.blue);
@@ -939,7 +951,41 @@ static void G_ResetPlayerGamepadIndicatorColor(INT32 playernum)
I_SetGamepadIndicatorColor(playernum, 0, 0, 255);
}
else
{
G_SetPlayerGamepadIndicatorColor(playernum, 0);
}
}
static UINT8 curcolor[MAXSPLITSCREENPLAYERS] = {};
void G_DeviceLEDTick(void)
{
UINT8 i, newcolor;
if (numcontrollers == 0)
{
return;
}
for (i = 0; i <= splitscreen; i++)
{
if (!cv_usejoystick[i].value || !cv_gamepadled[i].value)
continue;
newcolor = G_GetSkinColorForGamepad(i);
if (curcolor[i] == newcolor) // dont update if same colour
continue;
G_SetPlayerGamepadIndicatorColor(i, newcolor);
curcolor[i] = newcolor;
}
}
// ensures next call to G_DeviceLEDTick will refresh the gamepad led
void G_ResetDeviceLED(void)
{
memset(curcolor, 0, sizeof(curcolor));
}
static void G_ResetPlayerDeviceRumble(INT32 playernum)
@@ -966,9 +1012,135 @@ void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_stre
return;
}
// doesent need to be super precise
// but ensure this is within range (0-65535)
// placed here so it applies to lua aswell
low_strength = (UINT16)min(FixedMul(low_strength, cv_rumblestrength[playernum].value), UINT16_MAX);
high_strength = (UINT16)min(FixedMul(high_strength, cv_rumblestrength[playernum].value), UINT16_MAX);
I_GamepadRumble(playernum, low_strength, high_strength, duration);
}
// rumble strengths
enum
{
RUMBLE_VERYSTRONG = FRACUNIT / 4, // 16384
RUMBLE_STRONG = FRACUNIT / 8, // 8192
RUMBLE_MODERATE = FRACUNIT / 64, // 1024
RUMBLE_WEAK = FRACUNIT / 128, // 512
RUMBLE_VERYWEAK = FRACUNIT / 256, // 256
};
// Controller rumble!
// this keeps track of a bunch of things
// and makes your controller rumble accordingly
void G_DeviceRumbleTick(void)
{
UINT8 i;
if (dedicated || numcontrollers == 0 || gamestate != GS_LEVEL)
{
return;
}
for (i = 0; i <= splitscreen; i++)
{
if (!cv_usejoystick[i].value || !cv_rumble[i].value)
{
continue;
}
if (camera[i].freecam)
{
continue;
}
// SDL rumble strength goes from a range or 0-65535 respectively
// the higher, the stronger it is
UINT16 low = 0, high = 0;
// for how long the action should rumble, in ms
UINT16 lenght = 57; // 57ms is a short pulse, matches super well with this updating once per tic
const player_t *player = P_GetLocalPlayerForNum(i);
// allow lua to do some crap for spectators
if (player->spectator || !player->mo)
{
continue;
}
// reset the rumble if you exit or are ded lel
if (player->exiting ||
player->playerstate == PST_DEAD ||
player->kartstuff[k_respawn] > 1)
{
G_PlayerDeviceRumble(i, low, high, 0);
continue;
}
if (player->kartstuff[k_spinouttimer])
{
//low = high = FRACUNIT / 6;
low = high = FixedMul((RUMBLE_VERYSTRONG), (FixedDiv(player->kartstuff[k_spinouttimer], (3*TICRATE / 2)))); // try do some some kinda fadeout, 3*TICRATE / 2 is the "default" spinout time
}
else if (player->kartstuff[k_sneakertimer] > (sneakertime-(TICRATE/2)))
{
low = high = RUMBLE_STRONG;
}
else if ((player->kartstuff[k_offroad])
&& player->speed != 0
&& P_IsObjectOnGround(player->mo))
{
// weaken this depending on if you got hyu or invinc
if (player->kartstuff[k_hyudorotimer])
{
high = RUMBLE_WEAK;
}
else if (player->kartstuff[k_invincibilitytimer])
{
high = RUMBLE_MODERATE;
}
else
{
low = high = RUMBLE_MODERATE;
}
}
else if ((player->kartstuff[k_bananadrag] > TICRATE)
&& player->speed != 0
&& P_IsObjectOnGround(player->mo))
{
if (leveltime & 1) // this is actually funny lel
high = RUMBLE_MODERATE;
}
if (player->kartstuff[k_brakedrift])
{
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
}
// pulse when gettin new driftlevel
// let this come last
if (player->kartstuff[k_driftcharge]
&& player->driftlevel)
{
high = CLAMP((high + RUMBLE_VERYWEAK), 0, UINT16_MAX);
if (player->driftlevel == 2)
lenght = 114;
else if (player->driftlevel == 3)
lenght = 174;
}
// hack alert! i just dont want this thing constantly resetting the rumble lol
if (low == 0 && high == 0)
{
continue;
}
G_PlayerDeviceRumble(i, low, high, lenght);
}
}
//
// Detach any keys associated to the given game control
// - pass the pointer to the gamecontrol table for the player being edited
@@ -1033,7 +1205,7 @@ INT32 G_KeyStringtoNum(const char *keystr)
return atoi(&keystr[3]);
for (j = 0; j < NUMKEYNAMES; j++)
if (!stricmp(keynames[j].name, keystr))
if (fasticmp(keynames[j].name, keystr))
return keynames[j].keynum;
return 0;
@@ -1333,14 +1505,15 @@ static void setcontrol(INT32 (*gc)[2])
player = 0;
namectrl = COM_Argv(1);
for (numctrl = 0; numctrl < num_gamecontrols && stricmp(namectrl, gamecontrolname[numctrl]);
numctrl++)
for (numctrl = 0; numctrl < num_gamecontrols && !fasticmp(namectrl, gamecontrolname[numctrl]); numctrl++)
;
if (numctrl == num_gamecontrols)
{
CONS_Printf(M_GetText("Control '%s' unknown\n"), namectrl);
return;
}
keynum1 = G_KeyStringtoNum(COM_Argv(2));
keynum2 = G_KeyStringtoNum(COM_Argv(3));
keynum = G_FilterKeyByVersion(numctrl, 0, player, &keynum1, &keynum2, &nestedoverride);
+10 -5
View File
@@ -37,7 +37,7 @@ typedef enum
KEY_JOY1 = KEY_MOUSE1 + MOUSEBUTTONS,
KEY_HAT1 = KEY_JOY1 + JOYBUTTONS,
KEY_DBLMOUSE1 =KEY_HAT1 + JOYHATS*4, // double clicks
KEY_DBLMOUSE1 = KEY_HAT1 + JOYHATS*4, // double clicks
KEY_DBLJOY1 = KEY_DBLMOUSE1 + MOUSEBUTTONS,
KEY_DBLHAT1 = KEY_DBLJOY1 + JOYBUTTONS,
@@ -113,6 +113,7 @@ extern consvar_t cv_mousesens, cv_mouseysens;
extern consvar_t cv_controlperkey;
extern consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumblestrength[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
extern INT32 mousex, mousey;
@@ -131,13 +132,17 @@ extern INT32 gamecontrol[MAXSPLITSCREENPLAYERS][num_gamecontrols][2];
#define PLAYER3INPUTDOWN(gc) (gamekeydown[gamecontrol[2][gc][0]] || gamekeydown[gamecontrol[2][gc][1]])
#define PLAYER4INPUTDOWN(gc) (gamekeydown[gamecontrol[3][gc][0]] || gamekeydown[gamecontrol[3][gc][1]])
// peace to my little coder fingers!
// check a gamecontrol being active or not
UINT8 G_GetSkinColorForGamepad(INT32 playernum);
void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT8 color);
void G_DeviceLEDTick(void);
void G_ResetDeviceLED(void);
UINT16 G_GetSkinColor(INT32 playernum);
void G_SetPlayerGamepadIndicatorColor(INT32 playernum, UINT16 color);
void G_ResetAllDeviceRumbles(void);
void G_PlayerDeviceRumble(INT32 playernum, UINT16 low_strength, UINT16 high_strength, UINT32 duration);
void G_DeviceRumbleTick(void);
// peace to my little coder fingers!
// check a gamecontrol being active or not
// remaps the input event to a game control.
void G_MapEventsToControls(event_t *ev);
Loaded 100 of 217 files, more files were not shown because too many files have changed in this diff. Show more