Compare commits

..
Author SHA1 Message Date
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 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 87e0b55f01 fix windowmoved never resetting 2025-11-09 19:13:49 +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 88363cf45d add NOHOLEPUNCH flag to disable holepunch entirely 2025-10-27 22:58:42 +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
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
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 c07502bf5a use strl instead of strn stuff to copy cecho text
ALOT safer than whatever this did before
2025-10-23 20:51:24 +02:00
Alug f751161693 fix CECHO text being overwritten with nothing
strlcat not strlcpy
2025-10-23 20:37:57 +02:00
toaster ed16c4fd9f Simplify intermission timer code
- We had two ways of ending the intermission, but only one would actually be used, and it resulted in code duplication.
- Combine the two ways.
- Disable the reached-but-didn't-do-anything-before-now code path for setting endtic.
2025-10-22 23:08:43 +02:00
Alug 41407538d4 cleanup + optimizations mixer_sound
thx indev for the better ms rounding code <3
2025-10-22 22:53:14 +02:00
Alug 5f394cd938 handle more memory allocation failure cases
reported with -Wformat-overflow
2025-10-22 16:02:35 +02:00
Alug e5bae89d0f fix namescrollbuf and mapmusic.name copies
ensure those are properly null terminated
as reported by ubsan
2025-10-22 15:34:43 +02:00
Alug f749800276 fix playersetup skin speen reading out of bounds
reported by ubsan
2025-10-22 15:34:40 +02:00
Alug 5289027272 uninline ctf resynch stuff
this wont ever be used and just makes lto and others complain occasionally (maybe frenmod uses ctf? forgor)
2025-10-22 15:34:38 +02:00
Alug 77f4d4ef3b fix replays occasionally crashing when stopping
due to R_ReInitColormaps our extra_colormaps pointer may be freed
so ensure it only gets called after gamestate has been set to GS_NULL so we dont risk doing this mid renderframe
fixes crashes in software and palette render mode
2025-10-22 13:48:56 +02:00
AJ Martinez a94740f5e9 Fix unsteady camera movement in demos 2025-10-22 13:44:32 +02:00
toaster ab27090ecf Don't send a netxcmd when using addfile outside of netgame
Was supposed to be happening already, but `multiplayer` is a useless variable...
2025-10-22 11:32:49 +02:00
Alug 93d0106c28 remove erronous ";" 2025-10-22 11:32:46 +02:00
Alug 27433f6fb5 call R_SetupFreelook in R_ExecuteSetViewSize
to instantly update our now stale yslope pointer!
fixes random crashes when switching numbers of splitviews in replays
2025-10-21 19:26:31 +02:00
Alug f8e5049d76 fix R_MakeSpans accessing "spanstart" out of bounds when in splitscreen
it gets allocated for viewheight not vid.height!
2025-10-21 19:26:27 +02:00
Alug 2009cdeaeb init few more things 2025-10-21 18:36:05 +02:00
Alug 0f43f19b71 remove unused maskdraw_t struct 2025-10-21 18:01:03 +02:00
Alug 1ac7852bd2 initialize a bunch of stuff that gets passed to realloc 2025-10-21 17:52:21 +02:00
indev f5e7b65ae0 Fix replay names not displaying if you have more than INT16_MAX replays 2025-10-21 17:11:45 +03:00
Alug 4c5d34e82c Revert "Fix ghost hitlist causing zone errors (closes #118)"
This reverts commit ab13b28106.
2025-10-21 16:09:02 +02:00
Alug 0dad927c05 fix 4th player background not drawin in gl in 3 player splitscreen 2025-10-21 15:42:33 +02:00
Alug f231417465 fix splitscreen view in gl 2025-10-21 15:27:05 +02:00
Alug 51b8dc9101 m_menu: add textinput special case for playername string
itself it already checks to not write out of bounds, this is mostly just to fix visual issues
kind hacky, but works for now
2025-10-21 14:45:10 +02:00
Alug 71e9c4f5af use "viewssnum" for shadowdir stuff 2025-10-21 14:34:33 +02:00
Alug 1acae3e4af use malloc for spawnstate mapdata copies
they might be somewhat large and get completely overwritten eitherway so save us the 0 init
2025-10-21 14:34:30 +02:00
Alug 4c04d09d18 rename 2025-10-21 14:34:28 +02:00
indev b99cd88947 Fix possible buffer overflow in M_TextInputSetString when string length is greatter than buffer length 2025-10-21 01:46:39 +03:00
Alug 4a786449c4 fix NIGHTS hoop hoopcenter
fixes visual issues when going through them
2025-10-20 19:48:28 +02:00
Alug aef6dcdbc9 handle ceepeepee 2025-10-20 19:25:41 +02:00
Alug 0e9ec096c2 slightly clean up makefile
- pass "-g" on mingw builds generally after everything (needs testing)
-use "libs" instead of "LDFLAGS" (identical purpose)
- pass "mno-ms-bitfields" on gcc, shouldnt be really needed but just in case
2025-10-20 17:02:36 +01:00
Alug 50ce3c4431 R_FlushQuad: dont use 64bit/8byte copy on 32bit targets
on 32bit targets this will just compile into two 32bit copies which gcc cant optimize as well as it can with the byte copy (it seems to love to do some AVX stuff atleast in my tests)
so this is only useful for 64bit capable platforms (compiler does not seem to do 64bit copys for the byte copy case, so this ends up being faster)
2025-10-20 16:32:48 +02:00
Alug c6c1dbd066 R_FlushQuad: also check "source" for alignment 2025-10-20 16:17:01 +02:00
Alug ece8d9e80c R_FlushQuad: fix column flush on odd width resolutions 2025-10-20 00:56:30 +02:00
Alug fdcbd276e9 remove unessecaary template branch in R_DrawColumnPixel 2025-10-19 23:07:21 +02:00
Alug 6d77672ee3 no need to pass anything to R_InitViewBuffer 2025-10-19 22:19:20 +02:00
Alug 28aec6cad5 add USEUBSAN compiler flag
to compile with ubsan duh
2025-10-19 21:59:39 +02:00
Alug 1f028f523e R_FlushQuad: fix unaligned memory access 2025-10-19 21:59:35 +02:00
Alug 349bf06e4b macrofy column function definitions 2025-10-19 21:59:32 +02:00
Alug e044db73f5 those should be initialised to something 2025-10-19 21:59:29 +02:00
Alug 7555d689db clear our column buffer after allocation 2025-10-19 21:59:27 +02:00
Alug a6438da531 use spawn sector and line tags for P_ReloadSaveLevelData
should speed up resynch a little, now that we properly save them
2025-10-18 23:11:00 +02:00
Alug 8c6893cff6 init taglists in P_LoadMapData
no reason to init them in P_SpawnSpecials
fixes join crashes on some maps
2025-10-18 23:04:25 +02:00
Alug af03b51191 add guard to vid.screens free
not super necessary but better safe than sorry
2025-10-18 21:34:23 +02:00
Alug 178d8b7b53 fix demo_slug compiler warning
Zzz....
2025-10-18 16:15:19 +02:00
NepDisk de99a3036d Update Discord RPC
Based on some of the changes from RR.
Accounts for the fact discord does not have tags anymore and makes skin code easier to manage
2025-10-18 16:15:17 +02:00
NepDisk 5c613f6c8f Use a constant for file path stuff 2025-10-18 16:15:14 +02:00
James R 59628377fa Resize menudemo_t filepath to fix -Wformat-truncation 2025-10-18 16:15:11 +02:00
Alug 278f3c3ef6 turnsmoothing splitscreen player support
i hate our menus Zzz....
2025-10-17 09:24:33 +02:00
Alug 3ba1596976 change wheel input "sensitivity"
200 maps perfectly to our turn values
so the wheel now actually better reflects the inputs and does not turn fully super early uhh
2025-10-16 23:15:42 +02:00
Alug 02f6fa0665 HACK: call texture precache when toggling a setting that flushes opengl textures
workaround for batching sort issues
should be good eitherway to reduce stutters after toggling them
2025-10-16 22:21:37 +02:00
Alug f4aec1d591 port "Lite Steer" from RR
took me a while to realize RR makes everything go though "analogue" input handlers
2025-10-16 21:53:40 +02:00
Alug 5c2a87dea6 fix off by one when playing with controller sticks
also simplify driftturn handling
2025-10-16 21:53:37 +02:00
Alug d5aa9ae0f1 fix 32bit windoze compile
again......
2025-10-16 15:07:35 +01:00
indev 6096822cbb Use str.resize(size) instead of str = str.substr(0, size) (ty lug <3) 2025-10-16 15:16:23 +03:00
Alug 0030367649 fix UB in R_PointOnSide
by not shifting a 32bit int by 31 bits
this is more in line with the original function eitherways
2025-10-16 14:08:30 +02:00
Alug 66f67c91e8 G_SaveDemo: fix oob reads/writes for replay names
demo.titlename has a size of 65! not 128!
also handles memory failure and checks bounds for the remaining lenght in the demo slug
2025-10-16 14:01:02 +02:00
Alug c73c1af2d5 let replays with empty name save
this does not crash for us
2025-10-16 14:00:57 +02:00
toaster 638e95325a G_SaveDemo: Resolve memory errors that could result in crashes
- Empty `demo.titlename` case
    - Don't try to save demo of name `.lmp`
    - Doesn't fall back to anything, because emptying out the name field can be reasonably treated as not wanting to save
- `demo.titlename` consists only of invalid characters
    - Don't try to save demo of name `-.lmp`
    - Falls back to the default demo title, because the user clearly wanted to save and just happened to provide invalid text
2025-10-16 14:00:55 +02:00
Alug 66ce745e91 add allocation failure case in R_DrawMasked 2025-10-16 14:00:51 +02:00
Alug 2b39d137b4 guard against null string in stringwidth functions
hud drawlists may actually pass null to them
2025-10-16 14:00:48 +02:00
Alug 1ed616dcef pass rover directly to check_fof_offscreen 2025-10-16 14:00:45 +02:00
indev 24ef2819b0 Merge pull request #205 from Indev450/dsdacol
Software Renderer: Implement Column buffering system
2025-10-15 21:52:45 +03:00
Alug a9732e9564 Merge branch 'Saturn-Next' into dsdacol 2025-10-15 20:51:47 +02:00
Alug c262d3f532 prevent potential 0 division in CV_AddValue
as repoted by clang-tidy
2025-10-15 20:41:57 +02:00
Alug ae456fee31 force inline savegame archive stuff 2025-10-15 17:05:05 +02:00
LJ Sonic 68f69049d4 Fix incorrect error message during Lua archiving 2025-10-15 17:05:02 +02:00
LJ Sonic e180918e48 Do not archive nil table keys 2025-10-15 17:04:59 +02:00
Alam Ed Arias 951c090b35 set CURLOPT_MAXREDIRS to 30 2025-10-15 17:04:55 +02:00
Gustaf Alhäll a87e07155a Remove WINSOCK1 support
WINSOCK2 has been supported since Windows XP and is required for IPv6,
so I don't see a reason to support it anymore.
2025-10-15 17:04:52 +02:00
Alug da16ce3a23 mark flush error functions with noreturn
silences clang
2025-10-15 06:28:54 +02:00
Alug 64bdae5e5d delet dead code ogl models 2025-10-15 06:16:46 +02:00
Alug 4f91a0b234 remove dead renderer code
remove
- broken viewborder code (if we really want it back for some reason, we should rather port RR´s fixed version of it)
- remove console clipping code for software (this was broken eiherway)
- remove hud message clearing stuff
- remove renderscreen and linesize variables (they just pointed to vid.screen and vid.widht)
2025-10-15 06:16:46 +02:00
Alug bb0a59540f use stdlibs abs for CompareDrawNodePlanes
we dont need our own abs for this
2025-10-15 06:16:46 +02:00
Alug dd9d6de0d6 delet gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy gl_basewindowcenterx, gl_basewindowcentery
they were effectively unused
2025-10-15 06:16:46 +02:00
Alug 3de4c7cbad Merge branch 'Saturn-Next' into dsdacol 2025-10-14 23:14:24 +02:00
Alug 0eeacaf51e remove dead renderer code
remove
- broken viewborder code (if we really want it back for some reason, we should rather port RR´s fixed version of it)
- remove console clipping code for software (this was broken eiherway)
- remove hud message clearing stuff
- remove renderscreen and linesize variables (they just pointed to vid.screen and vid.widht)
2025-10-14 23:14:07 +02:00
Alug a4684b3004 use stdlibs abs for CompareDrawNodePlanes
we dont need our own abs for this
2025-10-14 23:13:52 +02:00
Alug 9c014eb2ea delet gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy gl_basewindowcenterx, gl_basewindowcentery
they were effectively unused
the last two werent ever even initialized to anything, using HWR_DrawViewBorder wouldve crashed
2025-10-14 23:13:49 +02:00
Alug 37579187cc remove dead renderer code
remove
- broken viewborder code (if we really want it back for some reason, we should rather port RR´s fixed version of it)
- remove console clipping code for software (this was broken eiherway)
- remove hud message clearing stuff
- remove renderscreen and linesize variables (they just pointed to vid.screen and vid.widht)
2025-10-14 23:13:39 +02:00
Alug af8ce028ba use stdlibs abs for CompareDrawNodePlanes
we dont need our own abs for this
2025-10-14 23:12:50 +02:00
Alug 9310a68cff delet gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy gl_basewindowcenterx, gl_basewindowcentery
they were effectively unused
the last two werent ever even initialized to anything, using HWR_DrawViewBorder wouldve crashed
2025-10-14 23:12:47 +02:00
Hanicef 89b8121282 Fix vertical aim being off when using lack of perspective 2025-10-14 22:28:18 +02:00
Alug b2260bbebb move R_SetColumnContext call
we set this later to flush eitherway for non skybox draw
2025-10-13 21:27:43 +02:00
Alug 6a9aea4dd1 use std::vector for our image buffers
this is just to have it cleaner and less code bloat
the resizing loop will almost never trigger, 1meg is enough to even rotate gigantamax eevee without needing to grow
2025-10-13 19:20:40 +02:00
Eidolon 6f4dfb35fa Calculate staging buffer maximum size in Picture_Convert 2025-10-13 19:20:37 +02:00
Alug 459b2e62ce oops missed this case 2025-10-12 23:12:26 +02:00
Alug 5765f3df5a this does not need marked as restrict 2025-10-12 22:30:25 +02:00
Alug 8488da4b1a smol style adjustment span stuff 2025-10-12 22:11:39 +02:00
Alug c82495f48b tiny optimization span drawers
if we dont "ripple" our spans, we dont need to increment an additional pointer for them
2025-10-12 22:11:36 +02:00
Alug f55b8793ec Merge branch 'Saturn-Next' into dsdacol 2025-10-12 22:11:23 +02:00
Alug b0b048c703 move "newview sky" check before skyplane loop
saves us some pointless work going through all planes if we dont need to draw the sky
2025-10-10 23:37:20 +02:00
Alug b7f1a0b631 speed up masked sprites a bit
thx eternity engine!
2025-10-10 22:33:04 +02:00
Alug 513613d83b dont update hud during skipped frames
this was to fix issues with some lua huds looking really bad during frameskip
but this causes issues with the hud flashing during gif recording
2025-10-09 19:13:09 +02:00
Alug f2afc5135c fix buffer overflows in dedi build too 2025-10-09 18:17:09 +02:00
K J 3783e30a8a fix: multiple additional buffer overruns
found by Zwip-Zwap_Zapony
2025-10-09 18:11:59 +02:00
Alug ff80a34627 unnest fsp counter and ping display stuff 2025-10-09 18:01:27 +02:00
Alug 38c96d5ec2 Merge branch 'Saturn-Next' into dsdacol 2025-10-08 21:38:26 +02:00
Alug 2ec467f062 check with "__SIZEOF_POINTER__" 2025-10-08 21:38:20 +02:00
Alug b3106d55d1 inline R_ThingLightLevel
just points to thing->lightlevel field eitherway
2025-10-08 21:38:17 +02:00
Alug 90c3d02dbf ensure columnbuffer gets flushed during portal traversal
in worst case this does nothing btw
2025-10-08 20:46:37 +02:00
Alug 48dc5461cd cleanup column flusher stuff
- properly make use of templates!, reduce code dupe
- inline the "DrawPixel" stuff
- use local "const" pointers everywhere
2025-10-08 16:50:17 +02:00
Alug 0843a586f8 fuckit, lets buffer 8 columns instead of 4
improves performance across the board on my ryzen 5600 cpu
between 10 -15fps + in best case and around 5fps+ in worst case
will need to check how this affects older cpus and 32bit builds since we do 64bit copies now
(if needed can always add 32bit specific code)
effectively, we also reduce the amount of flushing needed in many cases, writing more things at once during flushes
2025-10-08 16:47:54 +02:00
Alug 8c8f96cf49 force flush our column buffer directly after bsp traversal (again)
TODO: actually check what portals do
2025-10-08 16:47:54 +02:00
Alug 55afe9be7e update copyright header for draw flush stuff 2025-10-08 16:47:54 +02:00
Alug fe54f2fba2 add Column drawer context switching
reasoning explained in screen.c
effectively, there are cases where drawing our columns directly to the screen is the better choice
2025-10-08 16:47:54 +02:00
Alug b12989f51c lessen our manual column buffer resetting
not really needed
2025-10-08 16:47:54 +02:00
Alug 57990100c5 speed up masked sprites a bit
thx eternity engine!
2025-10-08 16:47:54 +02:00
Alug 32504b9e8e speed up Opague quad flush
from eternity engine
2025-10-08 16:47:54 +02:00
Alug ba3404d823 cleanup + type fixes 2025-10-08 16:47:54 +02:00
Alug c9f50ca0c8 sizeof(UINT8) is 1 lel 2025-10-08 16:47:54 +02:00
Alug b6943ce92e can check on compile if sizeof int == 4
can prob remove it alltogether we dont support 16 bit cpus kek
2025-10-08 16:47:54 +02:00
Alug 41b78feef5 remove R_GetColumnTranslucent 2025-10-08 16:47:54 +02:00
Alug c9b6276a02 merge sky column drawer back
lets hope this is safe lulul
2025-10-08 16:47:54 +02:00
Alug 39a5165d91 reset our column buffer directly after bsp traversal
we do not need to wait for sky draw since the sky gets instantly drawn
2025-10-08 16:47:54 +02:00
Alug e5a03dc3bb fix translucency being only half as translucent
oops lmao didnt notice in all of this doom uses the inverse of our blendlevels kek
2025-10-08 16:47:54 +02:00
Alug 4deebf8912 translucency is handled on the flush side! 2025-10-08 16:47:54 +02:00
Alug fa8901f6b0 fix ColumnFlushType enum 2025-10-08 16:47:54 +02:00
Alug 23512f0a6c align our tempbuf 2025-10-08 16:47:54 +02:00
Alug b44548b7ac dedupe those a bit 2025-10-08 16:47:54 +02:00
Alug 955812bd8d template the flush functions 2025-10-08 16:47:54 +02:00
indev e4ac394d29 Fix DC_COLORMAP and DC_TRANSMAP column drawers always using DC_COLORMAP|DC_TRANSMAP func 2025-10-08 16:47:54 +02:00
Alug 2b6185d7d6 reenable colormapped / translucent columns 2025-10-08 16:47:54 +02:00
Alug 2753052ee7 fix FlushColumns being called without being initialized
aack
2025-10-08 16:47:54 +02:00
Alug 3c9292c137 reorder column flush functions
also add some comments that used to be in drawcolumn X)
2025-10-08 16:47:54 +02:00
Alug e68136de3e remove tempbuf resolution limit
by allocating it dynamically per our actual screen resolution
2025-10-08 16:47:54 +02:00
Alug e852c23441 move the temp columndata into a struct
TODO:dynamic allocate our temporary screen buffer
2025-10-08 16:47:54 +02:00
Alug 031e8ee477 WIP: column buffering/flushing system
it "works" so far no performance improvement
everything but fully opague columns dont work for now until fixed
really messy and needs to be templated when working

from prboom & eternity engine
2025-10-08 16:47:54 +02:00
indev d7422b8ec9 Don't I_Error in W_InitFileError, that causes dedicated servers to bootloop 2025-10-06 17:44:47 +03:00
James R 0bbd8246cc Read only header bytes when creating textures list
R_LoadTextures was reading in the entirety of every
texture lump, now it only reads the 8 byte PNG header.
This saved more than 1 second for me (1.68 s -> 0.24 s).

PNG still need to be read in entirely to check their
dimensions; I didn't bother looking into optimizing it
since we don't have many PNG textures right now.
2025-10-05 20:59:40 +02:00
Alug 9e8ddd5f9e add a print to Joinable_OnChange
also change the other cvar messages to CONS_NOTICE
2025-10-05 20:39:09 +02:00
indev 3964d4e188 Always initialize all column offsets inside multi-patch textures 2025-10-05 21:12:46 +03:00
Alug 005af4362e remove unused W_LumpLenghtPwad call from R_GenerateTexture 2025-10-05 20:11:05 +02:00
Alug f817676033 fix uninitialized "i" counter in R_StoreWallRange 2025-10-05 20:10:49 +02:00
Alug 79140b3bdc fix oopsie in R_GenerateTexture 2025-10-05 20:10:46 +02:00
Alug 48722ef591 fix oob access in CV_AddValue and M_CanShowLevelInList
lets hope this doesent break anything Zzz....
2025-10-05 20:10:42 +02:00
Alug 6be5478fa8 dont free levelstate in D_ClearState
Titledemos be damned!
2025-10-05 20:10:36 +02:00
James R 953d9d15d6 Clear g_dc each frame
I was running into a memcpy of overlapping memory regions
in R_RenderMaskedSegRange.

- This is because of the reallocation of lightlists, which
  uses Z_Frame_Alloc.
- The memory pool that Z_Frame_Alloc draws from is cleared
  each frame.
- g_dc was not cleared though, so when the lightlists were
  reallocated, it'd try to copy from invalidated pointers.
- Access to invalid pointers within the memory pool does
  not cause a segfault directly (because the memory pool
  is allocated once). However, a memcpy involving such an
  invalid pointer leads to overlap, which may cause memory
  corruption.
2025-10-05 20:10:33 +02:00
Alug 0c56755e09 fix R_MarkSegBounds 2025-10-05 20:10:30 +02:00
Lactozilla c166075754 Don't generate textures in R_GetColumn 2025-10-05 20:10:27 +02:00
Alug 90ff1c4fc0 small fixups for r_segs 2025-10-05 20:10:23 +02:00
Alug 1d0fedddfd add bounds check to R_GetLinedefTransTable 2025-10-05 20:10:20 +02:00
Alug f5b60c3f36 port "Use separate table for maskedtexturecol"
from: https://git.do.srb2.org/STJr/SRB2/-/commit/97311dc5b00ab232a6e898c085c20d2f6bdbfa3b

~~cherry-picking this would be horrendous sry~~
2025-10-05 20:10:16 +02:00
Alug 78ad3e9710 some fixes for texture generation
- Fix negative y offsets for both normal and y-flipped patches
- simplify column wrapping/nonpow2 handling
- Single-patch textures: print an error if patch header is missing, cease memory errors

sadly does not fix our invalid columns we get occasionally
2025-10-05 20:10:13 +02:00
Alug b03d5c53ed simplify titledlighting stuff for span drawers
- use a std::vector for the tiltlightbufffer, only for easier checking if it needs to be resized from resolution change
- move stuff into its own function
- simplify R_CalcTiltedLighting
no functional change, no performance improvement, just looks neater
2025-10-04 22:05:07 +02:00
indev c5dce0e785 oops 2025-10-04 17:25:39 +03:00
indev f85c7ef961 Copyleft :3 2025-10-04 17:25:03 +03:00
Alug 4d211f8f82 Merge branch 'updatelibbacktrace' into Saturn-Next 2025-10-03 22:42:28 +01:00
Alug 8d3435291b fix windows compile 2025-10-03 22:41:02 +01:00
Alug 8f007155cd update libbacktrace (win x64) 2025-10-03 21:36:49 +01:00
Alug 58a38ac6c4 add "SATURN_TESTING" define
currently to hide the commit string from titlescreen on release builds
could be used for other crap
wish could use comptime to autogenerate this, but it runs after compile & linking
2025-10-03 16:40:31 +02:00
Alug 1e1dbfc450 oops all include guards 2025-10-03 16:39:51 +02:00
Alug 2eac9fc295 tiny cleanup p_map
also save a little division and abs
2025-10-03 16:39:48 +02: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
indev 4416be2ddc Merge pull request #203 from Indev450/curl-cli-args
CURL cli args
2025-10-02 19:00:29 +03: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
164 changed files with 5450 additions and 5418 deletions

No files matched your search

+4 -4
View File
@@ -5,13 +5,13 @@
# met:
# (1) Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# notice, this list of conditions and the following disclaimer.
# (2) 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.
# distribution.
# (3) The name of the author may not be used to
# endorse or promote products derived from this software without
# specific prior written permission.
@@ -26,4 +26,4 @@
# 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.
# POSSIBILITY OF SUCH DAMAGE.
+11 -1
View File
@@ -10,8 +10,18 @@ The libbacktrace library may be linked into a program or library and
used to produce symbolic backtraces.
Sample uses would be to print a detailed backtrace when an error
occurs or to gather detailed profiling information.
In general the functions provided by this library are async-signal-safe,
meaning that they may be safely called from a signal handler.
That said, on systems that use `dl_iterate_phdr`, such as GNU/Linux,
the first call to a libbacktrace function will call `dl_iterate_phdr`,
which is not in general async-signal-safe. Therefore, programs
that call libbacktrace from a signal handler should ensure that they
make an initial call from outside of a signal handler.
Similar considerations apply when arranging to call libbacktrace
from within malloc; `dl_iterate_phdr` can also call malloc,
so make an initial call to a libbacktrace function outside of
malloc before trying to call libbacktrace functions within malloc.
The libbacktrace library is provided under a BSD license.
See the source files for the exact license text.
@@ -25,7 +35,7 @@ will work.
See the source file backtrace-supported.h.in for the macros that it
defines.
As of October 2020, libbacktrace supports ELF, PE/COFF, Mach-O, and
As of July 2024, libbacktrace supports ELF, PE/COFF, Mach-O, and
XCOFF executables with DWARF debugging information.
In other words, it supports GNU/Linux, *BSD, macOS, Windows, and AIX.
The library is written to make it straightforward to add support for
Binary file not shown.
@@ -0,0 +1,41 @@
# libbacktrace.la - a libtool library file
# Generated by libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname=''
# Names of this library.
library_names=''
# The name of the static archive.
old_library='libbacktrace.a'
# Linker flags that can not go in dependency_libs.
inherited_linker_flags=''
# Libraries that this one depends upon.
dependency_libs=''
# Names of additional weak libraries provided by this library
weak_library_names=''
# Version information for libbacktrace.
current=0
age=0
revision=0
# Is this an already installed library?
installed=no
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='/mingw64/lib'
@@ -0,0 +1,41 @@
# libbacktrace.la - a libtool library file
# Generated by libtool (GNU libtool 1.3134 2009-11-29) 2.2.7a
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname=''
# Names of this library.
library_names=''
# The name of the static archive.
old_library='libbacktrace.a'
# Linker flags that can not go in dependency_libs.
inherited_linker_flags=''
# Libraries that this one depends upon.
dependency_libs=''
# Names of additional weak libraries provided by this library
weak_library_names=''
# Version information for libbacktrace.
current=0
age=0
revision=0
# Is this an already installed library?
installed=yes
# Should we warn about portability when linking against -modules?
shouldnotlink=no
# Files to dlopen/dlpreopen
dlopen=''
dlpreopen=''
# Directory that this library needs to be installed in:
libdir='/mingw64/lib'
+22 -13
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).
@@ -69,6 +70,7 @@
# VALGRIND=1 - Enable Valgrind memory debugging support.
# PROFILEMODE=1 - Enable performance profiling (gprof).
# USEASAN=1 - Enable building with Address Sanitizer.
# USEUBSAN=1 - Enable building with Undefined Behavior Sanitizer.
# NOLIBBACKTRACE=1 - Disable using Libbacktrace for crashlog traces.
#
# General flags for building:
@@ -243,10 +245,14 @@ ifdef STATIC
libs+=-static
endif
ifneq (,$(filter $(CC) $(CXX),gcc g++))
opts+=-mno-ms-bitfields
endif
# build with profiling information
ifdef PROFILEMODE
opts+=-pg
LDFLAGS+=-pg
libs+=-pg
endif
ifdef DEBUGMODE
@@ -256,29 +262,32 @@ debug_opts=-DNDEBUG
opts+=-O3
ifdef USELTO
# compile with LTO
ifdef MINGW
opts+=-flto=auto -g
LDFLAGS+=-flto=auto -g
else
opts+=-flto=auto
LDFLAGS+=-flto=auto
endif
libs+=-flto=auto
endif
endif
ifdef USEASAN
# compile with asan
ifdef MINGW
opts+=-fsanitize=address -g
libs+=-fsanitize=address -g
else
opts+=-fsanitize=address
libs+=-fsanitize=address
endif
ifdef USEUBSAN
# compile with asan
opts+=-fsanitize=undefined
libs+=-fsanitize=undefined
endif
ifeq ($(CC),clang)
LDFLAGS+= -fuse-ld=lld
ifneq (,$(filter $(CC) $(CXX),clang clang++))
libs+=-fuse-ld=lld
endif
ifdef MINGW
# mingw needs this passed AFTER lto and the likes were passed
# otherwise libbacktrace may break
opts+=-g
libs+=-g
endif
# debug_opts also get passed to windres
+2 -1
View File
@@ -6,7 +6,8 @@ passthru_opts+=\
NOHW NOMD5 NOPOSTPROCESSING\
MOBJCONSISTANCY PACKETDROP ZDEBUG\
HAVE_MINIUPNPC\
HAVE_DISCORDRPC DEVELOP
HAVE_DISCORDRPC DEVELOP\
NOHOLEPUNCH\
# build with debugging information
ifdef DEBUGMODE
+1 -1
View File
@@ -10,7 +10,7 @@
makedir:=$(makedir)/SDL
opts+=-DDIRECTFULLSCREEN -DHAVE_SDL
opts+=-DHAVE_SDL
sources+=$(call List,sdl/Sourcefile)
NOUPNP=1
+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 -1
View File
@@ -2,6 +2,8 @@
# Mingw, if you don't know, that's Win32/Win64
#
sources+=$(call List,win32/Sourcefile)
ifndef MINGW64
EXENAME?=srb2kart-saturn_32bit.exe
else
@@ -95,7 +97,7 @@ LIBBACKTRACE_libs:=-L$(lib)/lib/x86_64 -lbacktrace
$(eval $(call _set,LIBBACKTRACE))
else
lib:=../libs/drmingw
opts+=-I$(lib)/include
opts+=-I$(lib)/include -DHAVE_DRMINGW
libs+=-L$(lib)/lib/win32 -lmgwhelp -lexchndl
endif
+1 -1
View File
@@ -53,7 +53,7 @@ r_data.c
r_draw.c
r_fps.cpp
r_main.cpp
r_patch.c
r_patch.cpp
r_patchrotation.c
r_plane.cpp
r_segs.cpp
+2 -2
View File
@@ -110,7 +110,7 @@ void I_Error(const char *error, ...)
char logbuf[8192];
va_start(argptr, error);
vsprintf(logbuf, error, argptr);
vsnprintf(logbuf, 8192, error, argptr);
va_end(argptr);
LOGE(logbuf);
@@ -166,7 +166,7 @@ void I_OutputMsg(const char *fmt, ...)
char logbuf[8192];
va_start(argptr, fmt);
vsprintf(logbuf, fmt, argptr);
vsnprintf(logbuf, 8192, fmt, argptr);
va_end(argptr);
LOGD(logbuf);
+5
View File
@@ -10,8 +10,13 @@
/// \file b_bot.h
/// \brief Basic bot handling
#ifndef __B_BOT__
#define __B_BOT__
void B_BuildTiccmd(player_t *player, ticcmd_t *cmd);
void B_KeysToTiccmd(mobj_t *mo, ticcmd_t *cmd, boolean forward, boolean backward, boolean left, boolean right, boolean strafeleft, boolean straferight, boolean jump, boolean spin);
boolean B_CheckRespawn(player_t *player);
void B_MoveBlocked(player_t *player);
void B_RespawnBot(INT32 playernum);
#endif
+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 { \
+82 -75
View File
@@ -142,7 +142,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 +199,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_
@@ -281,7 +281,7 @@ 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 +359,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 +456,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 +492,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 +519,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 +571,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 +581,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"));
@@ -700,6 +700,7 @@ static void COM_Echo_f(void)
for (i = 1; i < COM_Argc(); i++)
CONS_Printf("%s ", COM_Argv(i));
CONS_Printf("\n");
}
@@ -708,11 +709,11 @@ static void COM_Echo_f(void)
static void COM_CEcho_f(void)
{
size_t i;
char cechotext[1024] = "";
char cechotext[1024] = {0};
for (i = 1; i < COM_Argc(); i++)
{
strlcpy(cechotext, COM_Argv(i), sizeof(cechotext)-1);
strlcat(cechotext, COM_Argv(i), sizeof(cechotext)-1);
strlcat(cechotext, " ", sizeof(cechotext)-1);
}
@@ -835,7 +836,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)
{
@@ -878,7 +879,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);
@@ -938,6 +939,8 @@ static void COM_Find_f(void)
}
help = COM_Argv(1);
if (!help)
return;
helplen = strlen(help);
CONS_Printf("\x82""Variables:\n");
matchesany = false;
@@ -1126,7 +1129,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
@@ -1143,9 +1146,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
}
// =========================================================================
@@ -1173,7 +1176,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;
@@ -1363,7 +1366,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
@@ -1376,21 +1379,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;
@@ -1408,7 +1411,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)
{
@@ -1421,9 +1424,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)
@@ -1471,7 +1474,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();
@@ -1497,11 +1500,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)
@@ -1515,9 +1518,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);
@@ -1573,8 +1577,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;
@@ -1585,11 +1590,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);
@@ -1607,7 +1614,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.
@@ -1619,7 +1626,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;
}
@@ -1640,7 +1647,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)
@@ -1650,21 +1657,21 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
UINT8 *p = buf;
if (!(server || (IsPlayerAdmin(consoleplayer))))
{
CONS_Printf(M_GetText("Only the server or admin can change: %s %s\n"), var->name, var->string);
CONS_Alert(CONS_NOTICE, "Only the server or admin can change: %s %s\n", var->name, var->string);
return;
}
if (var == &cv_kartencore && !M_SecretUnlocked(SECRET_ENCORE))
{
CONS_Printf(M_GetText("You haven't unlocked Encore Mode yet!\n"));
CONS_Alert(CONS_NOTICE, "You haven't unlocked Encore Mode yet!\n");
return;
}
if (var == &cv_kartspeed && !M_SecretUnlocked(SECRET_HARDSPEED))
{
if (!stricmp(value, "Hard") || atoi(value) == 2)
if (fasticmp(value, "Hard") || atoi(value) == 2)
{
CONS_Printf(M_GetText("You haven't unlocked this yet!\n"));
CONS_Alert(CONS_NOTICE, "You haven't unlocked this yet!\n");
return;
}
}
@@ -1681,14 +1688,13 @@ static void CV_SetCVar(consvar_t *var, const char *value, boolean stealth)
else
Setvalue(var, value, stealth);
}
else if ((var->flags & CV_NOTINNET) && netgame)
{
CONS_Alert(CONS_NOTICE, "This variable can't be changed while in netgame: %s %s\n", var->name, var->string);
return;
}
else
if ((var->flags & CV_NOTINNET) && netgame)
{
CONS_Printf(M_GetText("This variable can't be changed while in netgame: %s %s\n"), var->name, var->string);
return;
}
else
Setvalue(var, value, stealth);
Setvalue(var, value, stealth);
}
/** Sets a value to a variable without calling its callback function.
@@ -1771,7 +1777,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
newvalue = var->value - 1;
do
{
if(increment > 0) // Going up!
if (increment > 0) // Going up!
{
if (++newvalue == NUMMAPS)
newvalue = -1;
@@ -1785,7 +1791,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
if (newvalue == oldvalue)
break; // don't loop forever if there's none of a certain gametype
if(!mapheaderinfo[newvalue])
if (newvalue >= 0 && !mapheaderinfo[newvalue])
continue; // Don't allocate the header. That just makes memory usage skyrocket.
} while (!M_CanShowLevelInList(newvalue, gt));
@@ -1797,7 +1803,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)
@@ -1914,13 +1920,14 @@ void CV_AddValue(consvar_t *var, INT32 increment)
max = (M_SecretUnlocked(SECRET_HARDSPEED) ? 3 : 2);
}
#ifdef PARANOIA
if (currentindice == -1)
I_Error("CV_AddValue: current value %d not found in possible value\n",
var->value);
if (currentindice == -1 || max == 0)
I_Error("CV_AddValue: current value %d not found in possible value\n", var->value);
#endif
newindice = (currentindice + increment + max) % max;
CV_Set(var, var->PossibleValue[newindice].strvalue);
if (max > 0)
{
newindice = (currentindice + increment + max) % max;
CV_Set(var, var->PossibleValue[newindice].strvalue);
}
}
}
else
@@ -1968,12 +1975,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
@@ -2005,37 +2012,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;
@@ -2052,8 +2059,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;
}
@@ -2136,7 +2143,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);
+5 -36
View File
@@ -69,14 +69,9 @@ 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_clipviewtop; // (useless)
static UINT8 con_hudlines; // number of console heads up message lines
static UINT32 con_hudtime[MAXHUDLINES]; // remaining time of display for hud msg lines
INT32 con_clearlines; // top screen lines to refresh when view reduced
boolean con_hudupdate; // when messages scroll, we need a backgrnd refresh
// console text output
static char *con_line; // console text output current line
static size_t con_cx; // cursor position in current line
@@ -393,9 +388,6 @@ void CON_Init(void)
Lock_state();
//note: CON_Ticker should always execute at least once before D_Display()
con_clipviewtop = -1; // -1 does not clip
con_hudlines = atoi(cons_hudlines.defaultvalue);
Unlock_state();
@@ -529,7 +521,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;
@@ -555,7 +547,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--;
@@ -727,7 +719,6 @@ void CON_ToggleOff(void)
con_curlines = 0;
CON_ClearHUD();
con_forcepic = 0;
con_clipviewtop = -1; // remove console clipping of view
I_SetTextInput(false);
@@ -779,18 +770,6 @@ void CON_Ticker(void)
}
}
// clip the view, so that the part under the console is not drawn
con_clipviewtop = -1;
if (cons_backpic.value) // clip only when using an opaque background
{
if (con_curlines > 0)
con_clipviewtop = con_curlines - viewwindowy - 1 - 10;
// NOTE: BIG HACK::SUBTRACT 10, SO THAT WATER DON'T COPY LINES OF THE CONSOLE
// WINDOW!!! (draw some more lines behind the bottom of the console)
if (con_clipviewtop < 0)
con_clipviewtop = -1; // maybe not necessary, provided it's < 0
}
// check if console ready for prompt
if (con_destlines >= minheight)
{
@@ -1031,7 +1010,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);
@@ -1100,9 +1079,6 @@ static void CON_Linefeed(void)
con_line = &con_buffer[(con_cy%con_totallines)*con_width];
memset(con_line, ' ', con_width);
// make sure the view borders are refreshed if hud messages scroll
con_hudupdate = true; // see HU_Erase()
}
// Outputs text into the console text buffer
@@ -1282,7 +1258,7 @@ void CONS_Alert(alerttype_t level, const char *fmt, ...)
txt = malloc(8192);
va_start(argptr, fmt);
vsprintf(txt, fmt, argptr);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
switch (level)
@@ -1318,7 +1294,7 @@ void CONS_Debug(INT32 debugflags, const char *fmt, ...)
txt = malloc(8192);
va_start(argptr, fmt);
vsprintf(txt, fmt, argptr);
vsnprintf(txt, 8192, fmt, argptr);
va_end(argptr);
// Again I am lazy, oh well
@@ -1489,9 +1465,6 @@ static void CON_DrawHudlines(void)
//V_DrawCharacter(x, y, (p[c]&0xff) | cv_constextsize.value | V_NOSCALESTART, !cv_allcaps.value);
y += charheight;
}
// top screen lines that might need clearing when view is reduced
con_clearlines = y; // this is handled by HU_Erase();
}
// draw the console background, text, and prompt if enough place
@@ -1509,10 +1482,6 @@ static void CON_DrawConsole(void)
if (con_curlines <= 0)
return;
//FIXME: refresh borders only when console bg is translucent
con_clearlines = con_curlines; // clear console draw from view borders
con_hudupdate = true; // always refresh while console is on
// draw console background
if (cons_backpic.value || con_forcepic)
{
-5
View File
@@ -30,14 +30,9 @@ extern boolean con_recalc;
extern boolean con_startup;
// top clip value for view render: do not draw part of view hidden by console
extern INT32 con_clipviewtop;
// 0 means console if off, or moving out
extern INT32 con_destlines;
extern INT32 con_clearlines; // lines of top of screen to refresh
extern boolean con_hudupdate; // hud messages have changed, need refresh
extern UINT32 con_scalefactor; // console text scale factor
extern consvar_t cons_backcolor, cons_menuhighlight;
+1 -1
View File
@@ -1,4 +1,4 @@
// BLANKART
// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
+1 -1
View File
@@ -1,4 +1,4 @@
// BLANKART
// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
+1 -1
View File
@@ -1,4 +1,4 @@
// BLANKART
// SONIC ROBO BLAST 2 KART
//-----------------------------------------------------------------------------
// Copyright (C) 2024 by Ronald "Eidolon" Kinard
// Copyright (C) 2024 by Kart Krew
+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__
+64 -53
View File
@@ -78,14 +78,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 +98,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 +117,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 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 +143,12 @@ 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
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 +195,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 +226,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};
@@ -285,7 +284,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 +311,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 +330,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 +459,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)
@@ -823,7 +822,7 @@ static void resynch_read_player(resynch_pak *rsp)
P_SetThingPosition(players[i].mo);
}
static inline void resynch_write_ctf(resynchend_pak *rst)
static void resynch_write_ctf(resynchend_pak *rst)
{
mobj_t *mflag;
UINT8 i, j;
@@ -863,7 +862,7 @@ static inline void resynch_write_ctf(resynchend_pak *rst)
}
}
static inline void resynch_read_ctf(resynchend_pak *p)
static void resynch_read_ctf(resynchend_pak *p)
{
UINT8 i;
@@ -1585,7 +1584,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;
@@ -1656,12 +1655,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.
@@ -2179,7 +2173,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 +2218,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 +3214,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 +3224,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 +3239,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 +3263,7 @@ static void Command_connect(void)
splitscreen = cv_splitplayers.value-1;
SplitScreen_OnChange();
}
botingame = false;
botskin = 0;
CL_ConnectToServer();
@@ -3761,7 +3756,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 +4146,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)
{
@@ -4161,7 +4156,10 @@ static void Joinable_OnChange(void)
UINT8 maxplayer;
if (!server)
{
CONS_Alert(CONS_NOTICE, ("Only the server can change: %s %s\n"), cv_allownewplayer.name, cv_allownewplayer.string);
return;
}
#ifdef SATURNJOIN
// disabling joins should also disable saturn joins unless its called with CV_StealthSet and vice versa to make life a bit easier
@@ -4401,7 +4399,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;
@@ -4488,7 +4486,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;
@@ -4649,13 +4647,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);
@@ -5217,7 +5228,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?
@@ -5677,7 +5688,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];
}
}
@@ -5784,7 +5795,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;
}
}
@@ -6322,7 +6333,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...
@@ -6332,7 +6343,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);
}
@@ -6445,7 +6456,7 @@ static void SV_SendTics(void)
{
(*ntextcmd)++;
WRITEUINT8(bufpos, j);
M_Memcpy(bufpos, textcmd, size + 1);
memcpy(bufpos, textcmd, size + 1);
bufpos += size + 1;
}
}
+1 -1
View File
@@ -604,7 +604,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);
+202 -252
View File
@@ -97,15 +97,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 +113,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 +142,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,68 +161,17 @@ 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.
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 UINT16 curcolor[MAXSPLITSCREENPLAYERS] = {};
static void D_DeviceLEDTick(void)
{
UINT8 i;
static UINT16 color[MAXSPLITSCREENPLAYERS] = {0};
static UINT16 color[MAXSPLITSCREENPLAYERS] = {};
if (numcontrollers == 0)
{
@@ -347,11 +298,68 @@ static void D_Renderview(void)
}
}
for (i = 0; i <= splitscreen; i++)
{
if (!P_MobjWasRemoved(players[displayplayers[i]].mo) || players[displayplayers[i]].playerstate == PST_DEAD)
{
viewssnum = i;
switch (i)
{
case 1:
if (splitscreen > 1)
{
viewwindowx = viewwidth;
viewwindowy = 0;
}
else
{
viewwindowx = 0;
viewwindowy = viewheight;
}
break;
case 2:
viewwindowx = 0;
viewwindowy = viewheight;
break;
case 3:
viewwindowx = viewwidth;
viewwindowy = viewheight;
break;
default: // Initialize for P1
viewwindowy = viewwindowx = 0;
objectsdrawn = 0;
break;
}
#ifdef HWRENDER
if (rendermode == render_opengl)
{
HWR_RenderPlayerView();
}
else if (rendermode == render_soft)
#endif
R_RenderPlayerView(&players[displayplayers[i]]);
}
if (rendermode == render_soft)
{
if (i == 0)
R_ApplyViewMorph();
#ifdef MOTIONBLUR
V_DoPostProcessor(i, postimgparam[i]);
#else
V_DoPostProcessor(i, 0);
#endif
}
}
// Draw over the fourth screen so you don't have to stare at a HOM :V
if (splitscreen == 2)
{
// V_DrawPatchFill, but for the fourth screen only
patch_t *pat = W_CachePatchName("SRB2BACK", PU_CACHE);
patch_t *pat = W_CachePatchName("SRB2BACK", PU_PATCH);
INT32 x, y, pw = SHORT(pat->width) * vid.dup, ph = SHORT(pat->height) * vid.dup;
for (x = vid.width>>1; x < vid.width; x += pw)
@@ -361,65 +369,6 @@ static void D_Renderview(void)
}
}
for (i = 0; i <= splitscreen; i++)
{
const boolean issplitscreen = (i > 0);
if (!P_MobjWasRemoved(players[displayplayers[i]].mo) || players[displayplayers[i]].playerstate == PST_DEAD)
{
viewssnum = i;
if (!issplitscreen) // Initialize for P1
{
viewwindowy = viewwindowx = 0;
objectsdrawn = 0;
}
#ifdef HWRENDER
if (rendermode == render_opengl)
{
HWR_RenderPlayerView();
R_RestoreLevelInterpolators();
continue;
}
#endif
if (issplitscreen) // Splitscreen-specific
{
switch (i)
{
case 1:
if (splitscreen > 1)
{
viewwindowx = viewwidth;
viewwindowy = 0;
}
else
{
viewwindowx = 0;
viewwindowy = viewheight;
}
break;
case 2:
viewwindowx = 0;
viewwindowy = viewheight;
break;
case 3:
viewwindowx = viewwidth;
viewwindowy = viewheight;
default:
break;
}
}
R_RenderPlayerView(&players[displayplayers[i]]);
}
if (!issplitscreen)
R_ApplyViewMorph();
V_DoPostProcessor(i, postimgparam[i]);
}
R_RestoreLevelInterpolators();
}
@@ -522,19 +471,16 @@ static boolean D_Display(void)
case GS_LEVEL:
if (!gametic)
break;
HU_Erase();
AM_Drawer();
break;
case GS_INTERMISSION:
Y_IntermissionDrawer();
HU_Erase();
HU_Drawer();
break;
case GS_VOTING:
Y_VoteDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -549,7 +495,6 @@ static boolean D_Display(void)
case GS_CUTSCENE:
F_CutsceneDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -559,7 +504,6 @@ static boolean D_Display(void)
case GS_EVALUATION:
F_GameEvaluationDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -569,7 +513,6 @@ static boolean D_Display(void)
case GS_CREDITS:
F_CreditDrawer();
HU_Erase();
HU_Drawer();
break;
@@ -586,7 +529,6 @@ static boolean D_Display(void)
{
// I don't think HOM from nothing drawing is independent...
F_WaitingPlayersDrawer();
HU_Erase();
HU_Drawer();
}
case GS_TIMEATTACK:
@@ -726,7 +668,7 @@ static boolean D_Display(void)
// D_SRB2Loop
// =========================================================================
tic_t rendergametic;
tic_t rendergametic = 0;
void D_SRB2Loop(void)
{
@@ -774,6 +716,7 @@ void D_SRB2Loop(void)
precise_t capbudget;
precise_t enterprecise = I_GetPreciseTime();
memset(&g_dc, 0, sizeof(g_dc));
Z_Frame_Reset();
// Casting the return value of a function is bad practice (apparently)
@@ -850,11 +793,6 @@ void D_SRB2Loop(void)
if (!dedicated)
{
if (menuactive)
{
D_GamePadMenuScrollTicker();
}
D_DeviceLEDTick();
}
}
@@ -889,12 +827,6 @@ void D_SRB2Loop(void)
// always update console and hud
// otherwise it may take minutes to open it
CON_Drawer();
if (gamestate == GS_LEVEL)
{
ST_Drawer();
HU_Drawer();
}
}
}
@@ -978,8 +910,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;
@@ -988,7 +923,10 @@ void D_ClearState(void)
CL_ClearPlayer(i);
splitscreen = 0;
SplitScreen_OnChange();
// recompute screen size
R_ExecuteSetViewSize();
botingame = false;
botskin = 0;
cv_debug = 0;
@@ -1007,7 +945,6 @@ void D_ClearState(void)
gameaction = ga_nothing;
memset(displayplayers, 0, sizeof(displayplayers));
consoleplayer = 0;
//demosequence = -1;
gametype = GT_RACE; // SRB2kart
paused = false;
@@ -1026,10 +963,15 @@ void D_ClearState(void)
S_StopSounds();
S_ResetKeepAndSpecialMus(); // just in case
P_FreeLevelState();
//P_FreeLevelState();
G_SetGamestate(GS_NULL);
wipegamestate = GS_NULL;
M_ClearMenus(true);
// map palettes affect this
D_ResetDeviceLED();
}
//
@@ -1037,25 +979,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)
{
@@ -1063,16 +998,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;
}
}
@@ -1085,28 +1021,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);
@@ -1116,9 +1051,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);
@@ -1126,7 +1058,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
{
@@ -1156,42 +1088,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))
{
@@ -1201,56 +1135,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;
}
@@ -1286,14 +1231,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);
}
@@ -1307,57 +1252,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)
#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;
@@ -1731,8 +1679,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);
@@ -1741,17 +1695,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';
@@ -1777,6 +1720,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);
@@ -1805,7 +1751,7 @@ void D_SRB2Main(void)
const char *s = M_GetNextParm();
if (s) // Check for NULL?
D_AddFile(s, startuppwads);
D_AddFile(s, startuppwads, startuppwadcount++);
}
}
}
@@ -1838,8 +1784,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
@@ -1878,15 +1826,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();
@@ -1930,9 +1879,7 @@ void D_SRB2Main(void)
G_LoadGameData();
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
VID_PrepareModeList(); // Regenerate Modelist according to cv_fullscreen
#endif
// set user default mode or mode set at cmdline
SCR_CheckDefaultMode();
@@ -2152,11 +2099,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
-3
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
+10 -11
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;
@@ -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;
}
+120 -99
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);
@@ -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},
@@ -964,10 +968,11 @@ void D_RegisterClientCommands(void)
// g_input.c
CV_RegisterVar(&cv_controlperkey);
CV_RegisterVar(&cv_turnsmooth);
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
CV_RegisterVar(&cv_turnsmooth[i]);
CV_RegisterVar(&cv_turnaxis[i]);
CV_RegisterVar(&cv_moveaxis[i]);
CV_RegisterVar(&cv_camturnaxis[i]);
@@ -984,6 +989,8 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_xdeadzone[i]);
CV_RegisterVar(&cv_ydeadzone[i]);
CV_RegisterVar(&cv_litesteer[i]);
CV_RegisterVar(&cv_usejoystick[i]);
CV_RegisterVar(&cv_joyscale[i]);
CV_RegisterVar(&cv_rumble[i]);
@@ -1040,6 +1047,7 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_betainterscreen);
CV_RegisterVar(&cv_laglesscam);
CV_RegisterVar(&cv_demoangturn);
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
@@ -1211,7 +1219,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
@@ -1328,7 +1336,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;
}
@@ -1378,7 +1386,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);
@@ -1500,9 +1508,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.
@@ -1905,7 +1913,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];
@@ -1937,7 +1945,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);
}
@@ -1991,11 +1999,6 @@ static void Got_NameAndColor(UINT8 **cp, INT32 playernum)
}
else
SetPlayerSkinByNum(playernum, skin);
#ifdef HAVE_DISCORDRPC
if (playernum == consoleplayer)
DRPC_UpdatePresence();
#endif
}
void SendWeaponPref(void)
@@ -2038,15 +2041,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)
@@ -2319,8 +2324,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
@@ -2489,15 +2494,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));
@@ -2598,14 +2606,18 @@ ConcatCommandArgv (int start, int end)
size += strlen(COM_Argv(i)) + 1;
}
final = ZZ_Alloc(size);
p = final;
p = final = ZZ_Alloc(size);
if (!p)
I_Error("ConcatCommandArgv: Out of memory!\n");
--end;/* handle the final argument separately */
for (i = start; i < end; ++i)
{
p += sprintf(p, "%s ", COM_Argv(i));
}
/* at this point "end" is actually the last argument's position */
strcpy(p, COM_Argv(end));
@@ -2838,7 +2850,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;
@@ -2957,7 +2969,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;
@@ -3069,7 +3081,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);
@@ -3104,7 +3116,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;
@@ -3139,7 +3151,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;
@@ -3184,20 +3196,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;
@@ -3274,20 +3286,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;
@@ -3365,20 +3377,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;
@@ -3456,20 +3468,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;
@@ -3555,33 +3567,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;
@@ -3656,7 +3668,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;
@@ -4013,7 +4025,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.
@@ -4123,7 +4135,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);
@@ -4175,7 +4187,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);
@@ -4216,23 +4228,32 @@ static void Command_MotD_f(void)
mymotd = Z_Malloc(sizeof(motd), PU_STATIC, NULL);
strlcpy(mymotd, COM_Argv(1), sizeof motd);
if (!mymotd)
return;
//I_Error("Command_MotD_f: Out of memory!\n"); // idk if this aint a bit too much lel
strlcpy(mymotd, COM_Argv(1), sizeof(motd));
for (i = 2; i < j; i++)
{
strlcat(mymotd, " ", sizeof motd);
strlcat(mymotd, COM_Argv(i), sizeof motd);
strlcat(mymotd, " ", sizeof(motd));
strlcat(mymotd, COM_Argv(i), sizeof(motd));
}
// Disallow non-printing characters and semicolons.
for (i = 0; mymotd[i] != '\0'; i++)
{
if (!isprint(mymotd[i]) || mymotd[i] == ';')
{
Z_Free(mymotd);
return;
}
}
if ((netgame || multiplayer) && client)
{
SendNetXCmd(XD_SETMOTD, mymotd, i); // send the actual size of the motd string, not the full buffer's size
}
else
{
strcpy(motd, mymotd);
@@ -4242,7 +4263,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;
@@ -4309,7 +4330,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;
@@ -4431,7 +4452,7 @@ static void Command_Addfile(void)
}
// Add file on your client directly if it is trivial, or you aren't in a netgame.
if (!(netgame || multiplayer) || musiconly)
if (!netgame || musiconly)
{
P_AddWadFile(fn, false);
return;
@@ -4474,7 +4495,7 @@ static void Command_Addfile(void)
if (IsPlayerAdmin(consoleplayer) && (!server)) // Request to add file
SendNetXCmd(XD_REQADDFILE, buf, buf_p - buf);
else
SendNetXCmd(XD_ADDFILE, buf, buf_p - buf);;
SendNetXCmd(XD_ADDFILE, buf, buf_p - buf);
}
/** Adds something at runtime.
@@ -4587,7 +4608,7 @@ static void Command_GLocalSkin (void)
}
}
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;
@@ -4646,7 +4667,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;
@@ -5190,14 +5211,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;
@@ -5446,7 +5467,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;
@@ -5467,7 +5488,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;
@@ -5519,7 +5540,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);
@@ -5528,7 +5549,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);
@@ -6168,7 +6189,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,
+23 -22
View File
@@ -110,14 +110,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 +131,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 +550,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 +666,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 +902,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 +947,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);
@@ -1103,7 +1104,7 @@ void nameonly(char *s)
ns = &(s[j+1]);
len = strlen(ns);
#if 0
M_Memcpy(s, ns, len+1);
memcpy(s, ns, len+1);
#else
memmove(s, ns, len+1);
#endif
@@ -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);
+5
View File
@@ -9,6 +9,9 @@
/// \file d_protocol.h
/// \brief srb2kart:// protocol stuff
#ifndef __D_PROTOCOL__
#define __D_PROTOCOL__
void D_SetupProtocol(void);
void D_CreateProtocol(void);
@@ -16,3 +19,5 @@ void D_DeleteProtocol(void);
#ifdef HAVE_CURL
void D_DownloadReplay(const char *url, const char *path);
#endif
#endif //__D_PROTOCOL__
+5 -5
View File
@@ -1442,7 +1442,7 @@ static INT32 errorcount = 0;
*/
static boolean shutdowning = false;
void I_Error(const char *error, ...)
FUNCIERROR void ATTRNORETURN I_Error(const char *error, ...)
{
va_list argptr;
char buffer[8192];
@@ -1468,7 +1468,7 @@ void I_Error(const char *error, ...)
if (errorcount > 20)
{
va_start(argptr, error);
vsprintf(buffer, error, argptr);
vsnprintf(buffer, 8192, error, argptr);
va_end(argptr);
I_OutputMsg("SRB2Kart %s Recursive Error", buffer);
@@ -1482,7 +1482,7 @@ void I_Error(const char *error, ...)
// Display error message in the console before we start shutting it down
va_start(argptr, error);
vsprintf(buffer, error, argptr);
vsnprintf(buffer, 8192, error, argptr);
va_end(argptr);
I_OutputMsg("\nI_Error(): %s\n", buffer);
@@ -1709,9 +1709,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
}
+30 -4
View File
@@ -49,6 +49,27 @@ discordRequest_t *discordRequestList = NULL;
static char self_ip[IP_SIZE+1];
/*--------------------------------------------------
* const char *DRPC_HideUsername(const char *input)
*
* See header file for description.
* --------------------------------------------------*/
const char *DRPC_HideUsername(const char *input)
{
static char buffer[5];
int i;
buffer[0] = input[0];
for (i = 1; i < 4; ++i)
{
buffer[i] = '.';
}
buffer[4] = '\0';
return buffer;
}
boolean drpc_init = false;
/*--------------------------------------------------
@@ -105,7 +126,7 @@ static void DRPC_HandleReady(const DiscordUser *user)
}
else
{
CONS_Printf("Discord: connected to %s#%s (%s)\n", user->username, user->discriminator, user->userId);
CONS_Printf("Discord: connected to %s (%s)\n", user->username, user->userId);
}
}
@@ -241,8 +262,10 @@ static void DRPC_HandleJoinRequest(const DiscordUser *requestUser)
newRequest->username = Z_Calloc(344, PU_STATIC, NULL);
snprintf(newRequest->username, 344, "%s", requestUser->username);
#if 0
newRequest->discriminator = Z_Calloc(8, PU_STATIC, NULL);
snprintf(newRequest->discriminator, 8, "%s", requestUser->discriminator);
#endif
newRequest->userID = Z_Calloc(32, PU_STATIC, NULL);
snprintf(newRequest->userID, 32, "%s", requestUser->userId);
@@ -254,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);
@@ -308,6 +331,9 @@ void DRPC_RemoveRequest(discordRequest_t *removeRequest)
}
Z_Free(removeRequest->username);
#if 0
Z_Free(removeRequest->discriminator);
#endif
Z_Free(removeRequest->userID);
Z_Free(removeRequest);
}
@@ -393,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 :)
@@ -658,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;
+11
View File
@@ -29,7 +29,9 @@ extern struct discordInfo_s {
typedef struct discordRequest_s {
char *username; // Discord user name.
#if 0 // Good night, sweet prince...
char *discriminator; // Discord discriminator (The little hashtag thing after the username). Separated for a "hide discriminators" cvar.
#endif
char *userID; // The ID of the Discord user, gets used with Discord_Respond()
// HAHAHA, no.
@@ -44,6 +46,15 @@ typedef struct discordRequest_s {
extern discordRequest_t *discordRequestList;
/*--------------------------------------------------
* const char *DRPC_HideUsername(const char *input);
*
* Handle usernames while cv_discordstreamer is activated.
* (The loss of discriminators is still a dumbass regression
* that I will never forgive the Discord developers for.)
* --------------------------------------------------*/
const char *DRPC_HideUsername(const char *input);
/*--------------------------------------------------
void DRPC_RemoveRequest(void);
+7 -11
View File
@@ -69,6 +69,8 @@ extern "C" {
#include <sys/stat.h>
#include <ctype.h>
#include "fastcmp.h"
#ifdef _WIN32
#include <io.h>
#endif
@@ -90,12 +92,6 @@ extern FILE *logstream;
extern char logfilename[1024];
#endif
// not sure if this belongs here lul
// TODO: figure out whats preventing 32bit windows from working with libbacktrace
#if defined(_WIN32) && !defined(MINGW64)
#define HAVE_DRMINGW
#endif
#if defined (HAVE_LIBBACKTRACE)
#define CRASH_LOGFILE_NAME "srb2kart-crash-log.txt"
#elif defined (HAVE_DRMINGW)
@@ -120,6 +116,9 @@ extern char logfilename[1024];
#define SUBVERSION 6 // more precise version number
#define VERSIONSTRING "Saturn v9"
#define VERSIONSTRINGW L"Saturn v9"
#define SATURN_TESTING // comment out for saturn release builds!
// Hey! If you change this, add 1 to the MODVERSION below! Otherwise we can't force updates!
// And change CMakeLists.txt (not src/, but in root), for CMake users!
#endif
@@ -454,11 +453,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);
@@ -654,7 +648,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;
-1
View File
@@ -43,7 +43,6 @@ extern "C" {
#define UINT64 uint64_t
#ifdef __APPLE_CC__
#define DIRECTFULLSCREEN 1
#define DEBUG_LOG
#define NOIPX
#endif
+1
View File
@@ -963,6 +963,7 @@ void F_StartTitleScreen(void)
finalecount = 0;
else
wipegamestate = GS_TITLESCREEN;
G_SetGamestate(GS_TITLESCREEN);
CON_ClearHUD();
+2 -2
View File
@@ -257,7 +257,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 +266,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;
}
}
+14 -14
View File
@@ -44,7 +44,7 @@ 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[1024];
char menupath[MAXFILEPATH];
size_t menupathindex[menudepth];
size_t menudepthleft = menudepth;
@@ -111,7 +111,7 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
int found = 0;
char *searchname;
int depthleft = maxsearchdepth;
char searchpath[1024];
char searchpath[MAXFILEPATH];
size_t *searchpathindex;
dirhandle = (DIR**)malloc(maxsearchdepth * sizeof(DIR*));
@@ -198,7 +198,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 +212,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 +227,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 +353,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 +400,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 +478,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 +559,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 +567,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 +587,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 +598,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;
}
+2 -1
View File
@@ -34,7 +34,8 @@ filestatus_t filesearch(char *filename, const char *startpath, const UINT8 *want
#define menudepth 20
extern char menupath[1024];
#define MAXFILEPATH 1024
extern char menupath[MAXFILEPATH];
extern size_t menupathindex[menudepth];
extern size_t menudepthleft;
+452 -372
View File
File diff suppressed because it is too large. Load diff
+1 -1
View File
@@ -67,7 +67,7 @@ typedef enum {
} menudemotype_e;
typedef struct menudemo_s {
char filepath[256];
char filepath[1023 + 256]; // see M_PrepReplayList and sizeof menupath
menudemotype_e type;
char title[65]; // Null-terminated for string prints
+209 -187
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,67 +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;
INT16 prevmap = 0, nextmap = 0;
// Analog Control
void SendWeaponPref(void);
@@ -452,6 +451,13 @@ consvar_t cv_ydeadzone[MAXSPLITSCREENPLAYERS] = {
{"joy4_ydeadzone", "0.5", CV_FLOAT|CV_SAVE, deadzone_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
};
consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS] = {
{"litesteer", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"litesteer2", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"litesteer3", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL},
{"litesteer4", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}
};
static CV_PossibleValue_t driftsparkpulse_t[] = {{0, "MIN"}, {FRACUNIT*3, "MAX"}, {0, NULL}};
consvar_t cv_driftsparkpulse = {"driftsparkpulse", "1.4", CV_FLOAT | CV_SAVE, driftsparkpulse_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -463,7 +469,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] =
@@ -486,7 +492,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] =
{
@@ -563,6 +569,7 @@ static void G_SetSaveGameModified(void)
{
if (!unlockables[i].conditionset)
continue;
if (!unlockables[i].unlocked)
{
unlockables[i].unlocked = true;
@@ -588,7 +595,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)
@@ -627,6 +634,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;
}
@@ -680,11 +688,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:
@@ -743,45 +752,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)
@@ -799,9 +796,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};
@@ -1014,8 +1011,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
else
th = 0;
if (th < SLOWTURNTICS)
tspeed = cv_turnsmooth.value == 2 ? 2 : 0; // slow turn
if (th < (cv_turnsmooth[forplayer].value * 3))
tspeed = cv_turnsmooth[forplayer].value == 2 ? 2 : 0; // slow turn
else
tspeed = 1;
@@ -1024,30 +1021,32 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
// let movement keys cancel each other out
if (turnright && !(turnleft))
{
cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn - (angleturn[tspeed]));
cmd->angleturn -= angleturn[tspeed];
side += sidemove[1];
}
else if (turnleft && !(turnright))
{
cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed]));
cmd->driftturn = (INT16)(cmd->driftturn + (angleturn[tspeed]));
cmd->angleturn += angleturn[tspeed];
side -= sidemove[1];
}
if (analogjoystickmove && axis != 0)
{
// JOYAXISRANGE should be 1023 (divide by 1024)
cmd->angleturn = (INT16)(cmd->angleturn - (((axis * angleturn[1]) >> 10))); // ANALOG!
cmd->driftturn = (INT16)(cmd->driftturn - (((axis * angleturn[1]) >> 10)));
side += ((axis * sidemove[0]) >> 10);
cmd->angleturn -= (axis * KART_FULLTURN) / JOYAXISRANGE;
side += (axis * sidemove[0]) / JOYAXISRANGE;
}
if (cv_mouseturn.value)
{
//THIS WORKS WTF????????
cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8)));
cmd->driftturn = (INT16)(cmd->driftturn - ((mousex*(encoremode ? -1 : 1)*8)));
cmd->angleturn -= (mousex*(encoremode ? -1 : 1)*8);
}
// Digital users can input diagonal-back for shallow turns.
if (cv_litesteer[forplayer].value && InputDown(gc_aimbackward, ssplayer)
&& abs(cmd->angleturn) == KART_FULLTURN) // My keyboard hits 1024 but my keyboard only hits 1023, video games
{
cmd->angleturn /= 2;
}
if (objectplacing) // SRB2Kart: spectators need special controls // not anymore huehuehue
@@ -1160,10 +1159,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
else if (cmd->angleturn < (-angleturn[1]))
cmd->angleturn = (-angleturn[1]);
if (cmd->driftturn > (angleturn[1]))
cmd->driftturn = (angleturn[1]);
else if (cmd->driftturn < (-angleturn[1]))
cmd->driftturn = (-angleturn[1]);
// until here both are the very same
cmd->driftturn = cmd->angleturn;
if (player->mo)
cmd->angleturn = K_GetKartTurnValue(player, cmd->angleturn);
@@ -1203,7 +1200,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))
{
@@ -1212,12 +1209,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++)
@@ -1254,7 +1251,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);
@@ -2322,12 +2319,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;
}
//
@@ -2346,22 +2337,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;
@@ -2761,7 +2755,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
@@ -2863,17 +2857,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;
}
@@ -3056,6 +3056,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
@@ -3065,8 +3066,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))
@@ -3210,10 +3213,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.
{
@@ -3222,7 +3229,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)
@@ -3359,10 +3368,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)
@@ -3372,6 +3384,7 @@ void G_EndGame(void)
F_StartCredits();
return;
}
if (nextmap == 1101-1) // end game with evaluation
{
F_StartGameEvaluation();
@@ -3456,7 +3469,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);
@@ -3470,9 +3484,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...
@@ -3537,10 +3550,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);
@@ -3751,7 +3765,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"),
@@ -4029,7 +4044,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;
@@ -4054,7 +4069,11 @@ char *G_BuildMapTitle(INT32 mapnum)
title = Z_Malloc(len, PU_STATIC, NULL);
if (!title)
return NULL;
sprintf(title, "%s", mapheaderinfo[mapnum-1]->lvlttl);
if (zonetext) sprintf(title + strlen(title), " %s", zonetext);
if (actnum) sprintf(title + strlen(title), " %s", actnum);
}
@@ -4252,18 +4271,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 */
+2 -1
View File
@@ -72,6 +72,8 @@ extern consvar_t cv_custom3axis[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_xdeadzone[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_ydeadzone[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_litesteer[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_ghost_besttime, cv_ghost_bestlap, cv_ghost_last, cv_ghost_guest, cv_ghost_staff;
// Hud offsets
@@ -153,7 +155,6 @@ typedef enum
// mouseaiming (looking up/down with the mouse or keyboard)
#define KB_LOOKSPEED (1<<25)
#define MAXPLMOVE (50)
#define SLOWTURNTICS (cv_turnsmooth.value * 3)
// build an internal map name MAPxx from map number
const char *G_BuildMapName(INT32 map);
+11 -7
View File
@@ -37,7 +37,13 @@ static CV_PossibleValue_t turnsmooth_cons_t[] = {{2, "Slow"}, {1, "Fast"}, {0, "
consvar_t cv_mousesens = {"mousesens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_mouseysens = {"mouseysens", "20", CV_SAVE, mousesens_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_controlperkey = {"controlperkey", "One", CV_SAVE, onecontrolperkey_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_turnsmooth = {"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS] = {
{"turnsmoothing", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing2", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing3", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL},
{"turnsmoothing4", "Slow", CV_SAVE, turnsmooth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL}
};
static void G_ResetPlayerDeviceRumble(INT32 player);
static void rumble_off_handle(void);
@@ -256,9 +262,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));
}
//
@@ -1027,7 +1030,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;
@@ -1327,14 +1330,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);
+3 -2
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,
@@ -110,7 +110,8 @@ typedef enum
// mouse values are used once
extern consvar_t cv_mousesens, cv_mouseysens;
extern consvar_t cv_controlperkey, cv_turnsmooth;
extern consvar_t cv_controlperkey;
extern consvar_t cv_turnsmooth[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_rumble[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_gamepadled[MAXSPLITSCREENPLAYERS];
+1 -104
View File
@@ -80,14 +80,6 @@ static poly_t *HWR_AllocPoly(INT32 numpts)
return p;
}
static polyvertex_t *HWR_AllocVertex(void)
{
polyvertex_t *p;
size_t size = sizeof(polyvertex_t);
p = Z_Malloc(size, PU_HWRPLANE, NULL);
return p;
}
/// \todo polygons should be freed in reverse order for efficiency,
/// for now don't free because it doesn't free in reverse order
static void HWR_FreePoly(poly_t *poly)
@@ -637,7 +629,7 @@ static void WalkBSPNode(INT32 bspnum, poly_t *poly, UINT16 *leafnode, fixed_t *b
WalkBSPNode(bsp->children[0], frontpoly, &bsp->children[0],bsp->bbox[0]);
// copy child bbox
M_Memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
memcpy(bbox, bsp->bbox[0], 4*sizeof (fixed_t));
}
else
I_Error("WalkBSPNode: no front poly?");
@@ -855,100 +847,6 @@ static INT32 SolveTProblem(void)
return numsplitpoly;
}
#define NEARDIST (0.75f)
#define MYMAX (10000000000000.0f)
/* Adjust true segs (from the segs lump) to be exactely the same as
* plane polygone segs
* This also convert fixed_t point of segs in float (in moste case
* it share the same vertice
*/
static void AdjustSegs(void)
{
size_t i, count;
INT32 j;
seg_t *lseg;
poly_t *p;
INT32 v1found = 0, v2found = 0;
float nearv1, nearv2;
for (i = 0; i < numsubsectors; i++)
{
count = subsectors[i].numlines;
lseg = &segs[subsectors[i].firstline];
p = extrasubsectors[i].planepoly;
if (!p)
continue;
for (; count--; lseg++)
{
float distv1,distv2,tmp;
nearv1 = nearv2 = MYMAX;
// Don't touch polyobject segs. We'll compensate
// for this when we go about drawing them.
if (lseg->polyseg)
continue;
for (j = 0; j < p->numpts; j++)
{
distv1 = p->pts[j].x - FIXED_TO_FLOAT(lseg->v1->x);
tmp = p->pts[j].y - FIXED_TO_FLOAT(lseg->v1->y);
distv1 = distv1*distv1+tmp*tmp;
if (distv1 <= nearv1)
{
v1found = j;
nearv1 = distv1;
}
// the same with v2
distv2 = p->pts[j].x - FIXED_TO_FLOAT(lseg->v2->x);
tmp = p->pts[j].y - FIXED_TO_FLOAT(lseg->v2->y);
distv2 = distv2*distv2+tmp*tmp;
if (distv2 <= nearv2)
{
v2found = j;
nearv2 = distv2;
}
}
if (nearv1 <= NEARDIST*NEARDIST)
// share vertice with segs
lseg->pv1 = &(p->pts[v1found]);
else
{
// BP: here we can do better, using PointInSeg and compute
// the right point position also split a polygone side to
// solve a T-intersection, but too mush work
// convert fixed vertex to float vertex
polyvertex_t *pv = HWR_AllocVertex();
pv->x = FIXED_TO_FLOAT(lseg->v1->x);
pv->y = FIXED_TO_FLOAT(lseg->v1->y);
lseg->pv1 = pv;
}
if (nearv2 <= NEARDIST*NEARDIST)
lseg->pv2 = &(p->pts[v2found]);
else
{
polyvertex_t *pv = HWR_AllocVertex();
pv->x = FIXED_TO_FLOAT(lseg->v2->x);
pv->y = FIXED_TO_FLOAT(lseg->v2->y);
lseg->pv2 = pv;
}
lseg->pv1->x2 = FloatToFixed(lseg->pv1->x);
lseg->pv1->y2 = FloatToFixed(lseg->pv1->y);
lseg->pv2->x2 = FloatToFixed(lseg->pv2->x);
lseg->pv2->y2 = FloatToFixed(lseg->pv2->y);
}
}
}
// call this routine after the BSP of a Doom wad file is loaded,
// and it will generate all the convex polys for the hardware renderer
@@ -1017,7 +915,6 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
#else
SolveTProblem();
#endif
AdjustSegs();
#ifdef DEBUG_HWBSP
//debug debug..
+39 -25
View File
@@ -346,7 +346,7 @@ static void HWR_GenerateTexture(INT32 texnum, GLMapTexture_t *gltex, boolean noe
gltex->mipmap.colormap = Z_Calloc(sizeof(*gltex->mipmap.colormap), PU_HWRPATCHCOLMIPMAP, NULL);
gltex->mipmap.colormap->source = colormap;
M_Memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(gltex->mipmap.colormap->data, colormap, 256 * sizeof(UINT8));
blockwidth = texture->width;
blockheight = texture->height;
@@ -437,8 +437,16 @@ void HWR_MakePatch(const patch_t *patch, GLPatch_t *glPatch, GLMipmap_t *glMipma
// CACHING HANDLING
// =================================================
typedef struct
{
GLMapTexture_t normal;
#ifdef GLENCORE
GLMapTexture_t encore;
#endif
} GLMapTextureSet_t; // idk i suck at naming things
static size_t gl_numtextures = 0; // Texture count
static GLMapTexture_t *gl_textures; // For all textures
static GLMapTextureSet_t *gl_textures; // For all textures
static void HWR_FreeTextureData(patch_t *patch)
{
@@ -578,13 +586,12 @@ void HWR_FreeMapTextures(void)
{
size_t i;
#ifdef GLENCORE
for (i = 0; i < gl_numtextures*2; i++)
#else
for (i = 0; i < gl_numtextures; i++)
#endif
{
FreeMapTexture(&gl_textures[i]);
FreeMapTexture(&gl_textures[i].normal);
#ifdef GLENCORE
FreeMapTexture(&gl_textures[i].encore);
#endif
}
// now the heap don't have any 'user' pointing to our
@@ -603,7 +610,7 @@ static void HWR_PrecacheLevelFlats(void)
// special case for encore
#ifdef GLENCORE
if (encoremode)
if (encoremap)
{
// go through all sectors to determine if it should be remapped for encore
for (i = 0; i < numsectors; i++)
@@ -678,8 +685,6 @@ static void HWR_PrecacheLevelTextures(void)
const line_t *line = &lines[i];
#ifdef GLENCORE
const int noencoremap = ((encoremap && (line->flags & ML_TFERLINE)) ? 2 : 1);
#else
const int noencoremap = 1;
#endif
// two sides
for (j = 0; j < 2; j++)
@@ -695,11 +700,14 @@ static void HWR_PrecacheLevelTextures(void)
for (f = 0; f < 3; f++)
{
const INT32 texnum = sidetex[f];
if (texnum < 0 || texnum >= numtextures || texturepresent[texnum])
continue;
#ifdef GLENCORE
texturepresent[texnum] = 1|noencoremap;
#else
texturepresent[texnum] = 1;
#endif
HWR_GetTexture(texnum, false);
#ifdef GLENCORE
if (noencoremap & 2)
@@ -737,7 +745,7 @@ static void HWR_PrecacheLevelTextures(void)
free(texturepresent);
}
static void HWR_PrecacheLevelSprites(void)
/*static void HWR_PrecacheLevelSprites(void)
{
patch_t *spritepatch;
char *spritepresent;
@@ -800,21 +808,30 @@ static void HWR_PrecacheLevelSprites(void)
}
}
free(spritepresent);
}
}*/
void HWR_PrecacheLevel(void)
{
if (rendermode != render_opengl)
if (gamestate != GS_LEVEL || !cv_precachetextures.value)
return;
// Precache flats.
HWR_PrecacheLevelFlats();
// prevent timeouts
NetKeepAlive();
// Precache textures.
HWR_PrecacheLevelTextures();
// prevent timeouts
NetKeepAlive();
// Precache sprites.
HWR_PrecacheLevelSprites();
//HWR_PrecacheLevelSprites();
// prevent timeouts
//NetKeepAlive();
}
void HWR_LoadMapTextures(size_t pnumtextures)
@@ -823,11 +840,8 @@ void HWR_LoadMapTextures(size_t pnumtextures)
HWR_FreeMapTextures();
gl_numtextures = pnumtextures;
#ifdef GLENCORE
gl_textures = calloc(gl_numtextures, sizeof (*gl_textures)*2); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore)
#else
gl_textures = calloc(gl_numtextures, sizeof (*gl_textures));
#endif
gl_textures = calloc(gl_numtextures, sizeof(*gl_textures)); // *2 - 1 for encore-remapped texture and another for noencore texture (unused when not in encore), see: GLMapTextureSet_t
if (gl_textures == NULL)
I_Error("HWR_LoadMapTextures: ran out of memory for OpenGL textures. Sad!");
}
@@ -851,7 +865,7 @@ GLMapTexture_t *HWR_GetTexture(INT32 tex, boolean noencore)
// Every texture in memory, stored in the
// hardware renderer's bit depth format. Wow!
#ifdef GLENCORE
gltex = &gl_textures[tex*2 + (encoremap && !noencore ? 0 : 1)];
gltex = (encoremap && !noencore) ? &gl_textures[tex].encore : &gl_textures[tex].normal;
#else
gltex = &gl_textures[tex];
#endif
@@ -965,7 +979,7 @@ void HWR_GetFlat(lumpnum_t flatlumpnum, boolean noencoremap)
#endif
glMipmap->colormap = Z_Calloc(sizeof(*glMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
glMipmap->colormap->source = colormap;
M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
}
if (!glMipmap->downloaded)
@@ -1063,7 +1077,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
{
if (memcmp(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)))
{
M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
HWR_UpdatePatchMipmap(patch, glMipmap);
}
else
@@ -1086,7 +1100,7 @@ void HWR_GetMappedPatch(patch_t *patch, const UINT8 *colormap)
newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
newMipmap->colormap->source = colormap;
M_Memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
HWR_LoadPatchMipmap(patch, newMipmap);
}
+6 -7
View File
@@ -80,14 +80,13 @@
typedef struct clipnode_s
{
struct clipnode_s *prev, *next;
angle_t start, end;
} clipnode_t;
{
struct clipnode_s *prev, *next;
angle_t start, end;
} clipnode_t;
clipnode_t *freelist;
clipnode_t *clipnodes;
clipnode_t *cliphead;
static clipnode_t *freelist;
static clipnode_t *cliphead;
static clipnode_t * gld_clipnode_GetNew(void);
static clipnode_t * gld_clipnode_NewRange(angle_t start, angle_t end);
+1 -1
View File
@@ -117,7 +117,7 @@ typedef struct
typedef struct
{
FLOAT x,y,z; // position
FLOAT x, y, z; // position
FLOAT anglex, angley, anglez; // aimingangle / viewangle
FLOAT scalex, scaley, scalez;
FLOAT fovangle;
+30 -223
View File
@@ -31,11 +31,6 @@
#include "../st_stuff.h"
#include <fcntl.h>
#include "../i_video.h" // for rendermode != render_glide
#ifndef O_BINARY
#define O_BINARY 0
#endif
typedef struct
{
@@ -51,75 +46,13 @@ typedef struct
UINT8 image_descriptor; //18
} ATTRPACK TGAHeader; // sizeof is 18
static UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255};
static UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
static UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
static const UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255};
static const UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
static const UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
static const float FLOATBASEVIDWIDTH = (float)BASEVIDWIDTH;
static const float FLOATBASEVIDHEIGHT = (float)BASEVIDHEIGHT;
//
// -----------------+
// HWR_DrawPatch : Draw a 'tile' graphic
// Notes : x,y : positions relative to the original Doom resolution
// : textes(console+score) + menus + status bar
// -----------------+
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option)
{
FOutVector v[4];
FBITFIELD flags;
GLPatch_t *hwrPatch;
// 3--2
// | /|
// |/ |
// 0--1
float sdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
float pdup = FIXED_TO_FLOAT(vid.fdup)*2.0f;
// make patch ready in hardware cache
HWR_GetPatch(gpatch);
hwrPatch = ((GLPatch_t *)gpatch->hardware);
switch (option & V_SCALEPATCHMASK)
{
case V_NOSCALEPATCH:
pdup = 2.0f;
break;
case V_SMALLSCALEPATCH:
pdup = 2.0f * FIXED_TO_FLOAT(vid.smalldup*FRACUNIT);
break;
case V_MEDSCALEPATCH:
pdup = 2.0f * FIXED_TO_FLOAT(vid.meddup*FRACUNIT);
break;
}
if (option & V_NOSCALESTART)
sdup = 2.0f;
v[0].x = v[3].x = (x*sdup-gpatch->leftoffset*pdup)/vid.width - 1;
v[2].x = v[1].x = (x*sdup+(gpatch->width - gpatch->leftoffset)*pdup)/vid.width - 1;
v[0].y = v[1].y = 1-(y*sdup-gpatch->topoffset*pdup)/vid.height;
v[2].y = v[3].y = 1-(y*sdup+(gpatch->height - gpatch->topoffset)*pdup)/vid.height;
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
v[0].s = v[3].s = 0.0f;
v[2].s = v[1].s = hwrPatch->max_s;
v[0].t = v[1].t = 0.0f;
v[2].t = v[3].t = hwrPatch->max_t;
flags = PF_Translucent|PF_NoDepthTest;
if (option & V_WRAPX)
flags |= PF_ForceWrapX;
if (option & V_WRAPY)
flags |= PF_ForceWrapY;
// clip it since it is used for bunny scroll in doom I
GL_DrawPolygon(NULL, v, 4, flags);
}
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags)
{
FOutVector v[4];
@@ -154,15 +87,15 @@ void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t p
switch (option & V_SCALEPATCHMASK)
{
case V_NOSCALEPATCH:
dup = 1.0f;
break;
case V_SMALLSCALEPATCH:
dup = (float)vid.smalldup;
break;
case V_MEDSCALEPATCH:
dup = (float)vid.meddup;
break;
case V_NOSCALEPATCH:
dup = 1.0f;
break;
case V_SMALLSCALEPATCH:
dup = (float)vid.smalldup;
break;
case V_MEDSCALEPATCH:
dup = (float)vid.meddup;
break;
}
fscalew = fscaleh = FIXED_TO_FLOAT(pscale);
@@ -336,15 +269,15 @@ void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale,
switch (option & V_SCALEPATCHMASK)
{
case V_NOSCALEPATCH:
dup = 1.0f;
break;
case V_SMALLSCALEPATCH:
dup = (float)vid.smalldup;
break;
case V_MEDSCALEPATCH:
dup = (float)vid.meddup;
break;
case V_NOSCALEPATCH:
dup = 1.0f;
break;
case V_SMALLSCALEPATCH:
dup = (float)vid.smalldup;
break;
case V_MEDSCALEPATCH:
dup = (float)vid.meddup;
break;
}
fscale = FIXED_TO_FLOAT(pscale);
@@ -573,7 +506,7 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
if (color & 0xFF00) // Do COLORMAP fade.
{
if (HWR_ShouldUsePaletteRendering() && cv_glscreentextures.value)
if (cv_glscreentextures.value && HWR_ShouldUsePaletteRendering())
{
const hwdscreentexture_t scr_tex = HWD_SCREENTEXTURE_GENERIC2;
@@ -585,12 +518,10 @@ void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
GL_UnSetShader();
return;
}
else
{
Surf.PolyColor.rgba = UINT2RGBA(0x01010160);
Surf.PolyColor.s.alpha = (strength*8);
poly_flags |= PF_Translucent;
}
Surf.PolyColor.rgba = UINT2RGBA(0x01010160);
Surf.PolyColor.s.alpha = (strength*8);
poly_flags |= PF_Translucent;
}
else // Do TRANSMAP** fade.
{
@@ -636,133 +567,6 @@ void HWR_DrawConsoleBack(UINT32 color, INT32 height)
}
// ==========================================================================
// R_DRAW.C STUFF
// ==========================================================================
// ------------------
// HWR_DrawViewBorder
// Fill the space around the view window with a Doom flat texture, draw the
// beveled edges.
// 'clearlines' is useful to clear the heads up messages, when the view
// window is reduced, it doesn't refresh all the view borders.
// ------------------
void HWR_DrawViewBorder(INT32 clearlines)
{
INT32 x, y;
INT32 top, side;
INT32 baseviewwidth, baseviewheight;
INT32 basewindowx, basewindowy;
patch_t *patch;
if (!clearlines)
clearlines = BASEVIDHEIGHT; // refresh all
// calc view size based on original game resolution
baseviewwidth = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewwidth), vid.fdup)); //(cv_viewsize.value * BASEVIDWIDTH/10)&~7;
baseviewheight = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_viewheight), vid.fdup));
top = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowy), vid.fdup));
side = FixedInt(FixedDiv(FLOAT_TO_FIXED(gl_baseviewwindowx), vid.fdup));
// top
HWR_DrawFlatFill(0, 0,
BASEVIDWIDTH, (top < clearlines ? top : clearlines),
st_borderpatchnum);
// left
if (top < clearlines)
HWR_DrawFlatFill(0, top, side,
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
st_borderpatchnum);
// right
if (top < clearlines)
HWR_DrawFlatFill(side + baseviewwidth, top, side,
(clearlines-top < baseviewheight ? clearlines-top : baseviewheight),
st_borderpatchnum);
// bottom
if (top + baseviewheight < clearlines)
HWR_DrawFlatFill(0, top + baseviewheight,
BASEVIDWIDTH, BASEVIDHEIGHT, st_borderpatchnum);
//
// draw the view borders
//
basewindowx = (BASEVIDWIDTH - baseviewwidth)>>1;
if (baseviewwidth == BASEVIDWIDTH)
basewindowy = 0;
else
basewindowy = top;
// top edge
if (clearlines > basewindowy - 8)
{
patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x, basewindowy - 8,
0);
}
// bottom edge
if (clearlines > basewindowy + baseviewheight)
{
patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x,
basewindowy + baseviewheight, 0);
}
// left edge
if (clearlines > basewindowy)
{
patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy + y < clearlines;
y += 8)
{
HWR_DrawPatch(patch, basewindowx - 8, basewindowy + y,
0);
}
}
// right edge
if (clearlines > basewindowy)
{
patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy+y < clearlines;
y += 8)
{
HWR_DrawPatch(patch, basewindowx + baseviewwidth,
basewindowy + y, 0);
}
}
// Draw beveled corners.
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TL],
PU_PATCH),
basewindowx - 8, basewindowy - 8, 0);
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TR],
PU_PATCH),
basewindowx + baseviewwidth, basewindowy - 8, 0);
if (clearlines > basewindowy+baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BL],
PU_PATCH),
basewindowx - 8, basewindowy + baseviewheight, 0);
if (clearlines > basewindowy + baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BR],
PU_PATCH),
basewindowx + baseviewwidth,
basewindowy + baseviewheight, 0);
}
// ==========================================================================
// AM_MAP.C DRAWING STUFF
// ==========================================================================
@@ -1084,11 +888,13 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
if (fx >= vid.width || fy >= vid.height)
return;
if (fx < 0)
{
fw += fx;
fx = 0;
}
if (fy < 0)
{
fh += fy;
@@ -1100,6 +906,7 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
if (fx + fw > vid.width)
fw = fvw - fx;
if (fy + fh > vid.height)
fh = fvh - fy;
@@ -1168,7 +975,7 @@ static inline boolean saveTGA(const char *file_name, void *buffer,
INT32 i;
UINT8 *buf8 = buffer;
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
return false;
+93 -178
View File
@@ -65,8 +65,6 @@
// Globals
// ==========================================================================
#define ABS(x) ((x) < 0 ? -(x) : (x))
// false if shaders have not been initialized yet, or if shaders are not available
boolean gl_shadersavailable = false;
@@ -77,24 +75,19 @@ boolean gl_drawing_stencil = false;
static INT32 current_bsp_culling_distance = 0;
// base values set at SetViewSize
float gl_baseviewwindowy, gl_baseviewwindowx;
static float gl_viewwindowy, gl_viewwindowx; // top left corner of view window
float gl_viewwidth, gl_viewheight; // viewport clipping boundaries (screen coords)
FTransform atransform;
FTransform atransform = {};
// Float variants of viewx, viewy, viewz, etc.
static float gl_viewx, gl_viewy, gl_viewz;
float gl_viewsin, gl_viewcos;
float gl_viewsin = 0.0f, gl_viewcos = 0.0f;
static float gl_viewludsin, gl_viewludcos;
static angle_t gl_aimingangle;
seg_t *gl_curline;
side_t *gl_sidedef;
line_t *gl_linedef;
sector_t *gl_frontsector;
sector_t *gl_backsector;
seg_t *gl_curline = NULL;
side_t *gl_sidedef = NULL;
line_t *gl_linedef = NULL;
sector_t *gl_frontsector = NULL;
sector_t *gl_backsector = NULL;
// values for the far clipping plane
static constexpr float clipping_distances[] = {1024.0f, 2048.0f, 4096.0f, 6144.0f, 8192.0f, 12288.0f, 16384.0f};
@@ -284,6 +277,7 @@ static void CV_glshaders_OnChange(void)
{
// can't do palette rendering without shaders, so update the state if needed
HWR_TogglePaletteRendering();
HWR_PrecacheLevel();
}
M_UpdateOGLMenu();
}
@@ -301,18 +295,21 @@ static void CV_gltextureformat_OnChange(void)
{
ONLY_IF_GL_LOADED
GL_SetSpecialState(HWD_SET_TEXTURE_FORMAT, cv_gltexturedepth.value);
HWR_PrecacheLevel();
}
static void CV_filtermode_OnChange(void)
{
ONLY_IF_GL_LOADED
GL_SetSpecialState(HWD_SET_TEXTUREFILTERMODE, cv_glfiltermode.value);
HWR_PrecacheLevel();
}
static void CV_anisotropic_OnChange(void)
{
ONLY_IF_GL_LOADED
GL_SetSpecialState(HWD_SET_TEXTUREANISOTROPICMODE, cv_glanisotropicmode.value);
HWR_PrecacheLevel();
}
static void CV_glpaletterendering_OnChange(void)
@@ -325,7 +322,9 @@ static void CV_glpaletterendering_OnChange(void)
{
HWR_CompileShaders();
HWR_TogglePaletteRendering();
HWR_PrecacheLevel();
}
M_UpdateOGLMenu();
}
@@ -459,8 +458,8 @@ void HWR_Lighting(FSurfaceInfo *Surface, INT32 light_level, extracolormap_t *col
// in palette rendering mode, this is not needed since it properly takes the changes to the palette itself
if (!HWR_ShouldUsePaletteRendering())
{
V_CubeApply(&tint_color.s.red, &tint_color.s.green, &tint_color.s.blue);
V_CubeApply(&fade_color.s.red, &fade_color.s.green, &fade_color.s.blue);
V_CubeApply(&tint_color);
V_CubeApply(&fade_color);
}
Surface->PolyColor.rgba = poly_color.rgba;
@@ -729,6 +728,9 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
for (i = 0; i < subsector->numlines; i++, line++)
{
if (line->polyseg)
continue;
line_t* ld = line->linedef;
// this check sucks and is a hotspot lel
@@ -741,27 +743,11 @@ static void HWR_RenderPlane(subsector_t *subsector, extrasubsector_t *xsub, bool
P_ClosestPointOnLine(viewx, viewy, ld, &v);
dist = FixedToFloat(R_PointToDist(v.x, v.y));
if (line->pv1)
{
x1 = line->pv1->x;
y1 = line->pv1->y;
}
else
{
x1 = FixedToFloat(line->v1->x);
y1 = FixedToFloat(line->v1->y);
}
x1 = (line->fv1.x);
y1 = (line->fv1.y);
if (line->pv2)
{
xd = line->pv2->x - x1;
yd = line->pv2->y - y1;
}
else
{
xd = FixedToFloat(line->v2->x) - x1;
yd = FixedToFloat(line->v2->y) - y1;
}
xd = (line->fv2.x) - x1;
yd = (line->fv2.y) - y1;
// Based on the seg length and the distance from the line, split horizon into multiple poly sets to reduce distortion
dist = sqrtf((xd*xd) + (yd*yd)) / dist / 16.0f;
@@ -825,11 +811,11 @@ static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf)
M_ClearBox(segbbox);
M_AddToBox(segbbox,
FloatToFixed(gl_curline->pv1->x),
FloatToFixed(gl_curline->pv1->y));
FloatToFixed(gl_curline->fv1.x),
FloatToFixed(gl_curline->fv1.y));
M_AddToBox(segbbox,
FloatToFixed(gl_curline->pv2->x),
FloatToFixed(gl_curline->pv2->y));
FloatToFixed(gl_curline->fv2.x),
FloatToFixed(gl_curline->fv2.y));
splat = (wallsplat_t *)gl_curline->linedef->splats;
for (; splat; splat = splat->next)
@@ -1238,7 +1224,7 @@ static void HWR_DrawSkyWall(FOutVector *wallVerts, FSurfaceInfo *Surf)
// Returns true if the midtexture is visible, and false if... it isn't...
static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
{
FUINT blendmode = PF_Masked;
FUINT blendmode = PF_Masked | PF_Translucent;
pSurf->PolyColor.s.alpha = 0xFF;
@@ -1260,8 +1246,6 @@ static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
case 256:
if (gl_linedef->blendmode)
blendmode = HWR_SurfaceBlend(gl_linedef->blendmode, R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
else
blendmode = PF_Translucent;
break;
default:
if (gl_linedef->blendmode)
@@ -1273,8 +1257,6 @@ static inline boolean HWR_BlendMidtextureSurface(FSurfaceInfo *pSurf)
}
else if (gl_linedef->alpha >= 0 && gl_linedef->alpha < FRACUNIT)
blendmode = HWR_TranstableToAlpha(R_GetLinedefTransTable(gl_linedef->alpha), pSurf);
else
blendmode = PF_Masked;
break;
}
}
@@ -1324,34 +1306,24 @@ void HWR_ProcessSeg(void) // Sort of like GLWall::Process in GZDoom
const boolean noencore = (gl_linedef->flags & ML_TFERLINE);
if (LIKELY(gl_curline->pv1))
{
vs.x = gl_curline->pv1->x;
vs.y = gl_curline->pv1->y;
v1x = gl_curline->pv1->x2;
v1y = gl_curline->pv1->y2;
}
else
{
vs.x = FixedToFloat(gl_curline->v1->x);
vs.y = FixedToFloat(gl_curline->v1->y);
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
}
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
if (LIKELY(gl_curline->pv2))
if (gl_curline->polyseg)
{
ve.x = gl_curline->pv2->x;
ve.y = gl_curline->pv2->y;
v2x = gl_curline->pv2->x2;
v2y = gl_curline->pv2->y2;
vs.x = FixedToFloat(v1x);
vs.y = FixedToFloat(v1y);
ve.x = FixedToFloat(v2x);
ve.y = FixedToFloat(v2y);
}
else
{
ve.x = FixedToFloat(gl_curline->v2->x);
ve.y = FixedToFloat(gl_curline->v2->y);
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
vs.x = gl_curline->fv1.x;
vs.y = gl_curline->fv1.y;
ve.x = gl_curline->fv2.x;
ve.y = gl_curline->fv2.y;
}
#define SLOPEPARAMS(slope, end1, end2, normalheight) \
@@ -2203,27 +2175,11 @@ static boolean CheckClip(sector_t * afrontsector, sector_t * abacksector)
{
fixed_t v1x, v1y, v2x, v2y; // the seg's vertexes as fixed_t
if (LIKELY(gl_curline->pv1))
{
v1x = gl_curline->pv1->x2;
v1y = gl_curline->pv1->y2;
}
else
{
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
}
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
if (LIKELY(gl_curline->pv2))
{
v2x = gl_curline->pv2->x2;
v2y = gl_curline->pv2->y2;
}
else
{
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
}
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
#define SLOPEPARAMS(slope, end1, end2, normalheight) \
end1 = P_GetZAt(slope, v1x, v1y, normalheight); \
@@ -2428,27 +2384,11 @@ static void HWR_AddLine(seg_t *line)
gl_curline = line;
if (LIKELY(gl_curline->pv1))
{
v1x = gl_curline->pv1->x2;
v1y = gl_curline->pv1->y2;
}
else
{
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
}
v1x = gl_curline->v1->x;
v1y = gl_curline->v1->y;
if (LIKELY(gl_curline->pv2))
{
v2x = gl_curline->pv2->x2;
v2y = gl_curline->pv2->y2;
}
else
{
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
}
v2x = gl_curline->v2->x;
v2y = gl_curline->v2->y;
// OPTIMIZE: quickly reject orthogonal back sides.
angle1 = R_PointToAngle64(v1x, v1y);
@@ -3377,6 +3317,9 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
fixed_t slopez;
float offset = 0;
if (!spr->mobj)
return;
R_GetShadowZ(spr->mobj, &floorslope);
mobjfloor = HWR_OpaqueFloorAtPos(
@@ -3388,14 +3331,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
angle_t shadowdir;
// Set direction
if (splitscreen && R_GetViewNumber() == 1)
shadowdir = localangle[1] + FixedAngle(cv_cam_rotate[1].value);
else if (splitscreen > 1 && R_GetViewNumber() == 2)
shadowdir = localangle[2] + FixedAngle(cv_cam_rotate[2].value);
else if (splitscreen > 2 && R_GetViewNumber() == 3)
shadowdir = localangle[3] + FixedAngle(cv_cam_rotate[3].value);
else
shadowdir = localangle[0] + FixedAngle(cv_cam_rotate[0].value);
shadowdir = localangle[viewssnum] + FixedAngle(cv_cam_rotate[viewssnum].value);
// Find floorheight
floorheight = HWR_OpaqueFloorAtPos(
@@ -3407,18 +3343,17 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
// Don't draw it, then!
if (spr->mobj->z < floorheight)
return;
else
{
fixed_t floorz;
floorz = HWR_OpaqueFloorAtPos(
spr->mobj->x + P_ReturnThrustX(spr->mobj, shadowdir, spr->mobj->z - floorheight),
spr->mobj->y + P_ReturnThrustY(spr->mobj, shadowdir, spr->mobj->z - floorheight),
spr->mobj->z, spr->mobj->height);
// The shadow would be falling on a wall? Don't draw it, then.
// Would draw midair otherwise.
if (floorz < floorheight)
return;
}
fixed_t floorz;
floorz = HWR_OpaqueFloorAtPos(
spr->mobj->x + P_ReturnThrustX(spr->mobj, shadowdir, spr->mobj->z - floorheight),
spr->mobj->y + P_ReturnThrustY(spr->mobj, shadowdir, spr->mobj->z - floorheight),
spr->mobj->z, spr->mobj->height);
// The shadow would be falling on a wall? Don't draw it, then.
// Would draw midair otherwise.
if (floorz < floorheight)
return;
floorheight = FixedInt(spr->mobj->z - floorheight);
@@ -3428,12 +3363,11 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
floorheight = FixedInt(spr->mobj->z - mobjfloor);
// technically this_scale gets multiplied and added to sprite y/x scale, but this thing needs it for some crap so ill just throw it in here again
const boolean hires = (spr->mobj && spr->mobj->skin && K_GetMobjSkin(spr->mobj)->flags & SF_HIRES);
this_scale = FixedToFloat(spr->mobj->scale);
if (spr->mobj)
this_scale = FixedToFloat(spr->mobj->scale);
if (hires)
this_scale = this_scale * FixedToFloat(K_GetMobjSkin(spr->mobj)->highresscale);
const skin_t *moskin = K_GetMobjSkin(spr->mobj);
if (moskin && moskin->flags & SF_HIRES)
this_scale *= FixedToFloat(moskin->highresscale);
// create the sprite billboard
//
@@ -3540,7 +3474,7 @@ static void HWR_DrawSpriteShadow(gl_vissprite_t *spr, patch_t *gpatch, GLPatch_t
// This is expecting a pointer to an array containing 4 wallVerts for a sprite
static void HWR_RotateSpritePolyToAim(gl_vissprite_t *spr, FOutVector *wallVerts, const boolean precip, const boolean papersprite)
{
if (!cv_glspritebillboarding.value || papersprite)
if (!cv_glspritebillboarding.value || cv_glshearing.value || papersprite)
{
return;
}
@@ -4054,7 +3988,7 @@ static void HWR_DrawPrecipitationSprite(gl_vissprite_t *spr)
const precipmobj_t *sprmo = spr->precip;
if (UNLIKELY(!sprmo || !sprmo->subsector))
if (UNLIKELY(!sprmo->subsector))
return;
// cache sprite graphics
@@ -4287,8 +4221,8 @@ static void HWR_AddTransparentWall(FOutVector *wallVerts, FSurfaceInfo *pSurf, I
{
wallinfo_t *wallinfo = static_cast<wallinfo_t*>(HWR_CreateDrawNode(DRAWNODE_WALL));
M_Memcpy(wallinfo->wallVerts, wallVerts, sizeof (wallinfo->wallVerts));
M_Memcpy(&wallinfo->Surf, pSurf, sizeof (FSurfaceInfo));
memcpy(wallinfo->wallVerts, wallVerts, sizeof (wallinfo->wallVerts));
memcpy(&wallinfo->Surf, pSurf, sizeof (FSurfaceInfo));
wallinfo->texnum = texnum;
wallinfo->noencore = noencore;
wallinfo->blend = blend;
@@ -4335,7 +4269,7 @@ static int CompareDrawNodePlanes(const void *p1, const void *p2)
const INT32 n1 = *(const INT32*)p1;
const INT32 n2 = *(const INT32*)p2;
return ABS(drawnodes[n2].u.plane.fixedheight - viewz) - ABS(drawnodes[n1].u.plane.fixedheight - viewz);
return abs(drawnodes[n2].u.plane.fixedheight - viewz) - abs(drawnodes[n1].u.plane.fixedheight - viewz);
}
//
@@ -5316,10 +5250,10 @@ static void HWR_DrawSkyBackground(void)
// -----------------+
static inline void HWR_ClearView(void)
{
GL_GClipRect((INT32)gl_viewwindowx,
(INT32)gl_viewwindowy,
(INT32)(gl_viewwindowx + gl_viewwidth),
(INT32)(gl_viewwindowy + gl_viewheight),
GL_GClipRect(viewwindowx,
viewwindowy,
(viewwindowx + viewwidth),
(viewwindowy + viewheight),
ZCLIP_PLANE, FAR_ZCLIP_DEFAULT);
GL_ClearBuffer(false, true, true, NULL);
}
@@ -5329,19 +5263,6 @@ static inline void HWR_ClearView(void)
// -----------------+
void HWR_SetViewSize(void)
{
// setup view size
gl_viewwidth = (float)vid.width;
gl_viewheight = (float)vid.height;
if (splitscreen)
gl_viewheight /= 2;
if (splitscreen > 1)
gl_viewwidth /= 2;
gl_baseviewwindowy = 0;
gl_baseviewwindowx = 0;
GL_FlushScreenTextures();
}
@@ -5352,7 +5273,9 @@ static void HWR_SetTransformAiming(FTransform *trans)
if (cv_glshearing.value)
{
fixed_t fixedaiming = AIMINGTODY(aimingangle);
trans->viewaiming = FixedToFloat(fixedaiming);
trans->viewaiming = FixedToFloat(fixedaiming) * ((float)vid.width / vid.height) / ((float)BASEVIDWIDTH / BASEVIDHEIGHT);
if (splitscreen == 1) // only for 2 player splitscreen
trans->viewaiming *= 2.125; // splitscreen adjusts fov with 0.8, so compensate (but only halfway, since splitscreen means only half the screen is used)
trans->shearing = true;
gl_aimingangle = 0;
}
@@ -5387,8 +5310,12 @@ void HWR_SetTransform(float fpov)
HWR_SetTransformAiming(&atransform);
atransform.angley = (float)(viewangle>>ANGLETOFINESHIFT)*(FINEDEGREE);
gl_viewludsin = FixedToFloat(FINECOSINE(gl_aimingangle>>ANGLETOFINESHIFT));
gl_viewludcos = FixedToFloat(-FINESINE(gl_aimingangle>>ANGLETOFINESHIFT));
// only needed for sprite billboarding
if (cv_glspritebillboarding.value && !cv_glshearing.value)
{
gl_viewludsin = FixedToFloat(FINECOSINE(gl_aimingangle>>ANGLETOFINESHIFT));
gl_viewludcos = FixedToFloat(-FINESINE(gl_aimingangle>>ANGLETOFINESHIFT));
}
atransform.fovangle = fpov; // Tails
HWR_RollTransform(&atransform, viewroll);
@@ -5404,7 +5331,9 @@ void HWR_SetTransform(float fpov)
atransform.fliptype = TRANSFORM_FLIP;
}
else if (postimg & POSTIMG_MIRROR)
{
atransform.fliptype = TRANSFORM_MIRROR;
}
// Set transform.
GL_SetTransform(&atransform);
@@ -5594,20 +5523,6 @@ extern "C" {
// ==========================================================================
static void HWR_RenderFrame(player_t *player, boolean skybox)
{
// set window position
gl_viewwindowx = gl_baseviewwindowx;
gl_viewwindowy = gl_baseviewwindowy;
if ((splitscreen == 1 && viewssnum == 1) || (splitscreen > 1 && viewssnum > 1))
{
gl_viewwindowy += gl_viewheight;
}
if (splitscreen > 1 && viewssnum & 1)
{
gl_viewwindowx += gl_viewwidth;
}
// check for new console commands.
NetUpdate();
@@ -5623,10 +5538,10 @@ static void HWR_RenderFrame(player_t *player, boolean skybox)
if (!skybox && cv_glrenderdistance.value)
{
GL_GClipRect((INT32)gl_viewwindowx,
(INT32)gl_viewwindowy,
(INT32)(gl_viewwindowx + gl_viewwidth),
(INT32)(gl_viewwindowy + gl_viewheight),
GL_GClipRect(viewwindowx,
viewwindowy,
(viewwindowx + viewwidth),
(viewwindowy + viewheight),
ZCLIP_PLANE, clipping_distances[cv_glrenderdistance.value - 1]);
current_bsp_culling_distance = bsp_culling_distances[cv_glrenderdistance.value - 1];
}
@@ -5872,7 +5787,7 @@ static void COM_HWR_glinfo(void)
{
argv = COM_Argv(i);
if (strcmp(argv, "--list-extensions") == 0 || strcmp(argv, "-l") == 0)
if (fastcmp(argv, "--list-extensions")|| fastcmp(argv, "-l"))
{
list_extensions = 1;
}
@@ -5994,7 +5909,7 @@ static void HWR_DoPostProcessor(player_t *player)
Surf.PolyColor.s.alpha = 0xc0; // match software mode
V_CubeApply(&Surf.PolyColor.s.red, &Surf.PolyColor.s.green, &Surf.PolyColor.s.blue);
V_CubeApply(&Surf.PolyColor);
GL_DrawPolygon(&Surf, v, 4, PF_Modulated|PF_Translucent|PF_NoTexture|PF_NoDepthTest);
}
-6
View File
@@ -42,10 +42,6 @@ extern "C" {
void HWR_Startup(void);
void HWR_Shutdown(void);
extern float gl_viewwidth, gl_viewheight, gl_baseviewwindowx, gl_baseviewwindowy;
extern float gl_basewindowcenterx, gl_basewindowcentery;
extern unsigned msaa;
extern boolean a2c;
@@ -89,7 +85,6 @@ extern ps_metric_t ps_hw_batchdrawtime;
extern boolean gl_shadersavailable;
// hw_draw.c
void HWR_DrawPatch(patch_t *gpatch, INT32 x, INT32 y, INT32 option);
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags);
void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, INT32 option, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h);
void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color);
@@ -98,7 +93,6 @@ void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color);
void HWR_drawAMline(const fline_t *fl, INT32 color);
void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength);
void HWR_DrawConsoleBack(UINT32 color, INT32 height);
void HWR_DrawViewBorder(INT32 clearlines);
void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum);
UINT8 *HWR_GetScreenshot(INT32 scale);
+13 -12
View File
@@ -72,10 +72,9 @@
#include <errno.h>
#endif
md2_t md2_models[NUMSPRITES];
md2_t md2_playermodels[MAXSKINS];
md2_t md2_localplayermodels[MAXLOCALSKINS];
md2_t md2_models[NUMSPRITES] = {};
md2_t md2_playermodels[MAXSKINS] = {};
md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
/*
* free model
@@ -417,7 +416,7 @@ static void md2_loadTexture(md2_t *model)
size = w*h;
while (size--)
{
V_CubeApply(&image->s.red, &image->s.green, &image->s.blue);
V_CubeApply(image);
image++;
}
}
@@ -549,7 +548,7 @@ void HWR_InitMD2(void)
{
for (i = 0; i < NUMSPRITES; i++)
{
if (stricmp(name, sprnames[i]) == 0)
if (fasticmp(name, sprnames[i]))
{
md2_models[i].scale = scale;
md2_models[i].offset = offset;
@@ -561,7 +560,7 @@ void HWR_InitMD2(void)
for (s = 0; s < MAXSKINS; s++)
{
if (stricmp(name, skins[s].name) == 0)
if (fasticmp(name, skins[s].name))
{
md2_playermodels[s].skin = s;
md2_playermodels[s].scale = scale;
@@ -607,11 +606,12 @@ void HWR_AddPlayerMD2(int skin, boolean local) // For MD2's that were added afte
}
}
md2s = ( (local) ? md2_localplayermodels : md2_playermodels );
md2s = (local ? md2_localplayermodels : md2_playermodels);
// Check for any MD2s that match the names of player skins!
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
{
if (stricmp(name, K_GetSkinArray(local)[skin].name) == 0)
if (fasticmp(name, K_GetSkinArray(local)[skin].name))
{
md2s[skin].skin = skin;
md2s[skin].scale = scale;
@@ -650,6 +650,7 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
if (!f)
{
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
if (!f)
{
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
@@ -661,7 +662,7 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
// Check for any MD2s that match the names of sprite names!
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
{
if (stricmp(name, sprnames[spritenum]) == 0)
if (fasticmp(name, sprnames[spritenum]))
{
md2_models[spritenum].scale = scale;
md2_models[spritenum].offset = offset;
@@ -1056,7 +1057,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
{
if (memcmp(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)))
{
M_Memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
HWR_CreateBlendedTexture(patch, blendgpatch, glMipmap, skinnum, color);
GL_UpdateTexture(glMipmap);
}
@@ -1083,7 +1084,7 @@ static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 sk
newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
newMipmap->colormap->source = colormap;
M_Memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
HWR_CreateBlendedTexture(patch, blendgpatch, newMipmap, skinnum, color);
+10 -155
View File
@@ -114,7 +114,6 @@ void UnloadModel(model_t *model)
if (model->materials)
Z_Free(model->materials);
DeleteVBOs(model);
Z_Free(model);
}
@@ -127,7 +126,7 @@ tag_t *GetTagByName(model_t *model, char *name, int frame)
int i;
for (i = 0; i < model->numTags; i++)
{
if (!stricmp(iterator[i].name, name))
if (fasticmp(iterator[i].name, name))
return &iterator[i];
}
}
@@ -164,22 +163,22 @@ model_t *LoadModel(const char *filename, int ztag)
return NULL;
}
if (!strcmp(extension, ".md3"))
if (fastcmp(extension, ".md3"))
{
if (!(model = MD3_LoadModel(filename, ztag, false)))
return NULL;
}
else if (!strcmp(extension, ".md3s")) // MD3 that will be converted in memory to use full floats
else if (fastcmp(extension, ".md3s")) // MD3 that will be converted in memory to use full floats
{
if (!(model = MD3_LoadModel(filename, ztag, true)))
return NULL;
}
else if (!strcmp(extension, ".md2"))
else if (fastcmp(extension, ".md2"))
{
if (!(model = MD2_LoadModel(filename, ztag, false)))
return NULL;
}
else if (!strcmp(extension, ".md2s"))
else if (fastcmp(extension, ".md2s"))
{
if (!(model = MD2_LoadModel(filename, ztag, true)))
return NULL;
@@ -194,7 +193,6 @@ model_t *LoadModel(const char *filename, int ztag)
strcpy(model->mdlFilename, filename);
Optimize(model);
GeneratePolygonNormals(model, ztag);
// Default material properties
for (i = 0 ; i < model->numMaterials; i++)
@@ -244,14 +242,7 @@ void GenerateVertexNormals(model_t *model)
float *vertPtr = frame->vertices;
float *oldNormals;
M_Memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
/* if (!systemSucks)
{
memTag = Z_GetTag(frame->tangents);
float *newTangents = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag);
M_Memcpy(newTangents, frame->tangents, sizeof(float)*3*mesh->numTriangles*3);
}*/
memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
for (k = 0; k < mesh->numVertices; k++)
{
@@ -288,32 +279,15 @@ void GenerateVertexNormals(model_t *model)
if (vCount > 1)
{
// Vector::Normalize(&normal);
newNormals[3 * k + 0] = (float)normal.x;
newNormals[3 * k + 1] = (float)normal.y;
newNormals[3 * k + 2] = (float)normal.z;
/* if (!systemSucks)
{
Vector::vector_t tangent;
Vector::Tangent(&normal, &tangent);
newTangents[3 * k + 0] = tangent.x;
newTangents[3 * k + 1] = tangent.y;
newTangents[3 * k + 2] = tangent.z;
}*/
}
}
oldNormals = frame->normals;
frame->normals = newNormals;
Z_Free(oldNormals);
/* if (!systemSucks)
{
float *oldTangents = frame->tangents;
frame->tangents = newTangents;
Z_Free(oldTangents);
}*/
}
}
}
@@ -404,15 +378,11 @@ void Optimize(model_t *model)
newMesh->numTriangles = numTriangles;
newMesh->numVertices = numTriangles * 3;
newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
// if (node->material->lightmap)
// newMesh->lightuvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
curFrame = &newMesh->frames[0];
curFrame->material = curMat;
curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
// if (!systemSucks)
// curFrame->tangents = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, 0);
@@ -432,39 +402,24 @@ void Optimize(model_t *model)
char *destByte;
char *srcByte;
M_Memcpy(&newMesh->uvs[uvCount],
memcpy(&newMesh->uvs[uvCount],
curMesh->uvs,
sizeof(float)*2*curMesh->numTriangles*3);
/* if (node->material->lightmap)
{
M_Memcpy(&newMesh->lightuvs[uvCount],
curMesh->lightuvs,
sizeof(float)*2*curMesh->numTriangles*3);
}*/
uvCount += 2*curMesh->numTriangles*3;
dest = (float*)newMesh->frames[0].vertices;
src = (float*)curMesh->frames[0].vertices;
M_Memcpy(&dest[vertCount],
memcpy(&dest[vertCount],
src,
sizeof(float)*3*curMesh->numTriangles*3);
dest = (float*)newMesh->frames[0].normals;
src = (float*)curMesh->frames[0].normals;
M_Memcpy(&dest[vertCount],
memcpy(&dest[vertCount],
src,
sizeof(float)*3*curMesh->numTriangles*3);
/* if (!systemSucks)
{
dest = (float*)newMesh->frames[0].tangents;
src = (float*)curMesh->frames[0].tangents;
M_Memcpy(&dest[vertCount],
src,
sizeof(float)*3*curMesh->numTriangles*3);
}*/
vertCount += 3 * curMesh->numTriangles * 3;
destByte = (char*)newMesh->frames[0].colors;
@@ -472,7 +427,7 @@ void Optimize(model_t *model)
if (srcByte)
{
M_Memcpy(&destByte[colorCount],
memcpy(&destByte[colorCount],
srcByte,
sizeof(char)*4*curMesh->numTriangles*3);
}
@@ -494,103 +449,3 @@ void Optimize(model_t *model)
model->meshes = newMeshes;
model->numMeshes = numMeshes;
}
void GeneratePolygonNormals(model_t *model, int ztag)
{
int i;
for (i = 0; i < model->numMeshes; i++)
{
int j;
mesh_t *mesh = &model->meshes[i];
if (!mesh->frames)
continue;
for (j = 0; j < mesh->numFrames; j++)
{
int k;
mdlframe_t *frame = &mesh->frames[j];
const float *vertices = frame->vertices;
vector_t *polyNormals;
frame->polyNormals = (vector_t*)Z_Malloc(sizeof(vector_t) * mesh->numTriangles, ztag, 0);
polyNormals = frame->polyNormals;
for (k = 0; k < mesh->numTriangles; k++)
{
/// TODO: normalize vectors
(void)vertices;
(void)polyNormals;
// Vector::Normal(vertices, polyNormals);
vertices += 3 * 3;
polyNormals++;
}
}
}
}
//
// Reload
//
// Reload VBOs
//
#if 0
static void Reload(void)
{
/* model_t *node;
for (node = modelHead; node; node = node->next)
{
int i;
for (i = 0; i < node->numMeshes; i++)
{
mesh_t *mesh = &node->meshes[i];
if (mesh->frames)
{
int j;
for (j = 0; j < mesh->numFrames; j++)
CreateVBO(mesh, &mesh->frames[j]);
}
else if (mesh->tinyframes)
{
int j;
for (j = 0; j < mesh->numFrames; j++)
CreateVBO(mesh, &mesh->tinyframes[j]);
}
}
}*/
}
#endif
void DeleteVBOs(model_t *model)
{
(void)model;
/* for (int i = 0; i < model->numMeshes; i++)
{
mesh_t *mesh = &model->meshes[i];
if (mesh->frames)
{
for (int j = 0; j < mesh->numFrames; j++)
{
mdlframe_t *frame = &mesh->frames[j];
if (!frame->vboID)
continue;
bglDeleteBuffers(1, &frame->vboID);
frame->vboID = 0;
}
}
else if (mesh->tinyframes)
{
for (int j = 0; j < mesh->numFrames; j++)
{
tinyframe_t *frame = &mesh->tinyframes[j];
if (!frame->vboID)
continue;
bglDeleteBuffers(1, &frame->vboID);
frame->vboID = 0;
}
}
}*/
}
-6
View File
@@ -28,8 +28,6 @@ typedef struct
float ambient[4], diffuse[4], specular[4], emissive[4];
float shininess;
boolean spheremap;
// Texture::texture_t *texture;
// Texture::texture_t *lightmap;
} material_t;
typedef struct
@@ -40,7 +38,6 @@ typedef struct
float *tangents;
char *colors;
unsigned int vboID;
vector_t *polyNormals;
} mdlframe_t;
typedef struct
@@ -70,7 +67,6 @@ typedef struct mesh_s
typedef struct tag_s
{
char name[64];
// matrix_t transform;
} tag_t;
typedef struct model_s
@@ -96,9 +92,7 @@ model_t *LoadModel(const char *filename, int ztag);
void UnloadModel(model_t *model);
void Optimize(model_t *model);
void GenerateVertexNormals(model_t *model);
void GeneratePolygonNormals(model_t *model, int ztag);
void CreateVBOTiny(mesh_t *mesh, tinyframe_t *frame);
void CreateVBO(mesh_t *mesh, mdlframe_t *frame);
void DeleteVBOs(model_t *model);
#endif
+3 -1
View File
@@ -30,7 +30,7 @@
SINT8 gl_portal_state = GLPORTAL_OFF;
gl_portallist_t *currentportallist;
gl_portallist_t *currentportallist = NULL;
// clip the area outside the portal destination window
void HWR_PortalClipping(gl_portal_t *portal)
@@ -168,8 +168,10 @@ void HWR_RenderPortal(gl_portal_t* portal, gl_portal_t* rootportal, const float
// go to portal frame lmao
HWR_PortalFrame(portal);
// call HWR_RenderViewpoint
HWR_RenderPortalViewpoint(portal, player, stencil_level + 1, true);
// return to current frame
if (rootportal)
HWR_PortalFrame(rootportal);
+8 -8
View File
@@ -201,7 +201,7 @@ static char *HWR_PreprocessShader(char *original)
CONS_Alert(CONS_ERROR, "HWR_PreprocessShader: Syntax error in #version. Expected version with 3 digits, but got %d digits.\n", version_number_len);
return NULL;
}
M_Memcpy(shader_glsl_version, read_pos, 3);
memcpy(shader_glsl_version, read_pos, 3);
ADVANCE(version_number_len)
version_len = (read_pos - original) - version_pos;
whitespace_len = strspn(read_pos, WHITESPACE_CHARS);
@@ -304,7 +304,7 @@ static char *HWR_PreprocessShader(char *original)
{
strcpy(write_pos, VERSION_PART);
write_pos += sizeof(VERSION_PART) - 1;
M_Memcpy(write_pos, shader_glsl_version, 3);
memcpy(write_pos, shader_glsl_version, 3);
write_pos += 3;
strcpy(write_pos, line_ending);
write_pos += line_ending_len;
@@ -344,7 +344,7 @@ static char *HWR_PreprocessShader(char *original)
}
// Copy the original shader.
M_Memcpy(write_pos, read_pos, original_len);
memcpy(write_pos, read_pos, original_len);
// Erase the original #version directive, if it exists and was copied.
if (new_len != original_len && version_pos != -1)
@@ -573,7 +573,7 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
size = W_LumpLengthPwad(wadnum, lump);
line = Z_Malloc(size+1, PU_STATIC, NULL);
M_Memcpy(line, shaderdef, size);
memcpy(line, shaderdef, size);
line[size] = '\0';
stoken = strtok(line, "\r\n ");
@@ -586,7 +586,7 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
goto skip_field;
}
if (!stricmp(stoken, "GLSL"))
if (fasticmp(stoken, "GLSL"))
{
value = strtok(NULL, "\r\n ");
if (!value)
@@ -596,9 +596,9 @@ void HWR_LoadCustomShadersFromFile(UINT16 wadnum, boolean PK3)
goto skip_lump;
}
if (!stricmp(value, "VERTEX"))
if (fasticmp(value, "VERTEX"))
shadertype = 1;
else if (!stricmp(value, "FRAGMENT"))
else if (fasticmp(value, "FRAGMENT"))
shadertype = 2;
skip_lump:
@@ -624,7 +624,7 @@ skip_lump:
for (i = 0; shaderxlat[i].type; i++)
{
if (!stricmp(shaderxlat[i].type, stoken))
if (fasticmp(shaderxlat[i].type, stoken))
{
size_t shader_string_length;
char *shader_source;
+102 -83
View File
@@ -110,6 +110,7 @@ GLint screen_texsizew = 512; // Power-of-two screen texture render resolution
GLint screen_texsizeh = 512; // Power-of-two screen texture render resolution
GLbyte screen_depth = 0;
GLint maximumAnisotropy = 0;
boolean supportNPO2tex = false;
static GLboolean MipMap = GL_FALSE;
static GLint min_filter = GL_LINEAR;
static GLint mag_filter = GL_LINEAR;
@@ -1176,12 +1177,20 @@ void GL_SetModelView(GLint w, GLint h)
screen_texsizew = screen_texsizeh = 512;
// look for power of two that is large enough for the screen
while (screen_texsizew < w)
screen_texsizew <<= 1;
if (supportNPO2tex)
{
screen_texsizew = screen_width;
screen_texsizeh = screen_height;
}
else
{
// look for power of two that is large enough for the screen
while (screen_texsizew < w)
screen_texsizew <<= 1;
while (screen_texsizeh < h)
screen_texsizeh <<= 1;
while (screen_texsizeh < h)
screen_texsizeh <<= 1;
}
pglGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxtexsize); // Get the maximum supported texture size
if ((screen_texsizew > maxtexsize || screen_texsizeh > maxtexsize) && maxtexsize > 0)
@@ -1814,47 +1823,72 @@ static void GL_AllocTextureBuffer(GLMipmap_t *pTexInfo)
}
}
#define PADDING_CHECK(offset, alphaCheck) { from = to + (offset); if ((alphaCheck)) from = NULL; else goto foundFrom; }
static void PadRGBABitmap(RGBA_t *tex, UINT16 w, UINT16 h)
static void PadRGBABitmap(RGBA_t *tex, UINT16 w, UINT16 h, UINT32 flags)
{
INT32 i;
boolean notLeft, notRight, notTop, notBottom;
RGBA_t *to = tex - 1, *from;
INT32 i, c1, c2, idxAdd;
UINT16 c1size, c2size;
RGBA_t *current, *prev, *next, *first;
boolean ignorePrev, wrap;
for (i = 0; i < w * h; i++)
for (i = 0; i < 2; i++)
{
to++;
if (to->rgba != 0)
continue;
from = NULL;
c1size = i ? h : w;
c2size = i ? w : h;
idxAdd = i ? 1 : w;
wrap = i ? flags & TF_WRAPX : flags & TF_WRAPY;
notLeft = i % w != 0;
notRight = i % w != w - 1;
notTop = i / w != 0;
notBottom = i / w != h - 1;
if (notRight) PADDING_CHECK(1, from->s.alpha == 0) // Check +X
if (notBottom) PADDING_CHECK(w, from->s.alpha == 0) // Check +Y
if (notLeft) PADDING_CHECK(-1, from->s.alpha == 0) // Check -X
if (notTop) PADDING_CHECK(-w, from->s.alpha == 0) // Check -Y
if (notRight && notBottom) PADDING_CHECK(1 + w, from->s.alpha == 0) // Check +X+Y
if (notLeft && notBottom) PADDING_CHECK(-1 + w, from->s.alpha == 0) // Check -X+Y
if (notLeft && notTop) PADDING_CHECK(-1 - w, from->s.alpha == 0) // Check -X-Y
if (notRight && notTop) PADDING_CHECK(1 - w, from->s.alpha == 0) // Check +X-Y
foundFrom:
if (from != NULL)
for (c1 = 0; c1 < c1size; c1++)
{
*to = *from;
to->s.alpha = 0;
if (i)
{
first = current = tex + (c1 * w);
prev = wrap ? tex + (w - 1 + c1 * w) : current;
next = tex + (1 + c1 * w);
}
else
{
first = current = tex + c1;
prev = wrap ? tex + (c1 + (h - 1) * w) : current;
next = tex + (c1 + w);
}
ignorePrev = false;
for (c2 = 0; c2 < c2size; c2++)
{
if (c2 == c2size - 1)
next = wrap ? first : current;
if (current->rgba)
{
ignorePrev = false;
}
else if (prev->rgba && !ignorePrev)
{
*current = *prev;
current->s.alpha = 0;
ignorePrev = true;
}
else if (next->rgba)
{
*current = *next;
current->s.alpha = 0;
ignorePrev = false;
}
else
{
ignorePrev = false;
}
prev = current;
current = next;
next += idxAdd;
}
}
}
}
#undef PADDING_CHECK
static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD)
static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD, UINT32 flags)
{
if (tex == NULL)
{
@@ -1916,7 +1950,7 @@ static void GenerateMipmaps(INT32 w, INT32 h, RGBA_t *tex, INT32 maxLOD)
h /= 2;
if (padTexture)
PadRGBABitmap(tex, w, h);
PadRGBABitmap(tex, w, h, flags);
pglTexSubImage2D(GL_TEXTURE_2D, m + 1, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, tex);
}
@@ -1991,7 +2025,7 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
}
if (applyPadding)
PadRGBABitmap(tex, w, h);
PadRGBABitmap(tex, w, h, pTexInfo->flags);
break;
case GL_TEXFMT_RGBA:
@@ -2007,7 +2041,7 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
ptex = tex;
if (applyPadding)
PadRGBABitmap(tex, w, h);
PadRGBABitmap(tex, w, h, pTexInfo->flags);
}
break;
@@ -2052,21 +2086,10 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
pglBindTexture(GL_TEXTURE_2D, num);
tex_downloaded = num;
const int transparent = (pTexInfo->flags & TF_TRANSPARENT);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
// disable texture filtering on any texture that has holes so there's no dumb borders or blending issues
if (transparent)
{
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
else
{
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
}
if (MipMap && !transparent) // No mipmaps on transparent stuff
if (MipMap)
{
pglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
@@ -2077,8 +2100,16 @@ void GL_UpdateTexture(GLMipmap_t *pTexInfo)
// Control the mipmap level of detail
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0);
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 5);
GenerateMipmaps(w, h, tex, 5);
if (pTexInfo->flags & TF_TRANSPARENT)
{
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 0); // No mipmaps on transparent stuff
}
else
{
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4);
GenerateMipmaps(w, h, tex, 4, pTexInfo->flags);
}
}
else
{
@@ -2459,12 +2490,10 @@ void GL_DrawIndexedTriangles(FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT i
// the DrawPolygon variant of this has some code about polyflags and wrapping here but havent noticed any problems from omitting it?
}
static const boolean gl_ext_arb_vertex_buffer_object = true;
#define NULL_VBO_VERTEX ((gl_skyvertex_t*)NULL)
#define sky_vbo_x (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->x : &sky->data[0].x)
#define sky_vbo_u (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->u : &sky->data[0].u)
#define sky_vbo_r (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->r : &sky->data[0].r)
//#define NULL_VBO_VERTEX ((gl_skyvertex_t*)NULL)
#define sky_vbo_x ((void*)offsetof(gl_skyvertex_t, x))
#define sky_vbo_u ((void*)offsetof(gl_skyvertex_t, u))
#define sky_vbo_r ((void*)offsetof(gl_skyvertex_t, r))
void GL_RenderSkyDome(gl_sky_t *sky)
{
@@ -2476,30 +2505,23 @@ void GL_RenderSkyDome(gl_sky_t *sky)
if (sky->rebuild)
{
// delete VBO when already exists
if (gl_ext_arb_vertex_buffer_object)
{
if (sky->vbo)
pglDeleteBuffers(1, &sky->vbo);
}
if (sky->vbo)
pglDeleteBuffers(1, &sky->vbo);
if (gl_ext_arb_vertex_buffer_object)
{
// generate a new VBO and get the associated ID
pglGenBuffers(1, &sky->vbo);
// generate a new VBO and get the associated ID
pglGenBuffers(1, &sky->vbo);
// bind VBO in order to use
pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
// bind VBO in order to use
pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
// upload data to VBO
pglBufferData(GL_ARRAY_BUFFER, sky->vertex_count * sizeof(sky->data[0]), sky->data, GL_STATIC_DRAW);
}
// upload data to VBO
pglBufferData(GL_ARRAY_BUFFER, sky->vertex_count * sizeof(sky->data[0]), sky->data, GL_STATIC_DRAW);
sky->rebuild = false;
}
// bind VBO in order to use
if (gl_ext_arb_vertex_buffer_object)
pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
pglBindBuffer(GL_ARRAY_BUFFER, sky->vbo);
// activate and specify pointers to arrays
pglVertexPointer(3, GL_FLOAT, sizeof(sky->data[0]), sky_vbo_x);
@@ -2543,8 +2565,7 @@ void GL_RenderSkyDome(gl_sky_t *sky)
pglColor4ubv(white);
// bind with 0, so, switch back to normal pointer operation
if (gl_ext_arb_vertex_buffer_object)
pglBindBuffer(GL_ARRAY_BUFFER, 0);
pglBindBuffer(GL_ARRAY_BUFFER, 0);
// deactivate color array
pglDisableClientState(GL_COLOR_ARRAY);
@@ -3692,7 +3713,6 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
float xfix, yfix;
float origaspect, newaspect;
float xoff = 1, yoff = 1; // xoffset and yoffset for the polygon to have black bars around the screen
FRGBAFloat clearColour;
static float off[12];
static float fix[8];
@@ -3743,8 +3763,7 @@ void GL_DrawScreenFinalTexture(int tex, INT32 width, INT32 height, boolean usesh
pglViewport(0, 0, width, height);
clearColour.red = clearColour.green = clearColour.blue = 0;
clearColour.alpha = 1;
FRGBAFloat clearColour = {0, 0, 0, 1};
GL_ClearBuffer(true, false, false, &clearColour);
GL_SetBlend(PF_NoDepthTest);
+1
View File
@@ -124,6 +124,7 @@ extern GLint screen_width;
extern GLint screen_height;
extern GLbyte screen_depth;
extern GLint maximumAnisotropy;
extern boolean supportNPO2tex;
extern boolean supportMipMap;
/** \brief OpenGL flags for video driver
+3
View File
@@ -253,6 +253,9 @@ HMS_connect (const char *format, ...)
cc = curl_easy_setopt(curl, CURLOPT_TIMEOUT, (long)cv_masterserver_timeout.value);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
cc = curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 30L);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
cc = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, HMS_on_read);
if (cc != CURLE_OK) I_OutputMsg("libcurl: %s\n", buffer->errbuf);
+115 -165
View File
@@ -280,7 +280,7 @@ static void Command_Say_f(void);
static void Command_Sayto_f(void);
static void Command_Sayteam_f(void);
static void Command_CSay_f(void);
static void Got_Saycmd(UINT8 **p, INT32 playernum);
static void Got_Saycmd(const UINT8 **p, INT32 playernum);
void HU_LoadGraphics(void)
{
@@ -431,7 +431,7 @@ void HU_Start(void)
void HU_Shiftform(void)
{
shiftxform = cv_keyboardlayout.value == 3 ? french_shiftxform : english_shiftxform;
shiftxform = (cv_keyboardlayout.value == 3) ? french_shiftxform : english_shiftxform;
}
//======================================================================
@@ -465,8 +465,8 @@ static INT16 addy = 0; // use this to make the messages scroll smoothly when one
static void HU_removeChatText_Mini(void)
{
// MPC: Don't create new arrays, just iterate through an existing one
size_t i;
for(i=0;i<chat_nummsg_min-1;i++) {
for (size_t i = 0; i < chat_nummsg_min - 1; i++)
{
strcpy(chat_mini[i], chat_mini[i+1]);
chat_timers[i] = chat_timers[i+1];
}
@@ -485,8 +485,8 @@ static void HU_removeChatText_Log(void)
return;
free(chat_log[0]);
size_t i;
for(i=0;i<chat_nummsg_log-1;i++)
for (size_t i = 0; i < chat_nummsg_log - 1;i++)
{
chat_log[i] = chat_log[i+1];
}
@@ -879,11 +879,12 @@ const char *HU_SkinColorToConsoleColor(skincolors_t color)
* \sa DoSayCommand
* \author Graue <graue@oceanbase.org>
*/
static void Got_Saycmd(UINT8 **p, INT32 playernum)
static void Got_Saycmd(const UINT8 **p, INT32 playernum)
{
SINT8 target;
UINT8 flags;
const char *dispname;
char buf[HU_MAXMSGLEN + 1];
char *msg;
boolean action = false;
char *ptr;
@@ -893,8 +894,8 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
target = READSINT8(*p);
flags = READUINT8(*p);
msg = (char *)*p;
SKIPSTRINGL(*p, HU_MAXMSGLEN + 1);
msg = buf;
READSTRINGL(*p, msg, HU_MAXMSGLEN + 1);
if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
{
@@ -1101,14 +1102,14 @@ void HU_Ticker(void)
size_t i = 0;
// handle spam while we're at it:
for(; (i<MAXPLAYERS); i++)
for(; (i < MAXPLAYERS); i++)
{
if (stop_spamming[i] > 0)
stop_spamming[i]--;
}
// handle chat timers
for (i=0; (i<chat_nummsg_min); i++)
for (i = 0; (i < chat_nummsg_min); i++)
{
if (chat_timers[i] > 0)
chat_timers[i]--;
@@ -1231,7 +1232,7 @@ static void HU_SendChatMessage(void)
nodenum[2] = '\0';
// check for undesirable characters in our "number"
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
if (((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
{
// check if nodenum[1] is a space
if (nodenum[1] == ' ')
@@ -1499,7 +1500,7 @@ static void HU_drawMiniChat(void)
if (splitscreen > 1)
boxw = max(64, boxw/2);
for (; i>0; i--)
for (; i > 0; i--)
{
char *msg = CHAT_WordWrap(x+2, boxw-(charwidth*2), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i-1]);
size_t j = 0;
@@ -1572,7 +1573,7 @@ static void HU_drawMiniChat(void)
i = 0;
prev_linereturn = false;
for (; i<=(chat_nummsg_min-1); i++) // iterate through our hot messages
for (; i <= (chat_nummsg_min-1); i++) // iterate through our hot messages
{
INT32 clrflag = 0;
INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9; // see below...
@@ -1749,7 +1750,6 @@ static void HU_drawChatLog(INT32 offset)
Z_Free(msg);
}
if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime)) // was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.
{
atbottom = true; // we should scroll
@@ -2284,6 +2284,7 @@ static void HU_DrawSongCreditsBox(void)
V_DrawFill(x, y, strwidth*dup, BOXCREDITHEIGHT*dup, 28|flags|(bgt<<V_ALPHASHIFT));
V_DrawFill(x+dup, y+dup, (strwidth-2)*dup, (BOXCREDITHEIGHT-2)*dup, 30|flags|(bgt<<V_ALPHASHIFT));
}
if (cursongcredit.trans < NUMTRANSMAPS)
{
V_DrawSmallString(x+2*dup, y+2*dup, V_ALLOWLOWERCASE|flags|(cursongcredit.trans<<V_ALPHASHIFT), str);
@@ -2391,76 +2392,6 @@ void HU_Drawer(void)
}
}
//======================================================================
// HUD MESSAGES CLEARING FROM SCREEN
//======================================================================
// Clear old messages from the borders around the view window
// (only for reduced view, refresh the borders when needed)
//
// startline: y coord to start clear,
// clearlines: how many lines to clear.
//
static INT32 oldclearlines;
void HU_Erase(void)
{
INT32 topline, bottomline;
INT32 y, yoffset;
#ifdef HWRENDER
// clear hud msgs on double buffer (OpenGL mode)
boolean secondframe;
static INT32 secondframelines;
#endif
if (con_clearlines == oldclearlines && !con_hudupdate && !chat_on)
return;
#ifdef HWRENDER
// clear the other frame in double-buffer modes
secondframe = (con_clearlines != oldclearlines);
if (secondframe)
secondframelines = oldclearlines;
#endif
// clear the message lines that go away, so use _oldclearlines_
bottomline = oldclearlines;
oldclearlines = con_clearlines;
if (chat_on && OLDCHAT)
if (bottomline < 8)
bottomline = 8; // only do it for consolechat. consolechat is gay.
if (automapactive || viewwindowx == 0) // hud msgs don't need to be cleared
return;
// software mode copies view border pattern & beveled edges from the backbuffer
if (rendermode == render_soft)
{
topline = 0;
for (y = topline, yoffset = y*vid.width; y < bottomline; y++, yoffset += vid.width)
{
if (y < viewwindowy || y >= viewwindowy + viewheight)
R_VideoErase(yoffset, vid.width); // erase entire line
else
{
R_VideoErase(yoffset, viewwindowx); // erase left border
// erase right border
R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
}
}
con_hudupdate = false; // if it was set..
}
#ifdef HWRENDER
else if (rendermode != render_none)
{
// refresh just what is needed from the view borders
HWR_DrawViewBorder(secondframelines);
con_hudupdate = secondframe;
}
#endif
}
//======================================================================
// IN-LEVEL MULTIPLAYER RANKINGS
//======================================================================
@@ -2540,17 +2471,91 @@ Ping_conversion (UINT32 lag)
// HU_drawPing
//
static void HU_drawOldPing(INT32 x, INT32 y, UINT32 lag, INT32 flags, boolean gentleman)
{
const INT32 measureid = cv_pingmeasurement.value ? 1 : 0;
if (vid.width >= 640) // how sad, we're using a shit resolution.
{
if (measureid == 1)
{
V_DrawRightAlignedSmallString(x+12, y+13, V_ALLOWLOWERCASE|flags, va("%dms", Ping_conversion(lag)));
}
else if (measureid == 0)
{
V_DrawRightAlignedSmallString(x+12, y+13, flags, va("d%d", Ping_conversion(lag)));
}
}
if (cv_pingicon.value)
{
UINT8 numbars = 0; // how many ping bars do we draw?
UINT8 barcolor = 31; // color we use for the bars (green, yellow, red or black)
SINT8 i = 0;
SINT8 yoffset = 6;
switch (lag)
{
case 0 ... 1:
numbars = 3;
barcolor = 215; // Blue
break;
case 2 ... 3:
numbars = 3;
barcolor = 184; // Green
break;
case 4 ... 6:
numbars = 2; // Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
barcolor = 103; // Yellow
break;
case 7 ... 9:
numbars = 1;
barcolor = 155; // Red
break;
default: // Brazil
numbars = 0;
barcolor = 31; // black
break;
}
if (gentleman)
{
barcolor = 194; // make it purplish
// bars get indirectly set earlier
}
for (i = 0; (i < 3); i++) // Draw the ping bar
{
V_DrawFill(x+2 *(i-1)+7, y+8+yoffset-4, 2, 8-yoffset, 31|flags);
if (i < numbars)
V_DrawFill(x+2 *(i-1)+7, y+8+yoffset-3, 1, 8-yoffset-1, barcolor|flags);
yoffset -= 2;
}
}
}
static void HU_drawKartPing(INT32 x, INT32 y, UINT32 lag, INT32 flags, boolean gentleman)
{
const INT32 measureid = cv_pingmeasurement.value ? 1 : 0;
if (measureid == 1)
V_DrawScaledPatch(x+11 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
if (cv_pingicon.value)
{
INT32 gfxnum = Ping_gfx_num(lag); // gfx to draw
V_DrawScaledPatch(x+2, y, flags, pinggfx[gfxnum]);
}
x = V_DrawPingNum(x + (measureid == 1 ? 11 - pingmeasure[measureid]->width : 10), y+9, flags, Ping_conversion(lag), Ping_gfx_colormap(lag, gentleman));
if (measureid == 0)
V_DrawScaledPatch(x+1 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
}
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags)
{
INT32 measureid = cv_pingmeasurement.value ? 1 : 0;
INT32 gfxnum; // gfx to draw
//SRB2/Kart v1.0 style
UINT8 numbars = 0; // how many ping bars do we draw?
UINT8 barcolor = 31; // color we use for the bars (green, yellow, red or black)
SINT8 i = 0;
SINT8 yoffset = 6;
UINT32 lag = playerpingtable[pnum];
const boolean gentleman = (cv_mindelay.value && (lag < (tic_t)simulated_lag));
@@ -2561,74 +2566,11 @@ void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags)
if (cv_pingstyle.value == 0) // kart
{
gfxnum = Ping_gfx_num(lag);
if (measureid == 1)
V_DrawScaledPatch(x+11 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
if (cv_pingicon.value)
V_DrawScaledPatch(x+2, y, flags, pinggfx[gfxnum]);
x = V_DrawPingNum(x + (measureid == 1 ? 11 - pingmeasure[measureid]->width : 10), y+9, flags, Ping_conversion(lag), Ping_gfx_colormap(lag, gentleman));
if (measureid == 0)
V_DrawScaledPatch(x+1 - pingmeasure[measureid]->width, y+9, flags, pingmeasure[measureid]);
HU_drawKartPing(x, y, lag, flags, gentleman);
}
else if (cv_pingstyle.value == 1) // old style ping
{
if (vid.width >= 640) // how sad, we're using a shit resolution.
{
if (measureid == 1)
{
V_DrawRightAlignedSmallString(x+12, y+13, V_ALLOWLOWERCASE|flags, va("%dms", Ping_conversion(lag)));
}
else if (measureid == 0)
{
V_DrawRightAlignedSmallString(x+12, y+13, flags, va("d%d", Ping_conversion(lag)));
}
}
if (cv_pingicon.value)
{
switch (lag)
{
case 0 ... 1:
numbars = 3;
barcolor = 215; // Blue
break;
case 2 ... 3:
numbars = 3;
barcolor = 184; // Green
break;
case 4 ... 6:
numbars = 2; // Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
barcolor = 103; // Yellow
break;
case 7 ... 9:
numbars = 1;
barcolor = 155; // Red
break;
default: // Brazil
numbars = 0;
barcolor = 31; // black
break;
}
if (gentleman)
{
barcolor = 194; // make it purplish
// bars get indirectly set earlier
}
for (i = 0; (i < 3); i++) // Draw the ping bar
{
V_DrawFill(x+2 *(i-1)+7, y+8+yoffset-4, 2, 8-yoffset, 31|flags);
if (i < numbars)
V_DrawFill(x+2 *(i-1)+7, y+8+yoffset-3, 1, 8-yoffset-1, barcolor|flags);
yoffset -= 2;
}
}
HU_drawOldPing(x, y, lag, flags, gentleman);
}
}
@@ -2904,12 +2846,8 @@ void HU_SetCEchoFlags(INT32 flags)
void HU_DoCEcho(const char *msg)
{
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstringop-truncation" // This is fine, we set null byte later
strncpy(cechotext, msg, sizeof(cechotext));
#pragma GCC diagnostic pop
strncat(cechotext, "\\", sizeof(cechotext) - strlen(cechotext) - 1);
cechotext[sizeof(cechotext) - 1] = '\0';
strlcpy(cechotext, msg, sizeof(cechotext));
strlcat(cechotext, "\\", sizeof(cechotext));
// just print it to console
if (cv_cechotoggle.value == 2)
@@ -2918,8 +2856,20 @@ void HU_DoCEcho(const char *msg)
strncpy(temp, cechotext, sizeof(temp));
for (char *p = temp; *p != '\0'; ++p)
{
if (*p == '\\')
{
*p = '\n';
++p;
char *skip_p = p; // Point at which we will move part of string after all \'s
while (*p == '\\')
++p;
memmove(skip_p, p, strlen(p)+1); // move the rest of string with null byte
p = skip_p; // Restore p
}
}
CONS_Printf("%s\n", temp);
-1
View File
@@ -117,7 +117,6 @@ void HU_TickSongCredits(void);
void HU_DrawSongCredits(void);
void HU_Drawer(void);
char HU_dequeueChatChar(void);
void HU_Erase(void);
void HU_clearChatChars(void);
void HU_drawPlayerPing(INT32 x, INT32 y, INT32 pnum, INT32 flags); // Lat': Ping drawer for scoreboard.
//void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer);
-680
View File
@@ -1,680 +0,0 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2011-2018 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file i_addrinfo.c
/// \brief getaddr stubs, for lesser OSes
///
/// Some systems/SDKs, like PSL1GHT v2 does not have addrinfo functions
/// So a stub is needed
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#ifdef _WIN32
#ifdef USE_WINSOCK2
#include <ws2tcpip.h>
#else
#include <winsock.h>
#endif
#else
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif
#include "i_addrinfo.h"
/*
* This addrinfo stub have a testcases:
* To test the stub, use this command to compile the stub testcase:
* gcc -g -DTESTCASE -Dtest_stub -Wall -W i_addrinfo.c -o stub
* To test the real getaddrinfo API, use this command to get real one:
* gcc -g -DTESTCASE -Utest_stub -Wall -W i_addrinfo.c -o real
* For Win32,you need the WinSock library, version 1.1 or 2.2
* for 1.1, add -lwsock32
* i686-w64-mingw32-gcc -g -DTESTCASE -Dtest_stub -UUSE_WINSOCK2 -Wall -W i_addrinfo.c -o stub.exe -lwsock32
* for 2.2, add -DUSE_WINSOCK2 -lws2_32
* i686-w64-mingw32-gcc -g -DTESTCASE -Utest_stub -DUSE_WINSOCK2 -Wall -W i_addrinfo.c -o real.exe -lws2_32
*/
#ifndef I_getaddrinfo
#include <stdbool.h>
#ifdef _WIN32
// it seems windows doesn't define that... maybe some other OS? OS/2
static int inet_aton(const char *cp, struct in_addr *addr)
{
if( cp == NULL || addr == NULL )
{
return(0);
}
if (strcmp(cp, "255.255.255.225") == 0)
{
addr->s_addr = htonl(INADDR_BROADCAST);
return 0;
}
return (addr->s_addr = inet_addr(cp)) != htonl(INADDR_NONE);
}
#endif
#ifdef USE_WINSOCK2
static HMODULE ipv6dll = NULL;
typedef int (WSAAPI *p_getaddrinfo) (const char *, const char *,
const struct my_addrinfo *,
struct my_addrinfo **);
typedef void (WSAAPI *p_freeaddrinfo) (struct my_addrinfo *);
static p_getaddrinfo WS_getaddrinfo = NULL;
static p_freeaddrinfo WS_freeaddrinfo = NULL;
static HMODULE WS_getfunctions(HMODULE tmp)
{
if (tmp != NULL)
{
WS_getaddrinfo = (p_getaddrinfo)(LPVOID)GetProcAddress(tmp, "getaddrinfo");
if (WS_getaddrinfo == NULL)
return NULL;
WS_freeaddrinfo = (p_freeaddrinfo)(LPVOID)GetProcAddress(tmp, "freeaddrinfo");
if (WS_freeaddrinfo == NULL)
{
WS_getaddrinfo = NULL;
return NULL;
}
}
return tmp;
}
static void WS_addrinfosetup(void)
{
if (WS_getaddrinfo && WS_freeaddrinfo)
return; // already have the functions
// why not hold it into ipv6dll? becase we already link with ws2_32, silly!
if (WS_getfunctions(GetModuleHandleA("ws2_32.dll")) == NULL)
ipv6dll = WS_getfunctions(LoadLibraryA("wship6.dll"));
}
void WS_addrinfocleanup(void)
{
if (ipv6dll)
FreeLibrary(ipv6dll);
ipv6dll = NULL;
WS_getaddrinfo = NULL;
WS_freeaddrinfo = NULL;
}
#else
void WS_addrinfocleanup(void) {}
#endif
int I_getaddrinfo(const char *node, const char *service,
const struct my_addrinfo *hints,
struct my_addrinfo **res)
{
struct hostent *nodename = NULL;
bool hostlookup = true, passivemode = false;
int flags = 0;
int socktype = 0;
int sockport = 0;
struct my_addrinfo *ai;
struct sockaddr_in *addr;
struct in_addr ipv4;
size_t addrlen = 1;
size_t ailen = 1, i = 0, j;
size_t famsize = sizeof(struct sockaddr_in);
#ifdef USE_WINSOCK2
WS_addrinfosetup();
if (WS_getaddrinfo)
return WS_getaddrinfo(node, service, hints, res);
#endif
// param check
if (node == NULL && service == NULL)
return EAI_NONAME;
//note: testcase show NULL as res crashes libc
if (res == NULL)
return -1;
// check hints
if (hints)
{
// no support for IPv6
if (hints->ai_family != AF_INET && hints->ai_family != AF_UNSPEC)
return -1; //EAI_FAMILY
#ifdef AI_NUMERICHOST
// do not look up hostnames
if ((hints->ai_flags & AI_NUMERICHOST) == AI_NUMERICHOST)
{
hostlookup = false;
flags |= AI_NUMERICHOST;
}
#endif
#ifdef AI_PASSIVE
// return loopback or any address?
if ((hints->ai_flags & AI_PASSIVE) == AI_PASSIVE)
{
passivemode = true;
flags |= AI_PASSIVE;
}
#endif
// why no support for canon names? lazy
//AI_CANONNAME
// what kind of socket?
socktype = hints->ai_socktype;
}
else
{
#ifdef AI_V4MAPPED
flags |= AI_V4MAPPED;
#endif
#ifdef AI_ADDRCONFIG
flags |= AI_ADDRCONFIG;
#endif
}
// we need gethostbyname to convert numeric strings
if (node && hostlookup)
{
if (node == NULL)
return -1;
nodename = gethostbyname(node);
if (nodename == NULL)
{
if (inet_aton(node, &ipv4) != 0)
addrlen = 1;
else
return -1;
}
else while (nodename->h_addr_list[addrlen] != NULL)
addrlen++;
}
else if (node)
{
if (inet_aton(node, &ipv4) != 0)
addrlen = 1;
else if (!hostlookup)
return EAI_NONAME;
}
else
addrlen = 1;
if (service) //AI_NUMERICSERV
sockport = atoi(service);
if (socktype == 0)
ailen = addrlen*3;
else
ailen = addrlen;
ai = calloc(ailen, sizeof(struct my_addrinfo));
if (ai == NULL)
return -1;
else
*res = ai;
addr = calloc(ailen*2, famsize);
if (addr == NULL)
{
free(ai);
return -1;
}
else
ai->ai_addr = memset(addr, 0x00, ailen*ai->ai_addrlen);
for (i = 0; i < ailen; i++)
{
ai = *res+i;
ai->ai_flags = flags;
ai->ai_family = AF_INET;
ai->ai_socktype = socktype;
switch (ai->ai_socktype)
{
case SOCK_STREAM:
ai->ai_protocol = IPPROTO_TCP;
break;
case SOCK_DGRAM:
ai->ai_protocol = IPPROTO_UDP;
break;
default:
ai->ai_protocol = 0;
}
ai->ai_addrlen = famsize;
ai->ai_addr = (struct sockaddr *)&addr[i];
//ai_cannonname
ai->ai_next = ai+1;
}
ai->ai_next = NULL;
ai = *res;
for (i = 0, j = 0; i < ailen; i++, j++)
{
ai = *res+i;
addr[i].sin_port = htons((UINT16)sockport);
if (nodename)
{
memcpy(&addr[i].sin_addr, nodename->h_addr_list[j], ai->ai_addrlen);
addr[i].sin_family = nodename->h_addrtype;
}
else if (node)
{
memcpy(&addr[i].sin_addr, &ipv4, ai->ai_addrlen);
addr[i].sin_family = AF_INET;
}
else
{
if (passivemode)
addr[i].sin_addr.s_addr = htonl(INADDR_ANY);
else
addr[i].sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr[i].sin_family = AF_INET;
}
if (socktype == 0)
{
ai->ai_socktype = SOCK_STREAM;
ai->ai_protocol = IPPROTO_TCP;
memcpy(&addr[i+1], &addr[i], ai->ai_addrlen);
i++; ai++;
ai->ai_socktype = SOCK_DGRAM;
ai->ai_protocol = IPPROTO_UDP;
memcpy(&addr[i+1], &addr[i], ai->ai_addrlen);
i++; ai++;
ai->ai_socktype = SOCK_RAW;
ai->ai_protocol = IPPROTO_IP;
}
}
return 0;
}
#endif
#ifndef I_freeaddrinfo
void I_freeaddrinfo(struct my_addrinfo *res)
{
#ifdef USE_WINSOCK2
if (WS_freeaddrinfo)
{
WS_freeaddrinfo(res);
return;
}
#endif
if (!res)
return;
free(res->ai_addr);
free(res);
}
#endif
#ifdef TESTCASE
#include <stdio.h>
#ifdef USE_WINSOCK2
#define inet_ntop inet_ntopA
#define HAVE_NTOP
static const char* inet_ntopA(int af, const void *cp, char *buf, socklen_t len)
{
DWORD Dlen = len, AFlen = 0;
SOCKADDR_STORAGE any;
LPSOCKADDR anyp = (LPSOCKADDR)&any;
LPSOCKADDR_IN any4 = (LPSOCKADDR_IN)&any;
LPSOCKADDR_IN6 any6 = (LPSOCKADDR_IN6)&any;
if (!buf)
{
WSASetLastError(STATUS_INVALID_PARAMETER);
return NULL;
}
if (af != AF_INET && af != AF_INET6)
{
WSASetLastError(WSAEAFNOSUPPORT);
return NULL;
}
ZeroMemory(&any, sizeof(SOCKADDR_STORAGE));
any.ss_family = af;
switch (af)
{
case AF_INET:
{
CopyMemory(&any4->sin_addr, cp, sizeof(IN_ADDR));
AFlen = sizeof(SOCKADDR_IN);
break;
}
case AF_INET6:
{
CopyMemory(&any6->sin6_addr, cp, sizeof(IN6_ADDR));
AFlen = sizeof(SOCKADDR_IN6);
break;
}
}
if (WSAAddressToStringA(anyp, AFlen, NULL, buf, &Dlen) == SOCKET_ERROR)
return NULL;
return buf;
}
#elif defined (_WIN32)
// w32api, ws2tcpip.h, r1.12
static inline char* gai_strerror(int ecode)
{
static char message[1024+1];
DWORD dwFlags = FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS
| FORMAT_MESSAGE_MAX_WIDTH_MASK;
DWORD dwLanguageId = MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT);
FormatMessageA(dwFlags, NULL, ecode, dwLanguageId, message, 1024, NULL);
return message;
}
#else
#define HAVE_NTOP
#endif
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
static inline void printflags(int ai_flags)
{
printf("flags: %x(", ai_flags);
if (ai_flags == 0)
printf("NONE|");
#ifdef AI_PASSIVE
if ((ai_flags & AI_PASSIVE) == AI_PASSIVE)
printf("AI_PASSIVE|");
ai_flags &= ~AI_PASSIVE;
#endif
#ifdef AI_CANONNAME
if ((ai_flags & AI_CANONNAME) == AI_CANONNAME)
printf("AI_CANONNAME|");
ai_flags &= ~AI_CANONNAME;
#endif
#ifdef AI_NUMERICHOST
if ((ai_flags & AI_NUMERICHOST) == AI_NUMERICHOST)
printf("AI_NUMERICHOST|");
ai_flags &= ~AI_NUMERICHOST;
#endif
#ifdef AI_V4MAPPED
if ((ai_flags & AI_V4MAPPED) == AI_V4MAPPED)
printf("AI_V4MAPPED|");
ai_flags &= ~AI_V4MAPPED;
#endif
#ifdef AI_ALL
if ((ai_flags & AI_ALL) == AI_ALL)
printf("AI_ALL|");
ai_flags &= ~AI_ALL;
#endif
#ifdef AI_ADDRCONFIG
if ((ai_flags & AI_ADDRCONFIG) == AI_ADDRCONFIG)
printf("AI_ADDRCONFIG|");
ai_flags &= ~AI_ADDRCONFIG;
#endif
#ifdef AI_IDN
if ((ai_flags & AI_IDN) == AI_IDN)
printf("AI_IDN|");
ai_flags &= ~AI_IDN;
#endif
#ifdef AI_CANONIDN
if ((ai_flags & AI_CANONIDN) == AI_CANONIDN)
printf("AI_CANONIDN|");
ai_flags &= ~AI_CANONIDN;
#endif
#ifdef AI_IDN_ALLOW_UNASSIGNED
if ((ai_flags & AI_IDN_ALLOW_UNASSIGNED) == AI_IDN_ALLOW_UNASSIGNED)
printf("AI_IDN_ALLOW_UNASSIGNED|");
ai_flags &= ~AI_IDN_ALLOW_UNASSIGNED;
#endif
#ifdef AI_IDN_USE_STD3_ASCII_RULES
if ((ai_flags & AI_IDN_USE_STD3_ASCII_RULES) == AI_IDN_USE_STD3_ASCII_RULES)
printf("AI_IDN_USE_STD3_ASCII_RULES|");
ai_flags &= ~AI_PASSIVE;
#endif
#ifdef AI_NUMERICSERV
if ((ai_flags & AI_NUMERICSERV) == AI_NUMERICSERV)
printf("AI_NUMERICSERV|");
ai_flags &= ~AI_NUMERICSERV;
#endif
printf("%x", ai_flags);
printf(")\n");
}
static inline void printsocktype(int ai_socktype)
{
printf("socktype: %d(", ai_socktype);
switch (ai_socktype)
{
case 0:
printf("SOCK_ Woe32");
break;
case SOCK_STREAM:
printf("SOCK_STREAM");
break;
case SOCK_DGRAM:
printf("SOCK_DGRAM");
break;
case SOCK_RAW:
printf("SOCK_RAW");
break;
default:
printf("SOCK_ERROR\n");
exit(-1);
}
printf(")\n");
}
static inline void printprotocol(int ai_protocol)
{
printf("protocol: %d(", ai_protocol);
switch (ai_protocol)
{
case IPPROTO_IP:
printf("IPPROTO_IP");
break;
case IPPROTO_TCP:
printf("IPPROTO_TCP");
break;
case IPPROTO_UDP:
printf("IPPROTO_UDP");
break;
default:
printf("IPPROTO_ERROR\n");
exit(-1);
}
printf(")\n");
}
static inline void printaddr(int ai_family, const struct sockaddr *ai_addr)
{
char str[INET_ADDRSTRLEN+1] = "FAKE";
printf("family: %d(", ai_family);
switch (ai_family)
{
case AF_UNSPEC:
printf("AF_UNSPEC");
break;
case AF_INET:
printf("AF_INET");
break;
#ifdef AF_INET6
case AF_INET6:
printf("AF_INET6");
break;
#endif
default:
printf("AF_ERROR\n");
exit(-1);
}
printf(")\n");
if (ai_family == AF_INET && ai_addr)
{
const struct sockaddr_in *ip4 = (void *)ai_addr;
#ifdef HAVE_NTOP
inet_ntop(ai_family, &ip4->sin_addr, str, INET_ADDRSTRLEN);
#else
strncpy(str, inet_ntoa(ip4->sin_addr), INET_ADDRSTRLEN);
#endif
printf("port: %d\n", ntohs(ip4->sin_port));
}
printf("addr: %s\n", str);
}
void printaddrinfo(const struct my_addrinfo *data)
{
if(data == NULL)
{
printf("no data\n");
return;
}
else
printf("starting addrinfo dump\n");
while (data != NULL)
{
printflags(data->ai_flags);
printsocktype(data->ai_socktype);
printaddr(data->ai_family, data->ai_addr);
printprotocol(data->ai_protocol);
//addrlen
data = data->ai_next;
}
}
int main(int argc, char **argv)
{
struct my_addrinfo *res = NULL, hints;
int gaie;
(void)argc;
(void)argv;
memset(&hints, 0x00, sizeof(struct my_addrinfo));
hints.ai_family = AF_INET;
#ifdef _WIN32
{
#ifdef USE_WINSOCK2
const WORD VerNeed = MAKEWORD(2,2);
#else
const WORD VerNeed = MAKEWORD(1,1);
#endif
WSADATA WSAData;
WSAStartup(VerNeed, &WSAData);
}
#endif
printf("-----------------------------------------------------------\n");
#ifndef _WIN32 //NULL as res crashes Win32
gaie = I_getaddrinfo(NULL, NULL, &hints, NULL);
if (gaie != EAI_NONAME)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
I_freeaddrinfo(res);
#endif
#if 0 //NULL as res crashes
gaie = I_getaddrinfo("localhost", "5029", NULL, NULL);
if (gaie == 0)
printf("NULL crashes: %s(%d)\n", gai_strerror(gaie), gaie);
I_freeaddrinfo(res);
#endif
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_flags = AI_NUMERICHOST;
gaie = I_getaddrinfo("localhost", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo(NULL, "5029", &hints, &res);
//if (gaie != 0)
printf("NULLs test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("localhost", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
gaie = I_getaddrinfo("127.0.0.1", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("127.0.0.1", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
gaie = I_getaddrinfo("255.255.255.255", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("255.255.255.255", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
printf("-----------------------------------------------------------\n");
hints.ai_flags = AI_PASSIVE;
gaie = I_getaddrinfo("0.0.0.0", NULL, &hints, &res);
//if (gaie != 0)
printf("NULL service test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
gaie = I_getaddrinfo("0.0.0.0", "5029", &hints, &res);
//if (gaie != 0)
printf("no hints test returned: %s(%d)\n", gai_strerror(gaie), gaie);
printaddrinfo(res);
I_freeaddrinfo(res); res = NULL;
return 0;
}
#endif
-71
View File
@@ -1,71 +0,0 @@
// SONIC ROBO BLAST 2
//-----------------------------------------------------------------------------
// Copyright (C) 2011-2018 by Sonic Team Junior.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file i_addrinfo.h
/// \brief getaddrinfo stub
#ifndef __I_ADDRINFO__
#define __I_ADDRINFO__
#ifdef __GNUG__
#pragma interface
#endif
#ifndef AI_PASSIVE
#define AI_PASSIVE 0x01
#endif
#ifndef AI_NUMERICHOST
#define AI_NUMERICHOST 0x04
#endif
#ifndef AI_V4MAPPED
#define AI_V4MAPPED 0x08
#endif
#ifndef AI_ADDRCONFIG
#define AI_ADDRCONFIG 0x20
#endif
#ifdef _WIN32
#ifndef EAI_NONAME
#define EAI_NONAME WSAHOST_NOT_FOUND
#endif
#endif
#ifndef EAI_NONAME
#define EAI_NONAME -2
#endif
#ifdef _WIN32 // already use the stub for Win32
// w32api, ws2tcpip.h, r1.12
struct my_addrinfo {
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
size_t ai_addrlen;
char *ai_canonname;
struct sockaddr *ai_addr;
struct my_addrinfo *ai_next;
};
#else
#define my_addrinfo addrinfo
#endif
void WS_addrinfocleanup(void);
#ifndef my_addrinfo
void I_freeaddrinfo(struct my_addrinfo *res);
int I_getaddrinfo(const char *node, const char *service,
const struct my_addrinfo *hints,
struct my_addrinfo **res);
#elif !defined (test_stub)
#define I_getaddrinfo getaddrinfo
#define I_freeaddrinfo freeaddrinfo
#endif
#endif
-4
View File
@@ -221,10 +221,6 @@ INT32 I_mkdir(const char *dirname, INT32 unixright);
*/
const char *I_LocateWad(void);
/** \brief Joystick events
*/
void I_GetJoystickEvents(UINT8 index);
char *I_GetEnv(const char *name);
INT32 I_PutEnv(char *variable);
+108 -119
View File
@@ -28,43 +28,37 @@
#endif
#ifdef _WIN32
#define USE_WINSOCK
#if defined (_WIN64) || defined (HAVE_IPV6)
#define USE_WINSOCK2
#else //_WIN64/HAVE_IPV6
#define USE_WINSOCK1
#endif
#define USE_WINSOCK
#endif //WIN32 OS
#ifdef USE_WINSOCK2
#include <ws2tcpip.h>
#ifdef USE_WINSOCK
#include <ws2tcpip.h>
#define addrinfo_t ADDRINFOA
#else
#define addrinfo_t struct addrinfo
#endif
#include "doomdef.h"
#ifndef USE_WINSOCK
#include <arpa/inet.h>
#ifdef __APPLE_CC__
#ifndef _BSD_SOCKLEN_T_
#define _BSD_SOCKLEN_T_
#endif //_BSD_SOCKLEN_T_
#endif //__APPLE_CC__
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/ioctl.h>
#endif //normal BSD API
#include <errno.h>
#include <time.h>
#ifdef USE_WINSOCK1
#include <winsock.h>
#else
#ifndef USE_WINSOCK
#include <arpa/inet.h>
#ifdef __APPLE_CC__
#ifndef _BSD_SOCKLEN_T_
#define _BSD_SOCKLEN_T_
#endif //_BSD_SOCKLEN_T_
#endif //__APPLE_CC__
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/ioctl.h>
#endif //normal BSD API
#include <errno.h>
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
#include <sys/time.h>
#endif // UNIXCOMMON
#endif
#if defined (__unix__) || defined (__APPLE__) || defined (UNIXCOMMON)
#include <sys/time.h>
#endif // UNIXCOMMON
#ifdef USE_WINSOCK
// some undefined under win32
@@ -152,27 +146,22 @@ static UINT8 UPNP_support = TRUE;
#define close closesocket
#endif
#include "i_addrinfo.h"
#define DEFAULTPORT "5029"
#if defined (USE_WINSOCK)
typedef SOCKET SOCKET_TYPE;
#define ERRSOCKET (SOCKET_ERROR)
#ifdef USE_WINSOCK
typedef SOCKET SOCKET_TYPE;
#define ERRSOCKET (SOCKET_ERROR)
#else
#if defined (__unix__) || defined (__APPLE__) || defined (__HAIKU__)
typedef int SOCKET_TYPE;
#else
typedef unsigned long SOCKET_TYPE;
#endif
#define ERRSOCKET (-1)
#if defined (__unix__) || defined (__APPLE__) || defined (__HAIKU__)
typedef int SOCKET_TYPE;
#else
typedef unsigned long SOCKET_TYPE;
#endif
#define ERRSOCKET (-1)
#endif
#define IPV6_MULTICAST_ADDRESS "ff15::57e1:1a12"
#ifdef USE_WINSOCK1
typedef int socklen_t;
#endif
typedef struct
{
mysockaddr_t address;
@@ -232,9 +221,8 @@ static char *get_WSAErrorStr(int e)
#define strerror get_WSAErrorStr
#endif
#ifdef USE_WINSOCK2
#ifdef USE_WINSOCK
#define inet_ntop inet_ntopA
#define HAVE_NTOP
static const char* inet_ntopA(short af, const void *cp, char *buf, socklen_t len)
{
DWORD Dlen = len, AFlen = 0;
@@ -278,8 +266,6 @@ static const char* inet_ntopA(short af, const void *cp, char *buf, socklen_t len
return NULL;
return buf;
}
#elif !defined (USE_WINSOCK1)
#define HAVE_NTOP
#endif
#ifdef HAVE_MINIUPNPC // based on old XChat patch
@@ -359,18 +345,15 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
{
static char s[64]; // 255.255.255.255:65535 or
// [ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]:65535
#ifdef HAVE_NTOP
#ifdef HAVE_IPV6
int v6 = (sk->any.sa_family == AF_INET6);
#else
int v6 = 0;
#endif
void *addr;
int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
if(sk->any.sa_family == AF_INET)
if (sk->any.sa_family == AF_INET)
addr = &sk->ip4.sin_addr;
#ifdef HAVE_IPV6
else if(sk->any.sa_family == AF_INET6)
@@ -379,9 +362,11 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
else
addr = NULL;
if(addr == NULL)
if (addr == NULL)
{
sprintf(s, "No address");
else if(inet_ntop(sk->any.sa_family, addr, &s[v6], sizeof (s) - v6) == NULL)
}
else if (inet_ntop(sk->any.sa_family, addr, &s[v6], sizeof (s) - v6) == NULL)
{
e = errno;
sprintf(s, "Unknown family type, error #%u: %s", e, strerror(e));
@@ -396,17 +381,9 @@ static const char *SOCK_AddrToStr(mysockaddr_t *sk)
strcat(s, va(":%d", ntohs(sk->ip6.sin6_port)));
}
#endif
else if(sk->any.sa_family == AF_INET && sk->ip4.sin_port != 0)
else if (sk->any.sa_family == AF_INET && sk->ip4.sin_port != 0)
strcat(s, va(":%d", ntohs(sk->ip4.sin_port)));
#else
if (sk->any.sa_family == AF_INET)
{
strcpy(s, inet_ntoa(sk->ip4.sin_addr));
if (sk->ip4.sin_port != 0) strcat(s, va(":%d", ntohs(sk->ip4.sin_port)));
}
else
sprintf(s, "Unknown type");
#endif
return s;
}
@@ -504,7 +481,6 @@ static boolean SOCK_cmpaddr(mysockaddr_t *a, mysockaddr_t *b, UINT8 mask)
return false;
}
// This is a hack. For some reason, nodes aren't being freed properly.
// This goes through and cleans up what nodes were supposed to be freed.
/** \warning This function causes the file downloading to stop if someone joins.
@@ -659,7 +635,7 @@ static boolean SOCK_Get(void)
c = recvfrom(mysockets[n], (char *)&doomcom->data, MAXPACKETLENGTH, 0,
(void *)&fromaddress, &fromlen);
if (c > 0)
if (c != ERRSOCKET)
{
#ifdef USE_STUN
if (STUN_got_response(doomcom->data, c))
@@ -675,25 +651,26 @@ static boolean SOCK_Get(void)
#endif
// find remote node number
for (j = 1; j <= MAXNETNODES; j++) //include LAN
for (j = 1; j <= MAXNETNODES; j++) // include LAN
{
if (SOCK_cmpaddr(&fromaddress, &clientaddress[j], 0))
{
doomcom->remotenode = (INT16)j; // good packet from a game player
doomcom->datalength = (INT16)c;
nodesocket[j] = mysockets[n];
return false;
return true;
}
}
// not found
// find a free slot
j = getfreenode();
if (j > 0)
{
const time_t curTime = time(NULL);
M_Memcpy(&clientaddress[j], &fromaddress, fromlen);
memcpy(&clientaddress[j], &fromaddress, fromlen);
nodesocket[j] = mysockets[n];
DEBFILE(va("New node detected: node:%d address:%s\n", j,
SOCK_GetNodeAddress(j)));
@@ -775,7 +752,7 @@ static void SOCK_Send(void)
int e = 0; // save error code so it can't be modified later code and avoid calling WSAGetLastError() more then once
size_t i, j;
if (!nodeconnected[doomcom->remotenode])
if (doomcom->remotenode < 0 || !nodeconnected[doomcom->remotenode])
return;
if (doomcom->remotenode == BROADCASTADDR)
@@ -868,15 +845,11 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
#ifdef USE_WINSOCK
{ // Alam_GBC: disable the new UDP connection reset behavior for Win2k and up
#ifdef USE_WINSOCK2
DWORD dwBytesReturned = 0;
BOOL bfalse = FALSE;
rc = WSAIoctl(s, SIO_UDP_CONNRESET, &bfalse, sizeof(bfalse),
NULL, 0, &dwBytesReturned, NULL, NULL);
#else
unsigned long falseval = false;
rc = ioctl(s, SIO_UDP_CONNRESET, &falseval);
#endif
if (rc == -1)
{
e = errno;
@@ -997,7 +970,7 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
e = errno;
I_OutputMsg("getting SO_RCVBUF failed: #%u, %s\n", e, strerror(e));
}
CONS_Printf(M_GetText("Network system buffer: %dKb\n"), opt>>10);
CONS_Printf(M_GetText("Network receive buffer: %dKb\n"), opt>>10);
if (opt < 64<<10) // 64k
{
@@ -1018,9 +991,44 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
}
if (opt < 64<<10)
CONS_Alert(CONS_WARNING, M_GetText("Can't set buffer length to 64k, file transfer will be bad\n"));
CONS_Alert(CONS_WARNING, M_GetText("Can't set receive buffer length to 64k, file transfer will be bad\n"));
else
CONS_Printf(M_GetText("Network system buffer set to: %dKb\n"), opt>>10);
CONS_Printf(M_GetText("Network receive buffer set to: %dKb\n"), opt>>10);
}
opt = 0;
opts = (socklen_t)sizeof(opt);
rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &opts);
if (rc <= -1)
{
e = errno;
I_OutputMsg("getting SO_SNDBUF failed: #%u, %s\n", e, strerror(e));
}
CONS_Printf(M_GetText("Network send buffer: %dKb\n"), opt>>10);
if (opt < 64<<10) // 64k
{
opt = 64<<10;
opts = (socklen_t)sizeof(opt);
rc = setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, opts);
if (rc <= -1)
{
e = errno;
I_OutputMsg("setting SO_SNDBUF to %dKb failed: #%u, %s\n", opt>>10, e, strerror(e));
}
opt = 0;
rc = getsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&opt, &opts);
if (rc <= -1)
{
e = errno;
I_OutputMsg("getting SO_SNDBUF failed: #%u, %s\n", e, strerror(e));
}
if (opt < 64<<10)
CONS_Alert(CONS_WARNING, M_GetText("Can't set send buffer length to 64k, file transfer will be bad\n"));
else
CONS_Printf(M_GetText("Network send system buffer set to: %dKb\n"), opt>>10);
}
rc = getsockname(s, &straddr.any, &len);
@@ -1046,7 +1054,7 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
static boolean UDP_Socket(void)
{
size_t s;
struct my_addrinfo *ai, *runp, hints;
addrinfo_t *ai, *runp, hints;
int gaie;
#ifdef HAVE_IPV6
const INT32 b_ipv6 = M_CheckParm("-ipv6");
@@ -1075,7 +1083,7 @@ static boolean UDP_Socket(void)
{
while (M_IsNextParm())
{
gaie = I_getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
gaie = getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1089,13 +1097,13 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
else
{
gaie = I_getaddrinfo("0.0.0.0", serv, &hints, &ai);
gaie = getaddrinfo("0.0.0.0", serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1116,7 +1124,7 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
@@ -1128,7 +1136,7 @@ static boolean UDP_Socket(void)
{
while (M_IsNextParm())
{
gaie = I_getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
gaie = getaddrinfo(M_GetNextParm(), serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1142,13 +1150,13 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
else
{
gaie = I_getaddrinfo("::", serv, &hints, &ai);
gaie = getaddrinfo("::", serv, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1162,7 +1170,7 @@ static boolean UDP_Socket(void)
}
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
}
}
}
@@ -1216,11 +1224,7 @@ boolean I_InitTcpDriver(void)
if (!init_tcp_driver)
{
#ifdef USE_WINSOCK
#ifdef USE_WINSOCK2
const WORD VerNeed = MAKEWORD(2,2);
#else
const WORD VerNeed = MAKEWORD(1,1);
#endif
WSADATA WSAData;
const int WSAresult = WSAStartup(VerNeed, &WSAData);
if (WSAresult != 0)
@@ -1247,21 +1251,14 @@ boolean I_InitTcpDriver(void)
if (WSAresult != WSAVERNOTSUPPORTED)
CONS_Debug(DBG_NETPLAY, "WinSock(TCP/IP) error: %s\n",WSError);
}
#ifdef USE_WINSOCK2
if(LOBYTE(WSAData.wVersion) != 2 ||
if (LOBYTE(WSAData.wVersion) != 2 ||
HIBYTE(WSAData.wVersion) != 2)
{
WSACleanup();
CONS_Debug(DBG_NETPLAY, "No WinSock(TCP/IP) 2.2 driver detected\n");
}
#else
if (LOBYTE(WSAData.wVersion) != 1 ||
HIBYTE(WSAData.wVersion) != 1)
{
WSACleanup();
CONS_Debug(DBG_NETPLAY, "No WinSock(TCP/IP) 1.1 driver detected\n");
}
#endif
CONS_Debug(DBG_NETPLAY, "WinSock description: %s\n",WSAData.szDescription);
CONS_Debug(DBG_NETPLAY, "WinSock System Status: %s\n",WSAData.szSystemStatus);
#endif
@@ -1301,35 +1298,31 @@ void I_ShutdownTcpDriver(void)
CONS_Printf("I_ShutdownTcpDriver: ");
#ifdef USE_WINSOCK
WS_addrinfocleanup();
WSACleanup();
#endif
CONS_Printf("shut down\n");
init_tcp_driver = false;
}
static boolean SOCK_GetAddr(struct sockaddr_in *sin, const char *address, const char *port, boolean test)
static boolean SOCK_GetAddr(mysockaddr_t *sin, const char *address, const char *port, boolean test)
{
struct my_addrinfo *ai = NULL, *runp, hints;
addrinfo_t *ai, *runp, hints;
int gaie;
size_t i;
if (!port || !port[0])
port = DEFAULTPORT;
memset (&hints, 0x00, sizeof (hints));
memset(&hints, 0x00, sizeof (hints));
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo(address, port, &hints, &ai);
gaie = getaddrinfo(address, port, &hints, &ai);
if (gaie != 0)
{
I_freeaddrinfo(ai);
return false;
}
runp = ai;
@@ -1356,7 +1349,7 @@ static boolean SOCK_GetAddr(struct sockaddr_in *sin, const char *address, const
if (runp != NULL)
memcpy(sin, runp->ai_addr, runp->ai_addrlen);
I_freeaddrinfo(ai);
freeaddrinfo(ai);
return (runp != NULL);
}
@@ -1369,7 +1362,7 @@ static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
if (newnode != -1)
{
if (!SOCK_GetAddr(&clientaddress[newnode].ip4, address, port, true))
if (!SOCK_GetAddr(&clientaddress[newnode], address, port, true))
{
nodeconnected[newnode] = false;
return -1;
@@ -1397,7 +1390,7 @@ static void rendezvous(int size)
if (tic != refreshtic)
{
if (SOCK_GetAddr(&rzv.ip4, host, (port ? port : "7777"), false))
if (SOCK_GetAddr(&rzv, host, (port ? port : "7777"), false))
{
refreshtic = tic;
}
@@ -1492,7 +1485,7 @@ static boolean SOCK_Ban(INT32 node)
ban = numbans;
AddBannedIndex();
M_Memcpy(&banned[ban].address, &clientaddress[node], sizeof (mysockaddr_t));
memcpy(&banned[ban].address, &clientaddress[node], sizeof (mysockaddr_t));
if (banned[ban].address.any.sa_family == AF_INET)
{
@@ -1554,7 +1547,7 @@ static boolean SOCK_SetUnbanTime(time_t timestamp)
static boolean SOCK_SetBanAddress(const char *address, const char *mask)
{
struct my_addrinfo *ai, *runp, hints;
addrinfo_t *ai, *runp, hints;
int gaie;
if (!address)
@@ -1566,7 +1559,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
gaie = I_getaddrinfo(address, "0", &hints, &ai);
gaie = getaddrinfo(address, "0", &hints, &ai);
if (gaie != 0)
return false;
@@ -1611,7 +1604,7 @@ static boolean SOCK_SetBanAddress(const char *address, const char *mask)
runp = runp->ai_next;
}
I_freeaddrinfo(ai);
freeaddrinfo(ai);
return true;
}
@@ -1660,8 +1653,6 @@ boolean I_InitTcpNetwork(void)
// FIXME: for dedicated server, numnodes needs to be set to 0 upon start
if (dedicated)
doomcom->numnodes = 0;
/* else if (M_IsNextParm())
doomcom->numnodes = (INT16)atoi(M_GetNextParm());*/
else
doomcom->numnodes = 1;
@@ -1746,5 +1737,3 @@ boolean I_InitTcpNetwork(void)
return ret;
}
#include "i_addrinfo.c"
+3 -1
View File
@@ -94,8 +94,8 @@ INT32 VID_SetMode(INT32 modenum);
\return name of video mode
*/
const char *VID_GetModeName(INT32 modenum);
void VID_PrepareModeList(void); /// note hack for SDL
void VID_PrepareModeList(void);
/** \brief can video system do fullscreen
*/
@@ -143,6 +143,8 @@ boolean I_CheckNativeRes(void);
void I_SetBorderlessWindow(void);
void I_HandleControllerHatRepeat(void);
#ifdef USE_FBO_OGL
void RefreshOGLSDLSurface(void);
+5
View File
@@ -10,9 +10,14 @@
/// \file k_director.h
/// \brief SRB2kart automatic spectator camera.
#ifndef __K_DIRECTOR__
#define __K_DIRECTOR__
boolean K_DirectorIsAvailable(void);
void K_InitDirector(void);
void K_UpdateDirector(void);
void K_DrawDirectorDebugger(void);
void K_DirectorFollowAttack(player_t *player, mobj_t *inflictor, mobj_t *source);
void K_ToggleDirector(void);
#endif
+1 -1
View File
@@ -4333,7 +4333,7 @@ static void K_drawInput(void)
target = 0;
else // turning of multiple strengths!
{
target = ((abs(cmd->driftturn) - 1)/125)+1;
target = ((abs(cmd->driftturn) - 1)/200)+1; // was 125, do we need another toggle for this? Zzz...
if (target > 4)
target = 4;
if (cmd->driftturn < 0)
+6 -6
View File
@@ -608,9 +608,6 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
if (color >= MAXTRANSLATIONS)
I_Error("Invalid skin color #%hu.", (UINT16)color);
if (skinnum < 0 && skinnum > TC_DEFAULT)
I_Error("Invalid translation colormap index %d.", skinnum);
starttranscolor = (skinnum != TC_DEFAULT) ? K_GetSkinArray(local)[skinnum].starttranscolor : DEFAULT_STARTTRANSCOLOR;
if (starttranscolor >= NUM_PALETTE_ENTRIES)
@@ -640,11 +637,14 @@ void K_GenerateKartColormap(UINT8 *dest_colormap, INT32 skinnum, UINT8 color, bo
UINT8 K_GetKartColorByName(const char *name)
{
UINT8 color = (UINT8)atoi(name);
if (color > 0 && color < MAXSKINCOLORS)
return color;
for (color = 1; color < MAXSKINCOLORS; color++)
if (!stricmp(KartColor_Names[color], name))
if (fasticmp(KartColor_Names[color], name))
return color;
return 0;
}
@@ -2860,9 +2860,9 @@ void K_SpawnKartExplosion(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32
v[3] = FRACUNIT;
res = VectorMatrixMultiply(v, *RotateXMatrix(rotangle));
M_Memcpy(&v, res, sizeof (v));
memcpy(&v, res, sizeof (v));
res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
M_Memcpy(&v, res, sizeof (v));
memcpy(&v, res, sizeof (v));
finalx = x + v[0];
finaly = y + v[1];
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file k_stats.c
/// \brief Game statistics handling
#include "k_stats.h"
#include "doomstat.h"
#include "g_game.h"
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file k_stats.h
/// \brief Game statistics handling
#ifndef __K_STATS__
#define __K_STATS__
+43 -36
View File
@@ -45,27 +45,33 @@ boolean luaL_checkboolean(lua_State *L, int narg) {
// String concatination
static int lib_concat(lua_State *L)
{
int n = lua_gettop(L); /* number of arguments */
int i;
char *r = NULL;
size_t rl = 0,sl;
lua_getglobal(L, "tostring");
for (i=1; i<=n; i++) {
const char *s;
lua_pushvalue(L, -1); /* function to be called */
lua_pushvalue(L, i); /* value to print */
lua_call(L, 1, 1);
s = lua_tolstring(L, -1, &sl); /* get result */
if (s == NULL)
return luaL_error(L, LUA_QL("tostring") " must return a string to "
LUA_QL("__add"));
int n = lua_gettop(L); /* number of arguments */
int i;
char *r = NULL;
size_t rl = 0, sl;
lua_getglobal(L, "tostring");
for (i=1; i<=n; i++) {
const char *s;
lua_pushvalue(L, -1); /* function to be called */
lua_pushvalue(L, i); /* value to print */
lua_call(L, 1, 1);
s = lua_tolstring(L, -1, &sl); /* get result */
if (sl == 0) {
lua_pop(L, 1); /* pop result */
continue;
}
if (s == NULL)
return luaL_error(L, LUA_QL("tostring") " must return a string to "
LUA_QL("__add"));
r = Z_Realloc(r, rl+sl, PU_STATIC, NULL);
M_Memcpy(r+rl, s, sl);
memcpy(r+rl, s, sl);
rl += sl;
lua_pop(L, 1); /* pop result */
}
lua_pushlstring(L, r, rl);
Z_Free(r);
lua_pop(L, 1); /* pop result */
}
lua_pushlstring(L, r, rl);
Z_Free(r);
return 1;
}
@@ -73,23 +79,24 @@ static int lib_concat(lua_State *L)
// Copied from base Lua code
static int lib_print(lua_State *L)
{
int n = lua_gettop(L); /* number of arguments */
int i;
//HUDSAFE
lua_getglobal(L, "tostring");
for (i=1; i<=n; i++) {
const char *s;
lua_pushvalue(L, -1); /* function to be called */
lua_pushvalue(L, i); /* value to print */
lua_call(L, 1, 1);
s = lua_tostring(L, -1); /* get result */
if (s == NULL)
return luaL_error(L, LUA_QL("tostring") " must return a string to "
LUA_QL("print"));
if (i>1) CONS_Printf("\n");
CONS_Printf("%s", s);
lua_pop(L, 1); /* pop result */
}
int n = lua_gettop(L); /* number of arguments */
int i;
//HUDSAFE
lua_getglobal(L, "tostring");
for (i=1; i<=n; i++) {
const char *s;
lua_pushvalue(L, -1); /* function to be called */
lua_pushvalue(L, i); /* value to print */
lua_call(L, 1, 1);
s = lua_tostring(L, -1); /* get result */
if (s == NULL)
return luaL_error(L, LUA_QL("tostring") " must return a string to "
LUA_QL("print"));
if (i>1) CONS_Printf("\n");
CONS_Printf("%s", s);
lua_pop(L, 1); /* pop result */
}
CONS_Printf("\n");
return 0;
}
+62 -57
View File
@@ -28,13 +28,29 @@
#define NOHUD if (hud_running) return luaL_error(L, "HUD rendering code should not call this function!");
static const char *cvname = NULL;
static consvar_t *this_cvar;
void Got_Luacmd(UINT8 **cp, INT32 playernum)
static void clear_lua_stack(void)
{
if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
lua_settop(gL, 0); // clear stack
}
void Got_Luacmd(const UINT8 **cp, INT32 playernum)
{
UINT8 i, argc, flags;
const char *argv[256];
char buf[256];
argc = READUINT8(*cp);
argv[0] = (const char*)*cp;
SKIPSTRINGN(*cp, 255);
for (i = 1; i < argc; i++)
{
argv[i] = (const char*)*cp;
SKIPSTRINGN(*cp, 255);
}
// don't use I_Assert here, goto the deny code below
// to clean up and kick people who try nefarious exploits
// like sending random junk lua commands to crash the server
@@ -47,8 +63,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
lua_getfield(gL, LUA_REGISTRYINDEX, "COM_Command"); // push COM_Command
if (!lua_istable(gL, -1)) goto deny;
argc = READUINT8(*cp);
READSTRINGN(*cp, buf, 255);
strlcpy(buf, argv[0], 255);
strlwr(buf); // must lowercase buffer
lua_getfield(gL, -1, buf); // push command info table
if (!lua_istable(gL, -1)) goto deny;
@@ -74,10 +89,17 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
lua_remove(gL, -2); // pop command info table
if (!lua_checkstack(gL, argc)) // player + command arguments
{
clear_lua_stack();
CONS_Alert(CONS_WARNING, "lua command stack overflow from %s (%d, need %d more)\n", player_names[playernum], lua_gettop(gL), argc);
return;
}
LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
for (i = 1; i < argc; i++)
{
READSTRINGN(*cp, buf, 255);
strlcpy(buf, argv[i], 255);
lua_pushstring(gL, buf);
}
LUA_Call(gL, (int)argc, 0, 1); // argc is 1-based, so this will cover the player we passed too.
@@ -88,8 +110,7 @@ void Got_Luacmd(UINT8 **cp, INT32 playernum)
deny:
//must be hacked/buggy client
if (gL) // check if Lua is actually turned on first, you dummmy -- Monster Iestyn 04/07/18
lua_settop(gL, 0); // clear stack
clear_lua_stack();
CONS_Alert(CONS_WARNING, M_GetText("Illegal lua command received from %s\n"), player_names[playernum]);
if (server)
@@ -133,7 +154,7 @@ void COM_Lua_f(void)
{
if (!splitscreen)
{
lua_pop(gL, 1); // pop command info table
lua_pop(gL, 2); // pop command info table and LUA_GetErrorMessage
return; // can't execute splitscreen command without player 2!
}
@@ -178,6 +199,13 @@ void COM_Lua_f(void)
I_Assert(lua_isfunction(gL, -1));
lua_remove(gL, -2); // pop command info table
if (!lua_checkstack(gL, COM_Argc() + 1))
{
CONS_Alert(CONS_WARNING, "lua command stack overflow (%d, need %s more)\n", lua_gettop(gL), sizeu1(COM_Argc() + 1));
lua_pop(gL, 2); // pop function and LUA_GetErrorMessage
return;
}
LUA_PushUserdata(gL, &players[playernum], META_PLAYER);
for (i = 1; i < COM_Argc(); i++)
lua_pushstring(gL, COM_Argv(i));
@@ -284,16 +312,13 @@ static int lib_comBufInsertText(lua_State *L)
return 0;
}
void LUA_CVarChanged(const char *name)
void LUA_CVarChanged(void *cvar)
{
cvname = name;
this_cvar = cvar;
}
static void Lua_OnChange(void)
{
I_Assert(gL != NULL);
I_Assert(cvname != NULL);
/// \todo Network this! XD_LUAVAR
// Why?..
@@ -305,13 +330,10 @@ static void Lua_OnChange(void)
// From CV_OnChange registry field, get the function for this cvar by name.
lua_getfield(gL, LUA_REGISTRYINDEX, "CV_OnChange");
I_Assert(lua_istable(gL, -1));
lua_getfield(gL, -1, cvname); // get function
lua_pushlightuserdata(gL, this_cvar);
lua_rawget(gL, -2); // get function
// From the CV_Vars registry field, get the cvar's userdata by name.
lua_getfield(gL, LUA_REGISTRYINDEX, "CV_Vars");
I_Assert(lua_istable(gL, -1));
lua_getfield(gL, -1, cvname); // get consvar_t* userdata.
lua_remove(gL, -2); // pop the CV_Vars table.
LUA_RawPushUserdata(gL, this_cvar);
LUA_Call(gL, 1, 0, error_handler_i); // call function(cvar)
lua_pop(gL, 2); // pop CV_OnChange table and error handler
@@ -329,9 +351,8 @@ static int lib_cvRegisterVar(lua_State *L)
luaL_checktype(L, 1, LUA_TTABLE);
lua_settop(L, 1); // Clear out all other possible arguments, leaving only the first one.
NOHUD
cvar = lua_newuserdata(L, sizeof(consvar_t));
luaL_getmetatable(L, META_CVAR);
lua_setmetatable(L, -2);
cvar = ZZ_Calloc(sizeof(consvar_t));
LUA_PushUserdata(L, cvar, META_CVAR);
#define FIELDERROR(f, e) luaL_error(L, "bad value for " LUA_QL(f) " in table passed to " LUA_QL("CV_RegisterVar") " (%s)", e);
#define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))
@@ -384,7 +405,7 @@ static int lib_cvRegisterVar(lua_State *L)
lua_getfield(L, LUA_REGISTRYINDEX, "CV_PossibleValue");
I_Assert(lua_istable(L, 5));
lua_pushvalue(L, 2); // cvar userdata
lua_pushlightuserdata(L, cvar);
cvpv = lua_newuserdata(L, sizeof(CV_PossibleValue_t) * (count+1));
lua_rawset(L, 5);
lua_pop(L, 1); // pop CV_PossibleValue registry table
@@ -412,13 +433,14 @@ static int lib_cvRegisterVar(lua_State *L)
TYPEERROR("func", LUA_TFUNCTION)
lua_getfield(L, LUA_REGISTRYINDEX, "CV_OnChange");
I_Assert(lua_istable(L, 5));
lua_pushlightuserdata(L, cvar);
lua_pushvalue(L, 4);
lua_setfield(L, 5, cvar->name);
lua_rawset(L, 5);
lua_pop(L, 1);
cvar->func = Lua_OnChange;
}
else if (((i == 5 && !(cvar->flags & CV_CALL))
|| (cvar->flags & CV_CALL && i == 6))
|| (cvar->flags & CV_CALL && i == 6))
|| (k && fasticmp(k, "category")))
{
category = lua_isnoneornil(L, 4) ? NULL : lua_tostring(L, 4);
@@ -434,18 +456,12 @@ static int lib_cvRegisterVar(lua_State *L)
#undef FIELDERROR
#undef TYPEERROR
// stack: cvar table, cvar userdata
lua_getfield(L, LUA_REGISTRYINDEX, "CV_Vars");
I_Assert(lua_istable(L, 3));
lua_getfield(L, 3, cvar->name);
if (lua_type(L, -1) != LUA_TNIL)
return luaL_error(L, M_GetText("Variable %s is already defined\n"), cvar->name);
lua_pop(L, 1);
lua_pushvalue(L, 2);
lua_setfield(L, 3, cvar->name);
lua_pop(L, 1);
if (!cvar->name)
return luaL_error(L, M_GetText("Variable has no name!\n"));
if ((cvar->flags & CV_NOINIT) && !(cvar->flags & CV_CALL))
return luaL_error(L, M_GetText("Variable %s has CV_NOINIT without CV_CALL\n"), cvar->name);
if ((cvar->flags & CV_CALL) && !cvar->func)
return luaL_error(L, M_GetText("Variable %s has CV_CALL without a function\n"), cvar->name);
// actually time to register it to the console now! Finally!
cvar->flags |= CV_MODIFIED;
@@ -453,7 +469,7 @@ static int lib_cvRegisterVar(lua_State *L)
if (cvar->flags & CV_MODIFIED)
return luaL_error(L, "failed to register cvar (probable conflict with internal variable/command names)");
if (!(((cvar->flags & CV_HIDEN)) || (cvar->flags & CV_NOSHOWHELP)) && (cvar->PossibleValue || !(cvar->value == 0 && stricmp(cvar->string, "0"))))
if (!(((cvar->flags & CV_HIDEN)) || (cvar->flags & CV_NOSHOWHELP)) && (cvar->PossibleValue || !(cvar->value == 0 && !fasticmp(cvar->string, "0"))))
{
if (!category)
{
@@ -477,22 +493,9 @@ static int lib_cvRegisterVar(lua_State *L)
static int lib_cvFindVar(lua_State *L)
{
consvar_t *cv;
if (( cv = CV_FindVar(luaL_checkstring(L,1)) ))
{
lua_settop(L,1);/* We only want one argument in the stack. */
lua_pushlightuserdata(L, cv);/* Now the second value on stack. */
luaL_getmetatable(L, META_CVAR);
/*
The metatable is the last value on the stack, so this
applies it to the second value, which is the cvar.
*/
lua_setmetatable(L,2);
lua_pushvalue(L,2);
return 1;
}
else
return 0;
const char *name = luaL_checkstring(L, 1);
LUA_PushUserdata(L, CV_FindVar(name), META_CVAR);
return 1;
}
static int CVarSetFunction
@@ -501,7 +504,7 @@ static int CVarSetFunction
void (*Set)(consvar_t *, const char *),
void (*SetValue)(consvar_t *, INT32)
){
consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
switch (lua_type(L, 2))
{
@@ -530,7 +533,8 @@ static int lib_cvStealthSet(lua_State *L)
static int lib_cvAddValue(lua_State *L)
{
consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
CV_AddValue(cvar, (INT32)luaL_checknumber(L, 2));
return 0;
}
@@ -545,6 +549,7 @@ static int lib_consPrintf(lua_State *L)
if (n < 2)
return luaL_error(L, "CONS_Printf requires at least two arguments: player and text.");
//HUDSAFE
plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
if (!plr)
return LUA_ErrInvalid(L, "player_t");
@@ -605,7 +610,7 @@ static int cvar_fields_ref = LUA_NOREF;
static int cvar_get(lua_State *L)
{
consvar_t *cvar = (consvar_t *)luaL_checkudata(L, 1, META_CVAR);
consvar_t *cvar = *(consvar_t **)luaL_checkudata(L, 1, META_CVAR);
enum cvar_e field = Lua_optoption(L, 2, -1, cvar_fields_ref);
switch (field)
+5
View File
@@ -10,6 +10,9 @@
/// \file lua_hook.h
/// \brief hooks for Lua scripting
#ifndef __LUA_HOOK__
#define __LUA_HOOK__
#include "r_defs.h"
#include "d_player.h"
#include "s_sound.h"
@@ -146,3 +149,5 @@ boolean LUA_HookPlayerSquish(player_t *player, mobj_t *inflictor, mobj_t *source
// (note: function format in lua doesn't include maxresults, so its function(result, gametype, secondgametype, prevmap)
// to get maxresults use #result)
void LUA_HookSetupVote(INT16 result[], INT16 maxresults, UINT8 gt, UINT8 secondgt);
#endif //__LUA_HOOK__
+3 -3
View File
@@ -83,7 +83,7 @@ FUNCINLINE static ATTRINLINE unsigned hook_in_list
for (type = 0; list[type] != NULL; ++type)
{
if (strcmp(name, list[type]) == 0)
if (fastcmp(name, list[type]))
break;
}
@@ -240,7 +240,7 @@ static int lib_addHook(lua_State *L)
{
add_hook(&hookIds[type]);
}
/*else if (strcmp(name, "HUD") == 0) // ehh this is cool and all, but i dont want modders potentially breaking vanilla clients lol
/*else if (fastcmp(name, "HUD")) // ehh this is cool and all, but i dont want modders potentially breaking vanilla clients lol
{
add_hud_hook(L, 3);
}*/
@@ -818,7 +818,7 @@ typedef struct {
FUNCINLINE static ATTRINLINE boolean checkbotkey(const char *field)
{
return lua_toboolean(gL, -1) && strcmp(lua_tostring(gL, -2), field) == 0;
return lua_toboolean(gL, -1) && fastcmp(lua_tostring(gL, -2), field);
}
static void res_botai(Hook_State *hook)
+5
View File
@@ -10,6 +10,9 @@
/// \file lua_libs.h
/// \brief libraries for Lua scripting
#ifndef __LUA_LIBS__
#define __LUA_LIBS__
#include "doomtype.h"
#include "blua/lua.h"
@@ -73,3 +76,5 @@ int LUA_ThinkerLib(lua_State *L);
int LUA_MapLib(lua_State *L);
int LUA_BlockmapLib(lua_State *L);
int LUA_HudLib(lua_State *L);
#endif //__LUA_LIBS__
+3 -3
View File
@@ -455,12 +455,12 @@ int mobj_localskin_setter(lua_State *L)
strlcpy(skin, luaL_optstring(L, 2, "none"), sizeof skin);
strlwr(skin); // all skin names are lowercase
if (stricmp(skin, "none"))
if (!fasticmp(skin, "none"))
{
// Try localskins
for (i = 0; i < numlocalskins; i++)
{
if (stricmp(localskins[i].name, skin) == 0)
if (fasticmp(localskins[i].name, skin))
{
mo->localskin = &localskins[i];
mo->skinlocal = true;
@@ -471,7 +471,7 @@ int mobj_localskin_setter(lua_State *L)
// Try other skins
for (i = 0; i < numskins; i++)
{
if (stricmp(skins[i].name, skin) == 0)
if (fasticmp(skins[i].name, skin))
{
mo->localskin = &skins[i];
mo->skinlocal = false;
+86 -19
View File
@@ -288,6 +288,10 @@ void LUA_LoadLump(UINT16 wad, UINT16 lump)
lumpinfo_t *lump_p = &wadfiles[wad]->lumpinfo[lump];
len += 1 + strlen(lump_p->fullname); // length of file name, '|', and lump name
name = malloc(len+1);
if (!name)
I_Error("LUA_LoadLump: Out of memory!\n");
sprintf(name, "%s|%s", wadfiles[wad]->filename, lump_p->fullname);
name[len] = '\0';
}
@@ -488,25 +492,37 @@ void LUA_InvalidateMathlibCache(const char *name)
// Pushes it to the stack and stores it in the registry.
void LUA_PushUserdata(lua_State *L, void *data, const char *meta)
{
if (LUA_RawPushUserdata(L, data) == LPUSHED_NEW)
{
luaL_getmetatable(L, meta);
lua_setmetatable(L, -2);
}
}
// Same as LUA_PushUserdata but don't set a metatable yet.
lpushed_t LUA_RawPushUserdata(lua_State *L, void *data)
{
lpushed_t status = LPUSHED_NIL;
void **userdata;
if (!data) { // push a NULL
lua_pushnil(L);
return;
return status;
}
lua_getfield(L, LUA_REGISTRYINDEX, LREG_VALID);
I_Assert(lua_istable(L, -1));
lua_pushlightuserdata(L, data);
lua_rawget(L, -2);
if (lua_isnil(L, -1)) { // no userdata? deary me, we'll have to make one.
lua_pop(L, 1); // pop the nil
// create the userdata
userdata = lua_newuserdata(L, sizeof(void *));
*userdata = data;
luaL_getmetatable(L, meta);
lua_setmetatable(L, -2);
// Set it in the registry so we can find it again
lua_pushlightuserdata(L, data); // k (store the userdata via the data's pointer)
@@ -514,8 +530,15 @@ void LUA_PushUserdata(lua_State *L, void *data, const char *meta)
lua_rawset(L, -4);
// stack is left with the userdata on top, as if getting it had originally succeeded.
status = LPUSHED_NEW;
}
else
status = LPUSHED_EXISTING;
lua_remove(L, -2); // remove LREG_VALID
return status;
}
// When userdata is freed, use this function to remove it from Lua.
@@ -797,8 +820,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mobj_t *mobj = *((mobj_t **)lua_touserdata(gL, myindex));
if (!mobj)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MOBJ);
WRITEUINT32(*p, mobj->mobjnum);
}
@@ -808,8 +835,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
player_t *player = *((player_t **)lua_touserdata(gL, myindex));
if (!player)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_PLAYER);
WRITEUINT8(*p, player - players);
}
@@ -819,8 +850,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mapthing_t *mapthing = *((mapthing_t **)lua_touserdata(gL, myindex));
if (!mapthing)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MAPTHING);
WRITEUINT16(*p, mapthing - mapthings);
}
@@ -830,8 +865,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
vertex_t *vertex = *((vertex_t **)lua_touserdata(gL, myindex));
if (!vertex)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_VERTEX);
WRITEUINT16(*p, vertex - vertexes);
}
@@ -841,8 +880,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
line_t *line = *((line_t **)lua_touserdata(gL, myindex));
if (!line)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_LINE);
WRITEUINT16(*p, line - lines);
}
@@ -852,8 +895,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
side_t *side = *((side_t **)lua_touserdata(gL, myindex));
if (!side)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SIDE);
WRITEUINT16(*p, side - sides);
}
@@ -863,8 +910,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
subsector_t *subsector = *((subsector_t **)lua_touserdata(gL, myindex));
if (!subsector)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SUBSECTOR);
WRITEUINT16(*p, subsector - subsectors);
}
@@ -874,8 +925,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
sector_t *sector = *((sector_t **)lua_touserdata(gL, myindex));
if (!sector)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SECTOR);
WRITEUINT16(*p, sector - sectors);
}
@@ -885,8 +940,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
pslope_t *slope = *((pslope_t **)lua_touserdata(gL, myindex));
if (!slope)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_SLOPE);
WRITEUINT16(*p, slope->id);
}
@@ -896,8 +955,12 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
{
mapheader_t *header = *((mapheader_t **)lua_touserdata(gL, myindex));
if (!header)
{
WRITEUINT8(*p, ARCH_NULL);
else {
return 3;
}
else
{
WRITEUINT8(*p, ARCH_MAPHEADER);
WRITEUINT16(*p, header - *mapheaderinfo);
}
@@ -1003,19 +1066,23 @@ static void ArchiveTables(UINT8 **p)
e = ArchiveValue(p, TABLESINDEX, -2); // key should be either a number or a string, ArchiveValue can handle this.
if (e == 2) // invalid key type (function, thread, lightuserdata, or anything we don't recognise)
{
lua_pushvalue(gL, -2);
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -1), luaL_typename(gL, -1), i);
lua_pop(gL, 1);
CONS_Alert(CONS_ERROR, "Index '%s' (%s) of table %d could not be archived!\n", lua_tostring(gL, -2), luaL_typename(gL, -2), i);
}
else if (e == 3) // nil key due to invalid userdata. NOT an error.
{
lua_pop(gL, 1);
continue;
}
// Write value
e = ArchiveValue(p, TABLESINDEX, -1);
if (e == 1)
{
n++; // the table contained a new table we'll have to archive. :(
}
else if (e == 2) // invalid value type
{
lua_pushvalue(gL, -2);
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -1), luaL_typename(gL, -1));
lua_pop(gL, 1);
CONS_Alert(CONS_ERROR, "Type of value for table %d entry '%s' (%s) could not be archived!\n", i, lua_tostring(gL, -2), luaL_typename(gL, -1));
}
lua_pop(gL, 1);
+10 -2
View File
@@ -59,7 +59,15 @@ fixed_t LUA_GetConstant(const char *word);
// Need better name for this ;-;
void LUA_InvalidateMathlibCache(const char *name);
typedef enum {
LPUSHED_NIL,
LPUSHED_NEW,
LPUSHED_EXISTING,
} lpushed_t;
void LUA_PushUserdata(lua_State *L, void *data, const char *meta);
lpushed_t LUA_RawPushUserdata(lua_State *L, void *data);
void LUA_InvalidateUserdata(void *data);
void LUA_InvalidateLevel(void);
void LUA_InvalidateMapthings(void);
@@ -68,8 +76,8 @@ void LUA_InvalidatePlayer(player_t *player);
void LUA_Archive(savebuffer_t *save, boolean network);
void LUA_UnArchive(savebuffer_t *save, boolean network);
void Got_Luacmd(UINT8 **cp, INT32 playernum); // lua_consolelib.c
void LUA_CVarChanged(const char *name); // lua_consolelib.c
void Got_Luacmd(const UINT8 **cp, INT32 playernum); // lua_consolelib.c
void LUA_CVarChanged(void *cvar); // lua_consolelib.c
int Lua_optoption(lua_State *L, int narg, int def, int list_ref);
int Lua_CreateFieldTable(lua_State *L, const char *const lst[]);
void LUA_HookNetArchive(lua_CFunction archFunc, savebuffer_t *save);
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file lua_udatalib.c
/// \brief Implementation of lua userdata object metatables based on getter/setter functions
#include "doomtype.h"
#include "m_fixed.h"
#include "lua_udatalib.h"
+12 -1
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file lua_udatalib.h
/// \brief Implementation of lua userdata object metatables based on getter/setter functions
#ifndef __LUA_UDATALIB_H__
#define __LUA_UDATALIB_H__
@@ -100,4 +111,4 @@ void udatalib_addfields(lua_State *L, int mt, const udata_field_t fields[]);
return 0; \
}
#endif
#endif
+2 -2
View File
@@ -192,7 +192,7 @@ lzf_decompress (const void *const in_data, size_t in_len,
#endif
#if USE_MEMCPY
M_Memcpy (op, ip, ctrl);
memcpy(op, ip, ctrl);
op += ctrl;
ip += ctrl;
#else
@@ -435,7 +435,7 @@ lzf_compress (const void *const in_data,size_t in_len,
*op++ = MAX_LIT - 1;
#if USE_MEMCPY
M_Memcpy (op, ip - MAX_LIT, MAX_LIT);
memcpy(op, ip - MAX_LIT, MAX_LIT);
op += MAX_LIT;
lit = 0;
#else
+2 -2
View File
@@ -183,7 +183,7 @@ static aatree_node_t *M_AATreeSetString_Node(aatree_node_t *node, UINT32 flags,
else
{
aatree_entry_t *entry = node->value;
if (entry != NULL && strcmp(entry->key, key) != 0)
if (entry != NULL && !fastcmp(entry->key, key))
entry = entry->next;
if (entry != NULL)
{
@@ -252,7 +252,7 @@ void *M_AATreeGetString(aatree_t *aatree, const char *key)
I_Assert((aatree->flags & AATREE_STRING) == AATREE_STRING);
UINT32 hash = FNV1a_HashString(key);
aatree_entry_t *entry = M_AATreeGet_Node(aatree->root, hash);
while (entry != NULL && strcmp(entry->key, key) != 0)
while (entry != NULL && !fastcmp(entry->key, key))
entry = entry->next;
return entry != NULL ? entry->value : NULL;
}
+6 -4
View File
@@ -49,7 +49,7 @@ INT32 M_CheckParm(const char *check)
for (i = 1; i < myargc; i++)
{
if (!strcasecmp(check, myargv[i]))
if (fasticmp(check, myargv[i]))
{
found = i;
return i;
@@ -69,16 +69,18 @@ INT32 M_CheckProtoParam(const char *check)
for (i = 1; i < myargc; i++)
{
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
{
if (strncmp(myargv[i]+11, check, strlen(check))==0)
if (strncmp(myargv[i]+11, check, strlen(check)) == 0)
{
found = i;
return i;
}
}
}
found = 0;
return 0;
}
@@ -93,7 +95,7 @@ const char *M_GetProtoParam(void)
for (i = 1; i < myargc; i++)
{
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
if (strncmp(myargv[i], "srb2kart://", 11) == 0)
{
string = strchr(myargv[i], '/');
string = strchr(string+1, '/');
+5
View File
@@ -10,6 +10,9 @@
/// \file m_cond.h
/// \brief Unlockable condition system for SRB2 version 2.1
#ifndef __M_COND__
#define __M_COND__
#include "doomdef.h"
// --------
@@ -182,3 +185,5 @@ UINT8 M_GotLowEnoughTime(INT32 tictime);
//UINT8 M_GotHighEnoughRings(INT32 trings);
#define M_Achieved(a) ((a) >= MAXCONDITIONSETS || conditionSets[a].achieved)
#endif //__M_COND__
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file m_curl.c
/// \brief Common curl-related functions shared across http-mserv and file download
#include "m_curl.h"
#include "doomtype.h"
#include "i_system.h" // I_OutputMsg
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file m_curl.h
/// \brief Common curl-related functions shared across http-mserv and file download
#ifndef __M_CURL__
#define __M_CURL__
+15 -4
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file m_emotes.cpp
/// \brief Chat emotes handling
#include <map>
#include <string>
#include <sstream>
@@ -81,7 +92,7 @@ void M_LoadEmotes(UINT16 wadnum)
if (emote_name.size() > MAXEMOTENAME)
{
CONS_Alert(CONS_WARNING, "EMOTES: Emote name is too long, truncating. (file %s, line %d)\n", wadfiles[wadnum]->filename, linenum);
emote_name = emote_name.substr(0, MAXEMOTENAME);
emote_name.resize(MAXEMOTENAME);
}
emote = &emotes[emote_name];
@@ -101,7 +112,7 @@ void M_LoadEmotes(UINT16 wadnum)
trim(field);
trim(value);
if (stricmp(field.c_str(), "frames") == 0)
if (fasticmp(field.c_str(), "frames"))
{
UINT8 numframes = 0;
@@ -128,7 +139,7 @@ void M_LoadEmotes(UINT16 wadnum)
if (framelumpname.size() > 8)
{
CONS_Alert(CONS_WARNING, "EMOTES: Frame %d name is too long. (file %s, line %d)", numframes, wadfiles[wadnum]->filename, linenum);
framelumpname = framelumpname.substr(0, 8);
framelumpname.resize(8);
}
std::strncpy(emote->frames[numframes], framelumpname.c_str(), framelumpname.size()+1);
@@ -147,7 +158,7 @@ void M_LoadEmotes(UINT16 wadnum)
emote->numframes = numframes;
}
else if (stricmp(field.c_str(), "timeperframe") == 0)
else if (fasticmp(field.c_str(), "timeperframe"))
{
emote->timeperframe = std::stoi(value);
+11
View File
@@ -1,3 +1,14 @@
// SONIC ROBO BLAST 2 KART SATURN
//-----------------------------------------------------------------------------
// Copyright (C) 2025 by Indev.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file m_emotes.h
/// \brief Chat emotes handling
#ifndef __M_EMOTES__
#define __M_EMOTES__
+3 -3
View File
@@ -101,7 +101,7 @@ vector2_t *FV2_UnLoad(vector2_t *vec, fixed_t *x, fixed_t *y)
vector2_t *FV2_Copy(vector2_t *a_o, const vector2_t *a_i)
{
return M_Memcpy(a_o, a_i, sizeof(vector2_t));
return memcpy(a_o, a_i, sizeof(vector2_t));
}
vector2_t *FV2_AddEx(const vector2_t *a_i, const vector2_t *a_c, vector2_t *a_o)
@@ -250,7 +250,7 @@ vector3_t *FV3_UnLoad(vector3_t *vec, fixed_t *x, fixed_t *y, fixed_t *z)
vector3_t *FV3_Copy(vector3_t *a_o, const vector3_t *a_i)
{
return M_Memcpy(a_o, a_i, sizeof(vector3_t));
return memcpy(a_o, a_i, sizeof(vector3_t));
}
vector3_t *FV3_AddEx(const vector3_t *a_i, const vector3_t *a_c, vector3_t *a_o)
@@ -813,7 +813,7 @@ void FM_MultMatrix(matrix_t *dest, const matrix_t *multme)
R(i, j) = FixedMul(D(i, 0), M(0, j)) + FixedMul(D(i, 1), M(1, j)) + FixedMul(D(i, 2), M(2, j)) + FixedMul(D(i, 3), M(3, j));
}
M_Memcpy(dest, &result, sizeof(matrix_t));
memcpy(dest, &result, sizeof(matrix_t));
#undef R
#undef D
+51 -60
View File
@@ -702,7 +702,13 @@ static void M_CheckStringItem(void)
// Just in case
memset(menu_text_input_buf, 0, sizeof menu_text_input_buf);
M_TextInputInit(&menuinput, menu_text_input_buf, sizeof menu_text_input_buf);
// special case: name input, cap it to prevent writing outside the textbox
// kinda ugly but itll work
if (cv == &cv_playername)
M_TextInputInit(&menuinput, menu_text_input_buf, MAXPLAYERNAME +1);
else
M_TextInputInit(&menuinput, menu_text_input_buf, sizeof menu_text_input_buf);
M_TextInputSetString(&menuinput, cv->string);
}
@@ -753,8 +759,6 @@ static void Command_Manual_f(void)
itemOn = 0;
}
boolean dpadscrollstate[4] = {false, false, false, false};
//
// M_Responder
//
@@ -801,19 +805,15 @@ boolean M_Responder(event_t *ev)
break;
case KEY_HAT1:
ch = KEY_UPARROW;
dpadscrollstate[DPAD_UP] = true;
break;
case KEY_HAT1 + 1:
ch = KEY_DOWNARROW;
dpadscrollstate[DPAD_DOWN] = true;
break;
case KEY_HAT1 + 2:
ch = KEY_LEFTARROW;
dpadscrollstate[DPAD_LEFT] = true;
break;
case KEY_HAT1 + 3:
ch = KEY_RIGHTARROW;
dpadscrollstate[DPAD_RIGHT] = true;
break;
}
@@ -829,24 +829,6 @@ boolean M_Responder(event_t *ev)
}
}
}
else if (ev->type == ev_keyup)
{
switch (ev->data1) // if you let go of those set those to false
{
case KEY_HAT1:
dpadscrollstate[DPAD_UP] = false;
break;
case KEY_HAT1 + 1:
dpadscrollstate[DPAD_DOWN] = false;
break;
case KEY_HAT1 + 2:
dpadscrollstate[DPAD_LEFT] = false;
break;
case KEY_HAT1 + 3:
dpadscrollstate[DPAD_RIGHT] = false;
break;
}
}
else if (menuactive)
{
tic_t thistime = I_GetTime();
@@ -1432,10 +1414,11 @@ void M_Drawer(void)
V_DrawThinString(vid.dup, vid.height - 20*vid.dup, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, compbranch);
V_DrawThinString(vid.dup, vid.height - 10*vid.dup, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, comprevision);
#else // Regular build
V_DrawThinString(vid.dup, vid.height - 20*vid.dup, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, comprevision); // Removeur this for release! im just lazy to make a new flag or smth
#ifdef SATURN_TESTING // ok not regular build lmao, we dont need to show this stuff in Saturn release builds
V_DrawThinString(vid.dup, vid.height - 20*vid.dup, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, comprevision);
#endif
V_DrawThinString(vid.dup, vid.height - 10*vid.dup, V_NOSCALESTART|V_TRANSLUCENT|V_ALLOWLOWERCASE, va("%s", VERSIONSTRING));
#endif
#ifdef HWRENDER
if (rendermode == render_opengl)
V_DrawThinString(0, 0, V_GREENMAP|V_SNAPTOTOP|V_SNAPTOLEFT|V_TRANSLUCENT|V_ALLOWLOWERCASE, ("Opengl"));
@@ -1724,6 +1707,9 @@ void M_Ticker(void)
if (dedicated)
return;
if (menuactive)
I_HandleControllerHatRepeat();
if (--skullAnimCounter <= 0)
skullAnimCounter = 8;
@@ -2712,6 +2698,10 @@ static void M_PrepareLevelSelect(void)
//
boolean M_CanShowLevelInList(INT32 mapnum, INT32 gt)
{
// invalid mapnum
if (mapnum < -1)
return false;
// Random map!
if (mapnum == -1)
return (gamestate != GS_TIMEATTACK && !modeattacking);
@@ -3102,7 +3092,7 @@ static void M_AddonsInternal(void)
break;
}
strlcpy(menupath, pathname, 1024);
strlcpy(menupath, pathname, MAXFILEPATH);
menupathindex[(menudepthleft = menudepth-1)] = strlen(menupath) + 1;
if (menupath[menupathindex[menudepthleft]-2] != PATHSEP[0])
@@ -3215,9 +3205,9 @@ static void M_DrawTemperature(INT32 x, fixed_t t)
static char *M_AddonsHeaderPath(void)
{
UINT32 len;
static char header[1024];
static char header[MAXFILEPATH];
strlcpy(header, va("%s folder%s", cv_addons_option.string, menupath+menupathindex[menudepth-1]-1), 1024);
strlcpy(header, va("%s folder%s", cv_addons_option.string, menupath+menupathindex[menudepth-1]-1), MAXFILEPATH);
len = strlen(header);
if (len > 34)
{
@@ -3708,10 +3698,10 @@ static void M_HandleAddons(INT32 choice)
break;
case EXT_TXT:
case EXT_CFG:
if ((strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, CONFIGFILENAME) == 0)
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, AUTOLOADCONFIGFILENAME) == 0)
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartserv.cfg") == 0)
|| (strcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartexec.cfg") == 0))
if (fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, CONFIGFILENAME)
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, AUTOLOADCONFIGFILENAME)
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartserv.cfg")
|| fastcmp(dirmenu[dir_on[menudepthleft]]+DIR_STRING, "kartexec.cfg"))
{
M_StartMessage(va("%c%s\x80\nYou can't autoload this builds' base console scripts, silly!\n They're already autoloaded on startup! \n\n(Press a key)\n", ('\x80' + (highlightflags>>V_CHARCOLORSHIFT)), dirmenu[dir_on[menudepthleft]]+DIR_STRING),NULL,MM_NOTHING);
S_StartSound(NULL, sfx_s26d);
@@ -3819,7 +3809,7 @@ static void ReplayNamesLoadThread(void* userdata)
Lock_search_state();
if (strcmp(menupath, replaydirpath) == 0)
if (fastcmp(menupath, replaydirpath))
{
memcpy(demolist_all, demolist_all_local, sizeof(menudemo_t)*sizedirmenu);
replaynamesloaded = true;
@@ -3953,9 +3943,7 @@ static void PrepReplayList(boolean reset)
Lock_search_state();
if (demolist_all)
Z_Free(demolist_all);
Z_Free(demolist_all);
demolist_all = Z_Calloc(sizeof(menudemo_t) * sizedirmenu, PU_STATIC, NULL);
for (i = 0; i < sizedirmenu; i++)
@@ -3973,9 +3961,9 @@ static void PrepReplayList(boolean reset)
else
{
demolist_all[i].type = MD_NOTLOADED;
// FIXME - do something with buffer sizes. menupath is 1024 chars but filepath is only
// 256. I'm not really sure what to do here but don't want to leave warnings...
snprintf(demolist_all[i].filepath, 255, "%.254s%s", menupath, dirmenu[i] + DIR_STRING);
snprintf(demolist_all[i].filepath, sizeof(demolist_all[i].filepath),
// 255 = UINT8 limit. dirmenu entries are restricted to this length (see DIR_LEN).
"%s%.255s", menupath, dirmenu[i] + DIR_STRING);
sprintf(demolist_all[i].title, ".....");
}
}
@@ -4330,7 +4318,7 @@ static void DrawReplayHutReplayInfo(void)
static void M_DrawReplayHut(void)
{
INT32 x, y, cursory = 0;
INT16 i;
INT32 i;
INT16 replaylistitem = currentMenu->numitems-2;
boolean processed_one_this_frame = false;
const INT32 scaledviewheight = (vid.height/vid.dup);
@@ -4403,7 +4391,7 @@ static void M_DrawReplayHut(void)
V_DrawCenteredString(160, 100, V_ALLOWLOWERCASE, msg);
}
for (i = 0; i < (INT16)replayqueryfound; i++)
for (i = 0; i < (INT32)replayqueryfound; i++)
{
INT32 localy = y+i*10;
INT32 localx = x;
@@ -6947,9 +6935,9 @@ static void M_ConnectMenuModChecks(INT32 choice)
(void)choice;
// okay never mind we want to COMMUNICATE to the player pre-emptively instead of letting them try and then get confused when it doesn't work
if (modifiedgame || autoloaded)
if (modifiedgame)
{
M_StartMessage(M_GetText("You have addons loaded.\nYou won't be able to join netgames!\n\nTo play online, restart the game\nand don't load any addons.\nSRB2Kart will automatically add\neverything you need when you join.\n\n(Press a key)\n"),M_ConnectMenu,MM_EVENTHANDLER);
M_StartMessage("You have addons loaded.\nYou won't be able to join netgames!\n\nTo play online, restart the game\nand don't load any addons.\nSRB2Kart will automatically add\neverything you need when you join.\n\n(Press a key)\n", M_ConnectMenu, MM_EVENTHANDLER);
return;
}
@@ -7170,17 +7158,21 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
namescroll = 0;
}
if (renderisnewtic) namescroll++;
if (renderisnewtic)
namescroll++;
char *addonname = wadfiles[mapwads[cv_nextmap.value-1]]->filename;
INT32 len;
INT32 charlimit = min((size_t)(21 + (dupadjust/5)), sizeof(namescrollbuf)-1);
nameonly(addonname);
len = strlen(addonname);
if (len > charlimit)
M_ScrollString(addonname, len, namescrollbuf, charlimit, namescroll);
else
strncpy(namescrollbuf, addonname, sizeof(namescrollbuf));
strncpy(namescrollbuf, addonname, sizeof(namescrollbuf) - 1);
V_DrawThinString(x+w+5, y+i-8, V_TRANSLUCENT|MENUCAPS, namescrollbuf); // variable reuse...
}
@@ -7219,7 +7211,7 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
if (i == oldval)
return;
if(!mapheaderinfo[i])
if (i >= 0 && !mapheaderinfo[i])
continue; // Don't allocate the header. That just makes memory usage skyrocket.
} while (!M_CanShowLevelInList(i, cv_newgametype.value));
@@ -7257,7 +7249,7 @@ static void M_DrawLevelSelectOnly(boolean leftfade, boolean rightfade)
if (i == oldval)
return;
if(!mapheaderinfo[i])
if (i >= 0 && !mapheaderinfo[i])
continue; // Don't allocate the header. That just makes memory usage skyrocket.
} while (!M_CanShowLevelInList(i, cv_newgametype.value));
@@ -8270,12 +8262,12 @@ static void M_DrawSetupMultiPlayerMenu(void)
sprframe = &sprdef->spriteframes[frame];
//minenice's speen css, it's a piece of shit but hey
// minenice's speen css, it's a piece of shit but hey
speenframe = (I_GetTime()*cv_skinselectspin.value/TICRATE + 1)%8;
//this is a very shitty solution for checking if a sprite needs flipping
//but it works
if ((sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]) && (speenframe > 4))
// this is a very shitty solution for checking if a sprite needs flipping
// but it works
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
flags = V_FLIP; // This sprite is left/right flipped!
patch = (patch_t *)W_CachePatchNum(sprframe->lumppat[speenframe], PU_PATCH);
@@ -8795,7 +8787,7 @@ static boolean M_QuitMultiPlayerMenu(void)
size_t l;
// send name if changed
if (strcmp(setupm_name, setupm_cvname->string))
if (!fastcmp(setupm_name, setupm_cvname->string))
{
// remove trailing whitespaces
for (l= strlen(setupm_name)-1;
@@ -9437,9 +9429,8 @@ static void M_VideoModeMenu(INT32 choice)
memset(modedescs, 0, sizeof(modedescs));
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
VID_PrepareModeList(); // FIXME: hack
#endif
vidm_nummodes = 0;
vidm_selected = 0;
nummodes = VID_NumModes();
@@ -9457,7 +9448,7 @@ static void M_VideoModeMenu(INT32 choice)
// VESA mode, which is always a higher modenum
for (j = 0; j < vidm_nummodes; j++)
{
if (!strcmp(modedescs[j].desc, desc))
if (fastcmp(modedescs[j].desc, desc))
{
// mode(0): 320x200 is always standard VGA, not vesa
if (modedescs[j].modenum)
@@ -9631,7 +9622,7 @@ static void M_DrawLocalSkinMenu(void)
//this is a very shitty solution for checking if a sprite needs flipping
//but it works
if ((sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]) && (speenframe > 4))
if ((speenframe > 4) && (sprframe->lumppat[speenframe] == sprframe->lumppat[8-speenframe]))
{
flags = V_FLIP; // This sprite is left/right flipped!
}
@@ -10330,9 +10321,9 @@ static const char *M_GetDiscordName(discordRequest_t *r)
return "";
if (cv_discordstreamer.value)
return r->username;
return DRPC_HideUsername(r->username);
return va("%s#%s", r->username, r->discriminator);
return r->username;
}
// (this goes in k_hud.c when merged into v2)
-10
View File
@@ -38,16 +38,6 @@ extern boolean forceshowhud;
// Does all the real work of the menu interaction.
boolean M_Responder(event_t *ev);
// for scrolling through menus with controllers
extern boolean dpadscrollstate[4];
enum
{
DPAD_UP,
DPAD_DOWN,
DPAD_LEFT,
DPAD_RIGHT
};
// Called by main loop, runs for demo playback. If this returns true, nullify any further user input.
boolean M_DemoResponder(event_t *ev);
+92 -56
View File
@@ -645,10 +645,20 @@ static menuitem_t OP_ControlsMenu[] =
{IT_CALL | IT_STRING, NULL, "Player 3 Controls...", &M_Setup3PControlsMenu, 30},
{IT_CALL | IT_STRING, NULL, "Player 4 Controls...", &M_Setup4PControlsMenu, 40},
{IT_SUBMENU | IT_STRING, NULL, "Mouse Options...", &OP_MouseOptionsDef, 60},
{IT_SUBMENU | IT_STRING, NULL, "Mouse Options...", &OP_MouseOptionsDef, 55},
{IT_STRING | IT_CVAR, NULL, "Controls per key", &cv_controlperkey, 80},
{IT_STRING | IT_CVAR, NULL, "Digital turn easing", &cv_turnsmooth, 90},
{IT_STRING | IT_CVAR, NULL, "Controls per key", &cv_controlperkey, 75},
{IT_STRING | IT_CVAR, NULL, "Digital turn easing (P1)", &cv_turnsmooth[0], 85},
{IT_STRING | IT_CVAR, NULL, "Digital turn easing (P2)", &cv_turnsmooth[1], 95},
{IT_STRING | IT_CVAR, NULL, "Digital turn easing (P3)", &cv_turnsmooth[2], 105},
{IT_STRING | IT_CVAR, NULL, "Digital turn easing (P4)", &cv_turnsmooth[3], 115},
// i hate our menus sincerly
{IT_STRING | IT_CVAR, NULL, "Lite Steer (P1)", &cv_litesteer[0], 135},
{IT_STRING | IT_CVAR, NULL, "Lite Steer (P2)", &cv_litesteer[1], 145},
{IT_STRING | IT_CVAR, NULL, "Lite Steer (P3)", &cv_litesteer[2], 155},
{IT_STRING | IT_CVAR, NULL, "Lite Steer (P4)", &cv_litesteer[3], 165},
};
static const char* OP_ControlsTooltips[] =
@@ -659,7 +669,15 @@ static const char* OP_ControlsTooltips[] =
"Setup player 4 controls.",
"Options for mouse control.",
"Allowed amount of controls per key.",
"Turn smoothing for non-analog turning.",
"Turn smoothing for non-analog turning (Player 1).",
"Turn smoothing for non-analog turning (Player 2).",
"Turn smoothing for non-analog turning (Player 3).",
"Turn smoothing for non-analog turning (Player 4).",
"Hold DOWN on d-pad/keyboard for shallow turns (Player 1).",
"Hold DOWN on d-pad/keyboard for shallow turns (Player 2).",
"Hold DOWN on d-pad/keyboard for shallow turns (Player 3).",
"Hold DOWN on d-pad/keyboard for shallow turns (Player 4).",
};
static menuitem_t OP_AllControlsMenu[] =
@@ -800,26 +818,31 @@ static menuitem_t OP_VideoOptionsMenu[] =
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
{IT_STRING|IT_CVAR, NULL, "Fullscreen", &cv_fullscreen, 20},
#endif
#ifdef BACKWARDSCOMPATCORRECTION
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "Brightness", &cv_globalgamma, 30},
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "Saturation", &cv_globalsaturation , 40},
{IT_SUBMENU|IT_STRING, NULL, "Advanced Color Settings...", &OP_ColorOptionsDef, 50},
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 65},
{IT_STRING | IT_CVAR, NULL, "Weather Draw Distance", &cv_drawdist_precip, 75},
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 95},
{IT_STRING | IT_CVAR, NULL, "Vertical Sync", &cv_vidwait, 105},
{IT_STRING | IT_CVAR, NULL, "FPS Cap", &cv_fpscap, 115},
{IT_STRING | IT_CVAR, NULL, "Drift spark pulse size", &cv_driftsparkpulse, 125},
{IT_STRING | IT_CVAR, NULL, "VHS effect", &cv_vhseffect, 135},
#ifdef HWRENDER
{IT_SUBMENU|IT_STRING, NULL, "OpenGL Options...", &OP_OpenGLOptionsDef, 145},
NULL, "Gamma", &cv_globalgamma, 30},
#endif
{IT_SUBMENU|IT_STRING, NULL, "Advanced Video Options...", &OP_ExpOptionsDef, 155},
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "Brightness", &cv_globalbrightness, 40},
{IT_STRING | IT_CVAR | IT_CV_SLIDER,
NULL, "Saturation", &cv_globalsaturation , 50},
{IT_SUBMENU|IT_STRING, NULL, "Advanced Color Settings...", &OP_ColorOptionsDef, 60},
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 75},
{IT_STRING | IT_CVAR, NULL, "Weather Draw Distance", &cv_drawdist_precip, 85},
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 105},
{IT_STRING | IT_CVAR, NULL, "Vertical Sync", &cv_vidwait, 115},
{IT_STRING | IT_CVAR, NULL, "FPS Cap", &cv_fpscap, 125},
{IT_STRING | IT_CVAR, NULL, "Drift spark pulse size", &cv_driftsparkpulse, 135},
{IT_STRING | IT_CVAR, NULL, "VHS effect", &cv_vhseffect, 145},
#ifdef HWRENDER
{IT_SUBMENU|IT_STRING, NULL, "OpenGL Options...", &OP_OpenGLOptionsDef, 155},
#endif
{IT_SUBMENU|IT_STRING, NULL, "Advanced Video Options...", &OP_ExpOptionsDef, 165},
};
static const char* OP_VideoTooltips[] =
@@ -828,11 +851,12 @@ static const char* OP_VideoTooltips[] =
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
"Enable fullscreen.",
#endif
"Gamma (brightness) of the game.",
"Saturation of the game.",
"Increase the gamma of the displayed image.",
"Increase or decrease the brightness of the displayed image.",
"Reduce the saturation of the displayed image.",
"Advanced color settings of the game.",
"How far away objects are drawn.",
"How far away weather is drawn.",
"How far objects can be drawn.",
"Affects how far weather visuals can be drawn.",
"Show current game framerate and select the style.",
"Sync game framerate to refresh rate of monitor.",
"Set manual framerate cap.",
@@ -851,7 +875,10 @@ enum
#if defined (__unix__) || defined (UNIXCOMMON) || defined (HAVE_SDL)
op_video_fullscreen,
#endif
#ifdef BACKWARDSCOMPATCORRECTION
op_video_gamma,
#endif
op_video_bright,
op_video_sat,
op_video_color,
op_video_dd,
@@ -880,37 +907,37 @@ static menuitem_t OP_ColorOptionsMenu[] =
{IT_DISABLED, NULL, NULL, NULL, 35},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_rhue, 15},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_rsaturation, 20},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_rgamma, 25},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_rbrightness, 25},
{IT_HEADER, NULL, "Yellow", NULL, 34},
{IT_DISABLED, NULL, NULL, NULL, 73},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_yhue, 40},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_ysaturation, 45},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_ygamma, 50},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_ybrightness, 50},
{IT_HEADER, NULL, "Green", NULL, 59},
{IT_DISABLED, NULL, NULL, NULL, 112},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_ghue, 65},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_gsaturation, 70},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_ggamma, 75},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_gbrightness, 75},
{IT_HEADER, NULL, "Cyan", NULL, 84},
{IT_DISABLED, NULL, NULL, NULL, 255},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_chue, 90},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_csaturation, 95},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_cgamma, 100},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_cbrightness, 100},
{IT_HEADER, NULL, "Blue", NULL, 109},
{IT_DISABLED, NULL, NULL, NULL, 152},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_bhue, 115},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_bsaturation, 120},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_bgamma, 125},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_bbrightness, 125},
{IT_HEADER, NULL, "Magenta", NULL, 134},
{IT_DISABLED, NULL, NULL, NULL, 181},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Hue", &cv_mhue, 140},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Saturation", &cv_msaturation, 145},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_mgamma, 150},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness", &cv_mbrightness, 150},
};
static menuitem_t OP_ExpOptionsMenu[] =
@@ -926,21 +953,23 @@ static menuitem_t OP_ExpOptionsMenu[] =
{IT_STRING | IT_CVAR, NULL, "Skyboxes", &cv_skybox, 40},
{IT_STRING | IT_CVAR, NULL, "FPS counter sampling", &cv_accuratefps, 50},
{IT_STRING | IT_CVAR, NULL, "Precache Level Textures", &cv_precachetextures, 50},
{IT_STRING | IT_CVAR, NULL, "Frameskip", &cv_frameskip, 60},
{IT_STRING | IT_CVAR, NULL, "FPS counter sampling", &cv_accuratefps, 60},
{IT_STRING | IT_CVAR, NULL, "Votescreen Scaling", &cv_votebgscaling, 70},
{IT_STRING | IT_CVAR, NULL, "Frameskip", &cv_frameskip, 70},
{IT_STRING | IT_CVAR, NULL, "Votescreen Scaling", &cv_votebgscaling, 80},
#ifdef HWRENDER
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 80},
{IT_STRING | IT_CVAR, NULL, "Screen Textures", &cv_glscreentextures, 90},
#ifdef USE_FBO_OGL
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 85},
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 95},
{IT_DISABLED, NULL, "", NULL, 105}, // dummy text
{IT_STRING | IT_CVAR, NULL, "FBO Downsampling support", &cv_glframebuffer, 95},
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 105},
{IT_DISABLED, NULL, "", NULL, 115}, // dummy text
#else
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 90},
{IT_DISABLED, NULL, "", NULL, 100}, // dummy text
{IT_STRING | IT_CVAR, NULL, "Palette Depth", &cv_glpalettedepth, 100},
{IT_DISABLED, NULL, "", NULL, 110}, // dummy text
#endif
#endif
};
@@ -950,16 +979,17 @@ static const char* OP_ExpTooltips[] =
NULL,
"How far Mobj interpolation should take effect.",
"When weather is on this will cut the object amount used in half.",
"Sets minimum sector brightness, useful for dark areas",
"Sets minimum sector brightness, useful for dark areas.",
//"Should the directional lightning be randomized each map?\nTakes effect on next map load.",
"Toggle being able to see the sky.",
"Change the FPS counter sampling method\nInaccurate updates slower and might miss frame drops and such\nAccurate updates faster and is more accurate, but might be less readable", // how to ingles??
"Skips rendering frames if game logic takes too long preventing issues during performance drops." // idk im shit as describing things
"Preload all level textures on level load.\nMassively reduces texture related stuttering during gameplay\nat the cost of longer level loading times.\nDisable this if you experience timeouts during level switches.",
"Change the FPS counter sampling method\nInaccurate updates slower\nand might miss sudden framerate changes and drops,\nproviding a more averaged result.\nAccurate updates faster, but might be less readable.", // how to ingles??
"Skips rendering frames if game logic takes too long\npreventing gameplay issues during performance drops.", // idk im shit as describing things
"Different methods of scaling the votescreen backgrounds.",
#ifdef HWRENDER
"Should the game do Screen Textures? Provides a good boost to frames\nat the cost of some visual effects not working when disabled.",
#ifdef USE_FBO_OGL
"Allows the game to downsample from a higher resolution than your display\nin OpenGL renderer mode. Requires a GPU with atleast OpenGL 3.0 support.",
"Allows the game to downsample from a higher resolution\nthan your display in OpenGL renderer mode.\nRequires a GPU with atleast OpenGL 2.1 support.",
#endif
"Change the bit depth of the Lookup Palette in Palette rendering mode\n 16 bits is like software looks ingame\nwhile 24 bits is how software looks in screenshots.",
#endif
@@ -973,6 +1003,7 @@ enum
op_exp_secbright,
//op_exp_dirlight,
op_exp_skybox,
op_exp_texcache,
op_exp_accuratefps,
op_exp_frameskip,
op_exp_votescrn,
@@ -1131,8 +1162,10 @@ static menuitem_t OP_SoundAdvancedMenu[] =
{IT_STRING | IT_CVAR, NULL, "Keep Map Music", &cv_keepmusic, 80},
{IT_STRING | IT_CVAR, NULL, "Skip Intro Music", &cv_skipintromusic, 85},
{IT_STRING | IT_CVAR, NULL, "Audio Buffer Size", &cv_audbuffersize, 90},
{IT_DISABLED, NULL, "", NULL, 100}, // dummy text
{IT_STRING | IT_CVAR, NULL, "Cache Sound", &cv_cachesound, 90},
{IT_STRING | IT_CVAR, NULL, "Audio Buffer Size", &cv_audbuffersize, 95},
{IT_DISABLED, NULL, "", NULL, 105}, // dummy text
};
static const char* OP_SoundAdvancedTooltips[] =
@@ -1153,7 +1186,10 @@ static const char* OP_SoundAdvancedTooltips[] =
"Should the Invulnerability music be on or off?",
"Should music be kept when restarting the map?",
"Should the Intro fanfare be skipped\nand map music be played on map start?",
"Controls Sound effects caching.\nKeep will retain previously played sound effects in cache." // man idk how to describe this in a non awful way lmao
"\nOn will preload all sound effects.\nEliminates sound-related lag and stutters but increases memory usage.",
"Size of the Audio Buffer\nreducing it will result in less sound latency\nbut may cause issues such as crackling or distorted Sound.",
NULL,
};
static menuitem_t OP_FocusOptionsMenu[] =
@@ -1357,15 +1393,15 @@ static menuitem_t OP_Player4CamOptionsMenu[] =
static const char* OP_PlayerCamOptionsTooltips[] =
{
NULL,
"Should the Camera flip on gravity flipped sections?.",
"Should the Camera flip on gravity flipped sections?",
"Camera distance relative to the Player.",
"Height of the Camera",
"Pitch Camera on Upwards or Downhill Slopes",
"Speed of the Camera",
"Should looking back inherit the Players Momentum?\nEither inherit Player Momentum or double of it\nmay make looking back while boosting or going in high speed less jarring",
"Height of the Camera.",
"Pitch Camera on Upwards or Downhill Slopes.",
"Speed of the Camera.",
"Should looking back inherit the Players Momentum?\nEither inherit Player Momentum or double of it\nmay make looking back while boosting or going in high speed less jarring.",
"Allows looking up/down by holding\naim forward/backward while standing still.",
"Speed of the Freecam/Spectator Camera",
"Toggle between Third or First Person camera",
"Speed of the Freecam/Spectator Camera.",
"Toggle between Third or First Person camera.",
};
// Ok it's still called chatoptions but we'll put ping display in here to be clean
@@ -1745,7 +1781,7 @@ static const char* OP_PlayerDistortTooltips[] =
"Distance object rotation should be visable.",
"Player rotation when sliptiding.",
"Rotation of a player's boost trails and drift sparks.",
"Should banans rotate when thrown?\nAnd should they stay rotated when on the ground?.",
"Should banans rotate when thrown?\nAnd should they stay rotated when on the ground?",
"Player squash and stretch.",
"Player landing sound effect.",
"Kart hopping while drifting. This is purely visual.",
@@ -2424,7 +2460,7 @@ menu_t OP_MainDef =
NULL
};
menu_t OP_ControlsDef = DEFAULTMENUSTYLE("M_CONTRO", OP_ControlsMenu, &OP_MainDef, 60, 30, OP_ControlsTooltips);
menu_t OP_ControlsDef = DEFAULTMENUSTYLE("M_CONTRO", OP_ControlsMenu, &OP_MainDef, 40, 15, OP_ControlsTooltips);
//WTF
menu_t OP_MouseOptionsDef = DEFAULTMENUSTYLE("M_CONTRO", OP_MouseOptionsMenu, &OP_ControlsDef, 60, 30, OP_MouseTooltips);
menu_t OP_AllControlsDef = CONTROLMENUSTYLE(OP_AllControlsMenu, &OP_ControlsDef);
Loaded 100 of 164 files, more files were not shown because too many files have changed in this diff. Show more